From 95c684fc4d32b508daa2f74f8c256fa4cf351e83 Mon Sep 17 00:00:00 2001 From: wangdequan Date: Sat, 27 Jun 2026 08:45:38 -0400 Subject: [PATCH] =?UTF-8?q?=E5=90=8C=E6=AD=A5KDL=E5=B7=A5=E7=A8=8B?= =?UTF-8?q?=E6=BA=90=E7=A0=81=E5=88=B0=E4=BA=91=E4=BB=93=E5=BA=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 8 + .gitmodules | 3 + kdl-wasm/CMakeLists.txt | 76 + kdl-wasm/bindings/kdl.d.ts | 26 + kdl-wasm/bindings/kdl_c_api.cpp | 731 ++++ kdl-wasm/web/src/grl/ast/ast.ts | 239 ++ kdl-wasm/web/src/grl/ast/index.ts | 37 + kdl-wasm/web/src/grl/generator/generator.ts | 210 + kdl-wasm/web/src/grl/generator/index.ts | 10 + kdl-wasm/web/src/grl/ir/index.ts | 61 + kdl-wasm/web/src/grl/ir/motion.ts | 428 ++ kdl-wasm/web/src/grl/lexer/index.ts | 15 + kdl-wasm/web/src/grl/lexer/keywords.ts | 95 + kdl-wasm/web/src/grl/lexer/lexer.ts | 429 ++ kdl-wasm/web/src/grl/lexer/tokens.ts | 86 + kdl-wasm/web/src/grl/lexer/units.ts | 59 + kdl-wasm/web/src/grl/parser/errors.ts | 11 + .../web/src/grl/parser/expressionParser.ts | 351 ++ kdl-wasm/web/src/grl/parser/index.ts | 3 + kdl-wasm/web/src/grl/parser/parser.ts | 859 ++++ kdl-wasm/web/src/grl/post/index.ts | 8 + kdl-wasm/web/src/grl/post/postProcessor.ts | 232 ++ .../src/grl/semantic/compileControlFlow.ts | 576 +++ kdl-wasm/web/src/grl/semantic/compileData.ts | 296 ++ .../web/src/grl/semantic/compileException.ts | 321 ++ kdl-wasm/web/src/grl/semantic/compileIo.ts | 380 ++ .../web/src/grl/semantic/compileMotion.ts | 978 +++++ .../src/grl/semantic/compileProcFunction.ts | 647 +++ .../web/src/grl/semantic/compileSemantic.ts | 549 +++ kdl-wasm/web/src/grl/semantic/index.ts | 49 + kdl-wasm/web/src/kdl/kdl.worker.ts | 16 + kdl-wasm/web/src/kdl/kdlClient.ts | 318 ++ kdl-wasm/web/src/kdl/nativeAbi.ts | 118 + kdl-wasm/web/src/kdl/nativeModule.ts | 58 + kdl-wasm/web/src/kdl/performanceBaseline.ts | 256 ++ kdl-wasm/web/src/kdl/poseApi.ts | 99 + kdl-wasm/web/src/kdl/rpc.ts | 78 + kdl-wasm/web/src/kdl/runtime.ts | 329 ++ kdl-wasm/web/src/kdl/trajectoryUtils.ts | 163 + kdl-wasm/web/src/kdl/trapProfile.ts | 222 + kdl-wasm/web/src/kdl/types.ts | 494 +++ kdl-wasm/web/src/kdl/workerRpc.ts | 49 + kdl-wasm/web/src/math/poseMath.ts | 238 ++ kdl-wasm/web/src/robot/index.ts | 2 + .../web/src/robot/normalizedRobotModel.ts | 1781 ++++++++ kdl-wasm/web/src/robot/urdfParser.ts | 277 ++ kdl-wasm/web/tests/grl/controlFlow.test.ts | 197 + .../web/tests/grl/dataDeclarations.test.ts | 151 + .../web/tests/grl/exceptionCompile.test.ts | 125 + .../web/tests/grl/generator/roundtrip.test.ts | 149 + kdl-wasm/web/tests/grl/ioCompile.test.ts | 205 + kdl-wasm/web/tests/grl/lexer.test.ts | 94 + kdl-wasm/web/tests/grl/motionCompile.test.ts | 124 + .../web/tests/grl/operationCompile.test.ts | 153 + kdl-wasm/web/tests/grl/parser.test.ts | 103 + kdl-wasm/web/tests/grl/pathCompile.test.ts | 251 ++ kdl-wasm/web/tests/grl/procFunction.test.ts | 201 + kdl-wasm/web/tests/grl/semanticIr.test.ts | 148 + kdl-wasm/web/tests/kdl/cAbi.test.ts | 224 ++ kdl-wasm/web/tests/kdl/checks.test.ts | 178 + kdl-wasm/web/tests/kdl/fk.test.ts | 198 + kdl-wasm/web/tests/kdl/ik.test.ts | 166 + kdl-wasm/web/tests/kdl/path.test.ts | 167 + kdl-wasm/web/tests/kdl/performance.test.ts | 23 + kdl-wasm/web/tests/kdl/planMoveC.test.ts | 193 + kdl-wasm/web/tests/kdl/planMoveJ.test.ts | 192 + kdl-wasm/web/tests/kdl/planMoveL.test.ts | 175 + kdl-wasm/web/tests/kdl/poseApi.test.ts | 152 + kdl-wasm/web/tests/kdl/rpc.test.ts | 206 + .../web/tests/kdl/trajectoryUtils.test.ts | 179 + kdl-wasm/web/tests/kdl/trapProfile.test.ts | 138 + kdl-wasm/web/tests/kdl/urdf.test.ts | 182 + kdl-wasm/web/tests/post/postProcessor.test.ts | 88 + kdl-wasm/web/tsconfig.json | 16 + kdl-wasm/web/vitest.config.ts | 9 + orocos_kinematics_dynamics | 1 + package-lock.json | 1741 ++++++++ package.json | 18 + work/doc/KDL_WASM计算接口设计.md | 1032 +++++ .../通用机器人离线编程虚拟控制器技术方案.md | 3578 +++++++++++++++++ work/doc/通用机器人编程语法规范.md | 1541 +++++++ work/doc/通用机器人项目主要实施步骤.md | 530 +++ .../flow-01.mmd | 58 + .../flow-01.png | Bin 0 -> 696876 bytes .../flow-02.mmd | 42 + .../flow-02.png | Bin 0 -> 455271 bytes .../flow-03.mmd | 48 + .../flow-03.png | Bin 0 -> 500667 bytes .../flow-04.mmd | 92 + .../flow-04.png | Bin 0 -> 651380 bytes .../flow-05.mmd | 16 + .../flow-05.png | Bin 0 -> 251292 bytes work/doc/通用机器人项目功能与数据流程图.md | 357 ++ 93 files changed, 25712 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 kdl-wasm/CMakeLists.txt create mode 100644 kdl-wasm/bindings/kdl.d.ts create mode 100644 kdl-wasm/bindings/kdl_c_api.cpp create mode 100644 kdl-wasm/web/src/grl/ast/ast.ts create mode 100644 kdl-wasm/web/src/grl/ast/index.ts create mode 100644 kdl-wasm/web/src/grl/generator/generator.ts create mode 100644 kdl-wasm/web/src/grl/generator/index.ts create mode 100644 kdl-wasm/web/src/grl/ir/index.ts create mode 100644 kdl-wasm/web/src/grl/ir/motion.ts create mode 100644 kdl-wasm/web/src/grl/lexer/index.ts create mode 100644 kdl-wasm/web/src/grl/lexer/keywords.ts create mode 100644 kdl-wasm/web/src/grl/lexer/lexer.ts create mode 100644 kdl-wasm/web/src/grl/lexer/tokens.ts create mode 100644 kdl-wasm/web/src/grl/lexer/units.ts create mode 100644 kdl-wasm/web/src/grl/parser/errors.ts create mode 100644 kdl-wasm/web/src/grl/parser/expressionParser.ts create mode 100644 kdl-wasm/web/src/grl/parser/index.ts create mode 100644 kdl-wasm/web/src/grl/parser/parser.ts create mode 100644 kdl-wasm/web/src/grl/post/index.ts create mode 100644 kdl-wasm/web/src/grl/post/postProcessor.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileControlFlow.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileData.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileException.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileIo.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileMotion.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileProcFunction.ts create mode 100644 kdl-wasm/web/src/grl/semantic/compileSemantic.ts create mode 100644 kdl-wasm/web/src/grl/semantic/index.ts create mode 100644 kdl-wasm/web/src/kdl/kdl.worker.ts create mode 100644 kdl-wasm/web/src/kdl/kdlClient.ts create mode 100644 kdl-wasm/web/src/kdl/nativeAbi.ts create mode 100644 kdl-wasm/web/src/kdl/nativeModule.ts create mode 100644 kdl-wasm/web/src/kdl/performanceBaseline.ts create mode 100644 kdl-wasm/web/src/kdl/poseApi.ts create mode 100644 kdl-wasm/web/src/kdl/rpc.ts create mode 100644 kdl-wasm/web/src/kdl/runtime.ts create mode 100644 kdl-wasm/web/src/kdl/trajectoryUtils.ts create mode 100644 kdl-wasm/web/src/kdl/trapProfile.ts create mode 100644 kdl-wasm/web/src/kdl/types.ts create mode 100644 kdl-wasm/web/src/kdl/workerRpc.ts create mode 100644 kdl-wasm/web/src/math/poseMath.ts create mode 100644 kdl-wasm/web/src/robot/index.ts create mode 100644 kdl-wasm/web/src/robot/normalizedRobotModel.ts create mode 100644 kdl-wasm/web/src/robot/urdfParser.ts create mode 100644 kdl-wasm/web/tests/grl/controlFlow.test.ts create mode 100644 kdl-wasm/web/tests/grl/dataDeclarations.test.ts create mode 100644 kdl-wasm/web/tests/grl/exceptionCompile.test.ts create mode 100644 kdl-wasm/web/tests/grl/generator/roundtrip.test.ts create mode 100644 kdl-wasm/web/tests/grl/ioCompile.test.ts create mode 100644 kdl-wasm/web/tests/grl/lexer.test.ts create mode 100644 kdl-wasm/web/tests/grl/motionCompile.test.ts create mode 100644 kdl-wasm/web/tests/grl/operationCompile.test.ts create mode 100644 kdl-wasm/web/tests/grl/parser.test.ts create mode 100644 kdl-wasm/web/tests/grl/pathCompile.test.ts create mode 100644 kdl-wasm/web/tests/grl/procFunction.test.ts create mode 100644 kdl-wasm/web/tests/grl/semanticIr.test.ts create mode 100644 kdl-wasm/web/tests/kdl/cAbi.test.ts create mode 100644 kdl-wasm/web/tests/kdl/checks.test.ts create mode 100644 kdl-wasm/web/tests/kdl/fk.test.ts create mode 100644 kdl-wasm/web/tests/kdl/ik.test.ts create mode 100644 kdl-wasm/web/tests/kdl/path.test.ts create mode 100644 kdl-wasm/web/tests/kdl/performance.test.ts create mode 100644 kdl-wasm/web/tests/kdl/planMoveC.test.ts create mode 100644 kdl-wasm/web/tests/kdl/planMoveJ.test.ts create mode 100644 kdl-wasm/web/tests/kdl/planMoveL.test.ts create mode 100644 kdl-wasm/web/tests/kdl/poseApi.test.ts create mode 100644 kdl-wasm/web/tests/kdl/rpc.test.ts create mode 100644 kdl-wasm/web/tests/kdl/trajectoryUtils.test.ts create mode 100644 kdl-wasm/web/tests/kdl/trapProfile.test.ts create mode 100644 kdl-wasm/web/tests/kdl/urdf.test.ts create mode 100644 kdl-wasm/web/tests/post/postProcessor.test.ts create mode 100644 kdl-wasm/web/tsconfig.json create mode 100644 kdl-wasm/web/vitest.config.ts create mode 160000 orocos_kinematics_dynamics create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 work/doc/KDL_WASM计算接口设计.md create mode 100644 work/doc/通用机器人离线编程虚拟控制器技术方案.md create mode 100644 work/doc/通用机器人编程语法规范.md create mode 100644 work/doc/通用机器人项目主要实施步骤.md create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-01.mmd create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-01.png create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-02.mmd create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-02.png create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-03.mmd create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-03.png create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-04.mmd create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-04.png create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-05.mmd create mode 100644 work/doc/通用机器人项目功能与数据流程图-png/flow-05.png create mode 100644 work/doc/通用机器人项目功能与数据流程图.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ede28bd --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +node_modules/ +dist/ +coverage/ +kdl-wasm/build*/ +kdl_install/ +work/working1/ +git.txt +*.log diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d0193c9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "orocos_kinematics_dynamics"] + path = orocos_kinematics_dynamics + url = https://github.com/orocos/orocos_kinematics_dynamics.git diff --git a/kdl-wasm/CMakeLists.txt b/kdl-wasm/CMakeLists.txt new file mode 100644 index 0000000..da54f15 --- /dev/null +++ b/kdl-wasm/CMakeLists.txt @@ -0,0 +1,76 @@ +cmake_minimum_required(VERSION 3.16) + +project(kdl_wasm_wrapper LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +set(KDL_SOURCE_DIR "" CACHE PATH "Path to the Orocos KDL source tree") +if(KDL_SOURCE_DIR AND NOT EXISTS "${KDL_SOURCE_DIR}") + message(FATAL_ERROR "KDL_SOURCE_DIR does not exist: ${KDL_SOURCE_DIR}") +endif() + +set(EIGEN3_INCLUDE_DIR "" CACHE PATH "Path to the Eigen3 include directory") +if(KDL_SOURCE_DIR AND NOT EIGEN3_INCLUDE_DIR) + find_path(EIGEN3_INCLUDE_DIR Eigen/Core PATH_SUFFIXES eigen3) +endif() +if(KDL_SOURCE_DIR AND NOT EIGEN3_INCLUDE_DIR AND EXISTS "/usr/include/eigen3/Eigen/Core") + set(EIGEN3_INCLUDE_DIR "/usr/include/eigen3" CACHE PATH "Path to the Eigen3 include directory" FORCE) +endif() +if(KDL_SOURCE_DIR AND NOT EIGEN3_INCLUDE_DIR) + message(FATAL_ERROR "Eigen3 include directory was not found") +endif() + +set(KDL_WASM_SOURCES + bindings/kdl_c_api.cpp +) + +if(KDL_SOURCE_DIR) + list(APPEND KDL_WASM_SOURCES + "${KDL_SOURCE_DIR}/src/chain.cpp" + "${KDL_SOURCE_DIR}/src/chainfksolverpos_recursive.cpp" + "${KDL_SOURCE_DIR}/src/chainjnttojacsolver.cpp" + "${KDL_SOURCE_DIR}/src/frames.cpp" + "${KDL_SOURCE_DIR}/src/jacobian.cpp" + "${KDL_SOURCE_DIR}/src/jntarray.cpp" + "${KDL_SOURCE_DIR}/src/joint.cpp" + "${KDL_SOURCE_DIR}/src/rigidbodyinertia.cpp" + "${KDL_SOURCE_DIR}/src/rotationalinertia.cpp" + "${KDL_SOURCE_DIR}/src/segment.cpp" + "${KDL_SOURCE_DIR}/src/utilities/utility.cxx" + ) +endif() + +if(EMSCRIPTEN) + add_executable(kdl ${KDL_WASM_SOURCES}) + target_compile_options(kdl PRIVATE "-fexceptions") + if(KDL_SOURCE_DIR) + target_include_directories(kdl PRIVATE "${KDL_SOURCE_DIR}/src" "${EIGEN3_INCLUDE_DIR}") + target_compile_definitions(kdl PRIVATE KDL_WASM_HAS_OROCOS_KDL=1) + endif() + set_target_properties(kdl PROPERTIES OUTPUT_NAME "kdl" SUFFIX ".js") + target_link_options(kdl PRIVATE + "--no-entry" + "-sMODULARIZE=1" + "-sEXPORT_ES6=1" + "-sEXPORT_NAME=createKdlModule" + "-sENVIRONMENT=web,worker,node" + "-sALLOW_MEMORY_GROWTH=1" + "-fexceptions" + "-sDISABLE_EXCEPTION_CATCHING=0" + "-sEXPORTED_RUNTIME_METHODS=ccall,cwrap,UTF8ToString,stringToUTF8,lengthBytesUTF8,HEAPF64" + "-sEXPORTED_FUNCTIONS=['_malloc','_free','_kdl_init','_kdl_create_robot','_kdl_destroy_robot','_kdl_get_robot_info','_kdl_fk','_kdl_fk_all_links','_kdl_jacobian','_kdl_ik','_kdl_plan_movej','_kdl_plan_movel','_kdl_plan_movec','_kdl_plan_path','_kdl_sample_trap','_kdl_last_error']" + ) + add_custom_command(TARGET kdl POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + "${CMAKE_CURRENT_SOURCE_DIR}/bindings/kdl.d.ts" + "${CMAKE_CURRENT_BINARY_DIR}/kdl.d.ts" + ) +else() + add_library(kdl SHARED ${KDL_WASM_SOURCES}) + if(KDL_SOURCE_DIR) + target_include_directories(kdl PRIVATE "${KDL_SOURCE_DIR}/src" "${EIGEN3_INCLUDE_DIR}") + target_compile_definitions(kdl PRIVATE KDL_WASM_HAS_OROCOS_KDL=1) + endif() +endif() diff --git a/kdl-wasm/bindings/kdl.d.ts b/kdl-wasm/bindings/kdl.d.ts new file mode 100644 index 0000000..ad7f794 --- /dev/null +++ b/kdl-wasm/bindings/kdl.d.ts @@ -0,0 +1,26 @@ +export interface KdlModule { + ccall: ( + ident: string, + returnType: string | null, + argTypes: Array, + args: unknown[] + ) => unknown; + cwrap: ( + ident: string, + returnType: string | null, + argTypes: Array + ) => (...args: unknown[]) => unknown; + UTF8ToString: (ptr: number) => string; + stringToUTF8: (value: string, outPtr: number, maxBytesToWrite: number) => void; + lengthBytesUTF8: (value: string) => number; + _malloc: (size: number) => number; + _free: (ptr: number) => void; +} + +export interface KdlModuleFactoryOptions { + locateFile?: (path: string, prefix: string) => string; + print?: (text: string) => void; + printErr?: (text: string) => void; +} + +export default function createKdlModule(options?: KdlModuleFactoryOptions): Promise; diff --git a/kdl-wasm/bindings/kdl_c_api.cpp b/kdl-wasm/bindings/kdl_c_api.cpp new file mode 100644 index 0000000..810e201 --- /dev/null +++ b/kdl-wasm/bindings/kdl_c_api.cpp @@ -0,0 +1,731 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __EMSCRIPTEN__ +#include +#else +#define EMSCRIPTEN_KEEPALIVE +#endif + +#ifdef KDL_WASM_HAS_OROCOS_KDL +#include "chain.hpp" +#include "chainfksolverpos_recursive.hpp" +#include "chainjnttojacsolver.hpp" +#include "jntarray.hpp" +#include "segment.hpp" +#endif + +namespace { + +std::string last_error = + R"({"code":"KDL_OK","message":"No error","diagnostics":[]})"; +int next_robot_handle = 1; + +struct JsonValue { + enum class Kind { Null, Bool, Number, String, Array, Object }; + + Kind kind = Kind::Null; + bool bool_value = false; + double number_value = 0.0; + std::string string_value; + std::vector array_value; + std::map object_value; + + const JsonValue* get(const std::string& key) const { + if (kind != Kind::Object) { + return nullptr; + } + const auto it = object_value.find(key); + return it == object_value.end() ? nullptr : &it->second; + } +}; + +class JsonParser { + public: + explicit JsonParser(const std::string& input) : input_(input) {} + + JsonValue parse() { + JsonValue value = parse_value(); + skip_ws(); + if (pos_ != input_.size()) { + throw std::runtime_error("Unexpected trailing JSON content"); + } + return value; + } + + private: + const std::string& input_; + std::size_t pos_ = 0; + + JsonValue parse_value() { + skip_ws(); + if (pos_ >= input_.size()) { + throw std::runtime_error("Unexpected end of JSON"); + } + const char ch = input_[pos_]; + if (ch == '{') { + return parse_object(); + } + if (ch == '[') { + return parse_array(); + } + if (ch == '"') { + JsonValue value; + value.kind = JsonValue::Kind::String; + value.string_value = parse_string(); + return value; + } + if (ch == 't' || ch == 'f') { + return parse_bool(); + } + if (ch == 'n') { + expect_literal("null"); + return {}; + } + return parse_number(); + } + + JsonValue parse_object() { + consume('{'); + JsonValue value; + value.kind = JsonValue::Kind::Object; + skip_ws(); + if (match('}')) { + return value; + } + + while (true) { + skip_ws(); + const std::string key = parse_string(); + skip_ws(); + consume(':'); + value.object_value.emplace(key, parse_value()); + skip_ws(); + if (match('}')) { + return value; + } + consume(','); + } + } + + JsonValue parse_array() { + consume('['); + JsonValue value; + value.kind = JsonValue::Kind::Array; + skip_ws(); + if (match(']')) { + return value; + } + + while (true) { + value.array_value.push_back(parse_value()); + skip_ws(); + if (match(']')) { + return value; + } + consume(','); + } + } + + std::string parse_string() { + consume('"'); + std::string out; + while (pos_ < input_.size()) { + const char ch = input_[pos_++]; + if (ch == '"') { + return out; + } + if (ch != '\\') { + out.push_back(ch); + continue; + } + if (pos_ >= input_.size()) { + throw std::runtime_error("Invalid JSON string escape"); + } + const char escaped = input_[pos_++]; + switch (escaped) { + case '"': + case '\\': + case '/': + out.push_back(escaped); + break; + case 'b': + out.push_back('\b'); + break; + case 'f': + out.push_back('\f'); + break; + case 'n': + out.push_back('\n'); + break; + case 'r': + out.push_back('\r'); + break; + case 't': + out.push_back('\t'); + break; + case 'u': + if (pos_ + 4 > input_.size()) { + throw std::runtime_error("Invalid JSON unicode escape"); + } + out.push_back('?'); + pos_ += 4; + break; + default: + throw std::runtime_error("Invalid JSON string escape"); + } + } + throw std::runtime_error("Unterminated JSON string"); + } + + JsonValue parse_bool() { + JsonValue value; + value.kind = JsonValue::Kind::Bool; + if (starts_with("true")) { + value.bool_value = true; + pos_ += 4; + return value; + } + if (starts_with("false")) { + value.bool_value = false; + pos_ += 5; + return value; + } + throw std::runtime_error("Invalid JSON boolean"); + } + + JsonValue parse_number() { + const std::size_t start = pos_; + if (input_[pos_] == '-') { + pos_ += 1; + } + while (pos_ < input_.size() && std::isdigit(static_cast(input_[pos_]))) { + pos_ += 1; + } + if (pos_ < input_.size() && input_[pos_] == '.') { + pos_ += 1; + while (pos_ < input_.size() && std::isdigit(static_cast(input_[pos_]))) { + pos_ += 1; + } + } + if (pos_ < input_.size() && (input_[pos_] == 'e' || input_[pos_] == 'E')) { + pos_ += 1; + if (pos_ < input_.size() && (input_[pos_] == '+' || input_[pos_] == '-')) { + pos_ += 1; + } + while (pos_ < input_.size() && std::isdigit(static_cast(input_[pos_]))) { + pos_ += 1; + } + } + if (start == pos_) { + throw std::runtime_error("Expected JSON number"); + } + JsonValue value; + value.kind = JsonValue::Kind::Number; + value.number_value = std::stod(input_.substr(start, pos_ - start)); + return value; + } + + void expect_literal(const char* literal) { + if (!starts_with(literal)) { + throw std::runtime_error(std::string("Expected JSON literal ") + literal); + } + pos_ += std::strlen(literal); + } + + bool starts_with(const char* literal) const { + const std::size_t len = std::strlen(literal); + return input_.compare(pos_, len, literal) == 0; + } + + void skip_ws() { + while (pos_ < input_.size() && std::isspace(static_cast(input_[pos_]))) { + pos_ += 1; + } + } + + bool match(char expected) { + if (pos_ < input_.size() && input_[pos_] == expected) { + pos_ += 1; + return true; + } + return false; + } + + void consume(char expected) { + if (!match(expected)) { + throw std::runtime_error(std::string("Expected JSON character ") + expected); + } + } +}; + +struct NativeJoint { + std::string name; + std::string type; + std::string child; + double xyz[3] = {0.0, 0.0, 0.0}; + double rpy[3] = {0.0, 0.0, 0.0}; + double axis[3] = {1.0, 0.0, 0.0}; + bool active = false; +}; + +struct RobotRecord { + std::string model_json; + std::string robot_id; + std::string name; + std::string base_link; + std::string tip_link; + std::vector active_joint_names; + std::vector joints; +#ifdef KDL_WASM_HAS_OROCOS_KDL + KDL::Chain chain; + std::unique_ptr fk_solver; + std::unique_ptr jac_solver; +#endif +}; + +std::map robots; + +void set_last_error(const char* code, const char* message) { + last_error = std::string("{\"code\":\"") + code + "\",\"message\":\"" + + message + "\",\"diagnostics\":[{\"severity\":\"error\",\"code\":\"" + + code + "\",\"message\":\"" + message + "\"}]}"; +} + +void clear_last_error() { + last_error = R"({"code":"KDL_OK","message":"No error","diagnostics":[]})"; +} + +int write_json(const std::string& json, char* out_json, int out_len) { + if (out_json == nullptr || out_len <= 0) { + set_last_error("KDL_BUFFER_TOO_SMALL", "Output buffer is not writable"); + return -1; + } + + const int required = static_cast(json.size()) + 1; + if (out_len < required) { + set_last_error("KDL_BUFFER_TOO_SMALL", "Output buffer is too small"); + return -1; + } + + std::memcpy(out_json, json.c_str(), static_cast(required)); + return 0; +} + +int not_implemented(const char* function_name) { + set_last_error("KDL_NOT_IMPLEMENTED", function_name); + return -1; +} + +std::string json_escape(const std::string& value) { + std::string escaped; + for (const char ch : value) { + if (ch == '"' || ch == '\\') { + escaped.push_back('\\'); + } + escaped.push_back(ch); + } + return escaped; +} + +const JsonValue& required_object_property(const JsonValue& object, const std::string& key) { + const JsonValue* value = object.get(key); + if (!value) { + throw std::runtime_error("Missing model property: " + key); + } + return *value; +} + +std::string string_property(const JsonValue& object, const std::string& key) { + const JsonValue& value = required_object_property(object, key); + if (value.kind != JsonValue::Kind::String) { + throw std::runtime_error("Expected string model property: " + key); + } + return value.string_value; +} + +std::vector string_array_property(const JsonValue& object, const std::string& key) { + const JsonValue& value = required_object_property(object, key); + if (value.kind != JsonValue::Kind::Array) { + throw std::runtime_error("Expected string array model property: " + key); + } + + std::vector out; + out.reserve(value.array_value.size()); + for (const JsonValue& item : value.array_value) { + if (item.kind != JsonValue::Kind::String) { + throw std::runtime_error("Expected string item in model property: " + key); + } + out.push_back(item.string_value); + } + return out; +} + +void copy_number_triple(const JsonValue& object, const std::string& key, double out[3]) { + const JsonValue& value = required_object_property(object, key); + if (value.kind != JsonValue::Kind::Array || value.array_value.size() != 3) { + throw std::runtime_error("Expected numeric triple model property: " + key); + } + for (std::size_t index = 0; index < 3; index += 1) { + if (value.array_value[index].kind != JsonValue::Kind::Number) { + throw std::runtime_error("Expected numeric triple model property: " + key); + } + out[index] = value.array_value[index].number_value; + } +} + +std::vector parse_joints(const JsonValue& model, + const std::vector& active_joint_names) { + const JsonValue& joints_value = required_object_property(model, "joints"); + if (joints_value.kind != JsonValue::Kind::Array) { + throw std::runtime_error("Expected joints array"); + } + + std::vector joints; + joints.reserve(joints_value.array_value.size()); + for (const JsonValue& joint_value : joints_value.array_value) { + if (joint_value.kind != JsonValue::Kind::Object) { + throw std::runtime_error("Expected joint object"); + } + NativeJoint joint; + joint.name = string_property(joint_value, "name"); + joint.type = string_property(joint_value, "type"); + joint.child = string_property(joint_value, "child"); + + const JsonValue& origin = required_object_property(joint_value, "origin"); + if (origin.kind != JsonValue::Kind::Object) { + throw std::runtime_error("Expected joint origin object"); + } + copy_number_triple(origin, "xyz", joint.xyz); + copy_number_triple(origin, "rpy", joint.rpy); + copy_number_triple(joint_value, "axis", joint.axis); + joint.active = std::find(active_joint_names.begin(), active_joint_names.end(), joint.name) != + active_joint_names.end(); + joints.push_back(joint); + } + return joints; +} + +#ifdef KDL_WASM_HAS_OROCOS_KDL +KDL::Frame frame_from_xyz_rpy(const double xyz[3], const double rpy[3]) { + return KDL::Frame( + KDL::Rotation::RPY(rpy[0], rpy[1], rpy[2]), + KDL::Vector(xyz[0], xyz[1], xyz[2])); +} + +KDL::Joint kdl_joint_from_model(const NativeJoint& joint) { + if (joint.type == "fixed") { + return KDL::Joint(joint.name, KDL::Joint::Fixed); + } + const KDL::Vector axis(joint.axis[0], joint.axis[1], joint.axis[2]); + if (joint.type == "revolute" || joint.type == "continuous") { + return KDL::Joint(joint.name, KDL::Vector(0.0, 0.0, 0.0), axis, KDL::Joint::RotAxis); + } + if (joint.type == "prismatic") { + return KDL::Joint(joint.name, KDL::Vector(0.0, 0.0, 0.0), axis, KDL::Joint::TransAxis); + } + throw std::runtime_error("Unsupported KDL joint type: " + joint.type); +} + +void build_kdl_chain(RobotRecord& record) { + record.chain = KDL::Chain(); + for (const NativeJoint& joint : record.joints) { + const KDL::Frame origin = frame_from_xyz_rpy(joint.xyz, joint.rpy); + if (joint.xyz[0] != 0.0 || joint.xyz[1] != 0.0 || joint.xyz[2] != 0.0 || + joint.rpy[0] != 0.0 || joint.rpy[1] != 0.0 || joint.rpy[2] != 0.0) { + record.chain.addSegment(KDL::Segment(joint.name + "_origin", KDL::Joint(KDL::Joint::Fixed), origin)); + } + record.chain.addSegment(KDL::Segment(joint.child, kdl_joint_from_model(joint), KDL::Frame::Identity())); + } + record.fk_solver = std::make_unique(record.chain); + record.jac_solver = std::make_unique(record.chain); +} + +KDL::JntArray jnt_array_from_input(const RobotRecord& record, const double* joints, int n) { + if (joints == nullptr) { + throw std::runtime_error("Joint input is required"); + } + if (n != static_cast(record.active_joint_names.size())) { + throw std::runtime_error("Joint vector dimension does not match robot DOF"); + } + KDL::JntArray q(static_cast(n)); + for (int index = 0; index < n; index += 1) { + q(static_cast(index)) = joints[index]; + } + return q; +} + +void write_pose7(const KDL::Frame& frame, double* out_pose7) { + if (out_pose7 == nullptr) { + throw std::runtime_error("Output pose buffer is required"); + } + out_pose7[0] = frame.p.x(); + out_pose7[1] = frame.p.y(); + out_pose7[2] = frame.p.z(); + frame.M.GetQuaternion(out_pose7[3], out_pose7[4], out_pose7[5], out_pose7[6]); +} +#endif + +RobotRecord parse_robot_record(const char* model_json) { + if (model_json == nullptr) { + throw std::runtime_error("Robot model JSON is required"); + } + + RobotRecord record; + record.model_json = model_json; + const JsonValue model = JsonParser(record.model_json).parse(); + if (model.kind != JsonValue::Kind::Object) { + throw std::runtime_error("Robot model must be a JSON object"); + } + + record.robot_id = string_property(model, "robotId"); + record.name = string_property(model, "name"); + record.base_link = string_property(model, "baseLink"); + record.tip_link = string_property(model, "tipLink"); + record.active_joint_names = string_array_property(model, "activeJointNames"); + record.joints = parse_joints(model, record.active_joint_names); + + return record; +} + +std::map::iterator find_robot(int robot_handle) { + const auto it = robots.find(robot_handle); + if (it == robots.end()) { + set_last_error("KDL_INVALID_HANDLE", "RobotHandle does not exist"); + } + return it; +} + +} // namespace + +extern "C" { + +EMSCRIPTEN_KEEPALIVE +int kdl_init(const char* options_json) { + (void)options_json; + robots.clear(); + next_robot_handle = 1; + clear_last_error(); + return 0; +} + +EMSCRIPTEN_KEEPALIVE +int kdl_create_robot(const char* model_json) { + try { + RobotRecord record = parse_robot_record(model_json); + const int handle = next_robot_handle++; + auto [it, inserted] = robots.emplace(handle, std::move(record)); + (void)inserted; +#ifdef KDL_WASM_HAS_OROCOS_KDL + build_kdl_chain(it->second); +#endif + clear_last_error(); + return handle; + } catch (const std::exception& error) { + set_last_error("KDL_INVALID_MODEL", error.what()); + return -1; + } +} + +EMSCRIPTEN_KEEPALIVE +int kdl_destroy_robot(int robot_handle) { + if (robots.erase(robot_handle) == 0) { + set_last_error("KDL_INVALID_HANDLE", "RobotHandle does not exist"); + return -1; + } + clear_last_error(); + return 0; +} + +EMSCRIPTEN_KEEPALIVE +int kdl_get_robot_info(int robot_handle, char* out_json, int out_len) { + const auto it = find_robot(robot_handle); + if (it == robots.end()) { + return -1; + } + const RobotRecord& record = it->second; + + std::ostringstream json; + json << "{\"handle\":" << robot_handle << ",\"robotId\":\"" << json_escape(record.robot_id) + << "\",\"name\":\"" << json_escape(record.name) << "\",\"baseLink\":\"" + << json_escape(record.base_link) << "\",\"tipLink\":\"" << json_escape(record.tip_link) + << "\",\"dof\":" << record.active_joint_names.size() << ",\"jointNames\":["; + for (std::size_t index = 0; index < record.active_joint_names.size(); index += 1) { + if (index > 0) { + json << ","; + } + json << "\"" << json_escape(record.active_joint_names[index]) << "\""; + } + json << "],\"limits\":[],\"nativeState\":\"" +#ifdef KDL_WASM_HAS_OROCOS_KDL + << "kdl_chain" +#else + << "model_cached" +#endif + << "\"}"; + const int result = write_json(json.str(), out_json, out_len); + if (result == 0) { + clear_last_error(); + } + return result; +} + +EMSCRIPTEN_KEEPALIVE +int kdl_fk(int robot_handle, const double* joints, int n, double* out_pose7) { +#ifdef KDL_WASM_HAS_OROCOS_KDL + try { + const auto it = find_robot(robot_handle); + if (it == robots.end()) { + return -1; + } + RobotRecord& record = it->second; + const KDL::JntArray q = jnt_array_from_input(record, joints, n); + KDL::Frame frame; + const int result = record.fk_solver->JntToCart(q, frame); + if (result != 0) { + set_last_error("KDL_FK_FAILED", "Native KDL FK solver failed"); + return -1; + } + write_pose7(frame, out_pose7); + clear_last_error(); + return 0; + } catch (const std::exception& error) { + set_last_error("KDL_FK_FAILED", error.what()); + return -1; + } +#else + (void)robot_handle; + (void)joints; + (void)n; + (void)out_pose7; + return not_implemented("kdl_fk requires KDL_SOURCE_DIR"); +#endif +} + +EMSCRIPTEN_KEEPALIVE +int kdl_fk_all_links(int robot_handle, const double* joints, int n, char* out_json, + int out_len) { + (void)robot_handle; + (void)joints; + (void)n; + (void)out_json; + (void)out_len; + return not_implemented("kdl_fk_all_links is pending native link-pose serialization"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_jacobian(int robot_handle, const double* joints, int n, double* out_matrix) { +#ifdef KDL_WASM_HAS_OROCOS_KDL + try { + const auto it = find_robot(robot_handle); + if (it == robots.end()) { + return -1; + } + RobotRecord& record = it->second; + if (out_matrix == nullptr) { + throw std::runtime_error("Output Jacobian buffer is required"); + } + const KDL::JntArray q = jnt_array_from_input(record, joints, n); + KDL::Jacobian jac(static_cast(n)); + const int result = record.jac_solver->JntToJac(q, jac); + if (result != 0) { + set_last_error("KDL_JACOBIAN_FAILED", "Native KDL Jacobian solver failed"); + return -1; + } + for (int col = 0; col < n; col += 1) { + for (int row = 0; row < 6; row += 1) { + out_matrix[row * n + col] = jac(static_cast(row), static_cast(col)); + } + } + clear_last_error(); + return 0; + } catch (const std::exception& error) { + set_last_error("KDL_JACOBIAN_FAILED", error.what()); + return -1; + } +#else + (void)robot_handle; + (void)joints; + (void)n; + (void)out_matrix; + return not_implemented("kdl_jacobian requires KDL_SOURCE_DIR"); +#endif +} + +EMSCRIPTEN_KEEPALIVE +int kdl_ik(int robot_handle, const double* seed, int n, const double* target_pose7, + const char* options_json, double* out_joints) { + (void)robot_handle; + (void)seed; + (void)n; + (void)target_pose7; + (void)options_json; + (void)out_joints; + return not_implemented("kdl_ik is pending native IK binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_plan_movej(int robot_handle, const char* request_json, char* out_json, + int out_len) { + (void)robot_handle; + (void)request_json; + (void)out_json; + (void)out_len; + return not_implemented("kdl_plan_movej is pending KW-008 native binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_plan_movel(int robot_handle, const char* request_json, char* out_json, + int out_len) { + (void)robot_handle; + (void)request_json; + (void)out_json; + (void)out_len; + return not_implemented("kdl_plan_movel is pending KW-009 native binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_plan_movec(int robot_handle, const char* request_json, char* out_json, + int out_len) { + (void)robot_handle; + (void)request_json; + (void)out_json; + (void)out_len; + return not_implemented("kdl_plan_movec is pending KW-010 native binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_plan_path(int robot_handle, const char* request_json, char* out_json, + int out_len) { + (void)robot_handle; + (void)request_json; + (void)out_json; + (void)out_len; + return not_implemented("kdl_plan_path is pending KW-011 native binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_sample_trap(double length, const char* options_json, char* out_json, + int out_len) { + (void)length; + (void)options_json; + (void)out_json; + (void)out_len; + return not_implemented("kdl_sample_trap is pending KW-007 native binding"); +} + +EMSCRIPTEN_KEEPALIVE +int kdl_last_error(char* out_json, int out_len) { + return write_json(last_error, out_json, out_len); +} + +} diff --git a/kdl-wasm/web/src/grl/ast/ast.ts b/kdl-wasm/web/src/grl/ast/ast.ts new file mode 100644 index 0000000..51aa25b --- /dev/null +++ b/kdl-wasm/web/src/grl/ast/ast.ts @@ -0,0 +1,239 @@ +import type { GrlSourceRange, GrlToken } from "../lexer/index.js"; + +export type GrlAstNodeKind = + | "Program" + | "LanguageDeclaration" + | "ModuleDeclaration" + | "ImportDeclaration" + | "DataDeclaration" + | "TargetDeclaration" + | "PathDeclaration" + | "PathDefaultsBlock" + | "PathSourceBlock" + | "PathPoint" + | "PathEvent" + | "OperationDeclaration" + | "OperationProcessBlock" + | "OperationActionBlock" + | "ProcedureDeclaration" + | "FunctionDeclaration" + | "RawTopLevelDeclaration" + | "IdentifierExpression" + | "NumberLiteral" + | "StringLiteral" + | "BooleanLiteral" + | "ArrayExpression" + | "CallExpression" + | "ObjectExpression" + | "OffsetExpression"; + +export interface GrlAstNode { + kind: GrlAstNodeKind; + range: GrlSourceRange; +} + +export interface GrlLanguageDeclaration extends GrlAstNode { + kind: "LanguageDeclaration"; + language: "grl"; + version: string; +} + +export interface GrlImportDeclaration extends GrlAstNode { + kind: "ImportDeclaration"; + moduleName: string; +} + +export type GrlDeclarationStorage = "persistent" | "const" | "var"; + +export interface GrlDataDeclaration extends GrlAstNode { + kind: "DataDeclaration"; + storage: GrlDeclarationStorage; + typeName: string; + name: string; + initializer: GrlExpression; +} + +export interface GrlTargetDeclaration extends GrlAstNode { + kind: "TargetDeclaration"; + name: string; + target: GrlExpression; +} + +export interface GrlPathProperty { + key: string; + value: GrlExpression; + range: GrlSourceRange; +} + +export interface GrlPathDefaultsBlock extends GrlAstNode { + kind: "PathDefaultsBlock"; + properties: GrlPathProperty[]; +} + +export interface GrlPathSourceBlock extends GrlAstNode { + kind: "PathSourceBlock"; + properties: GrlPathProperty[]; +} + +export interface GrlPathPoint extends GrlAstNode { + kind: "PathPoint"; + id: string; + motionTokens: GrlToken[]; +} + +export interface GrlPathEvent extends GrlAstNode { + kind: "PathEvent"; + timing: "before" | "after" | "at"; + pointId: string; + distance?: GrlNumberLiteral; + actionTokens: GrlToken[]; +} + +export type GrlPathItem = + | GrlPathDefaultsBlock + | GrlPathSourceBlock + | GrlPathPoint + | GrlPathEvent; + +export interface GrlPathDeclaration extends GrlAstNode { + kind: "PathDeclaration"; + name: string; + items: GrlPathItem[]; +} + +export interface GrlOperationProcessBlock extends GrlAstNode { + kind: "OperationProcessBlock"; + properties: GrlPathProperty[]; +} + +export interface GrlOperationActionBlock extends GrlAstNode { + kind: "OperationActionBlock"; + actionKind: "start_action" | "end_action"; + actionTokens: GrlToken[]; +} + +export type GrlOperationItem = GrlOperationProcessBlock | GrlOperationActionBlock; + +export interface GrlOperationDeclaration extends GrlAstNode { + kind: "OperationDeclaration"; + name: string; + operationKind: string; + pathName: string; + items: GrlOperationItem[]; +} + +export interface GrlProcedureDeclaration extends GrlAstNode { + kind: "ProcedureDeclaration"; + name: string; + params: GrlToken[]; + bodyTokens: GrlToken[]; +} + +export interface GrlFunctionDeclaration extends GrlAstNode { + kind: "FunctionDeclaration"; + returnType: string; + name: string; + params: GrlToken[]; + bodyTokens: GrlToken[]; +} + +export interface GrlRawTopLevelDeclaration extends GrlAstNode { + kind: "RawTopLevelDeclaration"; + declarationType: string; + tokens: GrlToken[]; +} + +export type GrlTopLevelDeclaration = + | GrlImportDeclaration + | GrlDataDeclaration + | GrlTargetDeclaration + | GrlPathDeclaration + | GrlOperationDeclaration + | GrlProcedureDeclaration + | GrlFunctionDeclaration + | GrlRawTopLevelDeclaration; + +export interface GrlModuleDeclaration extends GrlAstNode { + kind: "ModuleDeclaration"; + name: string; + declarations: GrlTopLevelDeclaration[]; +} + +export interface GrlProgram extends GrlAstNode { + kind: "Program"; + language?: GrlLanguageDeclaration; + module: GrlModuleDeclaration; +} + +export interface GrlIdentifierExpression extends GrlAstNode { + kind: "IdentifierExpression"; + name: string; +} + +export interface GrlNumberLiteral extends GrlAstNode { + kind: "NumberLiteral"; + value: number; + raw: string; + unit?: { + raw: string; + kind: string; + siUnit: string; + normalizedValue: number; + }; +} + +export interface GrlStringLiteral extends GrlAstNode { + kind: "StringLiteral"; + value: string; +} + +export interface GrlBooleanLiteral extends GrlAstNode { + kind: "BooleanLiteral"; + value: boolean; +} + +export interface GrlArrayExpression extends GrlAstNode { + kind: "ArrayExpression"; + elements: GrlExpression[]; +} + +export interface GrlCallExpression extends GrlAstNode { + kind: "CallExpression"; + callee: string; + args: GrlExpression[]; +} + +export interface GrlObjectProperty { + key: string; + value: GrlExpression; + range: GrlSourceRange; +} + +export interface GrlObjectExpression extends GrlAstNode { + kind: "ObjectExpression"; + typeName: string; + properties: GrlObjectProperty[]; +} + +export interface GrlOffsetAxis { + axis: "x" | "y" | "z"; + value: GrlNumberLiteral; +} + +export interface GrlOffsetExpression extends GrlAstNode { + kind: "OffsetExpression"; + base: GrlExpression; + mode: "frame" | "tool"; + frameName?: string; + axes: GrlOffsetAxis[]; +} + +export type GrlExpression = + | GrlIdentifierExpression + | GrlNumberLiteral + | GrlStringLiteral + | GrlBooleanLiteral + | GrlArrayExpression + | GrlCallExpression + | GrlObjectExpression + | GrlOffsetExpression; diff --git a/kdl-wasm/web/src/grl/ast/index.ts b/kdl-wasm/web/src/grl/ast/index.ts new file mode 100644 index 0000000..1fb11b2 --- /dev/null +++ b/kdl-wasm/web/src/grl/ast/index.ts @@ -0,0 +1,37 @@ +export type { + GrlAstNode, + GrlAstNodeKind, + GrlArrayExpression, + GrlBooleanLiteral, + GrlCallExpression, + GrlDataDeclaration, + GrlDeclarationStorage, + GrlExpression, + GrlFunctionDeclaration, + GrlIdentifierExpression, + GrlImportDeclaration, + GrlLanguageDeclaration, + GrlModuleDeclaration, + GrlNumberLiteral, + GrlObjectExpression, + GrlObjectProperty, + GrlOffsetAxis, + GrlOffsetExpression, + GrlOperationActionBlock, + GrlOperationDeclaration, + GrlOperationItem, + GrlOperationProcessBlock, + GrlPathDeclaration, + GrlPathDefaultsBlock, + GrlPathEvent, + GrlPathItem, + GrlPathPoint, + GrlPathProperty, + GrlPathSourceBlock, + GrlProcedureDeclaration, + GrlProgram, + GrlRawTopLevelDeclaration, + GrlStringLiteral, + GrlTargetDeclaration, + GrlTopLevelDeclaration +} from "./ast.js"; diff --git a/kdl-wasm/web/src/grl/generator/generator.ts b/kdl-wasm/web/src/grl/generator/generator.ts new file mode 100644 index 0000000..62b3361 --- /dev/null +++ b/kdl-wasm/web/src/grl/generator/generator.ts @@ -0,0 +1,210 @@ +export type GrlGeneratorStyle = "expanded" | "compact"; + +export interface GeneratedTargetSpec { + name: string; + kind: "joint" | "pose"; + values: number[]; +} + +export interface GeneratedPathPointSpec { + id?: string; + motion: "movej" | "movel" | "movec"; + target: string; + via?: string; + speed?: string; + zone?: string; +} + +export interface GeneratedPathSpec { + name: string; + source?: Record; + defaults: { + speed: string; + zone: string; + }; + points: GeneratedPathPointSpec[]; +} + +export interface GeneratedOperationSpec { + name: string; + kind: string; + path: string; + startAction?: string; + endAction?: string; +} + +export interface GrlProgramGenerationSpec { + moduleName: string; + speeds?: Record; + zones?: Record; + targets: GeneratedTargetSpec[]; + path: GeneratedPathSpec; + operation: GeneratedOperationSpec; +} + +export interface GeneratedGrlProgram { + text: string; + stableIds: { + targets: string[]; + points: string[]; + path: string; + operation: string; + }; +} + +export function generateGrlProgram(spec: GrlProgramGenerationSpec, style: GrlGeneratorStyle = "expanded"): GeneratedGrlProgram { + const normalized = normalizeSpec(spec); + const text = style === "compact" ? renderCompact(normalized) : renderExpanded(normalized); + return { + text, + stableIds: { + targets: normalized.targets.map((target) => target.name), + points: normalized.path.points.map((point) => point.id!), + path: normalized.path.name, + operation: normalized.operation.name + } + }; +} + +function normalizeSpec(spec: GrlProgramGenerationSpec): GrlProgramGenerationSpec { + return { + ...spec, + speeds: sortRecord(spec.speeds ?? {}), + zones: sortRecord(spec.zones ?? {}), + targets: [...spec.targets].sort((left, right) => left.name.localeCompare(right.name)), + path: { + ...spec.path, + ...(spec.path.source ? { source: sortRecord(spec.path.source) } : {}), + points: spec.path.points.map((point, index) => ({ + ...point, + id: point.id ?? `p${String(index).padStart(2, "0")}` + })) + } + }; +} + +function renderExpanded(spec: GrlProgramGenerationSpec): string { + const lines: string[] = [`language grl 0.1`, `module ${spec.moduleName}`]; + for (const [name, expression] of Object.entries(spec.speeds ?? {})) { + lines.push(` const speed ${name} = ${expression}`); + } + for (const [name, expression] of Object.entries(spec.zones ?? {})) { + lines.push(` const zone ${name} = ${expression}`); + } + for (const target of spec.targets) { + lines.push(...renderTargetExpanded(target)); + } + lines.push(` path ${spec.path.name} {`); + if (spec.path.source && Object.keys(spec.path.source).length > 0) { + lines.push(` source {`); + for (const [key, value] of Object.entries(spec.path.source)) { + lines.push(` ${key}: ${formatSourceLiteral(key, value)}`); + } + lines.push(` }`); + } + lines.push(` defaults {`); + lines.push(` speed: ${spec.path.defaults.speed}`); + lines.push(` zone: ${spec.path.defaults.zone}`); + lines.push(` }`); + for (const point of spec.path.points) { + lines.push(` ${renderPoint(point)}`); + } + lines.push(` }`); + lines.push(...renderOperationExpanded(spec.operation)); + lines.push(` proc main()`); + lines.push(` run_operation ${spec.operation.name}`); + lines.push(` end`); + lines.push(`end`); + return lines.join("\n"); +} + +function renderCompact(spec: GrlProgramGenerationSpec): string { + const lines: string[] = [`language grl 0.1`, `module ${spec.moduleName}`]; + for (const [name, expression] of Object.entries(spec.speeds ?? {})) { + lines.push(` const speed ${name} = ${expression}`); + } + for (const [name, expression] of Object.entries(spec.zones ?? {})) { + lines.push(` const zone ${name} = ${expression}`); + } + for (const target of spec.targets) { + lines.push(` ${renderTargetCompact(target)}`); + } + const source = spec.path.source && Object.keys(spec.path.source).length > 0 + ? ` source { ${Object.entries(spec.path.source).map(([key, value]) => `${key}: ${formatSourceLiteral(key, value)}`).join(" ")} }` + : ""; + lines.push(` path ${spec.path.name} {${source} defaults { speed: ${spec.path.defaults.speed} zone: ${spec.path.defaults.zone} } ${spec.path.points.map(renderPoint).join(" ")} }`); + lines.push(` operation ${spec.operation.name} { kind: ${spec.operation.kind} path: ${spec.operation.path}${spec.operation.startAction ? ` start_action: ${spec.operation.startAction}` : ""}${spec.operation.endAction ? ` end_action: ${spec.operation.endAction}` : ""} }`); + lines.push(` proc main()`); + lines.push(` run_operation ${spec.operation.name}`); + lines.push(` end`); + lines.push(`end`); + return lines.join("\n"); +} + +function renderTargetExpanded(target: GeneratedTargetSpec): string[] { + if (target.kind === "joint") { + return [ + ` target ${target.name} = joint_target {`, + ` joints: [${target.values.map((value) => `${value} deg`).join(", ")}]`, + ` }` + ]; + } + return [ + ` target ${target.name} = pose_target {`, + ` pose: pose(${target.values.map((value, index) => `${value} ${index < 3 ? "mm" : "deg"}`).join(", ")})`, + ` }` + ]; +} + +function renderTargetCompact(target: GeneratedTargetSpec): string { + if (target.kind === "joint") { + return `target ${target.name} = joint_target { joints: [${target.values.map((value) => `${value} deg`).join(", ")}] }`; + } + return `target ${target.name} = pose_target { pose: pose(${target.values.map((value, index) => `${value} ${index < 3 ? "mm" : "deg"}`).join(", ")}) }`; +} + +function renderPoint(point: GeneratedPathPointSpec): string { + const params = [ + `point ${point.id} ${point.motion}`, + point.motion === "movec" ? `via ${point.via}` : undefined, + point.motion === "movec" ? `target ${point.target}` : point.target, + point.speed ? `speed ${point.speed}` : undefined, + point.zone ? `zone ${point.zone}` : undefined + ].filter(Boolean); + return params.join(" "); +} + +function renderOperationExpanded(operation: GeneratedOperationSpec): string[] { + const lines = [` operation ${operation.name} {`, ` kind: ${operation.kind}`, ` path: ${operation.path}`]; + if (operation.startAction) { + lines.push(` start_action:`); + lines.push(` ${operation.startAction}`); + } + if (operation.endAction) { + lines.push(` end_action:`); + lines.push(` ${operation.endAction}`); + } + lines.push(` }`); + return lines; +} + +function sortRecord(record: Record): Record { + return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right))); +} + +function formatLiteral(value: string | number | boolean): string { + if (typeof value === "string") { + return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) ? value : JSON.stringify(value); + } + return String(value); +} + +function formatSourceLiteral(key: string, value: string | number | boolean): string { + if (typeof value !== "string") { + return String(value); + } + if (key === "type" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) { + return value; + } + return JSON.stringify(value); +} diff --git a/kdl-wasm/web/src/grl/generator/index.ts b/kdl-wasm/web/src/grl/generator/index.ts new file mode 100644 index 0000000..577f3f7 --- /dev/null +++ b/kdl-wasm/web/src/grl/generator/index.ts @@ -0,0 +1,10 @@ +export { + generateGrlProgram, + type GeneratedGrlProgram, + type GeneratedOperationSpec, + type GeneratedPathPointSpec, + type GeneratedPathSpec, + type GeneratedTargetSpec, + type GrlGeneratorStyle, + type GrlProgramGenerationSpec +} from "./generator.js"; diff --git a/kdl-wasm/web/src/grl/ir/index.ts b/kdl-wasm/web/src/grl/ir/index.ts new file mode 100644 index 0000000..13c4bcf --- /dev/null +++ b/kdl-wasm/web/src/grl/ir/index.ts @@ -0,0 +1,61 @@ +export type { + CompiledMotionRequest, + CompiledOperation, + CompiledPath, + AlarmInstruction, + BreakInstruction, + CallInstruction, + CatchInstruction, + ContinueInstruction, + ControlExpression, + ControlFlowInstruction, + ExceptionFlowInstruction, + ExceptionInstruction, + ExecutableBranch, + ExecutableControlInstruction, + ExecutableForInstruction, + ExecutableIfInstruction, + ExecutableInstruction, + ExecutableProcedure, + ExecutableSwitchCase, + ExecutableSwitchInstruction, + ExecutableWhileInstruction, + FinallyInstruction, + ForInstruction, + FunctionSignature, + IfBranch, + IfInstruction, + IoDomain, + IoFlowInstruction, + IoReference, + IoWriteInstruction, + JumpInstruction, + KdlBridgeRequests, + LabelInstruction, + MotionInstruction, + MotionKind, + OperationActionInstruction, + OperationExecutionStep, + PathEventInstruction, + ProcedureFlowInstruction, + ProcedureSignature, + ProcFunctionAnalysis, + PulseInstruction, + RaiseInstruction, + RawProcedureStatement, + ReturnInstruction, + RoutineParameter, + RoutineParameterDirection, + SemanticProgramIr, + SemanticSourceMapEntry, + SemanticSymbol, + SemanticSymbolKind, + TryInstruction, + UnsupportedRuntimeInstruction, + RunOperationInstruction, + RunPathInstruction, + SwitchCaseInstruction, + SwitchInstruction, + WhileInstruction, + WaitInstruction +} from "./motion.js"; diff --git a/kdl-wasm/web/src/grl/ir/motion.ts b/kdl-wasm/web/src/grl/ir/motion.ts new file mode 100644 index 0000000..868b89f --- /dev/null +++ b/kdl-wasm/web/src/grl/ir/motion.ts @@ -0,0 +1,428 @@ +import type { + JointTarget, + MoveCRequest, + MoveJRequest, + MoveLRequest, + MotionDiagnostic, + MotionSourceMap, + PathEventRequest, + PathPlanRequest, + Pose, + PoseTarget, + SpeedSpec, + ZoneSpec +} from "../../kdl/types.js"; + +export type MotionKind = "MOVEJ" | "MOVEL" | "MOVEC"; + +export interface MotionInstruction { + id?: string; + kind: MotionKind; + target?: JointTarget | PoseTarget; + via?: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sourceMap?: MotionSourceMap; + pathId?: string; + pointId?: string; + source?: Record; +} + +export type CompiledMotionRequest = MoveJRequest | MoveLRequest | MoveCRequest; + +export interface PathEventInstruction { + id?: string; + timing: PathEventRequest["timing"]; + pointId: string; + distance?: number; + kind: string; + sourceMap?: MotionSourceMap; + data?: Record; +} + +export interface CompiledPath { + pathId: string; + request: PathPlanRequest; + motions: MotionInstruction[]; + events: PathEventInstruction[]; +} + +export interface RunPathInstruction { + kind: "RUN_PATH"; + pathId: string; + sourceMap?: MotionSourceMap; +} + +export interface OperationActionInstruction { + kind: "ACTION"; + actionKind: "start_action" | "end_action"; + operationId: string; + statement: string; + tokens?: unknown[]; + sourceMap?: MotionSourceMap; +} + +export interface CompiledOperation { + operationId: string; + kind: string; + pathId: string; + process: Record; + startActions: OperationActionInstruction[]; + endActions: OperationActionInstruction[]; +} + +export interface RunOperationInstruction { + kind: "RUN_OPERATION"; + operationId: string; + sourceMap?: MotionSourceMap; +} + +export type OperationExecutionStep = + | OperationActionInstruction + | RunPathInstruction; + +export type IoDomain = "di" | "do" | "ai" | "ao" | "gi" | "go" | "ri" | "ro" | "alias"; + +export interface IoReference { + domain: IoDomain; + index?: number; + alias?: string; + raw: string; +} + +export interface IoWriteInstruction { + kind: "IO_WRITE"; + target: IoReference; + value: boolean | number | string; + sourceMap?: MotionSourceMap; +} + +export interface WaitInstruction { + kind: "WAIT"; + condition: string; + timeout?: number; + onTimeout?: { + kind: "alarm" | "call"; + value: string; + }; + sourceMap?: MotionSourceMap; +} + +export interface PulseInstruction { + kind: "PULSE"; + target: IoReference; + duration: number; + trace: Array<{ + time: number; + action: "set" | "reset"; + target: IoReference; + value: boolean; + }>; + sourceMap?: MotionSourceMap; +} + +export type IoFlowInstruction = IoWriteInstruction | WaitInstruction | PulseInstruction; + +export interface ControlExpression { + text: string; + tokens?: unknown[]; + sourceMap?: MotionSourceMap; +} + +export interface RawProcedureStatement { + kind: "RAW_STATEMENT"; + text: string; + tokens?: unknown[]; + sourceMap?: MotionSourceMap; +} + +export interface IfBranch { + branchKind: "if" | "elseif" | "else"; + condition?: ControlExpression; + body: ProcedureFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface IfInstruction { + kind: "IF"; + branches: IfBranch[]; + sourceMap?: MotionSourceMap; +} + +export interface WhileInstruction { + kind: "WHILE"; + condition: ControlExpression; + body: ProcedureFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface ForInstruction { + kind: "FOR"; + iterator: string; + from: ControlExpression; + to: ControlExpression; + step?: ControlExpression; + body: ProcedureFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface SwitchCaseInstruction { + caseKind: "case" | "default"; + value?: string | number | boolean; + raw?: string; + body: ProcedureFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface SwitchInstruction { + kind: "SWITCH"; + expression: ControlExpression; + cases: SwitchCaseInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface BreakInstruction { + kind: "BREAK"; + sourceMap?: MotionSourceMap; +} + +export interface ContinueInstruction { + kind: "CONTINUE"; + sourceMap?: MotionSourceMap; +} + +export interface LabelInstruction { + kind: "LABEL"; + name: string; + scopePath: string[]; + sourceMap?: MotionSourceMap; +} + +export interface JumpInstruction { + kind: "JUMP"; + label: string; + scopePath: string[]; + sourceMap?: MotionSourceMap; +} + +export type ControlFlowInstruction = + | IfInstruction + | WhileInstruction + | ForInstruction + | SwitchInstruction + | BreakInstruction + | ContinueInstruction + | LabelInstruction + | JumpInstruction; + +export type ProcedureFlowInstruction = ControlFlowInstruction | RawProcedureStatement; + +export type RoutineParameterDirection = "in" | "out" | "inout"; + +export interface RoutineParameter { + name: string; + typeName: string; + direction: RoutineParameterDirection; + sourceMap?: MotionSourceMap; +} + +export interface ProcedureSignature { + kind: "PROC_SIGNATURE"; + name: string; + parameters: RoutineParameter[]; + sourceMap?: MotionSourceMap; +} + +export interface FunctionSignature { + kind: "FUNC_SIGNATURE"; + name: string; + returnType: string; + parameters: RoutineParameter[]; + sourceMap?: MotionSourceMap; +} + +export interface CallInstruction { + kind: "CALL"; + target: string; + args: ControlExpression[]; + sourceMap?: MotionSourceMap; +} + +export interface ReturnInstruction { + kind: "RETURN"; + value?: ControlExpression; + sourceMap?: MotionSourceMap; +} + +export interface ProcFunctionAnalysis { + procedures: ProcedureSignature[]; + functions: FunctionSignature[]; + calls: CallInstruction[]; + returns: ReturnInstruction[]; + diagnostics: MotionDiagnostic[]; +} + +export interface AlarmInstruction { + kind: "ALARM"; + alarmId: string; + message?: string; + severity?: string; + sourceMap?: MotionSourceMap; +} + +export interface RaiseInstruction { + kind: "RAISE"; + alarmId: string; + sourceMap?: MotionSourceMap; +} + +export interface CatchInstruction { + alarmId?: string; + body: ExceptionFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface FinallyInstruction { + body: ExceptionFlowInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface TryInstruction { + kind: "TRY"; + body: ExceptionFlowInstruction[]; + catches: CatchInstruction[]; + finally?: FinallyInstruction; + sourceMap?: MotionSourceMap; +} + +export interface UnsupportedRuntimeInstruction { + kind: "UNSUPPORTED_RUNTIME"; + feature: "trap" | "interrupt" | "task"; + message: string; + sourceMap?: MotionSourceMap; +} + +export type ExceptionInstruction = + | AlarmInstruction + | RaiseInstruction + | TryInstruction + | UnsupportedRuntimeInstruction; + +export type ExceptionFlowInstruction = ExceptionInstruction | RawProcedureStatement; + +export type SemanticSymbolKind = + | "data" + | "target" + | "path" + | "operation" + | "procedure" + | "function" + | "raw"; + +export interface SemanticSymbol { + kind: SemanticSymbolKind; + name: string; + typeName?: string; + sourceMap?: MotionSourceMap; +} + +export interface SemanticSourceMapEntry { + kind: string; + id: string; + sourceMap: MotionSourceMap; + pathId?: string; + pointId?: string; + operationId?: string; + procedureId?: string; +} + +export interface ExecutableBranch { + branchKind: "if" | "elseif" | "else"; + condition?: ControlExpression; + body: ExecutableInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface ExecutableIfInstruction { + kind: "EXEC_IF"; + branches: ExecutableBranch[]; + sourceMap?: MotionSourceMap; +} + +export interface ExecutableWhileInstruction { + kind: "EXEC_WHILE"; + condition: ControlExpression; + body: ExecutableInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface ExecutableForInstruction { + kind: "EXEC_FOR"; + iterator: string; + from: ControlExpression; + to: ControlExpression; + step?: ControlExpression; + body: ExecutableInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface ExecutableSwitchCase { + caseKind: "case" | "default"; + value?: string | number | boolean; + raw?: string; + body: ExecutableInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface ExecutableSwitchInstruction { + kind: "EXEC_SWITCH"; + expression: ControlExpression; + cases: ExecutableSwitchCase[]; + sourceMap?: MotionSourceMap; +} + +export type ExecutableControlInstruction = + | ExecutableIfInstruction + | ExecutableWhileInstruction + | ExecutableForInstruction + | ExecutableSwitchInstruction; + +export type ExecutableInstruction = + | MotionInstruction + | IoFlowInstruction + | RunPathInstruction + | RunOperationInstruction + | CallInstruction + | ReturnInstruction + | BreakInstruction + | ContinueInstruction + | AlarmInstruction + | RaiseInstruction + | UnsupportedRuntimeInstruction + | ExecutableControlInstruction + | RawProcedureStatement; + +export interface ExecutableProcedure { + name: string; + instructions: ExecutableInstruction[]; + sourceMap?: MotionSourceMap; +} + +export interface KdlBridgeRequests { + motionRequests: CompiledMotionRequest[]; + pathRequests: PathPlanRequest[]; +} + +export interface SemanticProgramIr { + moduleName: string; + symbols: SemanticSymbol[]; + semanticChecks: string[]; + procedures: ExecutableProcedure[]; + paths: CompiledPath[]; + operations: CompiledOperation[]; + diagnostics: MotionDiagnostic[]; + sourceMap: SemanticSourceMapEntry[]; + kdlBridge: KdlBridgeRequests; +} diff --git a/kdl-wasm/web/src/grl/lexer/index.ts b/kdl-wasm/web/src/grl/lexer/index.ts new file mode 100644 index 0000000..a269527 --- /dev/null +++ b/kdl-wasm/web/src/grl/lexer/index.ts @@ -0,0 +1,15 @@ +export { GRL_KEYWORDS, isGrlKeyword, type GrlKeyword } from "./keywords.js"; +export { lexGrl, type GrlLexerOptions } from "./lexer.js"; +export { isGrlUnitLiteral, normalizeUnitLiteral, normalizeUnitValue, type UnitKind } from "./units.js"; +export type { + GrlCommentToken, + GrlEofToken, + GrlIdentifierToken, + GrlKeywordToken, + GrlNumberToken, + GrlSourcePosition, + GrlSourceRange, + GrlStringToken, + GrlToken, + GrlTokenKind +} from "./tokens.js"; diff --git a/kdl-wasm/web/src/grl/lexer/keywords.ts b/kdl-wasm/web/src/grl/lexer/keywords.ts new file mode 100644 index 0000000..1bfd4b8 --- /dev/null +++ b/kdl-wasm/web/src/grl/lexer/keywords.ts @@ -0,0 +1,95 @@ +export const GRL_KEYWORDS = [ + "language", + "module", + "import", + "end", + "persistent", + "const", + "var", + "robot", + "tool", + "frame", + "load", + "target", + "speed", + "zone", + "path", + "operation", + "process", + "proc", + "func", + "return", + "call", + "if", + "elseif", + "else", + "switch", + "case", + "default", + "while", + "for", + "to", + "step", + "break", + "continue", + "label", + "jump", + "movej", + "movel", + "movec", + "run_path", + "run_operation", + "set_tool", + "set_frame", + "set_speed", + "set_zone", + "wait", + "pulse", + "timer", + "io", + "true", + "false", + "all", + "any", + "rising", + "falling", + "changed", + "trap", + "interrupt", + "enable", + "disable", + "raise", + "alarm", + "try", + "catch", + "finally", + "task", + "sync", + "post_hint", + "source", + "defaults", + "point", + "event", + "before", + "after", + "at", + "joint_target", + "pose_target", + "pose", + "poseq", + "joints", + "robot_config", + "ext_axis", + "fine", + "continuous", + "cnt", + "z" +] as const; + +export type GrlKeyword = (typeof GRL_KEYWORDS)[number]; + +const KEYWORD_SET = new Set(GRL_KEYWORDS); + +export function isGrlKeyword(value: string): value is GrlKeyword { + return KEYWORD_SET.has(value); +} diff --git a/kdl-wasm/web/src/grl/lexer/lexer.ts b/kdl-wasm/web/src/grl/lexer/lexer.ts new file mode 100644 index 0000000..f119b10 --- /dev/null +++ b/kdl-wasm/web/src/grl/lexer/lexer.ts @@ -0,0 +1,429 @@ +import { isGrlKeyword } from "./keywords.js"; +import { isGrlUnitLiteral, normalizeUnitLiteral } from "./units.js"; +import type { + GrlCommentToken, + GrlEofToken, + GrlIdentifierToken, + GrlKeywordToken, + GrlNumberToken, + GrlOperatorToken, + GrlPunctuationToken, + GrlSourcePosition, + GrlToken +} from "./tokens.js"; + +export interface GrlLexerOptions { + preserveComments?: boolean; +} + +interface ScannerState { + index: number; + line: number; + column: number; +} + +const TWO_CHAR_OPERATORS = new Set(["==", "!=", "<=", ">=", "&&", "||", "->", ":="]); +const PUNCTUATION = new Set(["(", ")", "{", "}", "[", "]", ",", ":", ";", "."]); +const OPERATORS = new Set(["+", "-", "*", "/", "=", "<", ">", "!"]); + +export function lexGrl(source: string, options: GrlLexerOptions = {}): GrlToken[] { + const scanner = new GrlScanner(source, options); + return scanner.scanTokens(); +} + +class GrlScanner { + private index = 0; + private line = 1; + private column = 1; + private readonly tokens: GrlToken[] = []; + private readonly preserveComments: boolean; + + constructor( + private readonly source: string, + options: GrlLexerOptions + ) { + this.preserveComments = options.preserveComments ?? true; + } + + scanTokens(): GrlToken[] { + while (!this.isAtEnd()) { + const char = this.peek(); + + if (this.isWhitespace(char)) { + this.advance(); + continue; + } + + if (char === "/" && this.peek(1) === "/") { + this.scanLineComment(); + continue; + } + + if (char === "/" && this.peek(1) === "*") { + this.scanBlockComment(); + continue; + } + + if (char === "\"") { + this.scanString(); + continue; + } + + if (this.isIdentifierStart(char)) { + this.scanIdentifierOrKeyword(); + continue; + } + + if (this.isNumberStart(char)) { + this.scanNumber(); + continue; + } + + this.scanPunctuationOrOperator(); + } + + const start = this.position(); + const token: GrlEofToken = { + kind: "eof", + raw: "", + value: "", + range: { start, end: start } + }; + this.tokens.push(token); + return this.tokens; + } + + private scanLineComment(): void { + const start = this.position(); + this.advance(); + this.advance(); + + const contentStart = this.index; + while (!this.isAtEnd() && this.peek() !== "\n") { + this.advance(); + } + + if (this.preserveComments) { + const value = this.source.slice(contentStart, this.index); + const token: GrlCommentToken = { + kind: "comment", + style: "line", + raw: this.source.slice(start.offset, this.index), + value, + range: { start, end: this.position() } + }; + this.tokens.push(token); + } + } + + private scanBlockComment(): void { + const start = this.position(); + this.advance(); + this.advance(); + + const contentStart = this.index; + while (!this.isAtEnd()) { + if (this.peek() === "*" && this.peek(1) === "/") { + const value = this.source.slice(contentStart, this.index); + this.advance(); + this.advance(); + + if (this.preserveComments) { + const token: GrlCommentToken = { + kind: "comment", + style: "block", + raw: this.source.slice(start.offset, this.index), + value, + range: { start, end: this.position() } + }; + this.tokens.push(token); + } + return; + } + + this.advance(); + } + + throw this.error(start, "Unterminated block comment"); + } + + private scanString(): void { + const start = this.position(); + this.advance(); + let value = ""; + + while (!this.isAtEnd()) { + const char = this.peek(); + if (char === "\"") { + this.advance(); + const token: GrlToken = { + kind: "string", + raw: this.source.slice(start.offset, this.index), + value, + range: { start, end: this.position() } + }; + this.tokens.push(token); + return; + } + + if (char === "\\") { + this.advance(); + value += this.readEscapedCharacter(start); + continue; + } + + value += this.advance(); + } + + throw this.error(start, "Unterminated string literal"); + } + + private readEscapedCharacter(start: GrlSourcePosition): string { + if (this.isAtEnd()) { + throw this.error(start, "Unterminated string escape"); + } + + const escaped = this.advance(); + switch (escaped) { + case "n": + return "\n"; + case "r": + return "\r"; + case "t": + return "\t"; + case "\\": + case "\"": + return escaped; + default: + return escaped; + } + } + + private scanIdentifierOrKeyword(): void { + const start = this.position(); + + while (!this.isAtEnd() && this.isIdentifierPart(this.peek())) { + this.advance(); + } + + const raw = this.source.slice(start.offset, this.index); + if (isGrlKeyword(raw)) { + const token: GrlKeywordToken = { + kind: "keyword", + raw, + value: raw, + range: { start, end: this.position() } + }; + this.tokens.push(token); + return; + } + + const token: GrlIdentifierToken = { + kind: "identifier", + raw, + value: raw, + range: { start, end: this.position() } + }; + this.tokens.push(token); + } + + private scanNumber(): void { + const start = this.position(); + + if (this.peek() === ".") { + this.advance(); + } + + while (!this.isAtEnd() && this.isDigit(this.peek())) { + this.advance(); + } + + if (this.peek() === "." && this.isDigit(this.peek(1))) { + this.advance(); + while (!this.isAtEnd() && this.isDigit(this.peek())) { + this.advance(); + } + } + + if ((this.peek() === "e" || this.peek() === "E") && this.isExponentStart()) { + this.advance(); + if (this.peek() === "+" || this.peek() === "-") { + this.advance(); + } + while (!this.isAtEnd() && this.isDigit(this.peek())) { + this.advance(); + } + } + + const numericEnd = this.position(); + const numericRaw = this.source.slice(start.offset, numericEnd.offset); + const value = Number(numericRaw); + if (!Number.isFinite(value)) { + throw this.error(start, `Invalid number literal: ${numericRaw}`); + } + + const unit = this.tryScanUnitAfterNumber(); + const token: GrlNumberToken = { + kind: "number", + raw: this.source.slice(start.offset, this.index), + value, + range: { start, end: this.position() }, + ...(unit + ? { + unit: { + raw: unit.literal, + kind: unit.kind, + siUnit: unit.siUnit, + normalizedValue: value * unit.factor + } + } + : {}) + }; + this.tokens.push(token); + } + + private tryScanUnitAfterNumber(): ReturnType | undefined { + const state = this.save(); + + while (!this.isAtEnd() && (this.peek() === " " || this.peek() === "\t")) { + this.advance(); + } + + const unitStart = this.index; + + if (this.peek() === "%") { + this.advance(); + } else { + while (!this.isAtEnd() && /[A-Za-z0-9/^]/.test(this.peek())) { + this.advance(); + } + } + + const literal = this.source.slice(unitStart, this.index); + if (!literal || !isGrlUnitLiteral(literal)) { + this.restore(state); + return undefined; + } + + return normalizeUnitLiteral(literal); + } + + private scanPunctuationOrOperator(): void { + const start = this.position(); + const two = `${this.peek()}${this.peek(1)}`; + + if (TWO_CHAR_OPERATORS.has(two)) { + this.advance(); + this.advance(); + const token: GrlOperatorToken = { + kind: "operator", + raw: two, + value: two, + range: { start, end: this.position() } + }; + this.tokens.push(token); + return; + } + + const char = this.advance(); + if (PUNCTUATION.has(char)) { + const token: GrlPunctuationToken = { + kind: "punctuation", + raw: char, + value: char, + range: { start, end: this.position() } + }; + this.tokens.push(token); + return; + } + + if (OPERATORS.has(char)) { + const token: GrlOperatorToken = { + kind: "operator", + raw: char, + value: char, + range: { start, end: this.position() } + }; + this.tokens.push(token); + return; + } + + throw this.error(start, `Unexpected character: ${char}`); + } + + private isExponentStart(): boolean { + const next = this.peek(1); + if (this.isDigit(next)) { + return true; + } + return (next === "+" || next === "-") && this.isDigit(this.peek(2)); + } + + private isNumberStart(char: string): boolean { + return this.isDigit(char) || (char === "." && this.isDigit(this.peek(1))); + } + + private isIdentifierStart(char: string): boolean { + return /[A-Za-z_]/.test(char); + } + + private isIdentifierPart(char: string): boolean { + return /[A-Za-z0-9_]/.test(char); + } + + private isDigit(char: string): boolean { + return /[0-9]/.test(char); + } + + private isWhitespace(char: string): boolean { + return char === " " || char === "\t" || char === "\r" || char === "\n"; + } + + private advance(): string { + const char = this.source[this.index] ?? ""; + this.index += 1; + + if (char === "\n") { + this.line += 1; + this.column = 1; + } else { + this.column += 1; + } + + return char; + } + + private peek(distance = 0): string { + return this.source[this.index + distance] ?? ""; + } + + private isAtEnd(): boolean { + return this.index >= this.source.length; + } + + private position(): GrlSourcePosition { + return { + offset: this.index, + line: this.line, + column: this.column + }; + } + + private save(): ScannerState { + return { + index: this.index, + line: this.line, + column: this.column + }; + } + + private restore(state: ScannerState): void { + this.index = state.index; + this.line = state.line; + this.column = state.column; + } + + private error(position: GrlSourcePosition, message: string): Error { + return new Error(`${message} at ${position.line}:${position.column}`); + } +} diff --git a/kdl-wasm/web/src/grl/lexer/tokens.ts b/kdl-wasm/web/src/grl/lexer/tokens.ts new file mode 100644 index 0000000..30179fb --- /dev/null +++ b/kdl-wasm/web/src/grl/lexer/tokens.ts @@ -0,0 +1,86 @@ +import type { GrlKeyword } from "./keywords.js"; +import type { UnitKind } from "./units.js"; + +export type GrlTokenKind = + | "keyword" + | "identifier" + | "number" + | "string" + | "comment" + | "punctuation" + | "operator" + | "eof"; + +export interface GrlSourcePosition { + offset: number; + line: number; + column: number; +} + +export interface GrlSourceRange { + start: GrlSourcePosition; + end: GrlSourcePosition; +} + +export interface GrlBaseToken { + kind: GrlTokenKind; + raw: string; + range: GrlSourceRange; +} + +export interface GrlKeywordToken extends GrlBaseToken { + kind: "keyword"; + value: GrlKeyword; +} + +export interface GrlIdentifierToken extends GrlBaseToken { + kind: "identifier"; + value: string; +} + +export interface GrlNumberToken extends GrlBaseToken { + kind: "number"; + value: number; + unit?: { + raw: string; + kind: UnitKind; + siUnit: string; + normalizedValue: number; + }; +} + +export interface GrlStringToken extends GrlBaseToken { + kind: "string"; + value: string; +} + +export interface GrlCommentToken extends GrlBaseToken { + kind: "comment"; + style: "line" | "block"; + value: string; +} + +export interface GrlPunctuationToken extends GrlBaseToken { + kind: "punctuation"; + value: string; +} + +export interface GrlOperatorToken extends GrlBaseToken { + kind: "operator"; + value: string; +} + +export interface GrlEofToken extends GrlBaseToken { + kind: "eof"; + value: ""; +} + +export type GrlToken = + | GrlKeywordToken + | GrlIdentifierToken + | GrlNumberToken + | GrlStringToken + | GrlCommentToken + | GrlPunctuationToken + | GrlOperatorToken + | GrlEofToken; diff --git a/kdl-wasm/web/src/grl/lexer/units.ts b/kdl-wasm/web/src/grl/lexer/units.ts new file mode 100644 index 0000000..b93b6a1 --- /dev/null +++ b/kdl-wasm/web/src/grl/lexer/units.ts @@ -0,0 +1,59 @@ +export type UnitKind = + | "length" + | "angle" + | "time" + | "mass" + | "linear_velocity" + | "angular_velocity" + | "linear_acceleration" + | "angular_acceleration" + | "percent"; + +export interface UnitDefinition { + literal: string; + kind: UnitKind; + siUnit: string; + factor: number; +} + +const UNIT_DEFINITIONS: UnitDefinition[] = [ + { literal: "m", kind: "length", siUnit: "m", factor: 1 }, + { literal: "mm", kind: "length", siUnit: "m", factor: 0.001 }, + { literal: "rad", kind: "angle", siUnit: "rad", factor: 1 }, + { literal: "deg", kind: "angle", siUnit: "rad", factor: Math.PI / 180 }, + { literal: "s", kind: "time", siUnit: "s", factor: 1 }, + { literal: "ms", kind: "time", siUnit: "s", factor: 0.001 }, + { literal: "kg", kind: "mass", siUnit: "kg", factor: 1 }, + { literal: "m/s", kind: "linear_velocity", siUnit: "m/s", factor: 1 }, + { literal: "mm/s", kind: "linear_velocity", siUnit: "m/s", factor: 0.001 }, + { literal: "rad/s", kind: "angular_velocity", siUnit: "rad/s", factor: 1 }, + { literal: "deg/s", kind: "angular_velocity", siUnit: "rad/s", factor: Math.PI / 180 }, + { literal: "m/s2", kind: "linear_acceleration", siUnit: "m/s2", factor: 1 }, + { literal: "m/s^2", kind: "linear_acceleration", siUnit: "m/s2", factor: 1 }, + { literal: "mm/s2", kind: "linear_acceleration", siUnit: "m/s2", factor: 0.001 }, + { literal: "mm/s^2", kind: "linear_acceleration", siUnit: "m/s2", factor: 0.001 }, + { literal: "rad/s2", kind: "angular_acceleration", siUnit: "rad/s2", factor: 1 }, + { literal: "rad/s^2", kind: "angular_acceleration", siUnit: "rad/s2", factor: 1 }, + { literal: "deg/s2", kind: "angular_acceleration", siUnit: "rad/s2", factor: Math.PI / 180 }, + { literal: "deg/s^2", kind: "angular_acceleration", siUnit: "rad/s2", factor: Math.PI / 180 }, + { literal: "%", kind: "percent", siUnit: "ratio", factor: 0.01 } +]; + +const UNITS = new Map(UNIT_DEFINITIONS.map((definition) => [definition.literal, definition])); + +export function normalizeUnitLiteral(literal: string): UnitDefinition { + const definition = UNITS.get(literal); + if (!definition) { + throw new Error(`Unknown GRL unit: ${literal}`); + } + return definition; +} + +export function isGrlUnitLiteral(literal: string): boolean { + return UNITS.has(literal); +} + +export function normalizeUnitValue(value: number, unitLiteral: string): number { + const unit = normalizeUnitLiteral(unitLiteral); + return value * unit.factor; +} diff --git a/kdl-wasm/web/src/grl/parser/errors.ts b/kdl-wasm/web/src/grl/parser/errors.ts new file mode 100644 index 0000000..9af2210 --- /dev/null +++ b/kdl-wasm/web/src/grl/parser/errors.ts @@ -0,0 +1,11 @@ +import type { GrlToken } from "../lexer/index.js"; + +export class GrlParseError extends Error { + constructor( + message: string, + readonly token: GrlToken + ) { + super(`${message} at ${token.range.start.line}:${token.range.start.column}`); + this.name = "GrlParseError"; + } +} diff --git a/kdl-wasm/web/src/grl/parser/expressionParser.ts b/kdl-wasm/web/src/grl/parser/expressionParser.ts new file mode 100644 index 0000000..be796fd --- /dev/null +++ b/kdl-wasm/web/src/grl/parser/expressionParser.ts @@ -0,0 +1,351 @@ +import type { + GrlArrayExpression, + GrlBooleanLiteral, + GrlCallExpression, + GrlExpression, + GrlIdentifierExpression, + GrlNumberLiteral, + GrlObjectExpression, + GrlObjectProperty, + GrlOffsetAxis, + GrlOffsetExpression, + GrlStringLiteral +} from "../ast/index.js"; +import type { GrlToken } from "../lexer/index.js"; +import { GrlParseError } from "./errors.js"; + +export function parseGrlExpression(tokens: GrlToken[]): GrlExpression { + const parser = new GrlExpressionParser(tokens); + return parser.parse(); +} + +class GrlExpressionParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parse(): GrlExpression { + const expression = this.parseOffsetExpression(); + if (!this.isAtEnd()) { + throw new GrlParseError("Unexpected token after expression", this.peek()); + } + return expression; + } + + private parseOffsetExpression(): GrlExpression { + const base = this.parsePrimary(); + if (this.matchKeyword("offset")) { + return this.finishOffsetExpression(base, "frame"); + } + if (this.matchKeyword("offset_in")) { + if (this.matchKeyword("tool")) { + return this.finishOffsetExpression(base, "tool"); + } + this.consumeKeyword("frame", "Expected tool or frame after offset_in"); + const frameName = this.consumeIdentifierLike("Expected frame name after offset_in frame"); + return this.finishOffsetExpression(base, "frame", frameName.raw); + } + return base; + } + + private finishOffsetExpression( + base: GrlExpression, + mode: "frame" | "tool", + frameName?: string + ): GrlOffsetExpression { + const axes: GrlOffsetAxis[] = []; + while (!this.isAtEnd()) { + const axis = this.consumeAxis(); + const valueExpression = this.parsePrimary(); + if (valueExpression.kind !== "NumberLiteral") { + throw new GrlParseError(`Expected length value after offset ${axis}`, valueExpression.range ? this.previous() : this.peek()); + } + const value = valueExpression; + axes.push({ axis, value }); + } + + if (axes.length === 0) { + throw new GrlParseError("Expected at least one offset axis", this.peek()); + } + + return { + kind: "OffsetExpression", + base, + mode, + ...(frameName ? { frameName } : {}), + axes, + range: { + start: base.range.start, + end: axes.at(-1)?.value.range.end ?? base.range.end + } + }; + } + + private parsePrimary(): GrlExpression { + const token = this.peek(); + + if (token.kind === "operator" && token.raw === "-") { + return this.parseNegativeNumber(); + } + + if (token.kind === "number") { + this.advance(); + return numberLiteralFromToken(token); + } + + if (token.kind === "string") { + this.advance(); + const literal: GrlStringLiteral = { + kind: "StringLiteral", + value: token.value, + range: token.range + }; + return literal; + } + + if (token.kind === "keyword" && (token.raw === "true" || token.raw === "false")) { + this.advance(); + const literal: GrlBooleanLiteral = { + kind: "BooleanLiteral", + value: token.raw === "true", + range: token.range + }; + return literal; + } + + if (token.kind === "punctuation" && token.raw === "[") { + return this.parseArrayExpression(); + } + + if (token.kind === "punctuation" && token.raw === "(") { + this.advance(); + const expression = this.parseOffsetExpression(); + this.consumePunctuation(")", "Expected ) after expression"); + return expression; + } + + if (token.kind === "identifier" || token.kind === "keyword") { + const name = this.advance(); + if (this.matchPunctuation("(")) { + return this.finishCallExpression(name); + } + if (this.matchPunctuation("{")) { + return this.finishObjectExpression(name); + } + const expression: GrlIdentifierExpression = { + kind: "IdentifierExpression", + name: name.raw, + range: name.range + }; + return expression; + } + + throw new GrlParseError("Expected expression", token); + } + + private parseArrayExpression(): GrlArrayExpression { + const start = this.consumePunctuation("[", "Expected ["); + const elements: GrlExpression[] = []; + while (!this.checkPunctuation("]") && !this.isAtEnd()) { + elements.push(this.parseOffsetExpression()); + this.matchPunctuation(","); + } + const end = this.consumePunctuation("]", "Expected ] after array expression"); + + return { + kind: "ArrayExpression", + elements, + range: { + start: start.range.start, + end: end.range.end + } + }; + } + + private parseNegativeNumber(): GrlNumberLiteral { + const minus = this.advance(); + const number = this.consumeNumberLiteral("Expected number after -"); + return { + ...number, + value: -number.value, + raw: `${minus.raw}${number.raw}`, + ...(number.unit + ? { + unit: { + ...number.unit, + normalizedValue: -number.unit.normalizedValue + } + } + : {}), + range: { + start: minus.range.start, + end: number.range.end + } + }; + } + + private finishCallExpression(callee: GrlToken): GrlCallExpression { + const args: GrlExpression[] = []; + while (!this.checkPunctuation(")") && !this.isAtEnd()) { + args.push(this.parseOffsetExpression()); + this.matchPunctuation(","); + } + const end = this.consumePunctuation(")", "Expected ) after call expression"); + + return { + kind: "CallExpression", + callee: callee.raw, + args, + range: { + start: callee.range.start, + end: end.range.end + } + }; + } + + private finishObjectExpression(typeName: GrlToken): GrlObjectExpression { + const properties: GrlObjectProperty[] = []; + while (!this.checkPunctuation("}") && !this.isAtEnd()) { + const key = this.consumeIdentifierLike("Expected object property name"); + this.consumePunctuation(":", "Expected : after object property name"); + const value = this.parseOffsetExpression(); + properties.push({ + key: key.raw, + value, + range: { + start: key.range.start, + end: value.range.end + } + }); + this.matchPunctuation(","); + } + const end = this.consumePunctuation("}", "Expected } after object expression"); + + return { + kind: "ObjectExpression", + typeName: typeName.raw, + properties, + range: { + start: typeName.range.start, + end: end.range.end + } + }; + } + + private consumeAxis(): "x" | "y" | "z" { + const token = this.consumeIdentifierLike("Expected offset axis"); + if (token.raw === "x" || token.raw === "y" || token.raw === "z") { + return token.raw; + } + throw new GrlParseError("Expected offset axis x, y, or z", token); + } + + private consumeNumberLiteral(message: string): GrlNumberLiteral { + const token = this.consume("number", message); + if (token.kind !== "number") { + throw new GrlParseError(message, token); + } + return numberLiteralFromToken(token); + } + + private consumeIdentifierLike(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw new GrlParseError(message, token); + } + + private consume(kind: GrlToken["kind"], message: string): GrlToken { + if (this.check(kind)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private consumeKeyword(keyword: string, message: string): GrlToken { + if (this.checkKeyword(keyword)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private consumePunctuation(value: string, message: string): GrlToken { + if (this.checkPunctuation(value)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private matchKeyword(keyword: string): boolean { + if (this.checkKeyword(keyword)) { + this.advance(); + return true; + } + return false; + } + + private matchPunctuation(value: string): boolean { + if (this.checkPunctuation(value)) { + this.advance(); + return true; + } + return false; + } + + private check(kind: GrlToken["kind"]): boolean { + return !this.isAtEnd() && this.peek().kind === kind; + } + + private checkKeyword(keyword: string): boolean { + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword; + } + + private checkPunctuation(value: string): boolean { + const token = this.peek(); + return token.kind === "punctuation" && token.raw === value; + } + + private advance(): GrlToken { + if (!this.isAtEnd()) { + this.current += 1; + } + return this.previous(); + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } + + private peek(): GrlToken { + return this.tokens[this.current] ?? this.tokens[this.tokens.length - 1]!; + } + + private previous(): GrlToken { + return this.tokens[this.current - 1] ?? this.tokens[0]!; + } +} + +function numberLiteralFromToken(token: GrlToken): GrlNumberLiteral { + if (token.kind !== "number") { + throw new GrlParseError("Expected number literal", token); + } + + return { + kind: "NumberLiteral", + value: token.value, + raw: token.raw, + ...(token.unit + ? { + unit: { + raw: token.unit.raw, + kind: token.unit.kind, + siUnit: token.unit.siUnit, + normalizedValue: token.unit.normalizedValue + } + } + : {}), + range: token.range + }; +} diff --git a/kdl-wasm/web/src/grl/parser/index.ts b/kdl-wasm/web/src/grl/parser/index.ts new file mode 100644 index 0000000..82a8e2b --- /dev/null +++ b/kdl-wasm/web/src/grl/parser/index.ts @@ -0,0 +1,3 @@ +export { GrlParseError } from "./errors.js"; +export { parseGrl } from "./parser.js"; +export { parseGrlExpression } from "./expressionParser.js"; diff --git a/kdl-wasm/web/src/grl/parser/parser.ts b/kdl-wasm/web/src/grl/parser/parser.ts new file mode 100644 index 0000000..2d5023b --- /dev/null +++ b/kdl-wasm/web/src/grl/parser/parser.ts @@ -0,0 +1,859 @@ +import { lexGrl, type GrlToken } from "../lexer/index.js"; +import type { + GrlDataDeclaration, + GrlDeclarationStorage, + GrlFunctionDeclaration, + GrlImportDeclaration, + GrlLanguageDeclaration, + GrlModuleDeclaration, + GrlOperationActionBlock, + GrlOperationDeclaration, + GrlOperationItem, + GrlOperationProcessBlock, + GrlPathDeclaration, + GrlPathDefaultsBlock, + GrlPathEvent, + GrlPathItem, + GrlPathPoint, + GrlPathProperty, + GrlPathSourceBlock, + GrlProcedureDeclaration, + GrlProgram, + GrlRawTopLevelDeclaration, + GrlTargetDeclaration, + GrlTopLevelDeclaration +} from "../ast/index.js"; +import { GrlParseError } from "./errors.js"; +import { parseGrlExpression } from "./expressionParser.js"; + +const RAW_TOP_LEVEL_KEYWORDS = new Set([ + "trap", + "task", + "post_hint" +]); + +export function parseGrl(source: string): GrlProgram { + const tokens = lexGrl(source).filter((token) => token.kind !== "comment"); + return new GrlParser(tokens).parseProgram(); +} + +class GrlParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parseProgram(): GrlProgram { + const first = this.peek(); + const language = this.matchKeyword("language") ? this.finishLanguageDeclaration(this.previous()) : undefined; + const module = this.parseModuleDeclaration(); + const eof = this.consume("eof", "Expected end of file after module declaration"); + + return { + kind: "Program", + ...(language ? { language } : {}), + module, + range: { + start: (language?.range ?? module.range).start, + end: eof.range.end + } + }; + } + + private finishLanguageDeclaration(languageToken: GrlToken): GrlLanguageDeclaration { + const languageName = this.consumeIdentifierLike("Expected language name after language"); + if (languageName.raw !== "grl") { + throw new GrlParseError("Only language grl is supported", languageName); + } + + const version = this.consume("number", "Expected GRL language version"); + return { + kind: "LanguageDeclaration", + language: "grl", + version: version.raw, + range: { + start: languageToken.range.start, + end: version.range.end + } + }; + } + + private parseModuleDeclaration(): GrlModuleDeclaration { + const moduleToken = this.consumeKeyword("module", "Expected module declaration"); + const name = this.consume("identifier", "Expected module name"); + const declarations: GrlTopLevelDeclaration[] = []; + + while (!this.checkKeyword("end") && !this.isAtEnd()) { + declarations.push(this.parseTopLevelDeclaration()); + } + + const end = this.consumeKeyword("end", "Expected end after module declaration"); + return { + kind: "ModuleDeclaration", + name: name.raw, + declarations, + range: { + start: moduleToken.range.start, + end: end.range.end + } + }; + } + + private parseTopLevelDeclaration(): GrlTopLevelDeclaration { + if (this.matchKeyword("import")) { + return this.finishImportDeclaration(this.previous()); + } + + if (this.matchKeyword("proc")) { + return this.finishProcedureDeclaration(this.previous()); + } + + if (this.matchKeyword("func")) { + return this.finishFunctionDeclaration(this.previous()); + } + + if (this.checkDataDeclarationStart()) { + return this.parseDataDeclaration(); + } + + if (this.matchKeyword("target")) { + return this.finishTargetDeclaration(this.previous()); + } + + if (this.matchKeyword("path")) { + return this.finishPathDeclaration(this.previous()); + } + + if (this.matchKeyword("operation")) { + return this.finishOperationDeclaration(this.previous()); + } + + const token = this.peek(); + if (token.kind === "keyword" && RAW_TOP_LEVEL_KEYWORDS.has(token.raw)) { + return this.parseRawTopLevelDeclaration(); + } + + throw new GrlParseError("Expected top-level declaration", token); + } + + private finishImportDeclaration(importToken: GrlToken): GrlImportDeclaration { + const moduleName = this.consume("identifier", "Expected imported module name"); + return { + kind: "ImportDeclaration", + moduleName: moduleName.raw, + range: { + start: importToken.range.start, + end: moduleName.range.end + } + }; + } + + private parseDataDeclaration(): GrlDataDeclaration { + const storageToken = this.advance(); + const storage = storageToken.raw as GrlDeclarationStorage; + const typeName = this.consumeIdentifierLike("Expected type name in data declaration"); + const name = this.consume("identifier", "Expected variable name in data declaration"); + this.consumeOperator("=", "Expected = in data declaration"); + const initializerTokens = this.collectFlatExpressionTokens(); + const initializer = parseGrlExpression(initializerTokens); + + return { + kind: "DataDeclaration", + storage, + typeName: typeName.raw, + name: name.raw, + initializer, + range: { + start: storageToken.range.start, + end: initializer.range.end + } + }; + } + + private finishTargetDeclaration(targetToken: GrlToken): GrlTargetDeclaration { + const name = this.consume("identifier", "Expected target name"); + this.consumeOperator("=", "Expected = in target declaration"); + const targetTokens = this.collectFlatExpressionTokens(); + const target = parseGrlExpression(targetTokens); + + return { + kind: "TargetDeclaration", + name: name.raw, + target, + range: { + start: targetToken.range.start, + end: target.range.end + } + }; + } + + private finishPathDeclaration(pathToken: GrlToken): GrlPathDeclaration { + const name = this.consume("identifier", "Expected path name"); + this.consumePunctuation("{", "Expected { after path name"); + const items: GrlPathItem[] = []; + + while (!this.checkPunctuation("}") && !this.isAtEnd()) { + if (this.matchKeyword("defaults")) { + items.push(this.finishPathDefaultsBlock(this.previous())); + continue; + } + if (this.matchKeyword("source")) { + items.push(this.finishPathSourceBlock(this.previous())); + continue; + } + if (this.matchKeyword("point")) { + items.push(this.finishPathPoint(this.previous())); + continue; + } + if (this.matchKeyword("event")) { + items.push(this.finishPathEvent(this.previous())); + continue; + } + throw new GrlParseError("Expected path item", this.peek()); + } + + const end = this.consumePunctuation("}", "Expected } after path declaration"); + return { + kind: "PathDeclaration", + name: name.raw, + items, + range: { + start: pathToken.range.start, + end: end.range.end + } + }; + } + + private finishPathDefaultsBlock(start: GrlToken): GrlPathDefaultsBlock { + const { properties, end } = this.parsePathPropertyBlock("defaults"); + return { + kind: "PathDefaultsBlock", + properties, + range: { + start: start.range.start, + end: end.range.end + } + }; + } + + private finishPathSourceBlock(start: GrlToken): GrlPathSourceBlock { + const { properties, end } = this.parsePathPropertyBlock("source"); + return { + kind: "PathSourceBlock", + properties, + range: { + start: start.range.start, + end: end.range.end + } + }; + } + + private parsePathPropertyBlock(blockName: string): { properties: GrlPathProperty[]; end: GrlToken } { + this.consumePunctuation("{", `Expected { after path ${blockName}`); + const properties: GrlPathProperty[] = []; + + while (!this.checkPunctuation("}") && !this.isAtEnd()) { + const key = this.consumeIdentifierLike(`Expected ${blockName} property name`); + this.consumePunctuation(":", `Expected : after ${blockName} property name`); + const valueTokens = this.collectPathPropertyValueTokens(); + const value = parseGrlExpression(valueTokens); + properties.push({ + key: key.raw, + value, + range: { + start: key.range.start, + end: value.range.end + } + }); + this.matchPunctuation(","); + } + + const end = this.consumePunctuation("}", `Expected } after path ${blockName}`); + return { properties, end }; + } + + private finishPathPoint(start: GrlToken): GrlPathPoint { + const id = this.consume("identifier", "Expected path point id"); + const motionTokens = this.collectPathMotionTokens(); + if (motionTokens.length === 0) { + throw new GrlParseError("Expected path point motion statement", this.peek()); + } + return { + kind: "PathPoint", + id: id.raw, + motionTokens, + range: { + start: start.range.start, + end: motionTokens.at(-1)?.range.end ?? id.range.end + } + }; + } + + private finishPathEvent(start: GrlToken): GrlPathEvent { + const timing = this.consumeIdentifierLike("Expected before, after, or at after event"); + if (timing.raw !== "before" && timing.raw !== "after" && timing.raw !== "at") { + throw new GrlParseError("Expected before, after, or at after event", timing); + } + const point = this.consume("identifier", "Expected event point id"); + let distance: GrlPathEvent["distance"]; + if (timing.raw === "at") { + this.consumeIdentifierValue("distance", "Expected distance in event at"); + const distanceToken = this.peek(); + const distanceTokens = this.collectSignedNumberTokens(); + const distanceExpression = parseGrlExpression(distanceTokens); + if (distanceExpression.kind !== "NumberLiteral") { + throw new GrlParseError("Expected numeric event distance", distanceToken); + } + distance = distanceExpression; + } + const actionTokens = this.collectPathEventActionTokens(); + if (actionTokens.length === 0) { + throw new GrlParseError("Expected path event action", this.peek()); + } + + return { + kind: "PathEvent", + timing: timing.raw, + pointId: point.raw, + ...(distance ? { distance } : {}), + actionTokens, + range: { + start: start.range.start, + end: actionTokens.at(-1)?.range.end ?? point.range.end + } + }; + } + + private finishOperationDeclaration(operationToken: GrlToken): GrlOperationDeclaration { + const name = this.consume("identifier", "Expected operation name"); + this.consumePunctuation("{", "Expected { after operation name"); + let operationKind: string | undefined; + let pathName: string | undefined; + const items: GrlOperationItem[] = []; + + while (!this.checkPunctuation("}") && !this.isAtEnd()) { + if (this.matchIdentifierValue("kind")) { + this.consumePunctuation(":", "Expected : after operation kind"); + operationKind = this.consumeIdentifierLike("Expected operation kind").raw; + this.matchPunctuation(","); + continue; + } + if (this.matchIdentifierValue("path")) { + this.consumePunctuation(":", "Expected : after operation path"); + pathName = this.consumeIdentifierLike("Expected operation path name").raw; + this.matchPunctuation(","); + continue; + } + if (this.matchIdentifierValue("process")) { + items.push(this.finishOperationProcessBlock(this.previous())); + continue; + } + if (this.matchIdentifierValue("start_action")) { + items.push(this.finishOperationActionBlock(this.previous(), "start_action")); + continue; + } + if (this.matchIdentifierValue("end_action")) { + items.push(this.finishOperationActionBlock(this.previous(), "end_action")); + continue; + } + throw new GrlParseError("Expected operation item", this.peek()); + } + + const end = this.consumePunctuation("}", "Expected } after operation declaration"); + if (!operationKind) { + throw new GrlParseError("Operation requires kind", end); + } + if (!pathName) { + throw new GrlParseError("Operation requires path", end); + } + + return { + kind: "OperationDeclaration", + name: name.raw, + operationKind, + pathName, + items, + range: { + start: operationToken.range.start, + end: end.range.end + } + }; + } + + private finishOperationProcessBlock(start: GrlToken): GrlOperationProcessBlock { + const { properties, end } = this.parsePathPropertyBlock("process"); + return { + kind: "OperationProcessBlock", + properties, + range: { + start: start.range.start, + end: end.range.end + } + }; + } + + private finishOperationActionBlock( + start: GrlToken, + actionKind: "start_action" | "end_action" + ): GrlOperationActionBlock { + this.consumePunctuation(":", `Expected : after ${actionKind}`); + const actionTokens = this.collectOperationActionTokens(); + if (actionTokens.length === 0) { + throw new GrlParseError(`Expected ${actionKind} action`, this.peek()); + } + return { + kind: "OperationActionBlock", + actionKind, + actionTokens, + range: { + start: start.range.start, + end: actionTokens.at(-1)?.range.end ?? start.range.end + } + }; + } + + private finishProcedureDeclaration(procToken: GrlToken): GrlProcedureDeclaration { + const name = this.consume("identifier", "Expected procedure name"); + this.consumePunctuation("(", "Expected ( after procedure name"); + + const params: GrlToken[] = []; + while (!this.checkPunctuation(")") && !this.isAtEnd()) { + params.push(this.advance()); + } + this.consumePunctuation(")", "Expected ) after procedure parameters"); + + const bodyTokens: GrlToken[] = []; + let nestedBlocks = 0; + while (!this.isAtEnd()) { + if (this.checkKeyword("end") && nestedBlocks === 0) { + break; + } + + const token = this.advance(); + bodyTokens.push(token); + + if (token.kind === "keyword" && token.raw === "end" && nestedBlocks > 0) { + nestedBlocks -= 1; + } else if (token.kind === "keyword" && ["if", "while", "for", "switch", "try"].includes(token.raw)) { + nestedBlocks += 1; + } + } + + const end = this.consumeKeyword("end", "Expected end after procedure declaration"); + + return { + kind: "ProcedureDeclaration", + name: name.raw, + params, + bodyTokens, + range: { + start: procToken.range.start, + end: end.range.end + } + }; + } + + private finishFunctionDeclaration(funcToken: GrlToken): GrlFunctionDeclaration { + const returnType = this.consumeIdentifierLike("Expected function return type"); + const name = this.consume("identifier", "Expected function name"); + this.consumePunctuation("(", "Expected ( after function name"); + + const params: GrlToken[] = []; + while (!this.checkPunctuation(")") && !this.isAtEnd()) { + params.push(this.advance()); + } + this.consumePunctuation(")", "Expected ) after function parameters"); + + const bodyTokens: GrlToken[] = []; + let nestedBlocks = 0; + while (!this.isAtEnd()) { + if (this.checkKeyword("end") && nestedBlocks === 0) { + break; + } + + const token = this.advance(); + bodyTokens.push(token); + + if (token.kind === "keyword" && token.raw === "end" && nestedBlocks > 0) { + nestedBlocks -= 1; + } else if (token.kind === "keyword" && ["if", "while", "for", "switch", "try"].includes(token.raw)) { + nestedBlocks += 1; + } + } + + const end = this.consumeKeyword("end", "Expected end after function declaration"); + + return { + kind: "FunctionDeclaration", + returnType: returnType.raw, + name: name.raw, + params, + bodyTokens, + range: { + start: funcToken.range.start, + end: end.range.end + } + }; + } + + private parseRawTopLevelDeclaration(): GrlRawTopLevelDeclaration { + const first = this.advance(); + const tokens: GrlToken[] = [first]; + + if (["path", "operation"].includes(first.raw)) { + this.collectBalancedBlock(tokens); + } else if (["trap", "task"].includes(first.raw)) { + this.collectUntilMatchingEnd(tokens); + } else { + this.collectFlatDeclaration(tokens); + } + + return { + kind: "RawTopLevelDeclaration", + declarationType: first.raw, + tokens, + range: { + start: first.range.start, + end: tokens.at(-1)?.range.end ?? first.range.end + } + }; + } + + private collectBalancedBlock(tokens: GrlToken[]): void { + let braceDepth = 0; + while (!this.isAtEnd()) { + const token = this.advance(); + tokens.push(token); + if (token.kind === "punctuation" && token.raw === "{") { + braceDepth += 1; + } else if (token.kind === "punctuation" && token.raw === "}") { + braceDepth -= 1; + if (braceDepth === 0) { + return; + } + } + } + } + + private collectUntilMatchingEnd(tokens: GrlToken[]): void { + let nestedBlocks = 0; + while (!this.isAtEnd()) { + const token = this.advance(); + tokens.push(token); + if (token.kind === "keyword" && token.raw === "end") { + if (nestedBlocks === 0) { + return; + } + nestedBlocks -= 1; + } else if (token.kind === "keyword" && ["if", "while", "for", "switch", "try"].includes(token.raw)) { + nestedBlocks += 1; + } + } + } + + private collectFlatDeclaration(tokens: GrlToken[]): void { + while (!this.isAtEnd()) { + if (this.checkKeyword("end") || this.startsTopLevelDeclaration(this.peek())) { + return; + } + tokens.push(this.advance()); + } + } + + private collectFlatExpressionTokens(): GrlToken[] { + const tokens: GrlToken[] = []; + let braceDepth = 0; + let bracketDepth = 0; + let parenDepth = 0; + + while (!this.isAtEnd()) { + if ( + braceDepth === 0 && + bracketDepth === 0 && + parenDepth === 0 && + (this.checkKeyword("end") || this.startsTopLevelDeclaration(this.peek()) || this.startsNextDataDeclaration()) + ) { + break; + } + + const token = this.advance(); + tokens.push(token); + + if (token.kind === "punctuation") { + if (token.raw === "{") { + braceDepth += 1; + } else if (token.raw === "}") { + braceDepth -= 1; + } else if (token.raw === "[") { + bracketDepth += 1; + } else if (token.raw === "]") { + bracketDepth -= 1; + } else if (token.raw === "(") { + parenDepth += 1; + } else if (token.raw === ")") { + parenDepth -= 1; + } + } + } + + if (tokens.length === 0) { + throw new GrlParseError("Expected expression", this.peek()); + } + return tokens; + } + + private collectPathPropertyValueTokens(): GrlToken[] { + return this.collectUntil((token, depth) => + depth.brace === 0 && + depth.bracket === 0 && + depth.paren === 0 && + ((token.kind === "punctuation" && (token.raw === "," || token.raw === "}")) || + this.isPathItemStart(token) || + this.isPathPropertyStart()) + ); + } + + private collectPathMotionTokens(): GrlToken[] { + return this.collectUntil((token, depth) => + depth.brace === 0 && + depth.bracket === 0 && + depth.paren === 0 && + ((token.kind === "punctuation" && token.raw === "}") || this.isPathItemStart(token)) + ); + } + + private collectPathEventActionTokens(): GrlToken[] { + return this.collectUntil((token, depth) => + depth.brace === 0 && + depth.bracket === 0 && + depth.paren === 0 && + ((token.kind === "punctuation" && token.raw === "}") || this.isPathItemStart(token)) + ); + } + + private collectOperationActionTokens(): GrlToken[] { + return this.collectUntil((token, depth) => + depth.brace === 0 && + depth.bracket === 0 && + depth.paren === 0 && + ((token.kind === "punctuation" && token.raw === "}") || this.isOperationItemStart(token)) + ); + } + + private collectSignedNumberTokens(): GrlToken[] { + const tokens: GrlToken[] = []; + if (this.peek().kind === "operator" && this.peek().raw === "-") { + tokens.push(this.advance()); + } + tokens.push(this.consume("number", "Expected numeric value")); + return tokens; + } + + private collectUntil( + shouldStop: ( + token: GrlToken, + depth: { brace: number; bracket: number; paren: number } + ) => boolean + ): GrlToken[] { + const tokens: GrlToken[] = []; + const depth = { brace: 0, bracket: 0, paren: 0 }; + + while (!this.isAtEnd() && !shouldStop(this.peek(), depth)) { + const token = this.advance(); + tokens.push(token); + + if (token.kind === "punctuation") { + if (token.raw === "{") { + depth.brace += 1; + } else if (token.raw === "}") { + depth.brace -= 1; + } else if (token.raw === "[") { + depth.bracket += 1; + } else if (token.raw === "]") { + depth.bracket -= 1; + } else if (token.raw === "(") { + depth.paren += 1; + } else if (token.raw === ")") { + depth.paren -= 1; + } + } + } + + if (tokens.length === 0) { + throw new GrlParseError("Expected expression", this.peek()); + } + return tokens; + } + + private isPathItemStart(token: GrlToken): boolean { + return ( + token.kind === "keyword" && + (token.raw === "defaults" || token.raw === "source" || token.raw === "point" || token.raw === "event") + ); + } + + private isOperationItemStart(token: GrlToken): boolean { + return ( + ((token.kind === "keyword" || token.kind === "identifier") && + (token.raw === "kind" || token.raw === "path" || token.raw === "process")) || + ((token.kind === "identifier" || token.kind === "keyword") && + (token.raw === "start_action" || token.raw === "end_action")) + ); + } + + private isPathPropertyStart(): boolean { + const token = this.peek(); + const next = this.peek(1); + return ( + (token.kind === "keyword" || token.kind === "identifier") && + next.kind === "punctuation" && + next.raw === ":" + ); + } + + private startsNextDataDeclaration(): boolean { + const current = this.peek(); + const next = this.peekNext(); + const following = this.peek(2); + + if (current.kind !== "identifier" && current.kind !== "keyword") { + return false; + } + if (next.kind !== "identifier" && next.kind !== "keyword") { + return false; + } + return following.kind === "operator" && following.raw === "="; + } + + private startsTopLevelDeclaration(token: GrlToken): boolean { + if (token.kind !== "keyword") { + return false; + } + if (token.raw === "target") { + const name = this.peek(1); + const equals = this.peek(2); + return name.kind === "identifier" && equals.kind === "operator" && equals.raw === "="; + } + + return ( + token.raw === "import" || + token.raw === "proc" || + token.raw === "path" || + token.raw === "operation" || + token.raw === "persistent" || + token.raw === "const" || + token.raw === "var" || + RAW_TOP_LEVEL_KEYWORDS.has(token.raw) + ); + } + + private checkDataDeclarationStart(): boolean { + return this.checkKeyword("persistent") || this.checkKeyword("const") || this.checkKeyword("var"); + } + + private consumeIdentifierLike(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw new GrlParseError(message, token); + } + + private consume(kind: GrlToken["kind"], message: string): GrlToken { + if (this.check(kind)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private consumeKeyword(keyword: string, message: string): GrlToken { + if (this.checkKeyword(keyword)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private consumeIdentifierValue(value: string, message: string): GrlToken { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === value) { + return this.advance(); + } + throw new GrlParseError(message, token); + } + + private consumePunctuation(value: string, message: string): GrlToken { + if (this.checkPunctuation(value)) { + return this.advance(); + } + throw new GrlParseError(message, this.peek()); + } + + private consumeOperator(value: string, message: string): GrlToken { + const token = this.peek(); + if (token.kind === "operator" && token.raw === value) { + return this.advance(); + } + throw new GrlParseError(message, token); + } + + private matchKeyword(keyword: string): boolean { + if (this.checkKeyword(keyword)) { + this.advance(); + return true; + } + return false; + } + + private matchIdentifierValue(value: string): boolean { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === value) { + this.advance(); + return true; + } + return false; + } + + private matchPunctuation(value: string): boolean { + if (this.checkPunctuation(value)) { + this.advance(); + return true; + } + return false; + } + + private check(kind: GrlToken["kind"]): boolean { + return this.peek().kind === kind; + } + + private checkKeyword(keyword: string): boolean { + const token = this.peek(); + return token.kind === "keyword" && token.raw === keyword; + } + + private checkPunctuation(value: string): boolean { + const token = this.peek(); + return token.kind === "punctuation" && token.raw === value; + } + + private advance(): GrlToken { + if (!this.isAtEnd()) { + this.current += 1; + } + return this.previous(); + } + + private isAtEnd(): boolean { + return this.peek().kind === "eof"; + } + + private peek(distance = 0): GrlToken { + return this.tokens[this.current + distance] ?? this.tokens[this.tokens.length - 1]!; + } + + private peekNext(): GrlToken { + return this.peek(1); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1] ?? this.tokens[0]!; + } +} diff --git a/kdl-wasm/web/src/grl/post/index.ts b/kdl-wasm/web/src/grl/post/index.ts new file mode 100644 index 0000000..7898fe8 --- /dev/null +++ b/kdl-wasm/web/src/grl/post/index.ts @@ -0,0 +1,8 @@ +export { + postProcessAllBrands, + postProcessBrand, + type MultiBrandPostResult, + type PostBrand, + type PostIssue, + type PostResult +} from "./postProcessor.js"; diff --git a/kdl-wasm/web/src/grl/post/postProcessor.ts b/kdl-wasm/web/src/grl/post/postProcessor.ts new file mode 100644 index 0000000..864aea0 --- /dev/null +++ b/kdl-wasm/web/src/grl/post/postProcessor.ts @@ -0,0 +1,232 @@ +import type { MotionDiagnostic, SpeedSpec, ZoneSpec } from "../../kdl/types.js"; +import type { + ExecutableInstruction, + MotionInstruction, + SemanticProgramIr +} from "../ir/index.js"; + +export type PostBrand = "abb" | "fanuc" | "kuka"; + +export interface PostIssue { + severity: MotionDiagnostic["severity"]; + code: string; + message: string; + brand?: PostBrand; +} + +export interface PostResult { + brand: PostBrand; + filename: string; + text: string; + report: PostIssue[]; +} + +export interface MultiBrandPostResult { + outputs: Record; + report: PostIssue[]; +} + +export function postProcessAllBrands(ir: SemanticProgramIr): MultiBrandPostResult { + const abb = postProcessBrand(ir, "abb"); + const fanuc = postProcessBrand(ir, "fanuc"); + const kuka = postProcessBrand(ir, "kuka"); + return { + outputs: { abb, fanuc, kuka }, + report: [...abb.report, ...fanuc.report, ...kuka.report] + }; +} + +export function postProcessBrand(ir: SemanticProgramIr, brand: PostBrand): PostResult { + const report: PostIssue[] = collectBrandHintIssues(ir, brand); + const text = renderBrandProgram(ir, brand, report); + return { + brand, + filename: filenameFor(ir.moduleName, brand), + text, + report + }; +} + +function renderBrandProgram(ir: SemanticProgramIr, brand: PostBrand, report: PostIssue[]): string { + switch (brand) { + case "abb": + return renderAbb(ir, report); + case "fanuc": + return renderFanuc(ir, report); + case "kuka": + return renderKuka(ir, report); + } +} + +function renderAbb(ir: SemanticProgramIr, report: PostIssue[]): string { + const lines = [`MODULE ${ir.moduleName}`, " PROC main()"]; + for (const instruction of mainInstructions(ir)) { + lines.push(` ${renderAbbInstruction(instruction, report)}`); + } + lines.push(" ENDPROC", "ENDMODULE"); + return lines.join("\n"); +} + +function renderFanuc(ir: SemanticProgramIr, report: PostIssue[]): string { + const lines = ["/PROG MAIN", "/MN"]; + mainInstructions(ir).forEach((instruction, index) => { + lines.push(` ${index + 1}: ${renderFanucInstruction(instruction, report)} ;`); + }); + lines.push("/END"); + return lines.join("\n"); +} + +function renderKuka(ir: SemanticProgramIr, report: PostIssue[]): string { + const lines = ["DEF Main()"]; + for (const instruction of mainInstructions(ir)) { + lines.push(` ${renderKukaInstruction(instruction, report)}`); + } + lines.push("END"); + return lines.join("\n"); +} + +function renderAbbInstruction(instruction: ExecutableInstruction, report: PostIssue[]): string { + if (isMotion(instruction)) { + const target = motionTargetName(instruction); + const zone = abbZone(instruction.zone); + const speed = abbSpeed(instruction.speed); + if (instruction.kind === "MOVEJ") return `MoveJ ${target},${speed},${zone},tool0;`; + if (instruction.kind === "MOVEL") return `MoveL ${target},${speed},${zone},tool0;`; + return `MoveC ${motionViaName(instruction)},${target},${speed},${zone},tool0;`; + } + if (instruction.kind === "IO_WRITE") return `SetDO ${instruction.target.raw},${formatValue(instruction.value)};`; + if (instruction.kind === "WAIT") return `WaitUntil ${instruction.condition};`; + if (instruction.kind === "PULSE") return `PulseDO ${instruction.target.raw},${instruction.duration.toFixed(3)};`; + return unsupportedLine("abb", instruction.kind, report); +} + +function renderFanucInstruction(instruction: ExecutableInstruction, report: PostIssue[]): string { + if (isMotion(instruction)) { + const target = motionTargetName(instruction); + const speed = fanucSpeed(instruction.speed); + const zone = fanucZone(instruction.zone); + if (instruction.kind === "MOVEJ") return `J ${target} ${speed} ${zone}`; + if (instruction.kind === "MOVEL") return `L ${target} ${speed} ${zone}`; + return `C ${motionViaName(instruction)} ${target} ${speed} ${zone}`; + } + if (instruction.kind === "IO_WRITE") return `${fanucIo(instruction.target.raw)}=${formatValue(instruction.value)}`; + if (instruction.kind === "WAIT") return `WAIT (${instruction.condition})`; + if (instruction.kind === "PULSE") return `PULSE ${fanucIo(instruction.target.raw)} ${Math.round(instruction.duration * 1000)}ms`; + return unsupportedLine("fanuc", instruction.kind, report); +} + +function renderKukaInstruction(instruction: ExecutableInstruction, report: PostIssue[]): string { + if (isMotion(instruction)) { + const target = motionTargetName(instruction); + const speed = kukaSpeed(instruction.speed); + const zone = kukaZone(instruction.zone); + if (instruction.kind === "MOVEJ") return `PTP ${target} ${speed}${zone}`; + if (instruction.kind === "MOVEL") return `LIN ${target} ${speed}${zone}`; + return `CIRC ${motionViaName(instruction)}, ${target} ${speed}${zone}`; + } + if (instruction.kind === "IO_WRITE") return `${kukaIo(instruction.target.raw)} = ${formatValue(instruction.value)}`; + if (instruction.kind === "WAIT") return `WAIT FOR ${instruction.condition}`; + if (instruction.kind === "PULSE") return `PULSE ${kukaIo(instruction.target.raw)} ${instruction.duration.toFixed(3)}`; + return unsupportedLine("kuka", instruction.kind, report); +} + +function mainInstructions(ir: SemanticProgramIr): ExecutableInstruction[] { + return ir.procedures.find((procedure) => procedure.name === "main")?.instructions ?? []; +} + +function isMotion(instruction: ExecutableInstruction): instruction is MotionInstruction { + return instruction.kind === "MOVEJ" || instruction.kind === "MOVEL" || instruction.kind === "MOVEC"; +} + +function motionTargetName(instruction: MotionInstruction): string { + const target = instruction.target; + if (target && "id" in target && target.id) { + return target.id; + } + return instruction.pointId ?? instruction.id ?? "p_auto"; +} + +function motionViaName(instruction: MotionInstruction): string { + const via = instruction.via; + if (via && "id" in via && via.id) { + return via.id; + } + return "via_auto"; +} + +function abbSpeed(speed: SpeedSpec): string { + if (speed.kind === "joint_percent") return `v${Math.round(speed.value * 100)}`; + if (speed.kind === "linear") return `v${Math.round(speed.velocity * 1000)}`; + return "v100"; +} + +function fanucSpeed(speed: SpeedSpec): string { + if (speed.kind === "joint_percent") return `${Math.round(speed.value * 100)}%`; + if (speed.kind === "linear") return `${Math.round(speed.velocity * 1000)}mm/sec`; + return "100mm/sec"; +} + +function kukaSpeed(speed: SpeedSpec): string { + if (speed.kind === "joint_percent") return `Vel=${Math.round(speed.value * 100)}%`; + if (speed.kind === "linear") return `Vel=${speed.velocity.toFixed(3)}m/s`; + return "Vel=0.100m/s"; +} + +function abbZone(zone: ZoneSpec): string { + if (zone.kind === "fine") return "fine"; + if (zone.kind === "distance") return `z${Math.round(zone.value * 1000)}`; + if (zone.kind === "cnt") return `z${Math.round(zone.value * 100)}`; + return "z10"; +} + +function fanucZone(zone: ZoneSpec): string { + if (zone.kind === "fine") return "FINE"; + if (zone.kind === "cnt") return `CNT${Math.round(zone.value * 100)}`; + if (zone.kind === "distance") return `CNT${Math.max(1, Math.round(zone.value * 1000))}`; + return "CNT10"; +} + +function kukaZone(zone: ZoneSpec): string { + return zone.kind === "fine" ? "" : " C_DIS"; +} + +function fanucIo(raw: string): string { + return raw.replace("io.do", "DO").replace("io.di", "DI").replace("[", "[").replace("]", "]"); +} + +function kukaIo(raw: string): string { + return raw.replace("io.do", "$OUT").replace("io.di", "$IN"); +} + +function formatValue(value: boolean | number | string): string { + if (typeof value === "boolean") return value ? "TRUE" : "FALSE"; + return String(value); +} + +function unsupportedLine(brand: PostBrand, kind: string, report: PostIssue[]): string { + report.push({ + severity: "warning", + code: "GRL_POST_UNSUPPORTED", + message: `${kind} is not supported by ${brand} prototype postprocessor`, + brand + }); + return `! unsupported ${kind}`; +} + +function collectBrandHintIssues(ir: SemanticProgramIr, brand: PostBrand): PostIssue[] { + return ir.symbols + .filter((symbol) => symbol.kind === "raw" && symbol.typeName === "post_hint") + .filter((symbol) => !symbol.name.includes(brand)) + .map((symbol) => ({ + severity: "info" as const, + code: "GRL_POST_HINT_IGNORED", + message: `post_hint ${symbol.name} ignored for ${brand}`, + brand + })); +} + +function filenameFor(moduleName: string, brand: PostBrand): string { + if (brand === "abb") return `${moduleName}.mod`; + if (brand === "fanuc") return `${moduleName}.ls`; + return `${moduleName}.src`; +} diff --git a/kdl-wasm/web/src/grl/semantic/compileControlFlow.ts b/kdl-wasm/web/src/grl/semantic/compileControlFlow.ts new file mode 100644 index 0000000..b0befad --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileControlFlow.ts @@ -0,0 +1,576 @@ +import { KdlStructuredError } from "../../kdl/rpc.js"; +import type { MotionSourceMap } from "../../kdl/types.js"; +import type { GrlProcedureDeclaration } from "../ast/index.js"; +import type { + ControlExpression, + ControlFlowInstruction, + ForInstruction, + IfInstruction, + JumpInstruction, + LabelInstruction, + ProcedureFlowInstruction, + RawProcedureStatement, + SwitchCaseInstruction, + SwitchInstruction, + WhileInstruction +} from "../ir/index.js"; +import type { GrlToken } from "../lexer/index.js"; + +type StopKeyword = "elseif" | "else" | "case" | "default" | "end"; + +interface ParseContext { + scopePath: string[]; + loopDepth: number; + switchDepth: number; +} + +export function parseProcedureControlFlow(procedure: GrlProcedureDeclaration): ProcedureFlowInstruction[] { + return parseControlFlowStatements(procedure.bodyTokens); +} + +export function parseControlFlowStatements(tokens: GrlToken[]): ProcedureFlowInstruction[] { + const parser = new ControlFlowParser(tokens); + const flow = parser.parseRoot(); + validateJumps(flow); + return flow; +} + +class ControlFlowParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parseRoot(): ProcedureFlowInstruction[] { + return this.parseBlock(new Set(), { + scopePath: [], + loopDepth: 0, + switchDepth: 0 + }); + } + + private parseBlock(stopKeywords: Set, context: ParseContext): ProcedureFlowInstruction[] { + const instructions: ProcedureFlowInstruction[] = []; + while (!this.isAtEnd()) { + if (this.isStopKeyword(stopKeywords)) { + break; + } + + if (this.matchKeyword("if")) { + instructions.push(this.finishIf(this.previous(), context)); + continue; + } + if (this.matchKeyword("while")) { + instructions.push(this.finishWhile(this.previous(), context)); + continue; + } + if (this.matchKeyword("for")) { + instructions.push(this.finishFor(this.previous(), context)); + continue; + } + if (this.matchKeyword("switch")) { + instructions.push(this.finishSwitch(this.previous(), context)); + continue; + } + if (this.matchKeyword("break")) { + instructions.push(this.finishBreak(this.previous(), context)); + continue; + } + if (this.matchKeyword("continue")) { + instructions.push(this.finishContinue(this.previous(), context)); + continue; + } + if (this.matchKeyword("label")) { + instructions.push(this.finishLabel(this.previous(), context)); + continue; + } + if (this.matchKeyword("jump")) { + instructions.push(this.finishJump(this.previous(), context)); + continue; + } + if (this.checkKeyword("end")) { + throw controlError("GRL_CONTROL_UNEXPECTED_END", "Unexpected end in procedure body", this.peek()); + } + + instructions.push(this.finishRawStatement()); + } + return instructions; + } + + private finishIf(start: GrlToken, context: ParseContext): IfInstruction { + const condition = this.parseBooleanLineExpression(start); + const branches: IfInstruction["branches"] = [ + { + branchKind: "if", + condition, + body: this.parseBlock(new Set(["elseif", "else", "end"]), { + ...context, + scopePath: [...context.scopePath, scopeId(start, "if")] + }), + sourceMap: tokenSourceMap(start) + } + ]; + + while (this.matchKeyword("elseif")) { + const branchStart = this.previous(); + const branchCondition = this.parseBooleanLineExpression(branchStart); + branches.push({ + branchKind: "elseif", + condition: branchCondition, + body: this.parseBlock(new Set(["elseif", "else", "end"]), { + ...context, + scopePath: [...context.scopePath, scopeId(branchStart, `elseif${branches.length}`)] + }), + sourceMap: tokenSourceMap(branchStart) + }); + } + + if (this.matchKeyword("else")) { + const branchStart = this.previous(); + branches.push({ + branchKind: "else", + body: this.parseBlock(new Set(["end"]), { + ...context, + scopePath: [...context.scopePath, scopeId(branchStart, "else")] + }), + sourceMap: tokenSourceMap(branchStart) + }); + } + + this.consumeKeyword("end", "Expected end after if block"); + return { + kind: "IF", + branches, + sourceMap: tokenSourceMap(start) + }; + } + + private finishWhile(start: GrlToken, context: ParseContext): WhileInstruction { + const condition = this.parseBooleanLineExpression(start); + const body = this.parseBlock(new Set(["end"]), { + scopePath: [...context.scopePath, scopeId(start, "while")], + loopDepth: context.loopDepth + 1, + switchDepth: context.switchDepth + }); + this.consumeKeyword("end", "Expected end after while block"); + return { + kind: "WHILE", + condition, + body, + sourceMap: tokenSourceMap(start) + }; + } + + private finishFor(start: GrlToken, context: ParseContext): ForInstruction { + const iterator = this.consumeIdentifier("Expected loop variable after for"); + if (!this.matchOperator("=") && !this.matchOperator(":=")) { + throw controlError("GRL_FOR_ASSIGNMENT_EXPECTED", "Expected = after for loop variable", this.peek()); + } + + const from = this.parseLineExpressionUntil(start, ["to"]); + this.consumeKeyword("to", "Expected to in for loop"); + const to = this.parseLineExpressionUntil(start, ["step"]); + const step = this.matchKeyword("step") ? this.parseLineExpressionUntil(start, []) : undefined; + const body = this.parseBlock(new Set(["end"]), { + scopePath: [...context.scopePath, scopeId(start, "for")], + loopDepth: context.loopDepth + 1, + switchDepth: context.switchDepth + }); + this.consumeKeyword("end", "Expected end after for block"); + + return { + kind: "FOR", + iterator: iterator.raw, + from, + to, + ...(step ? { step } : {}), + body, + sourceMap: tokenSourceMap(start) + }; + } + + private finishSwitch(start: GrlToken, context: ParseContext): SwitchInstruction { + const expression = this.parseLineExpressionUntil(start, []); + const cases: SwitchCaseInstruction[] = []; + const seenCases = new Set(); + let seenDefault = false; + + while (!this.isAtEnd() && !this.checkKeyword("end")) { + if (this.matchKeyword("case")) { + const caseStart = this.previous(); + const valueTokens = this.collectLineExpressionTokens(caseStart, []); + if (valueTokens.length === 0) { + throw controlError("GRL_SWITCH_CASE_VALUE_MISSING", "Expected case value", caseStart); + } + const constant = parseCaseConstant(valueTokens); + const key = `${typeof constant.value}:${String(constant.value)}`; + if (seenCases.has(key)) { + throw controlError("GRL_SWITCH_CASE_DUPLICATE", `Duplicate switch case ${constant.raw}`, caseStart); + } + seenCases.add(key); + cases.push({ + caseKind: "case", + value: constant.value, + raw: constant.raw, + body: this.parseBlock(new Set(["case", "default", "end"]), { + scopePath: [...context.scopePath, scopeId(caseStart, `case:${constant.raw}`)], + loopDepth: context.loopDepth, + switchDepth: context.switchDepth + 1 + }), + sourceMap: tokenSourceMap(caseStart) + }); + continue; + } + + if (this.matchKeyword("default")) { + const defaultStart = this.previous(); + if (seenDefault) { + throw controlError("GRL_SWITCH_DEFAULT_DUPLICATE", "Duplicate switch default case", defaultStart); + } + seenDefault = true; + cases.push({ + caseKind: "default", + body: this.parseBlock(new Set(["case", "default", "end"]), { + scopePath: [...context.scopePath, scopeId(defaultStart, "default")], + loopDepth: context.loopDepth, + switchDepth: context.switchDepth + 1 + }), + sourceMap: tokenSourceMap(defaultStart) + }); + continue; + } + + throw controlError("GRL_SWITCH_CASE_EXPECTED", "Expected case, default, or end in switch", this.peek()); + } + + this.consumeKeyword("end", "Expected end after switch block"); + return { + kind: "SWITCH", + expression, + cases, + sourceMap: tokenSourceMap(start) + }; + } + + private finishBreak(start: GrlToken, context: ParseContext): ControlFlowInstruction { + if (context.loopDepth === 0 && context.switchDepth === 0) { + throw controlError("GRL_BREAK_OUTSIDE_FLOW", "break is only valid inside loop or switch", start); + } + return { + kind: "BREAK", + sourceMap: tokenSourceMap(start) + }; + } + + private finishContinue(start: GrlToken, context: ParseContext): ControlFlowInstruction { + if (context.loopDepth === 0) { + throw controlError("GRL_CONTINUE_OUTSIDE_LOOP", "continue is only valid inside loop", start); + } + return { + kind: "CONTINUE", + sourceMap: tokenSourceMap(start) + }; + } + + private finishLabel(start: GrlToken, context: ParseContext): LabelInstruction { + const label = this.consumeIdentifier("Expected label name"); + return { + kind: "LABEL", + name: label.raw, + scopePath: [...context.scopePath], + sourceMap: tokenSourceMap(start) + }; + } + + private finishJump(start: GrlToken, context: ParseContext): JumpInstruction { + const label = this.consumeIdentifier("Expected label name after jump"); + return { + kind: "JUMP", + label: label.raw, + scopePath: [...context.scopePath], + sourceMap: tokenSourceMap(start) + }; + } + + private finishRawStatement(): RawProcedureStatement { + const start = this.peek(); + const tokens = this.collectLineExpressionTokens(start, []); + if (tokens.length === 0) { + const token = this.advance(); + return { + kind: "RAW_STATEMENT", + text: token.raw, + tokens: [token], + sourceMap: tokenSourceMap(token) + }; + } + return { + kind: "RAW_STATEMENT", + text: stringifyTokens(tokens), + tokens, + sourceMap: tokenSourceMap(start) + }; + } + + private parseBooleanLineExpression(start: GrlToken): ControlExpression { + const expression = this.parseLineExpressionUntil(start, []); + if (!isBooleanCondition(expression.tokens as GrlToken[])) { + throw controlError("GRL_CONTROL_CONDITION_NOT_BOOL", "Control condition must be boolean", start); + } + return expression; + } + + private parseLineExpressionUntil(start: GrlToken, stopKeywords: string[]): ControlExpression { + const tokens = this.collectLineExpressionTokens(start, stopKeywords); + if (tokens.length === 0) { + throw controlError("GRL_CONTROL_EXPRESSION_MISSING", "Expected control expression", start); + } + return { + text: stringifyTokens(tokens), + tokens, + sourceMap: tokenSourceMap(tokens[0]!) + }; + } + + private collectLineExpressionTokens(start: GrlToken, stopKeywords: string[]): GrlToken[] { + const tokens: GrlToken[] = []; + let parenDepth = 0; + let bracketDepth = 0; + let braceDepth = 0; + + while (!this.isAtEnd()) { + const token = this.peek(); + if (token.range.start.line !== start.range.start.line) { + break; + } + if ( + parenDepth === 0 && + bracketDepth === 0 && + braceDepth === 0 && + (token.kind === "keyword" || token.kind === "identifier") && + stopKeywords.includes(token.raw) + ) { + break; + } + + const consumed = this.advance(); + tokens.push(consumed); + if (consumed.kind === "punctuation") { + if (consumed.raw === "(") parenDepth += 1; + if (consumed.raw === ")") parenDepth = Math.max(0, parenDepth - 1); + if (consumed.raw === "[") bracketDepth += 1; + if (consumed.raw === "]") bracketDepth = Math.max(0, bracketDepth - 1); + if (consumed.raw === "{") braceDepth += 1; + if (consumed.raw === "}") braceDepth = Math.max(0, braceDepth - 1); + } + } + return tokens; + } + + private isStopKeyword(stopKeywords: Set): boolean { + if (stopKeywords.size === 0) { + return false; + } + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && stopKeywords.has(token.raw as StopKeyword); + } + + private matchKeyword(keyword: string): boolean { + if (this.checkKeyword(keyword)) { + this.advance(); + return true; + } + return false; + } + + private checkKeyword(keyword: string): boolean { + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword; + } + + private consumeKeyword(keyword: string, message: string): GrlToken { + if (this.checkKeyword(keyword)) { + return this.advance(); + } + throw controlError("GRL_KEYWORD_EXPECTED", message, this.peek()); + } + + private consumeIdentifier(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw controlError("GRL_IDENTIFIER_EXPECTED", message, token); + } + + private matchOperator(operator: string): boolean { + const token = this.peek(); + if (token.kind === "operator" && token.raw === operator) { + this.advance(); + return true; + } + return false; + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +function validateJumps(flow: ProcedureFlowInstruction[]): void { + const labels = new Map(); + const jumps: JumpInstruction[] = []; + + visitFlow(flow, (instruction) => { + if (instruction.kind === "LABEL") { + if (labels.has(instruction.name)) { + throw controlError("GRL_LABEL_DUPLICATE", `Duplicate label ${instruction.name}`, undefined, instruction.sourceMap); + } + labels.set(instruction.name, instruction); + } else if (instruction.kind === "JUMP") { + jumps.push(instruction); + } + }); + + for (const jump of jumps) { + const label = labels.get(jump.label); + if (!label) { + throw controlError("GRL_LABEL_NOT_FOUND", `Unknown label ${jump.label}`, undefined, jump.sourceMap); + } + if (!isPrefix(label.scopePath, jump.scopePath)) { + throw controlError( + "GRL_JUMP_INTO_BLOCK", + `jump ${jump.label} cannot enter a nested or sibling block`, + undefined, + jump.sourceMap + ); + } + } +} + +function visitFlow(flow: ProcedureFlowInstruction[], visit: (instruction: ProcedureFlowInstruction) => void): void { + for (const instruction of flow) { + visit(instruction); + if (instruction.kind === "IF") { + for (const branch of instruction.branches) { + visitFlow(branch.body, visit); + } + } else if (instruction.kind === "WHILE" || instruction.kind === "FOR") { + visitFlow(instruction.body, visit); + } else if (instruction.kind === "SWITCH") { + for (const switchCase of instruction.cases) { + visitFlow(switchCase.body, visit); + } + } + } +} + +function isPrefix(prefix: string[], value: string[]): boolean { + return prefix.length <= value.length && prefix.every((part, index) => value[index] === part); +} + +function isBooleanCondition(tokens: GrlToken[]): boolean { + if (tokens.length === 0) { + return false; + } + if (tokens.length === 1) { + const [token] = tokens; + if (!token) return false; + if (token.kind === "number" || token.kind === "string") { + return false; + } + return token.kind === "identifier" || token.kind === "keyword"; + } + if (tokens.length === 2 && tokens[0]?.raw === "-" && tokens[1]?.kind === "number") { + return false; + } + if (tokens.some((token) => token.kind === "operator" && ["==", "!=", "<", ">", "<=", ">=", "&&", "||", "!"].includes(token.raw))) { + return true; + } + if (tokens.some((token) => token.kind === "keyword" && (token.raw === "true" || token.raw === "false"))) { + return true; + } + const first = tokens[0]; + return Boolean( + first && + (first.kind === "keyword" || first.kind === "identifier") && + ["all", "any", "rising", "falling", "changed"].includes(first.raw) + ); +} + +function parseCaseConstant(tokens: GrlToken[]): { value: string | number | boolean; raw: string } { + if (tokens.length === 2 && tokens[0]?.kind === "operator" && tokens[0].raw === "-" && tokens[1]?.kind === "number") { + const value = -(tokens[1].unit?.normalizedValue ?? tokens[1].value); + return { value, raw: stringifyTokens(tokens) }; + } + + if (tokens.length !== 1) { + throw controlError("GRL_SWITCH_CASE_NOT_CONSTANT", "switch case must be a constant expression", tokens[0]); + } + + const token = tokens[0]!; + if (token.kind === "number") { + return { value: token.unit?.normalizedValue ?? token.value, raw: token.raw }; + } + if (token.kind === "string") { + return { value: token.value, raw: token.raw }; + } + if (token.kind === "keyword" && (token.raw === "true" || token.raw === "false")) { + return { value: token.raw === "true", raw: token.raw }; + } + if (token.kind === "identifier" || token.kind === "keyword") { + return { value: token.raw, raw: token.raw }; + } + + throw controlError("GRL_SWITCH_CASE_NOT_CONSTANT", "switch case must be a constant expression", token); +} + +function stringifyTokens(tokens: GrlToken[]): string { + return tokens.map((token) => token.raw).join(" "); +} + +function scopeId(token: GrlToken, kind: string): string { + return `${kind}@${token.range.start.line}:${token.range.start.column}`; +} + +function tokenSourceMap(token: GrlToken): MotionSourceMap { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function controlError( + code: string, + message: string, + token?: GrlToken, + sourceMap?: MotionSourceMap +): KdlStructuredError { + const map = sourceMap ?? (token ? tokenSourceMap(token) : undefined); + return new KdlStructuredError( + code, + message, + map + ? [ + { + severity: "error", + code, + message, + sourceMap: map + } + ] + : undefined + ); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileData.ts b/kdl-wasm/web/src/grl/semantic/compileData.ts new file mode 100644 index 0000000..4a684d9 --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileData.ts @@ -0,0 +1,296 @@ +import { rpyToQuaternion } from "../../math/poseMath.js"; +import type { JointTarget, OffsetSpec, Pose, PoseTarget, SpeedSpec, ZoneSpec } from "../../kdl/types.js"; +import { KdlStructuredError } from "../../kdl/rpc.js"; +import type { + GrlArrayExpression, + GrlCallExpression, + GrlDataDeclaration, + GrlExpression, + GrlNumberLiteral, + GrlObjectExpression, + GrlOffsetExpression, + GrlTargetDeclaration +} from "../ast/index.js"; + +export type CompiledGrlDataValue = + | Pose + | JointTarget + | PoseTarget + | SpeedSpec + | ZoneSpec + | OffsetSpec + | Record + | string + | number + | boolean + | number[]; + +export interface CompiledGrlDataDeclaration { + name: string; + storage: GrlDataDeclaration["storage"]; + typeName: string; + value: CompiledGrlDataValue; +} + +export interface CompiledGrlTargetDeclaration { + name: string; + target: JointTarget | PoseTarget; +} + +export function compileGrlDataDeclaration(declaration: GrlDataDeclaration): CompiledGrlDataDeclaration { + return { + name: declaration.name, + storage: declaration.storage, + typeName: declaration.typeName, + value: compileByType(declaration.typeName, declaration.initializer) + }; +} + +export function compileGrlTargetDeclaration(declaration: GrlTargetDeclaration): CompiledGrlTargetDeclaration { + const target = compileTargetExpression(declaration.target); + return { + name: declaration.name, + target: { + ...target, + id: target.id ?? declaration.name + } + }; +} + +export function compileTargetExpression(expression: GrlExpression): JointTarget | PoseTarget { + if (isObjectExpression(expression, "joint_target")) { + return { + joints: compileNumberArray(requiredProperty(expression, "joints")) + }; + } + + if (isObjectExpression(expression, "pose_target")) { + const pose = compilePoseExpression(requiredProperty(expression, "pose")); + const configExpression = findProperty(expression, "config"); + const config = configExpression ? compileRobotConfig(configExpression) : undefined; + return { + pose, + ...(config ? { config } : {}), + ...(findIdentifierName(expression, "tool") ? { tool: { id: findIdentifierName(expression, "tool") } as unknown as Pose } : {}), + ...(findIdentifierName(expression, "frame") ? { frame: { id: findIdentifierName(expression, "frame") } as unknown as Pose } : {}) + }; + } + + throw compileError("GRL_UNSUPPORTED_TARGET", "Expected joint_target or pose_target expression"); +} + +export function compileSpeedExpression(expression: GrlExpression): SpeedSpec { + if (!isCallExpression(expression)) { + throw compileError("GRL_INVALID_SPEED", "Speed expression must be a call"); + } + + const first = expression.args[0]; + if (!first || first.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_SPEED", "Speed expression requires a numeric value"); + } + + if (expression.callee === "joint") { + if (first.unit?.kind === "percent") { + return { kind: "joint_percent", value: first.unit.normalizedValue }; + } + return { kind: "joint_abs", velocity: normalizedNumber(first) }; + } + + if (expression.callee === "linear") { + return { kind: "linear", velocity: normalizedNumber(first), ...compileAcceleration(expression) }; + } + + if (expression.callee === "angular") { + return { kind: "linear", velocity: 0, angularVelocity: normalizedNumber(first), ...compileAcceleration(expression) }; + } + + throw compileError("GRL_INVALID_SPEED", `Unsupported speed expression: ${expression.callee}`); +} + +export function compileZoneExpression(expression: GrlExpression): ZoneSpec { + if (expression.kind === "IdentifierExpression") { + if (expression.name === "fine") { + return { kind: "fine" }; + } + if (expression.name === "continuous") { + return { kind: "continuous" }; + } + } + + if (isCallExpression(expression) && expression.callee === "z") { + const first = expression.args[0]; + if (!first || first.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_ZONE", "z(...) requires a distance"); + } + return { kind: "distance", value: normalizedNumber(first) }; + } + + if (isCallExpression(expression) && expression.callee === "cnt") { + const first = expression.args[0]; + if (!first || first.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_ZONE", "cnt(...) requires a percent value"); + } + return { kind: "cnt", value: normalizedNumber(first) }; + } + + throw compileError("GRL_INVALID_ZONE", "Unsupported zone expression"); +} + +export function compileOffsetExpression(expression: GrlOffsetExpression): OffsetSpec { + const xyz: [number, number, number] = [0, 0, 0]; + for (const axis of expression.axes) { + const index = axis.axis === "x" ? 0 : axis.axis === "y" ? 1 : 2; + xyz[index] = normalizedNumber(axis.value); + } + + return { + mode: expression.mode, + ...(expression.frameName ? { frameId: expression.frameName } : {}), + xyz + }; +} + +function compileByType(typeName: string, expression: GrlExpression): CompiledGrlDataValue { + if (typeName === "speed") { + return compileSpeedExpression(expression); + } + if (typeName === "zone") { + return compileZoneExpression(expression); + } + if (typeName === "pose") { + return compilePoseExpression(expression); + } + if (typeName === "pose_target" || typeName === "joint_target") { + return compileTargetExpression(expression); + } + if (expression.kind === "OffsetExpression") { + return compileOffsetExpression(expression); + } + if (typeName === "tool" && isObjectExpression(expression, "tool")) { + return { + tcp: compilePoseExpression(requiredProperty(expression, "tcp")), + ...(findProperty(expression, "mass") ? { mass: normalizedNumber(findProperty(expression, "mass") as GrlNumberLiteral) } : {}), + ...(findProperty(expression, "cog") ? { cog: compileNumberArray(findProperty(expression, "cog")!) } : {}) + }; + } + if (typeName === "frame" && isObjectExpression(expression, "frame")) { + return { + origin: compilePoseExpression(requiredProperty(expression, "origin")) + }; + } + if (expression.kind === "NumberLiteral") { + return normalizedNumber(expression); + } + if (expression.kind === "StringLiteral" || expression.kind === "BooleanLiteral") { + return expression.value; + } + if (expression.kind === "ArrayExpression") { + return compileNumberArray(expression); + } + + return { kind: expression.kind }; +} + +function compilePoseExpression(expression: GrlExpression): Pose { + if (!isCallExpression(expression) || (expression.callee !== "pose" && expression.callee !== "poseq")) { + throw compileError("GRL_INVALID_POSE", "Expected pose(...) or poseq(...) expression"); + } + + const values = expression.args.map((arg) => { + if (arg.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_POSE", "Pose arguments must be numeric"); + } + return normalizedNumber(arg); + }); + + if (expression.callee === "pose") { + if (values.length !== 6) { + throw compileError("GRL_INVALID_POSE", "pose(...) requires 6 arguments"); + } + return { + position: [values[0]!, values[1]!, values[2]!], + quaternion: rpyToQuaternion([values[3]!, values[4]!, values[5]!]) + }; + } + + if (values.length !== 7) { + throw compileError("GRL_INVALID_POSE", "poseq(...) requires 7 arguments"); + } + return { + position: [values[0]!, values[1]!, values[2]!], + quaternion: [values[3]!, values[4]!, values[5]!, values[6]!] + }; +} + +function compileRobotConfig(expression: GrlExpression) { + if (!isCallExpression(expression) || expression.callee !== "robot_config") { + throw compileError("GRL_INVALID_CONFIG", "Expected robot_config(...)"); + } + const values = expression.args.map((arg) => { + if (arg.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_CONFIG", "robot_config arguments must be numeric"); + } + return arg.value as -1 | 0 | 1; + }); + return { + ...(values[0] !== undefined ? { shoulder: values[0] } : {}), + ...(values[1] !== undefined ? { elbow: values[1] } : {}), + ...(values[2] !== undefined ? { wrist: values[2] } : {}) + }; +} + +function compileNumberArray(expression: GrlExpression): number[] { + if (expression.kind !== "ArrayExpression") { + throw compileError("GRL_INVALID_ARRAY", "Expected numeric array"); + } + return expression.elements.map((element) => { + if (element.kind !== "NumberLiteral") { + throw compileError("GRL_INVALID_ARRAY", "Array elements must be numeric"); + } + return normalizedNumber(element); + }); +} + +function compileAcceleration(expression: GrlCallExpression): { acceleration?: number } { + for (let index = 1; index < expression.args.length; index += 1) { + const marker = expression.args[index]; + const value = expression.args[index + 1]; + if (marker?.kind === "IdentifierExpression" && marker.name === "acc" && value?.kind === "NumberLiteral") { + return { acceleration: normalizedNumber(value) }; + } + } + return {}; +} + +function normalizedNumber(expression: GrlNumberLiteral): number { + return expression.unit?.normalizedValue ?? expression.value; +} + +function requiredProperty(expression: GrlObjectExpression, key: string): GrlExpression { + const property = findProperty(expression, key); + if (!property) { + throw compileError("GRL_MISSING_PROPERTY", `${expression.typeName} is missing ${key}`); + } + return property; +} + +function findProperty(expression: GrlObjectExpression, key: string): GrlExpression | undefined { + return expression.properties.find((property) => property.key === key)?.value; +} + +function findIdentifierName(expression: GrlObjectExpression, key: string): string | undefined { + const value = findProperty(expression, key); + return value?.kind === "IdentifierExpression" ? value.name : undefined; +} + +function isObjectExpression(expression: GrlExpression, typeName: string): expression is GrlObjectExpression { + return expression.kind === "ObjectExpression" && expression.typeName === typeName; +} + +function isCallExpression(expression: GrlExpression): expression is GrlCallExpression { + return expression.kind === "CallExpression"; +} + +function compileError(code: string, message: string): KdlStructuredError { + return new KdlStructuredError(code, message); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileException.ts b/kdl-wasm/web/src/grl/semantic/compileException.ts new file mode 100644 index 0000000..bed4c3f --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileException.ts @@ -0,0 +1,321 @@ +import { KdlStructuredError } from "../../kdl/rpc.js"; +import type { MotionDiagnostic, MotionSourceMap } from "../../kdl/types.js"; +import type { GrlProcedureDeclaration, GrlRawTopLevelDeclaration, GrlTopLevelDeclaration } from "../ast/index.js"; +import type { + AlarmInstruction, + ExceptionFlowInstruction, + RaiseInstruction, + RawProcedureStatement, + TryInstruction, + UnsupportedRuntimeInstruction +} from "../ir/index.js"; +import type { GrlToken } from "../lexer/index.js"; + +type StopKeyword = "catch" | "finally" | "end"; + +export interface ExceptionAnalysis { + procedures: Record; + unsupported: UnsupportedRuntimeInstruction[]; + diagnostics: MotionDiagnostic[]; +} + +export function analyzeExceptionSemantics(declarations: GrlTopLevelDeclaration[]): ExceptionAnalysis { + const diagnostics: MotionDiagnostic[] = []; + const procedures: Record = {}; + const unsupported: UnsupportedRuntimeInstruction[] = []; + + for (const declaration of declarations) { + if (declaration.kind === "ProcedureDeclaration") { + procedures[declaration.name] = parseProcedureExceptionFlow(declaration); + continue; + } + if (declaration.kind === "RawTopLevelDeclaration") { + const instruction = compileUnsupportedTopLevel(declaration); + if (instruction) { + unsupported.push(instruction); + diagnostics.push(diagnostic("warning", "GRL_P1_UNIMPLEMENTED", instruction.message, instruction.sourceMap)); + } + } + } + + return { procedures, unsupported, diagnostics }; +} + +export function parseProcedureExceptionFlow(procedure: GrlProcedureDeclaration): ExceptionFlowInstruction[] { + return parseExceptionFlowStatements(procedure.bodyTokens); +} + +export function parseExceptionFlowStatements(tokens: GrlToken[]): ExceptionFlowInstruction[] { + return new ExceptionFlowParser(tokens).parseRoot(); +} + +class ExceptionFlowParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parseRoot(): ExceptionFlowInstruction[] { + return this.parseBlock(new Set()); + } + + private parseBlock(stopKeywords: Set): ExceptionFlowInstruction[] { + const instructions: ExceptionFlowInstruction[] = []; + while (!this.isAtEnd()) { + if (this.isStopKeyword(stopKeywords)) { + break; + } + if (this.matchKeyword("alarm")) { + instructions.push(this.finishAlarm(this.previous())); + continue; + } + if (this.matchKeyword("raise")) { + instructions.push(this.finishRaise(this.previous())); + continue; + } + if (this.matchKeyword("try")) { + instructions.push(this.finishTry(this.previous())); + continue; + } + if (this.matchKeyword("enable") || this.matchKeyword("disable")) { + instructions.push(this.finishUnsupportedInterrupt(this.previous())); + continue; + } + instructions.push(this.finishRawStatement()); + } + return instructions; + } + + private finishAlarm(start: GrlToken): AlarmInstruction { + const tokens = this.collectLineTokens(start); + const id = tokens[0]; + if (!id || !isIdentifierLike(id)) { + throw exceptionError("GRL_ALARM_ID_MISSING", "alarm requires an alarm id", tokenSourceMap(start)); + } + const message = tokens.find((token) => token.kind === "string"); + const severityIndex = tokens.findIndex((token) => token.raw === "severity"); + const severity = severityIndex >= 0 ? tokens[severityIndex + 1] : undefined; + return { + kind: "ALARM", + alarmId: id.raw, + ...(message?.kind === "string" ? { message: message.value } : {}), + ...(severity && isIdentifierLike(severity) ? { severity: severity.raw } : {}), + sourceMap: tokenSourceMap(start) + }; + } + + private finishRaise(start: GrlToken): RaiseInstruction { + const tokens = this.collectLineTokens(start); + const id = tokens[0]; + if (!id || !isIdentifierLike(id)) { + throw exceptionError("GRL_RAISE_ID_MISSING", "raise requires an alarm id", tokenSourceMap(start)); + } + return { + kind: "RAISE", + alarmId: id.raw, + sourceMap: tokenSourceMap(start) + }; + } + + private finishTry(start: GrlToken): TryInstruction { + const body = this.parseBlock(new Set(["catch", "finally", "end"])); + const catches: TryInstruction["catches"] = []; + let finallyBlock: TryInstruction["finally"]; + + while (this.matchKeyword("catch")) { + const catchStart = this.previous(); + const header = this.collectLineTokens(catchStart); + const alarmId = header[0] && isIdentifierLike(header[0]) ? header[0].raw : undefined; + catches.push({ + ...(alarmId ? { alarmId } : {}), + body: this.parseBlock(new Set(["catch", "finally", "end"])), + sourceMap: tokenSourceMap(catchStart) + }); + } + + if (this.matchKeyword("finally")) { + const finallyStart = this.previous(); + finallyBlock = { + body: this.parseBlock(new Set(["end"])), + sourceMap: tokenSourceMap(finallyStart) + }; + } + + this.consumeKeyword("end", "Expected end after try block"); + if (catches.length === 0 && !finallyBlock) { + throw exceptionError("GRL_TRY_HANDLER_MISSING", "try requires catch or finally", tokenSourceMap(start)); + } + + return { + kind: "TRY", + body, + catches, + ...(finallyBlock ? { finally: finallyBlock } : {}), + sourceMap: tokenSourceMap(start) + }; + } + + private finishUnsupportedInterrupt(start: GrlToken): UnsupportedRuntimeInstruction { + const tokens = this.collectLineTokens(start); + const hasInterrupt = tokens.some((token) => token.raw === "interrupt"); + return { + kind: "UNSUPPORTED_RUNTIME", + feature: "interrupt", + message: hasInterrupt + ? `${start.raw} interrupt is parsed but not executable in P0` + : `${start.raw} is parsed but not executable in P0`, + sourceMap: tokenSourceMap(start) + }; + } + + private finishRawStatement(): RawProcedureStatement { + const start = this.peek(); + const tokens = this.collectLineTokens(start); + if (tokens.length === 0) { + const token = this.advance(); + return { + kind: "RAW_STATEMENT", + text: token.raw, + tokens: [token], + sourceMap: tokenSourceMap(token) + }; + } + return { + kind: "RAW_STATEMENT", + text: stringifyTokens(tokens), + tokens, + sourceMap: tokenSourceMap(start) + }; + } + + private collectLineTokens(start: GrlToken): GrlToken[] { + const tokens: GrlToken[] = []; + let parenDepth = 0; + let bracketDepth = 0; + let braceDepth = 0; + while (!this.isAtEnd()) { + const token = this.peek(); + if (token.range.start.line !== start.range.start.line) { + break; + } + const consumed = this.advance(); + tokens.push(consumed); + if (consumed.kind === "punctuation") { + if (consumed.raw === "(") parenDepth += 1; + if (consumed.raw === ")") parenDepth = Math.max(0, parenDepth - 1); + if (consumed.raw === "[") bracketDepth += 1; + if (consumed.raw === "]") bracketDepth = Math.max(0, bracketDepth - 1); + if (consumed.raw === "{") braceDepth += 1; + if (consumed.raw === "}") braceDepth = Math.max(0, braceDepth - 1); + } + if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) { + continue; + } + } + return tokens; + } + + private isStopKeyword(stopKeywords: Set): boolean { + if (stopKeywords.size === 0) { + return false; + } + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && stopKeywords.has(token.raw as StopKeyword); + } + + private matchKeyword(keyword: string): boolean { + if (this.checkKeyword(keyword)) { + this.advance(); + return true; + } + return false; + } + + private checkKeyword(keyword: string): boolean { + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword; + } + + private consumeKeyword(keyword: string, message: string): GrlToken { + if (this.checkKeyword(keyword)) { + return this.advance(); + } + throw exceptionError("GRL_KEYWORD_EXPECTED", message, tokenSourceMap(this.peek())); + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +function compileUnsupportedTopLevel(declaration: GrlRawTopLevelDeclaration): UnsupportedRuntimeInstruction | undefined { + if (declaration.declarationType === "trap") { + return { + kind: "UNSUPPORTED_RUNTIME", + feature: "trap", + message: `trap ${declaration.tokens[1]?.raw ?? ""}`.trim() + " is parsed but not executable in P0", + sourceMap: rangeSourceMap(declaration.range.start) + }; + } + if (declaration.declarationType === "task") { + return { + kind: "UNSUPPORTED_RUNTIME", + feature: "task", + message: `task ${declaration.tokens[1]?.raw ?? ""}`.trim() + " is parsed but not executable in P0", + sourceMap: rangeSourceMap(declaration.range.start) + }; + } + return undefined; +} + +function isIdentifierLike(token: GrlToken): boolean { + return token.kind === "identifier" || token.kind === "keyword"; +} + +function stringifyTokens(tokens: GrlToken[]): string { + return tokens.map((token) => token.raw).join(" "); +} + +function tokenSourceMap(token: GrlToken): MotionSourceMap { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function rangeSourceMap(position: { line: number; column: number }): MotionSourceMap { + return { + line: position.line, + column: position.column + }; +} + +function diagnostic( + severity: MotionDiagnostic["severity"], + code: string, + message: string, + sourceMap?: MotionSourceMap +): MotionDiagnostic { + return { + severity, + code, + message, + ...(sourceMap ? { sourceMap } : {}) + }; +} + +function exceptionError(code: string, message: string, sourceMap: MotionSourceMap): KdlStructuredError { + return new KdlStructuredError(code, message, [diagnostic("error", code, message, sourceMap)]); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileIo.ts b/kdl-wasm/web/src/grl/semantic/compileIo.ts new file mode 100644 index 0000000..05439da --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileIo.ts @@ -0,0 +1,380 @@ +import { KdlStructuredError } from "../../kdl/rpc.js"; +import type { MotionSourceMap } from "../../kdl/types.js"; +import type { + IoFlowInstruction, + IoReference, + IoWriteInstruction, + OperationActionInstruction, + PathEventInstruction, + PulseInstruction, + WaitInstruction +} from "../ir/index.js"; +import { lexGrl, type GrlToken } from "../lexer/index.js"; + +export interface IoMap { + aliases?: Record; + allowedRanges?: Partial>; +} + +export function parseIoFlowStatements(tokens: GrlToken[], ioMap: IoMap = {}): IoFlowInstruction[] { + const parser = new IoStatementParser(tokens, ioMap); + return parser.parseAll(); +} + +export function compilePathEventIo(event: PathEventInstruction, ioMap: IoMap = {}): IoFlowInstruction[] { + const tokens = event.data?.tokens; + if (Array.isArray(tokens)) { + return parseIoFlowStatements(tokens as GrlToken[], ioMap); + } + const statement = event.data?.statement; + if (typeof statement !== "string") { + return []; + } + return compileStatementString(statement, event.sourceMap, ioMap); +} + +export function compileOperationActionIo( + action: OperationActionInstruction, + ioMap: IoMap = {} +): IoFlowInstruction[] { + if (Array.isArray(action.tokens)) { + return parseIoFlowStatements(action.tokens as GrlToken[], ioMap); + } + return compileStatementString(action.statement, action.sourceMap, ioMap); +} + +class IoStatementParser { + private current = 0; + + constructor( + private readonly tokens: GrlToken[], + private readonly ioMap: IoMap + ) {} + + parseAll(): IoFlowInstruction[] { + const instructions: IoFlowInstruction[] = []; + while (!this.isAtEnd()) { + if (this.checkKeyword("wait")) { + instructions.push(this.finishWait(this.advance())); + continue; + } + if (this.checkKeyword("pulse")) { + instructions.push(this.finishPulse(this.advance())); + continue; + } + if (this.checkIoStart()) { + instructions.push(this.finishIoWrite(this.peek())); + continue; + } + this.advance(); + } + return instructions; + } + + private finishIoWrite(start: GrlToken): IoWriteInstruction { + const target = this.parseIoReference(); + this.consumeOperator("=", "Expected = in IO assignment"); + const value = this.parseValue(); + return { + kind: "IO_WRITE", + target, + value, + sourceMap: tokenSourceMap(start) + }; + } + + private finishWait(start: GrlToken): WaitInstruction { + const conditionTokens = this.collectUntilKeyword(["timeout", "on_timeout"]); + if (conditionTokens.length === 0) { + throw ioError("GRL_WAIT_CONDITION_MISSING", "wait requires a condition"); + } + + let timeout: number | undefined; + let onTimeout: WaitInstruction["onTimeout"]; + if (this.matchKeyword("timeout")) { + timeout = this.parseDuration(); + } + if (this.matchKeyword("on_timeout")) { + const kind = this.consumeIdentifier("Expected on_timeout action").raw; + if (kind === "alarm") { + const message = this.consumeString("Expected alarm message"); + onTimeout = { kind: "alarm", value: message.value }; + } else if (kind === "call") { + onTimeout = { kind: "call", value: this.collectRest().map((token) => token.raw).join(" ") }; + } else { + throw ioError("GRL_WAIT_TIMEOUT_ACTION_INVALID", `Unsupported on_timeout action ${kind}`); + } + } + + return { + kind: "WAIT", + condition: conditionTokens.map((token) => token.raw).join(" "), + ...(timeout !== undefined ? { timeout } : {}), + ...(onTimeout ? { onTimeout } : {}), + sourceMap: tokenSourceMap(start) + }; + } + + private finishPulse(start: GrlToken): PulseInstruction { + const target = this.parseIoReference(); + this.consumeKeyword("duration", "Expected duration in pulse"); + const duration = this.parseDuration(); + return { + kind: "PULSE", + target, + duration, + trace: [ + { time: 0, action: "set", target, value: true }, + { time: duration, action: "reset", target, value: false } + ], + sourceMap: tokenSourceMap(start) + }; + } + + private parseIoReference(): IoReference { + const io = this.consumeKeyword("io", "Expected io reference"); + this.consumePunctuation(".", "Expected . after io"); + const domain = this.consumeIdentifier("Expected IO domain").raw as IoReference["domain"]; + if (!["di", "do", "ai", "ao", "gi", "go", "ri", "ro", "alias"].includes(domain)) { + throw ioError("GRL_IO_DOMAIN_INVALID", `Unsupported IO domain ${domain}`); + } + + if (domain === "alias") { + this.consumePunctuation(".", "Expected . after io.alias"); + const alias = this.consumeIdentifier("Expected IO alias").raw; + const mapped = this.ioMap.aliases?.[alias]; + return mapped ?? { domain, alias, raw: `io.alias.${alias}` }; + } + + this.consumePunctuation("[", "Expected [ after IO domain"); + const indexToken = this.consumeNumber("Expected IO index"); + this.consumePunctuation("]", "Expected ] after IO index"); + const index = indexToken.value; + this.validateIoIndex(domain, index, io); + return { + domain, + index, + raw: `io.${domain}[${index}]` + }; + } + + private validateIoIndex(domain: IoReference["domain"], index: number, token: GrlToken): void { + if (!Number.isInteger(index) || index < 0) { + throw ioError("GRL_IO_INDEX_INVALID", `Invalid IO index ${index}`); + } + const range = this.ioMap.allowedRanges?.[domain]; + if (range && (index < range.min || index > range.max)) { + throw new KdlStructuredError( + "GRL_IO_ADDRESS_NOT_FOUND", + `IO address io.${domain}[${index}] is outside [${range.min}, ${range.max}]`, + [ + { + severity: "error", + code: "GRL_IO_ADDRESS_NOT_FOUND", + message: `IO address io.${domain}[${index}] is outside [${range.min}, ${range.max}]`, + sourceMap: tokenSourceMap(token) + } + ] + ); + } + } + + private parseValue(): boolean | number | string { + const token = this.advance(); + if (token.kind === "keyword" && (token.raw === "true" || token.raw === "false")) { + return token.raw === "true"; + } + if (token.kind === "number") { + return normalizedNumber(token); + } + if (token.kind === "string") { + return token.value; + } + if (token.kind === "identifier" || token.kind === "keyword") { + return token.raw; + } + throw ioError("GRL_IO_VALUE_INVALID", "Unsupported IO assignment value"); + } + + private parseDuration(): number { + const token = this.consumeNumber("Expected duration"); + return normalizedNumber(token); + } + + private collectUntilKeyword(keywords: string[]): GrlToken[] { + const tokens: GrlToken[] = []; + let parenDepth = 0; + while (!this.isAtEnd()) { + const token = this.peek(); + if (parenDepth === 0) { + if ((token.kind === "keyword" || token.kind === "identifier") && keywords.includes(token.raw)) { + break; + } + if (tokens.length > 0 && this.isCurrentStatementStartAfter(tokens)) { + break; + } + } + const consumed = this.advance(); + tokens.push(consumed); + if (consumed.kind === "punctuation" && consumed.raw === "(") { + parenDepth += 1; + } else if (consumed.kind === "punctuation" && consumed.raw === ")") { + parenDepth = Math.max(0, parenDepth - 1); + } + } + return tokens; + } + + private collectRest(): GrlToken[] { + const tokens: GrlToken[] = []; + while (!this.isAtEnd()) { + if (tokens.length > 0 && this.isCurrentStatementStartAfter(tokens)) { + break; + } + tokens.push(this.advance()); + } + return tokens; + } + + private checkIoStart(): boolean { + return this.isIoStartAtCurrent(); + } + + private isCurrentStatementStartAfter(tokens: GrlToken[]): boolean { + const token = this.peek(); + if (this.isKeywordLike(token, "wait") || this.isKeywordLike(token, "pulse")) { + return true; + } + if (!this.isIoStartAtCurrent()) { + return false; + } + const previous = tokens.at(-1); + return previous ? token.range.start.line > previous.range.end.line : true; + } + + private isIoStartAtCurrent(): boolean { + return this.peek().raw === "io" && this.maybePeek(1)?.raw === "."; + } + + private isKeywordLike(token: GrlToken, keyword: string): boolean { + return (token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword; + } + + private matchKeyword(keyword: string): boolean { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword) { + this.advance(); + return true; + } + return false; + } + + private checkKeyword(keyword: string): boolean { + const token = this.peek(); + return (token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword; + } + + private consumeKeyword(keyword: string, message: string): GrlToken { + if (this.checkKeyword(keyword)) { + return this.advance(); + } + throw ioError("GRL_KEYWORD_EXPECTED", message); + } + + private consumeIdentifier(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw ioError("GRL_IDENTIFIER_EXPECTED", message); + } + + private consumePunctuation(value: string, message: string): GrlToken { + const token = this.peek(); + if (token.kind === "punctuation" && token.raw === value) { + return this.advance(); + } + throw ioError("GRL_PUNCTUATION_EXPECTED", message); + } + + private consumeOperator(value: string, message: string): GrlToken { + const token = this.peek(); + if (token.kind === "operator" && token.raw === value) { + return this.advance(); + } + throw ioError("GRL_OPERATOR_EXPECTED", message); + } + + private consume(kind: GrlToken["kind"], message: string): GrlToken { + if (this.peek().kind === kind) { + return this.advance(); + } + throw ioError("GRL_TOKEN_EXPECTED", message); + } + + private consumeNumber(message: string): Extract { + const token = this.peek(); + if (token.kind === "number") { + return this.advance() as Extract; + } + throw ioError("GRL_TOKEN_EXPECTED", message); + } + + private consumeString(message: string): Extract { + const token = this.peek(); + if (token.kind === "string") { + return this.advance() as Extract; + } + throw ioError("GRL_TOKEN_EXPECTED", message); + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private maybePeek(distance = 0): GrlToken | undefined { + return this.tokens[this.current + distance]; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +function compileStatementString( + statement: string, + _sourceMap: MotionSourceMap | undefined, + ioMap: IoMap +): IoFlowInstruction[] { + const tokens = lexGrl(statement, { preserveComments: false }).filter( + (token) => token.kind !== "eof" && token.kind !== "comment" + ); + return parseIoFlowStatements(tokens, ioMap); +} + +function normalizedNumber(token: GrlToken): number { + if (token.kind !== "number") { + throw ioError("GRL_NUMBER_EXPECTED", "Expected number"); + } + return token.unit?.normalizedValue ?? token.value; +} + +function tokenSourceMap(token: GrlToken): MotionSourceMap { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function ioError(code: string, message: string): KdlStructuredError { + return new KdlStructuredError(code, message); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileMotion.ts b/kdl-wasm/web/src/grl/semantic/compileMotion.ts new file mode 100644 index 0000000..58a0004 --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileMotion.ts @@ -0,0 +1,978 @@ +import { KdlStructuredError } from "../../kdl/rpc.js"; +import { applyOffset } from "../../kdl/poseApi.js"; +import type { + JointTarget, + JsonObject, + MoveCRequest, + MoveJRequest, + MoveLRequest, + MotionSegmentRequest, + PathEventRequest, + PathPlanRequest, + Pose, + PoseTarget, + SpeedSpec, + ZoneSpec +} from "../../kdl/types.js"; +import type { + CompiledOperation, + CompiledPath, + MotionInstruction, + OperationActionInstruction, + OperationExecutionStep, + PathEventInstruction, + RunOperationInstruction, + RunPathInstruction +} from "../ir/index.js"; +import { parseGrlExpression } from "../parser/index.js"; +import type { + GrlExpression, + GrlOperationActionBlock, + GrlOperationDeclaration, + GrlOperationProcessBlock, + GrlPathDeclaration, + GrlPathDefaultsBlock, + GrlPathEvent, + GrlPathPoint, + GrlPathProperty, + GrlPathSourceBlock, + GrlProcedureDeclaration +} from "../ast/index.js"; +import type { GrlToken } from "../lexer/index.js"; +import { + compileOffsetExpression, + compileGrlDataDeclaration, + compileGrlTargetDeclaration, + compileSpeedExpression, + compileTargetExpression, + compileZoneExpression, + type CompiledGrlDataValue +} from "./compileData.js"; +import type { GrlDataDeclaration, GrlTargetDeclaration } from "../ast/index.js"; + +export interface GrlMotionContext { + targets: Map; + speeds: Map; + zones: Map; + tools: Map; + frames: Map; + currentSpeed?: SpeedSpec; + currentZone?: ZoneSpec; + currentTool?: Pose; + currentFrame?: Pose; +} + +export interface MotionRequestOptions { + startJoints: number[]; + sampleTime: number; +} + +interface PathDefaults { + speed?: SpeedSpec; + zone?: ZoneSpec; + tool?: Pose; + frame?: Pose; +} + +export interface PathCompileOptions extends MotionRequestOptions { + speedOverride?: number; + stopOnError?: boolean; +} + +export function buildMotionContext(declarations: Array): GrlMotionContext { + const context: GrlMotionContext = { + targets: new Map(), + speeds: new Map(), + zones: new Map(), + tools: new Map(), + frames: new Map() + }; + + for (const declaration of declarations) { + if (declaration.kind === "TargetDeclaration") { + const compiled = compileGrlTargetDeclaration(declaration); + context.targets.set(compiled.name, compiled.target); + continue; + } + + const compiled = compileGrlDataDeclaration(declaration); + addCompiledData(context, compiled.name, compiled.typeName, compiled.value); + } + + return context; +} + +export function parseProcedureMotionInstructions( + procedure: GrlProcedureDeclaration, + context: GrlMotionContext +): MotionInstruction[] { + const parser = new MotionStatementParser(procedure.bodyTokens, context); + return parser.parseAll(); +} + +export function parseProcedureRunPathStatements(procedure: GrlProcedureDeclaration): RunPathInstruction[] { + const parser = new RunPathStatementParser(procedure.bodyTokens); + return parser.parseAll(); +} + +export function parseProcedureRunOperationStatements(procedure: GrlProcedureDeclaration): RunOperationInstruction[] { + const parser = new RunOperationStatementParser(procedure.bodyTokens); + return parser.parseAll(); +} + +export function compilePathToPlanRequest( + path: GrlPathDeclaration, + context: GrlMotionContext, + options: PathCompileOptions +): CompiledPath { + const defaults = compilePathDefaults(path.items.find((item): item is GrlPathDefaultsBlock => item.kind === "PathDefaultsBlock"), context); + const source = compilePathSource(path.items.find((item): item is GrlPathSourceBlock => item.kind === "PathSourceBlock")); + const points = path.items.filter((item): item is GrlPathPoint => item.kind === "PathPoint"); + const events = path.items.filter((item): item is GrlPathEvent => item.kind === "PathEvent"); + + if (points.length === 0) { + throw motionError("GRL_PATH_EMPTY", `Path ${path.name} must contain at least one point`); + } + + const pointIds = new Set(); + const motions: MotionInstruction[] = []; + const segments: MotionSegmentRequest[] = []; + + for (const point of points) { + if (pointIds.has(point.id)) { + throw motionError("GRL_PATH_POINT_DUPLICATE", `Path ${path.name} contains duplicate point ${point.id}`); + } + pointIds.add(point.id); + + const pointContext = cloneMotionContext(context); + applyPathDefaults(pointContext, defaults); + const [motion] = new MotionStatementParser(point.motionTokens, pointContext).parseAll(); + if (!motion) { + throw motionError("GRL_PATH_POINT_MOTION_MISSING", `Path point ${point.id} has no motion`); + } + + const instruction: MotionInstruction = { + ...motion, + id: point.id, + pathId: path.name, + pointId: point.id, + ...(source ? { source } : {}) + }; + motions.push(instruction); + segments.push(motionToSegment(instruction, path.name, source)); + } + + const compiledEvents = events.map((event, index) => compilePathEvent(event, index, pointIds)); + const request: PathPlanRequest = { + pathId: path.name, + startJoints: options.startJoints, + segments, + ...(compiledEvents.length > 0 ? { events: compiledEvents } : {}), + sampleTime: options.sampleTime, + ...(options.speedOverride !== undefined ? { speedOverride: options.speedOverride } : {}), + ...(options.stopOnError !== undefined ? { stopOnError: options.stopOnError } : {}), + ...(source ? { source } : {}) + }; + + return { + pathId: path.name, + request, + motions, + events: compiledEvents + }; +} + +export function compileOperation( + operation: GrlOperationDeclaration, + paths: Map +): CompiledOperation { + if (!paths.has(operation.pathName)) { + throw motionError( + "GRL_OPERATION_PATH_NOT_FOUND", + `Operation ${operation.name} references unknown path ${operation.pathName}` + ); + } + + const processBlock = operation.items.find( + (item): item is GrlOperationProcessBlock => item.kind === "OperationProcessBlock" + ); + const actionBlocks = operation.items.filter( + (item): item is GrlOperationActionBlock => item.kind === "OperationActionBlock" + ); + + return { + operationId: operation.name, + kind: operation.operationKind, + pathId: operation.pathName, + process: processBlock ? compileProcessBlock(processBlock) : {}, + startActions: actionBlocks + .filter((item) => item.actionKind === "start_action") + .map((item) => compileOperationAction(operation.name, item)), + endActions: actionBlocks + .filter((item) => item.actionKind === "end_action") + .map((item) => compileOperationAction(operation.name, item)) + }; +} + +export function expandRunOperation( + run: RunOperationInstruction, + operations: Map +): OperationExecutionStep[] { + const operation = operations.get(run.operationId); + if (!operation) { + throw motionError("GRL_OPERATION_NOT_FOUND", `Unknown operation ${run.operationId}`); + } + return [ + ...operation.startActions, + { + kind: "RUN_PATH", + pathId: operation.pathId, + ...(run.sourceMap ? { sourceMap: run.sourceMap } : {}) + }, + ...operation.endActions + ]; +} + +export function compileMotionToKdlRequest( + instruction: MotionInstruction, + options: MotionRequestOptions +): MoveJRequest | MoveLRequest | MoveCRequest { + if (instruction.kind === "MOVEJ") { + if (!instruction.target) { + throw motionError("GRL_MOTION_TARGET_MISSING", "MOVEJ requires target"); + } + return { + startJoints: options.startJoints, + target: instruction.target, + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + sampleTime: options.sampleTime, + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }; + } + + if (instruction.kind === "MOVEL") { + if (!instruction.target || !isPoseTarget(instruction.target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEL requires PoseTarget"); + } + return { + startJoints: options.startJoints, + target: instruction.target, + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + sampleTime: options.sampleTime, + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }; + } + + if (!instruction.via || !instruction.target || !isPoseTarget(instruction.target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEC requires via and target PoseTarget"); + } + + return { + startJoints: options.startJoints, + via: instruction.via, + target: instruction.target, + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + sampleTime: options.sampleTime, + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }; +} + +function motionToSegment( + instruction: MotionInstruction, + pathId: string, + source?: Record +): MotionSegmentRequest { + if (instruction.kind === "MOVEJ") { + if (!instruction.target) { + throw motionError("GRL_MOTION_TARGET_MISSING", "MOVEJ requires target"); + } + const targetId = targetIdOf(instruction.target); + return { + id: instruction.pointId ?? instruction.id ?? `${pathId}_${instruction.kind.toLowerCase()}`, + motion: "MOVEJ", + target: instruction.target, + ...(targetId ? { targetId } : {}), + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}), + ...(source ? { source } : {}) + }; + } + + if (instruction.kind === "MOVEL") { + if (!instruction.target || !isPoseTarget(instruction.target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEL requires PoseTarget"); + } + const targetId = targetIdOf(instruction.target); + return { + id: instruction.pointId ?? instruction.id ?? `${pathId}_${instruction.kind.toLowerCase()}`, + motion: "MOVEL", + target: instruction.target, + ...(targetId ? { targetId } : {}), + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}), + ...(source ? { source } : {}) + }; + } + + if (!instruction.via || !instruction.target || !isPoseTarget(instruction.target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEC requires via and target PoseTarget"); + } + const targetId = targetIdOf(instruction.target); + return { + id: instruction.pointId ?? instruction.id ?? `${pathId}_${instruction.kind.toLowerCase()}`, + motion: "MOVEC", + via: instruction.via, + target: instruction.target, + ...(targetId ? { targetId } : {}), + speed: instruction.speed, + zone: instruction.zone, + ...(instruction.tool ? { tool: instruction.tool } : {}), + ...(instruction.frame ? { frame: instruction.frame } : {}), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}), + ...(source ? { source } : {}) + }; +} + +function addCompiledData( + context: GrlMotionContext, + name: string, + typeName: string, + value: CompiledGrlDataValue +): void { + if (typeName === "speed") { + context.speeds.set(name, value as SpeedSpec); + } else if (typeName === "zone") { + context.zones.set(name, value as ZoneSpec); + } else if (typeName === "tool") { + context.tools.set(name, (value as { tcp: Pose }).tcp); + } else if (typeName === "frame") { + context.frames.set(name, (value as { origin: Pose }).origin); + } +} + +class MotionStatementParser { + private current = 0; + + constructor( + private readonly tokens: GrlToken[], + private readonly context: GrlMotionContext + ) {} + + parseAll(): MotionInstruction[] { + const instructions: MotionInstruction[] = []; + while (!this.isAtEnd()) { + if (this.matchKeyword("set_tool")) { + this.context.currentTool = this.resolveNamedPose(this.consumeIdentifier("Expected tool name"), "tool"); + continue; + } + if (this.matchKeyword("set_frame")) { + this.context.currentFrame = this.resolveNamedPose(this.consumeIdentifier("Expected frame name"), "frame"); + continue; + } + if (this.matchKeyword("set_speed")) { + this.context.currentSpeed = this.parseSpeedArgument(); + continue; + } + if (this.matchKeyword("set_zone")) { + this.context.currentZone = this.parseZoneArgument(); + continue; + } + if (this.matchKeyword("movej")) { + instructions.push(this.finishMoveJ(this.previous())); + continue; + } + if (this.matchKeyword("movel")) { + instructions.push(this.finishMoveL(this.previous())); + continue; + } + if (this.matchKeyword("movec")) { + instructions.push(this.finishMoveC(this.previous())); + continue; + } + this.advance(); + } + return instructions; + } + + private finishMoveJ(start: GrlToken): MotionInstruction { + const target = this.parseTargetArgument(); + const params = this.parseMotionParams(); + return this.withDefaults({ + kind: "MOVEJ", + target, + ...params, + sourceMap: tokenSourceMap(start) + }); + } + + private finishMoveL(start: GrlToken): MotionInstruction { + const target = this.parseTargetArgument(); + if (!isPoseTarget(target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEL requires PoseTarget"); + } + const params = this.parseMotionParams(); + return this.withDefaults({ + kind: "MOVEL", + target, + ...params, + sourceMap: tokenSourceMap(start) + }); + } + + private finishMoveC(start: GrlToken): MotionInstruction { + this.consumeKeyword("via", "Expected via in MOVEC"); + const via = this.parseTargetArgument(); + if (!isPoseTarget(via)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEC via requires PoseTarget"); + } + this.consumeKeyword("target", "Expected target in MOVEC"); + const target = this.parseTargetArgument(); + if (!isPoseTarget(target)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "MOVEC target requires PoseTarget"); + } + const params = this.parseMotionParams(); + return this.withDefaults({ + kind: "MOVEC", + via, + target, + ...params, + sourceMap: tokenSourceMap(start) + }); + } + + private parseMotionParams(): Partial { + const params: Partial = {}; + while (!this.isAtEnd() && !this.isMotionStart(this.peek())) { + if (this.matchKeyword("speed")) { + params.speed = this.parseSpeedArgument(); + } else if (this.matchKeyword("zone")) { + params.zone = this.parseZoneArgument(); + } else if (this.matchKeyword("tool")) { + params.tool = this.resolveNamedPose(this.consumeIdentifier("Expected tool name"), "tool"); + } else if (this.matchKeyword("frame")) { + params.frame = this.resolveNamedPose(this.consumeIdentifier("Expected frame name"), "frame"); + } else { + break; + } + } + return params; + } + + private parseTargetArgument(): JointTarget | PoseTarget { + const expressionTokens = this.collectExpressionUntilParamKeyword(); + const expression = parseGrlExpression(expressionTokens); + return this.resolveTargetExpression(expression); + } + + private parseSpeedArgument(): SpeedSpec { + const token = this.peek(); + if ((token.kind === "identifier" || token.kind === "keyword") && this.context.speeds.has(token.raw)) { + this.advance(); + return this.context.speeds.get(token.raw)!; + } + return compileSpeedExpression(parseGrlExpression(this.collectExpressionUntilParamKeyword())); + } + + private parseZoneArgument(): ZoneSpec { + const token = this.peek(); + if ((token.kind === "identifier" || token.kind === "keyword") && this.context.zones.has(token.raw)) { + this.advance(); + return this.context.zones.get(token.raw)!; + } + return compileZoneExpression(parseGrlExpression(this.collectExpressionUntilParamKeyword())); + } + + private resolveTargetExpression(expression: GrlExpression): JointTarget | PoseTarget { + if (expression.kind === "OffsetExpression") { + const base = this.resolveTargetExpression(expression.base); + if (!isPoseTarget(base)) { + throw motionError("GRL_MOTION_TARGET_TYPE", "offset target requires PoseTarget"); + } + return applyOffset(base, compileOffsetExpression(expression)); + } + if (expression.kind === "IdentifierExpression") { + const target = this.context.targets.get(expression.name); + if (!target) { + throw motionError("GRL_TARGET_NOT_FOUND", `Unknown target ${expression.name}`); + } + return target; + } + return compileTargetExpression(expression); + } + + private withDefaults(instruction: Partial & Pick): MotionInstruction { + const speed = instruction.speed ?? this.context.currentSpeed; + const zone = instruction.zone ?? this.context.currentZone; + if (!speed) { + throw motionError("GRL_SPEED_UNRESOLVED", `${instruction.kind} has no speed`); + } + if (!zone) { + throw motionError("GRL_ZONE_UNRESOLVED", `${instruction.kind} has no zone`); + } + return { + kind: instruction.kind, + ...(instruction.target ? { target: instruction.target } : {}), + ...(instruction.via ? { via: instruction.via } : {}), + speed, + zone, + ...(instruction.tool ?? this.context.currentTool ? { tool: instruction.tool ?? this.context.currentTool } : {}), + ...(instruction.frame ?? this.context.currentFrame ? { frame: instruction.frame ?? this.context.currentFrame } : {}), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }; + } + + private resolveNamedPose(name: string, kind: "tool" | "frame"): Pose { + const source = kind === "tool" ? this.context.tools : this.context.frames; + const pose = source.get(name); + if (!pose) { + throw motionError(kind === "tool" ? "GRL_TOOL_NOT_FOUND" : "GRL_FRAME_NOT_FOUND", `Unknown ${kind} ${name}`); + } + return pose; + } + + private collectExpressionUntilParamKeyword(): GrlToken[] { + const tokens: GrlToken[] = []; + let parenDepth = 0; + let bracketDepth = 0; + let braceDepth = 0; + const startLine = this.peek().range.start.line; + + while (!this.isAtEnd()) { + const token = this.peek(); + if (tokens.length > 0 && token.range.start.line > startLine && this.isStatementStart(token)) { + break; + } + if ( + parenDepth === 0 && + bracketDepth === 0 && + braceDepth === 0 && + this.isExpressionTerminator(token) + ) { + break; + } + + const consumed = this.advance(); + tokens.push(consumed); + if (consumed.kind === "punctuation") { + if (consumed.raw === "(") parenDepth += 1; + if (consumed.raw === ")") parenDepth -= 1; + if (consumed.raw === "[") bracketDepth += 1; + if (consumed.raw === "]") bracketDepth -= 1; + if (consumed.raw === "{") braceDepth += 1; + if (consumed.raw === "}") braceDepth -= 1; + } + } + + if (tokens.length === 0) { + throw motionError("GRL_EXPRESSION_MISSING", "Expected motion expression"); + } + return tokens; + } + + private isExpressionTerminator(token: GrlToken): boolean { + return ( + this.isMotionStart(token) || + ((token.kind === "keyword" || token.kind === "identifier") && + ["speed", "zone", "tool", "frame", "via", "target"].includes(token.raw)) + ); + } + + private isMotionStart(token: GrlToken): boolean { + return ( + (token.kind === "keyword" || token.kind === "identifier") && + ["movej", "movel", "movec", "set_tool", "set_frame", "set_speed", "set_zone"].includes(token.raw) + ); + } + + private isStatementStart(token: GrlToken): boolean { + return ( + (token.kind === "keyword" || token.kind === "identifier") && + [ + "movej", + "movel", + "movec", + "set_tool", + "set_frame", + "set_speed", + "set_zone", + "io", + "wait", + "pulse", + "run_path", + "run_operation", + "if", + "elseif", + "else", + "while", + "for", + "switch", + "case", + "default", + "break", + "continue", + "label", + "jump", + "call", + "return", + "alarm", + "raise", + "try", + "catch", + "finally", + "enable", + "disable", + "end" + ].includes(token.raw) + ); + } + + private consumeIdentifier(message: string): string { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + this.advance(); + return token.raw; + } + throw motionError("GRL_IDENTIFIER_EXPECTED", message); + } + + private consumeKeyword(keyword: string, message: string): void { + if (!this.matchKeyword(keyword)) { + throw motionError("GRL_KEYWORD_EXPECTED", message); + } + } + + private matchKeyword(keyword: string): boolean { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword) { + this.advance(); + return true; + } + return false; + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +class RunPathStatementParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parseAll(): RunPathInstruction[] { + const instructions: RunPathInstruction[] = []; + while (!this.isAtEnd()) { + if (this.matchKeyword("run_path")) { + const start = this.previous(); + const path = this.consumeIdentifier("Expected path name after run_path"); + instructions.push({ + kind: "RUN_PATH", + pathId: path.raw, + sourceMap: tokenSourceMap(start) + }); + continue; + } + this.advance(); + } + return instructions; + } + + private consumeIdentifier(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw motionError("GRL_IDENTIFIER_EXPECTED", message); + } + + private matchKeyword(keyword: string): boolean { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword) { + this.advance(); + return true; + } + return false; + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +class RunOperationStatementParser { + private current = 0; + + constructor(private readonly tokens: GrlToken[]) {} + + parseAll(): RunOperationInstruction[] { + const instructions: RunOperationInstruction[] = []; + while (!this.isAtEnd()) { + if (this.matchKeyword("run_operation")) { + const start = this.previous(); + const operation = this.consumeIdentifier("Expected operation name after run_operation"); + instructions.push({ + kind: "RUN_OPERATION", + operationId: operation.raw, + sourceMap: tokenSourceMap(start) + }); + continue; + } + this.advance(); + } + return instructions; + } + + private consumeIdentifier(message: string): GrlToken { + const token = this.peek(); + if (token.kind === "identifier" || token.kind === "keyword") { + return this.advance(); + } + throw motionError("GRL_IDENTIFIER_EXPECTED", message); + } + + private matchKeyword(keyword: string): boolean { + const token = this.peek(); + if ((token.kind === "keyword" || token.kind === "identifier") && token.raw === keyword) { + this.advance(); + return true; + } + return false; + } + + private advance(): GrlToken { + this.current += 1; + return this.previous(); + } + + private previous(): GrlToken { + return this.tokens[this.current - 1]!; + } + + private peek(): GrlToken { + return this.tokens[this.current]!; + } + + private isAtEnd(): boolean { + return this.current >= this.tokens.length; + } +} + +function compileProcessBlock(block: GrlOperationProcessBlock): Record { + return Object.fromEntries(block.properties.map((property) => [property.key, compileLiteralValue(property.value)])); +} + +function compileOperationAction( + operationId: string, + block: GrlOperationActionBlock +): OperationActionInstruction { + const first = block.actionTokens[0] ?? block.actionTokens[block.actionTokens.length - 1]!; + return { + kind: "ACTION", + actionKind: block.actionKind, + operationId, + statement: block.actionTokens.map((token) => token.raw).join(" "), + tokens: block.actionTokens, + sourceMap: tokenSourceMap(first) + }; +} + +function compilePathDefaults(block: GrlPathDefaultsBlock | undefined, context: GrlMotionContext): PathDefaults { + const defaults: PathDefaults = {}; + if (!block) { + return defaults; + } + + for (const property of block.properties) { + if (property.key === "speed") { + defaults.speed = resolveSpeed(property.value, context); + } else if (property.key === "zone") { + defaults.zone = resolveZone(property.value, context); + } else if (property.key === "tool") { + defaults.tool = resolveNamedPoseFromExpression(property.value, context, "tool"); + } else if (property.key === "frame") { + defaults.frame = resolveNamedPoseFromExpression(property.value, context, "frame"); + } + } + return defaults; +} + +function compilePathSource(block: GrlPathSourceBlock | undefined): JsonObject | undefined { + if (!block) { + return undefined; + } + return Object.fromEntries(block.properties.map((property) => [property.key, compileLiteralValue(property.value)])); +} + +function compilePathEvent( + event: GrlPathEvent, + index: number, + pointIds: Set +): PathEventInstruction & PathEventRequest { + if (!pointIds.has(event.pointId)) { + throw motionError("GRL_PATH_EVENT_POINT_NOT_FOUND", `Path event references unknown point ${event.pointId}`); + } + + return { + id: `event_${index}`, + timing: event.timing, + pointId: event.pointId, + ...(event.distance ? { distance: normalizedNumber(event.distance) } : {}), + kind: event.actionTokens[0]?.raw ?? "statement", + sourceMap: tokenSourceMap(event.actionTokens[0] ?? event.actionTokens[event.actionTokens.length - 1]!), + data: { + statement: event.actionTokens.map((token) => token.raw).join(" "), + tokens: event.actionTokens + } + }; +} + +function cloneMotionContext(context: GrlMotionContext): GrlMotionContext { + return { + targets: context.targets, + speeds: context.speeds, + zones: context.zones, + tools: context.tools, + frames: context.frames, + ...(context.currentSpeed ? { currentSpeed: context.currentSpeed } : {}), + ...(context.currentZone ? { currentZone: context.currentZone } : {}), + ...(context.currentTool ? { currentTool: context.currentTool } : {}), + ...(context.currentFrame ? { currentFrame: context.currentFrame } : {}) + }; +} + +function applyPathDefaults(context: GrlMotionContext, defaults: PathDefaults): void { + if (defaults.speed) { + context.currentSpeed = defaults.speed; + } + if (defaults.zone) { + context.currentZone = defaults.zone; + } + if (defaults.tool) { + context.currentTool = defaults.tool; + } + if (defaults.frame) { + context.currentFrame = defaults.frame; + } +} + +function resolveSpeed(expression: GrlExpression, context: GrlMotionContext): SpeedSpec { + if (expression.kind === "IdentifierExpression" && context.speeds.has(expression.name)) { + return context.speeds.get(expression.name)!; + } + return compileSpeedExpression(expression); +} + +function resolveZone(expression: GrlExpression, context: GrlMotionContext): ZoneSpec { + if (expression.kind === "IdentifierExpression" && context.zones.has(expression.name)) { + return context.zones.get(expression.name)!; + } + return compileZoneExpression(expression); +} + +function resolveNamedPoseFromExpression( + expression: GrlExpression, + context: GrlMotionContext, + kind: "tool" | "frame" +): Pose { + if (expression.kind !== "IdentifierExpression") { + throw motionError(kind === "tool" ? "GRL_TOOL_NOT_FOUND" : "GRL_FRAME_NOT_FOUND", `Path ${kind} must reference a named ${kind}`); + } + const source = kind === "tool" ? context.tools : context.frames; + const pose = source.get(expression.name); + if (!pose) { + throw motionError(kind === "tool" ? "GRL_TOOL_NOT_FOUND" : "GRL_FRAME_NOT_FOUND", `Unknown ${kind} ${expression.name}`); + } + return pose; +} + +function compileLiteralValue(expression: GrlExpression): unknown { + if (expression.kind === "NumberLiteral") { + return normalizedNumber(expression); + } + if (expression.kind === "StringLiteral" || expression.kind === "BooleanLiteral") { + return expression.value; + } + if (expression.kind === "IdentifierExpression") { + return expression.name; + } + if (expression.kind === "ArrayExpression") { + return expression.elements.map(compileLiteralValue); + } + if (expression.kind === "ObjectExpression") { + return Object.fromEntries(expression.properties.map((property) => [property.key, compileLiteralValue(property.value)])); + } + if (expression.kind === "CallExpression") { + return { + callee: expression.callee, + args: expression.args.map(compileLiteralValue) + }; + } + return { + kind: expression.kind + }; +} + +function tokenSourceMap(token: GrlToken) { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function isPoseTarget(target: JointTarget | PoseTarget): target is PoseTarget { + return "pose" in target; +} + +function targetIdOf(target: JointTarget | PoseTarget): string | undefined { + return target.id; +} + +function normalizedNumber(expression: { value: number; unit?: { normalizedValue: number } }): number { + return expression.unit?.normalizedValue ?? expression.value; +} + +function motionError(code: string, message: string): KdlStructuredError { + return new KdlStructuredError(code, message); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileProcFunction.ts b/kdl-wasm/web/src/grl/semantic/compileProcFunction.ts new file mode 100644 index 0000000..df1022b --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileProcFunction.ts @@ -0,0 +1,647 @@ +import { KdlStructuredError } from "../../kdl/rpc.js"; +import type { MotionDiagnostic, MotionSourceMap } from "../../kdl/types.js"; +import type { + GrlDataDeclaration, + GrlFunctionDeclaration, + GrlProcedureDeclaration, + GrlTargetDeclaration, + GrlTopLevelDeclaration +} from "../ast/index.js"; +import type { + CallInstruction, + ControlExpression, + FunctionSignature, + ProcedureFlowInstruction, + ProcedureSignature, + ProcFunctionAnalysis, + ReturnInstruction, + RoutineParameter, + RoutineParameterDirection +} from "../ir/index.js"; +import type { GrlToken } from "../lexer/index.js"; +import { parseControlFlowStatements } from "./compileControlFlow.js"; + +type RoutineDeclaration = GrlProcedureDeclaration | GrlFunctionDeclaration; +type RoutineSignature = ProcedureSignature | FunctionSignature; +type RoutineKind = "proc" | "func"; +type InferredType = string | "unknown"; + +interface AnalysisContext { + routineName: string; + routineKind: RoutineKind; + returnType?: string; + parameters: RoutineParameter[]; + symbols: Map; + outerNames: Set; + signatures: Map; + diagnostics: MotionDiagnostic[]; + calls: CallInstruction[]; + returns: ReturnInstruction[]; +} + +interface FlowResult { + normalExits: Set[]; + returnExits: Set[]; +} + +export function analyzeProcFunctionSemantics(declarations: GrlTopLevelDeclaration[]): ProcFunctionAnalysis { + const procedures = declarations.filter( + (decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration" + ); + const functions = declarations.filter( + (decl): decl is GrlFunctionDeclaration => decl.kind === "FunctionDeclaration" + ); + const globalNames = collectGlobalNames(declarations); + const diagnostics: MotionDiagnostic[] = []; + const signatures = new Map(); + const procedureSignatures = procedures.map((procedure) => compileProcedureSignature(procedure, globalNames, diagnostics)); + const functionSignatures = functions.map((func) => compileFunctionSignature(func, globalNames, diagnostics)); + + for (const signature of [...procedureSignatures, ...functionSignatures]) { + if (signatures.has(signature.name)) { + throw routineError("GRL_ROUTINE_DUPLICATE", `Duplicate routine ${signature.name}`, signature.sourceMap); + } + signatures.set(signature.name, signature); + } + + const calls: CallInstruction[] = []; + const returns: ReturnInstruction[] = []; + for (const procedure of procedures) { + analyzeRoutineBody(procedure, "proc", undefined, signatures, globalNames, diagnostics, calls, returns); + } + for (const func of functions) { + analyzeRoutineBody(func, "func", func.returnType, signatures, globalNames, diagnostics, calls, returns); + } + + return { + procedures: procedureSignatures, + functions: functionSignatures, + calls, + returns, + diagnostics + }; +} + +export function compileProcedureSignature( + procedure: GrlProcedureDeclaration, + globalNames: Set = new Set(), + diagnostics: MotionDiagnostic[] = [] +): ProcedureSignature { + return { + kind: "PROC_SIGNATURE", + name: procedure.name, + parameters: parseRoutineParameters(procedure.params, procedure.name, globalNames, diagnostics), + sourceMap: rangeSourceMap(procedure.range.start) + }; +} + +export function compileFunctionSignature( + func: GrlFunctionDeclaration, + globalNames: Set = new Set(), + diagnostics: MotionDiagnostic[] = [] +): FunctionSignature { + return { + kind: "FUNC_SIGNATURE", + name: func.name, + returnType: func.returnType, + parameters: parseRoutineParameters(func.params, func.name, globalNames, diagnostics), + sourceMap: rangeSourceMap(func.range.start) + }; +} + +function analyzeRoutineBody( + declaration: RoutineDeclaration, + routineKind: RoutineKind, + returnType: string | undefined, + signatures: Map, + globalNames: Set, + diagnostics: MotionDiagnostic[], + calls: CallInstruction[], + returns: ReturnInstruction[] +): void { + const signature = signatures.get(declaration.name); + if (!signature) { + throw routineError("GRL_ROUTINE_NOT_FOUND", `Missing routine signature ${declaration.name}`); + } + + const symbols = new Map(signature.parameters.map((parameter) => [parameter.name, parameter.typeName])); + const context: AnalysisContext = { + routineName: declaration.name, + routineKind, + ...(returnType ? { returnType } : {}), + parameters: signature.parameters, + symbols, + outerNames: globalNames, + signatures, + diagnostics, + calls, + returns + }; + const flow = parseControlFlowStatements(declaration.bodyTokens); + const result = analyzeFlow(flow, new Set(), context); + const outParameters = signature.parameters.filter((parameter) => parameter.direction === "out"); + + for (const exit of [...result.normalExits, ...result.returnExits]) { + for (const parameter of outParameters) { + if (!exit.has(parameter.name)) { + throw routineError( + "GRL_OUT_PARAM_NOT_ASSIGNED", + `out parameter ${parameter.name} is not assigned on all normal return paths`, + parameter.sourceMap + ); + } + } + } + + if (routineKind === "func" && returnType !== "void" && result.normalExits.length > 0) { + throw routineError("GRL_FUNC_MISSING_RETURN", `Function ${declaration.name} does not return on all normal paths`, rangeSourceMap(declaration.range.start)); + } +} + +function analyzeFlow(flow: ProcedureFlowInstruction[], incoming: Set, context: AnalysisContext): FlowResult { + let normalStates: Set[] = [new Set(incoming)]; + const returnStates: Set[] = []; + + for (const instruction of flow) { + const nextNormalStates: Set[] = []; + for (const state of normalStates) { + const result = analyzeInstruction(instruction, state, context); + nextNormalStates.push(...result.normalExits); + returnStates.push(...result.returnExits); + } + normalStates = nextNormalStates; + if (normalStates.length === 0) { + break; + } + } + + return { + normalExits: normalStates, + returnExits: returnStates + }; +} + +function analyzeInstruction( + instruction: ProcedureFlowInstruction, + incoming: Set, + context: AnalysisContext +): FlowResult { + if (instruction.kind === "RAW_STATEMENT") { + return analyzeRawStatement(instruction.tokens as GrlToken[] | undefined, incoming, context); + } + + if (instruction.kind === "IF") { + const normalExits: Set[] = []; + const returnExits: Set[] = []; + for (const branch of instruction.branches) { + const result = analyzeFlow(branch.body, new Set(incoming), context); + normalExits.push(...result.normalExits); + returnExits.push(...result.returnExits); + } + if (!instruction.branches.some((branch) => branch.branchKind === "else")) { + normalExits.push(new Set(incoming)); + } + return { normalExits, returnExits }; + } + + if (instruction.kind === "WHILE" || instruction.kind === "FOR") { + const body = analyzeFlow(instruction.body, new Set(incoming), context); + return { + normalExits: [new Set(incoming), ...body.normalExits], + returnExits: body.returnExits + }; + } + + if (instruction.kind === "SWITCH") { + const normalExits: Set[] = []; + const returnExits: Set[] = []; + for (const switchCase of instruction.cases) { + const result = analyzeFlow(switchCase.body, new Set(incoming), context); + normalExits.push(...result.normalExits); + returnExits.push(...result.returnExits); + } + if (!instruction.cases.some((switchCase) => switchCase.caseKind === "default")) { + normalExits.push(new Set(incoming)); + } + return { normalExits, returnExits }; + } + + return { + normalExits: [new Set(incoming)], + returnExits: [] + }; +} + +function analyzeRawStatement( + tokens: GrlToken[] | undefined, + incoming: Set, + context: AnalysisContext +): FlowResult { + if (!tokens || tokens.length === 0) { + return { normalExits: [new Set(incoming)], returnExits: [] }; + } + + checkFunctionSideEffects(tokens, context); + const assigned = new Set(incoming); + const declaration = parseLocalDeclaration(tokens); + if (declaration) { + if (context.symbols.has(declaration.name) || context.outerNames.has(declaration.name)) { + context.diagnostics.push(diagnostic("warning", "GRL_NAME_SHADOWS_OUTER_SCOPE", `Local ${declaration.name} shadows an outer name`, declaration.sourceMap)); + } + context.symbols.set(declaration.name, declaration.typeName); + assigned.add(declaration.name); + return { normalExits: [assigned], returnExits: [] }; + } + + const assignment = parseAssignment(tokens); + if (assignment) { + assigned.add(assignment.name); + } + + const call = parseCallStatement(tokens); + if (call) { + validateCall(call, context); + applyCallAssignments(call, assigned, context); + context.calls.push(call); + if (call.target === context.routineName) { + context.diagnostics.push(diagnostic("warning", "GRL_RECURSIVE_CALL", `Routine ${context.routineName} calls itself`, call.sourceMap)); + } + return { normalExits: [assigned], returnExits: [] }; + } + + const returnInstruction = parseReturnStatement(tokens); + if (returnInstruction) { + validateReturn(returnInstruction, context); + context.returns.push(returnInstruction); + return { normalExits: [], returnExits: [assigned] }; + } + + return { normalExits: [assigned], returnExits: [] }; +} + +function parseRoutineParameters( + tokens: GrlToken[], + routineName: string, + globalNames: Set, + diagnostics: MotionDiagnostic[] +): RoutineParameter[] { + const parameters: RoutineParameter[] = []; + const seen = new Set(); + for (const group of splitTopLevel(tokens, ",")) { + if (group.length === 0) { + continue; + } + let offset = 0; + let direction: RoutineParameterDirection = "in"; + const first = group[0]!; + if (isDirection(first)) { + direction = first.raw as RoutineParameterDirection; + offset = 1; + } + const typeName = group[offset]; + const name = group[offset + 1]; + if (!typeName || !name || !isIdentifierLike(typeName) || !isIdentifierLike(name)) { + throw routineError("GRL_PARAMETER_INVALID", `Invalid parameter list for ${routineName}`, tokenSourceMap(first)); + } + if (seen.has(name.raw)) { + throw routineError("GRL_PARAMETER_DUPLICATE", `Duplicate parameter ${name.raw}`, tokenSourceMap(name)); + } + seen.add(name.raw); + if (globalNames.has(name.raw)) { + diagnostics.push(diagnostic("warning", "GRL_NAME_SHADOWS_OUTER_SCOPE", `Parameter ${name.raw} shadows an outer name`, tokenSourceMap(name))); + } + parameters.push({ + name: name.raw, + typeName: typeName.raw, + direction, + sourceMap: tokenSourceMap(name) + }); + } + return parameters; +} + +function parseLocalDeclaration(tokens: GrlToken[]): { name: string; typeName: string; sourceMap: MotionSourceMap } | undefined { + const storage = tokens[0]; + if (!storage || !["var", "const", "persistent"].includes(storage.raw)) { + return undefined; + } + const typeName = tokens[1]; + const name = tokens[2]; + if (!typeName || !name || !isIdentifierLike(typeName) || !isIdentifierLike(name)) { + return undefined; + } + return { + name: name.raw, + typeName: typeName.raw, + sourceMap: tokenSourceMap(name) + }; +} + +function parseAssignment(tokens: GrlToken[]): { name: string; sourceMap: MotionSourceMap } | undefined { + const name = tokens[0]; + const operator = tokens[1]; + if (!name || !operator || !isIdentifierLike(name) || operator.kind !== "operator" || (operator.raw !== "=" && operator.raw !== ":=")) { + return undefined; + } + return { + name: name.raw, + sourceMap: tokenSourceMap(name) + }; +} + +function parseCallStatement(tokens: GrlToken[]): CallInstruction | undefined { + const start = tokens[0]; + const target = tokens[1]; + if (!start || start.raw !== "call" || !target || !isIdentifierLike(target)) { + return undefined; + } + const argTokens = tokens.slice(2); + const args = parseCallArgs(argTokens); + return { + kind: "CALL", + target: target.raw, + args, + sourceMap: tokenSourceMap(start) + }; +} + +function parseReturnStatement(tokens: GrlToken[]): ReturnInstruction | undefined { + const start = tokens[0]; + if (!start || start.raw !== "return") { + return undefined; + } + const valueTokens = tokens.slice(1); + return { + kind: "RETURN", + ...(valueTokens.length > 0 ? { value: expressionFromTokens(valueTokens) } : {}), + sourceMap: tokenSourceMap(start) + }; +} + +function parseCallArgs(tokens: GrlToken[]): ControlExpression[] { + if (tokens[0]?.raw === "(" && tokens.at(-1)?.raw === ")") { + return splitTopLevel(tokens.slice(1, -1), ",").filter((group) => group.length > 0).map(expressionFromTokens); + } + return splitTopLevel(tokens, ",").filter((group) => group.length > 0).map(expressionFromTokens); +} + +function validateCall(call: CallInstruction, context: AnalysisContext): void { + const signature = context.signatures.get(call.target); + if (!signature) { + throw routineError("GRL_CALL_TARGET_NOT_FOUND", `Unknown call target ${call.target}`, call.sourceMap); + } + if (call.args.length !== signature.parameters.length) { + throw routineError("GRL_CALL_ARITY_MISMATCH", `Call ${call.target} expects ${signature.parameters.length} arguments`, call.sourceMap); + } + if (context.routineKind === "func" && signature.kind === "PROC_SIGNATURE") { + throw routineError("GRL_FUNC_SIDE_EFFECT", `Function ${context.routineName} cannot call procedure ${call.target}`, call.sourceMap); + } + + for (let index = 0; index < signature.parameters.length; index += 1) { + const parameter = signature.parameters[index]!; + const arg = call.args[index]!; + const argTokens = arg.tokens as GrlToken[] | undefined; + if ((parameter.direction === "out" || parameter.direction === "inout") && (!argTokens || !isLValueExpression(argTokens))) { + throw routineError("GRL_ARGUMENT_NOT_LVALUE", `${parameter.direction} argument ${parameter.name} must be a writable lvalue`, arg.sourceMap); + } + const actualType = inferExpressionType(argTokens ?? [], context); + if (!isTypeCompatible(parameter.typeName, actualType)) { + throw routineError("GRL_CALL_ARGUMENT_TYPE", `Argument ${index + 1} for ${call.target} is not compatible with ${parameter.typeName}`, arg.sourceMap); + } + } +} + +function applyCallAssignments(call: CallInstruction, assigned: Set, context: AnalysisContext): void { + const signature = context.signatures.get(call.target); + if (!signature) { + return; + } + for (let index = 0; index < signature.parameters.length; index += 1) { + const parameter = signature.parameters[index]!; + if (parameter.direction !== "out" && parameter.direction !== "inout") { + continue; + } + const argTokens = call.args[index]?.tokens as GrlToken[] | undefined; + const target = argTokens?.[0]; + if (target && isIdentifierLike(target)) { + assigned.add(target.raw); + } + } +} + +function validateReturn(returnInstruction: ReturnInstruction, context: AnalysisContext): void { + if (context.routineKind === "proc") { + if (returnInstruction.value) { + throw routineError("GRL_RETURN_VALUE_IN_PROC", "proc return cannot include a value", returnInstruction.sourceMap); + } + return; + } + + if (context.returnType === "void") { + if (returnInstruction.value) { + throw routineError("GRL_RETURN_TYPE_MISMATCH", "void function cannot return a value", returnInstruction.sourceMap); + } + return; + } + + if (!returnInstruction.value) { + throw routineError("GRL_RETURN_VALUE_MISSING", `Function ${context.routineName} must return ${context.returnType}`, returnInstruction.sourceMap); + } + + const actualType = inferExpressionType(returnInstruction.value.tokens as GrlToken[] | undefined ?? [], context); + if (!isTypeCompatible(context.returnType ?? "unknown", actualType)) { + throw routineError("GRL_RETURN_TYPE_MISMATCH", `Return value is not compatible with ${context.returnType}`, returnInstruction.value.sourceMap); + } +} + +function checkFunctionSideEffects(tokens: GrlToken[], context: AnalysisContext): void { + if (context.routineKind !== "func") { + return; + } + const first = tokens[0]; + if (!first) { + return; + } + if (["movej", "movel", "movec", "wait", "pulse", "run_path", "run_operation"].includes(first.raw)) { + throw routineError("GRL_FUNC_SIDE_EFFECT", `Function ${context.routineName} cannot execute ${first.raw}`, tokenSourceMap(first)); + } +} + +function inferExpressionType(tokens: GrlToken[], context: AnalysisContext): InferredType { + if (tokens.length === 0) { + return "unknown"; + } + if (tokens.some((token) => token.kind === "operator" && ["==", "!=", "<", ">", "<=", ">=", "&&", "||", "!"].includes(token.raw))) { + return "bool"; + } + if (tokens.length === 1) { + return inferSingleTokenType(tokens[0]!, context); + } + if (tokens[0] && isIdentifierLike(tokens[0]) && tokens[1]?.raw === "(") { + const signature = context.signatures.get(tokens[0].raw); + if (signature?.kind === "FUNC_SIGNATURE") { + return signature.returnType; + } + } + const operandTypes = tokens + .filter((token) => token.kind !== "operator" && token.kind !== "punctuation") + .map((token) => inferSingleTokenType(token, context)) + .filter((type) => type !== "unknown"); + if (operandTypes.length > 0 && operandTypes.every((type) => ["int", "real"].includes(type))) { + return operandTypes.includes("real") ? "real" : "int"; + } + return "unknown"; +} + +function inferSingleTokenType(token: GrlToken, context: AnalysisContext): InferredType { + if (token.kind === "number") { + if (token.unit?.kind === "time") return "time"; + if (token.unit?.kind === "length") return "length"; + if (token.unit?.kind === "angle") return "angle"; + if (token.unit?.kind === "percent") return "percent"; + return Number.isInteger(token.value) ? "int" : "real"; + } + if (token.kind === "string") { + return "string"; + } + if (token.kind === "keyword" && (token.raw === "true" || token.raw === "false")) { + return "bool"; + } + if (isIdentifierLike(token)) { + return context.symbols.get(token.raw) ?? "unknown"; + } + return "unknown"; +} + +function isTypeCompatible(expected: string, actual: InferredType): boolean { + if (expected === "unknown" || actual === "unknown") { + return true; + } + if (expected === actual) { + return true; + } + return expected === "real" && actual === "int"; +} + +function isLValueExpression(tokens: GrlToken[]): boolean { + const first = tokens[0]; + if (!first || !isIdentifierLike(first) || ["true", "false"].includes(first.raw)) { + return false; + } + return !tokens.some((token) => token.kind === "operator"); +} + +function expressionFromTokens(tokens: GrlToken[]): ControlExpression { + return { + text: stringifyTokens(tokens), + tokens, + ...(tokens[0] ? { sourceMap: tokenSourceMap(tokens[0]) } : {}) + }; +} + +function splitTopLevel(tokens: GrlToken[], separator: string): GrlToken[][] { + const groups: GrlToken[][] = []; + let current: GrlToken[] = []; + let parenDepth = 0; + let bracketDepth = 0; + let braceDepth = 0; + + for (const token of tokens) { + if ( + token.kind === "punctuation" && + token.raw === separator && + parenDepth === 0 && + bracketDepth === 0 && + braceDepth === 0 + ) { + groups.push(current); + current = []; + continue; + } + current.push(token); + if (token.kind === "punctuation") { + if (token.raw === "(") parenDepth += 1; + if (token.raw === ")") parenDepth = Math.max(0, parenDepth - 1); + if (token.raw === "[") bracketDepth += 1; + if (token.raw === "]") bracketDepth = Math.max(0, bracketDepth - 1); + if (token.raw === "{") braceDepth += 1; + if (token.raw === "}") braceDepth = Math.max(0, braceDepth - 1); + } + } + groups.push(current); + return groups; +} + +function collectGlobalNames(declarations: GrlTopLevelDeclaration[]): Set { + const names = new Set(); + for (const declaration of declarations) { + if ( + declaration.kind === "DataDeclaration" || + declaration.kind === "TargetDeclaration" || + declaration.kind === "PathDeclaration" || + declaration.kind === "OperationDeclaration" || + declaration.kind === "ProcedureDeclaration" || + declaration.kind === "FunctionDeclaration" + ) { + names.add(declaration.name); + } + } + return names; +} + +function isDirection(token: GrlToken | undefined): boolean { + return Boolean(token && (token.raw === "in" || token.raw === "out" || token.raw === "inout")); +} + +function isIdentifierLike(token: GrlToken): boolean { + return token.kind === "identifier" || token.kind === "keyword"; +} + +function stringifyTokens(tokens: GrlToken[]): string { + return tokens.map((token) => token.raw).join(" "); +} + +function tokenSourceMap(token: GrlToken): MotionSourceMap { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function rangeSourceMap(position: { line: number; column: number }): MotionSourceMap { + return { + line: position.line, + column: position.column + }; +} + +function diagnostic( + severity: MotionDiagnostic["severity"], + code: string, + message: string, + sourceMap?: MotionSourceMap +): MotionDiagnostic { + return { + severity, + code, + message, + ...(sourceMap ? { sourceMap } : {}) + }; +} + +function routineError(code: string, message: string, sourceMap?: MotionSourceMap): KdlStructuredError { + return new KdlStructuredError( + code, + message, + sourceMap + ? [ + { + severity: "error", + code, + message, + sourceMap + } + ] + : undefined + ); +} diff --git a/kdl-wasm/web/src/grl/semantic/compileSemantic.ts b/kdl-wasm/web/src/grl/semantic/compileSemantic.ts new file mode 100644 index 0000000..5ef9548 --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/compileSemantic.ts @@ -0,0 +1,549 @@ +import type { MotionDiagnostic, MotionSourceMap } from "../../kdl/types.js"; +import type { + GrlDataDeclaration, + GrlFunctionDeclaration, + GrlOperationDeclaration, + GrlPathDeclaration, + GrlProcedureDeclaration, + GrlProgram, + GrlRawTopLevelDeclaration, + GrlTargetDeclaration, + GrlTopLevelDeclaration +} from "../ast/index.js"; +import type { + AlarmInstruction, + BreakInstruction, + CallInstruction, + ContinueInstruction, + ControlFlowInstruction, + ExecutableBranch, + ExecutableInstruction, + ExecutableProcedure, + ExecutableSwitchCase, + IoFlowInstruction, + ProcedureFlowInstruction, + RawProcedureStatement, + ReturnInstruction, + SemanticProgramIr, + SemanticSourceMapEntry, + SemanticSymbol, + UnsupportedRuntimeInstruction +} from "../ir/index.js"; +import { + analyzeExceptionSemantics, + parseExceptionFlowStatements +} from "./compileException.js"; +import { analyzeProcFunctionSemantics } from "./compileProcFunction.js"; +import { + buildMotionContext, + compileMotionToKdlRequest, + compileOperation, + compilePathToPlanRequest, + parseProcedureMotionInstructions, + parseProcedureRunOperationStatements, + parseProcedureRunPathStatements +} from "./compileMotion.js"; +import { + parseControlFlowStatements +} from "./compileControlFlow.js"; +import { parseIoFlowStatements } from "./compileIo.js"; + +export interface SemanticCompileOptions { + startJoints: number[]; + sampleTime: number; +} + +const SEMANTIC_CHECKS = [ + "language/module/proc", + "const/var/persistent symbols", + "tool/frame/speed/zone", + "joint_target/pose_target", + "movej/movel/movec", + "path/point/event/run_path", + "operation/run_operation", + "io/wait/pulse", + "if/elseif/else/while/for/switch", + "call/return/break/continue", + "proc parameter directions", + "func returns and side effects", + "alarm/raise/try/catch", + "source map propagation", + "KDL motion request bridge", + "KDL path request bridge", + "duplicate symbol diagnostics", + "missing reference diagnostics", + "P1 unsupported diagnostics", + "operation action expansion", + "path event expansion", + "raw statement preservation" +] as const; + +export function compileSemanticProgram(program: GrlProgram, options: SemanticCompileOptions): SemanticProgramIr { + const declarations = program.module.declarations; + const diagnostics: MotionDiagnostic[] = []; + const sourceMap: SemanticSourceMapEntry[] = []; + const symbols = buildSemanticSymbols(declarations, diagnostics); + const motionContext = buildMotionContext( + declarations.filter( + (decl): decl is GrlDataDeclaration | GrlTargetDeclaration => + decl.kind === "DataDeclaration" || decl.kind === "TargetDeclaration" + ) + ); + const paths = declarations + .filter((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration") + .map((path) => compilePathToPlanRequest(path, motionContext, options)); + const pathDeclarations = new Map( + declarations + .filter((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration") + .map((path) => [path.name, path]) + ); + const operations = declarations + .filter((decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration") + .map((operation) => compileOperation(operation, pathDeclarations)); + const procFunction = analyzeProcFunctionSemantics(declarations); + const exceptionAnalysis = analyzeExceptionSemantics(declarations); + diagnostics.push(...procFunction.diagnostics, ...exceptionAnalysis.diagnostics); + const procedures = declarations + .filter((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration") + .map((procedure) => compileExecutableProcedure(procedure, motionContext, diagnostics)); + + for (const path of paths) { + collectPathSourceMaps(path, sourceMap); + } + for (const operation of operations) { + collectOperationSourceMaps(operation, sourceMap); + } + for (const procedure of procedures) { + collectExecutableSourceMaps(procedure.instructions, sourceMap, { procedureId: procedure.name }); + } + + return { + moduleName: program.module.name, + symbols, + semanticChecks: [...SEMANTIC_CHECKS], + procedures, + paths, + operations, + diagnostics, + sourceMap, + kdlBridge: { + motionRequests: procedures.flatMap((procedure) => + procedure.instructions.flatMap((instruction) => + instruction.kind === "MOVEJ" || instruction.kind === "MOVEL" || instruction.kind === "MOVEC" + ? [compileMotionToKdlRequest(instruction, options)] + : [] + ) + ), + pathRequests: paths.map((path) => path.request) + } + }; +} + +function compileExecutableProcedure( + procedure: GrlProcedureDeclaration, + motionContext: ReturnType, + diagnostics: MotionDiagnostic[] +): ExecutableProcedure { + const motion = parseProcedureMotionInstructions(procedure, cloneMotionContextForSemantic(motionContext)); + const io = parseIoFlowStatements(procedure.bodyTokens); + const runPaths = parseProcedureRunPathStatements(procedure); + const runOperations = parseProcedureRunOperationStatements(procedure); + const controls = parseControlFlowStatements(procedure.bodyTokens); + const exceptions = parseExceptionFlowStatements(procedure.bodyTokens); + const nestedControlLines = collectNestedControlLines(controls); + const topLevelMotion = motion.filter((instruction) => !isNestedInstruction(instruction, nestedControlLines)); + const topLevelIo = io.filter((instruction) => !isNestedInstruction(instruction, nestedControlLines)); + const topLevelRunPaths = runPaths.filter((instruction) => !isNestedInstruction(instruction, nestedControlLines)); + const topLevelRunOperations = runOperations.filter((instruction) => !isNestedInstruction(instruction, nestedControlLines)); + const topLevelExceptions = exceptions.filter( + (instruction): instruction is AlarmInstruction | UnsupportedRuntimeInstruction => + (instruction.kind === "ALARM" || instruction.kind === "UNSUPPORTED_RUNTIME") && + !isNestedInstruction(instruction, nestedControlLines) + ); + const topLevelStructuredLines = new Set([ + ...topLevelMotion, + ...topLevelIo, + ...topLevelRunPaths, + ...topLevelRunOperations, + ...topLevelExceptions + ].map((instruction) => instruction.sourceMap?.line).filter((line): line is number => line !== undefined)); + const instructions = mergeExecutableInstructions( + procedure.bodyTokens, + [ + ...topLevelMotion, + ...topLevelIo, + ...topLevelRunPaths, + ...topLevelRunOperations, + ...topLevelExceptions, + ...flattenControlInstructions(controls, topLevelStructuredLines), + ...extractRawCallsAndReturns(controls, topLevelStructuredLines) + ], + diagnostics + ); + + return { + name: procedure.name, + instructions, + sourceMap: rangeSourceMap(procedure.range.start) + }; +} + +function mergeExecutableInstructions( + tokens: GrlProcedureDeclaration["bodyTokens"], + instructions: ExecutableInstruction[], + diagnostics: MotionDiagnostic[] +): ExecutableInstruction[] { + const sorted = [...instructions].sort((left, right) => sourceOrder(left.sourceMap, right.sourceMap)); + const seen = new Set(); + const merged: ExecutableInstruction[] = []; + for (const instruction of sorted) { + const key = instructionKey(instruction); + if (key && seen.has(key)) { + continue; + } + if (key) { + seen.add(key); + } + merged.push(instruction); + } + for (const token of tokens) { + if (["catch", "finally", "end"].includes(token.raw)) { + continue; + } + if (!merged.some((instruction) => instruction.sourceMap?.line === token.range.start.line)) { + diagnostics.push(diagnostic("info", "GRL_RAW_STATEMENT_PRESERVED", `Statement ${token.raw} preserved as raw IR`, tokenSourceMap(token))); + } + } + return merged; +} + +function flattenControlInstructions(instructions: ProcedureFlowInstruction[], excludedRawLines = new Set()): ExecutableInstruction[] { + return instructions.flatMap((instruction): ExecutableInstruction[] => { + if (instruction.kind === "RAW_STATEMENT") { + return rawStatementToExecutable(instruction, excludedRawLines); + } + if (instruction.kind === "IF") { + return [ + { + kind: "EXEC_IF", + branches: instruction.branches.map((branch): ExecutableBranch => ({ + branchKind: branch.branchKind, + ...(branch.condition ? { condition: branch.condition } : {}), + body: flattenProcedureFlow(branch.body), + ...(branch.sourceMap ? { sourceMap: branch.sourceMap } : {}) + })), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + } + ]; + } + if (instruction.kind === "WHILE") { + return [ + { + kind: "EXEC_WHILE", + condition: instruction.condition, + body: flattenProcedureFlow(instruction.body), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + } + ]; + } + if (instruction.kind === "FOR") { + return [ + { + kind: "EXEC_FOR", + iterator: instruction.iterator, + from: instruction.from, + to: instruction.to, + ...(instruction.step ? { step: instruction.step } : {}), + body: flattenProcedureFlow(instruction.body), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + } + ]; + } + if (instruction.kind === "SWITCH") { + return [ + { + kind: "EXEC_SWITCH", + expression: instruction.expression, + cases: instruction.cases.map((switchCase): ExecutableSwitchCase => ({ + caseKind: switchCase.caseKind, + ...(switchCase.value !== undefined ? { value: switchCase.value } : {}), + ...(switchCase.raw ? { raw: switchCase.raw } : {}), + body: flattenProcedureFlow(switchCase.body), + ...(switchCase.sourceMap ? { sourceMap: switchCase.sourceMap } : {}) + })), + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + } + ]; + } + if (instruction.kind === "BREAK" || instruction.kind === "CONTINUE") { + return [instruction as BreakInstruction | ContinueInstruction]; + } + return []; + }); +} + +function flattenProcedureFlow(instructions: ProcedureFlowInstruction[]): ExecutableInstruction[] { + const controls = instructions.filter((instruction): instruction is ControlFlowInstruction => instruction.kind !== "RAW_STATEMENT"); + const raw = instructions.filter((instruction): instruction is RawProcedureStatement => instruction.kind === "RAW_STATEMENT"); + return [...flattenControlInstructions(controls), ...extractRawCallsAndReturns(raw)]; +} + +function extractRawCallsAndReturns( + instructions: Array, + excludedRawLines = new Set() +): ExecutableInstruction[] { + const extracted: ExecutableInstruction[] = []; + for (const instruction of instructions) { + if (instruction.kind !== "RAW_STATEMENT") { + continue; + } + extracted.push(...rawStatementToExecutable(instruction, excludedRawLines)); + } + return extracted; +} + +function rawStatementToExecutable( + instruction: RawProcedureStatement, + excludedRawLines = new Set() +): ExecutableInstruction[] { + if (instruction.sourceMap?.line && excludedRawLines.has(instruction.sourceMap.line)) { + return []; + } + const tokens = instruction.tokens as { raw: string }[] | undefined; + const first = tokens?.[0]?.raw; + const second = tokens?.[1]?.raw; + if (first && ["set_tool", "set_frame", "set_speed", "set_zone"].includes(first)) { + return []; + } + const typedTokens = instruction.tokens as GrlProcedureDeclaration["bodyTokens"] | undefined; + if (typedTokens && (first === "io" || first === "wait" || first === "pulse")) { + return parseIoFlowStatements(typedTokens); + } + if (typedTokens && (first === "alarm" || first === "raise" || first === "enable" || first === "disable")) { + return parseExceptionFlowStatements(typedTokens).filter( + (item): item is AlarmInstruction | UnsupportedRuntimeInstruction => item.kind === "ALARM" || item.kind === "UNSUPPORTED_RUNTIME" + ); + } + if (first === "call" && second) { + return [{ + kind: "CALL" as const, + target: second, + args: [], + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }]; + } + if (first === "return") { + return [{ + kind: "RETURN" as const, + ...(instruction.sourceMap ? { sourceMap: instruction.sourceMap } : {}) + }]; + } + return [instruction]; +} + +function collectNestedControlLines(instructions: ProcedureFlowInstruction[]): Set { + const lines = new Set(); + for (const instruction of instructions) { + if (instruction.kind === "RAW_STATEMENT") { + continue; + } + if (instruction.kind === "IF") { + for (const branch of instruction.branches) { + collectFlowLines(branch.body, lines); + } + } else if (instruction.kind === "WHILE" || instruction.kind === "FOR") { + collectFlowLines(instruction.body, lines); + } else if (instruction.kind === "SWITCH") { + for (const switchCase of instruction.cases) { + collectFlowLines(switchCase.body, lines); + } + } + } + return lines; +} + +function collectFlowLines(instructions: ProcedureFlowInstruction[], lines: Set): void { + for (const instruction of instructions) { + if (instruction.sourceMap?.line) { + lines.add(instruction.sourceMap.line); + } + if (instruction.kind === "IF") { + for (const branch of instruction.branches) { + collectFlowLines(branch.body, lines); + } + } else if (instruction.kind === "WHILE" || instruction.kind === "FOR") { + collectFlowLines(instruction.body, lines); + } else if (instruction.kind === "SWITCH") { + for (const switchCase of instruction.cases) { + collectFlowLines(switchCase.body, lines); + } + } + } +} + +function isNestedInstruction(instruction: { sourceMap?: MotionSourceMap }, nestedLines: Set): boolean { + return Boolean(instruction.sourceMap?.line && nestedLines.has(instruction.sourceMap.line)); +} + +function buildSemanticSymbols(declarations: GrlTopLevelDeclaration[], diagnostics: MotionDiagnostic[]): SemanticSymbol[] { + const symbols: SemanticSymbol[] = []; + const seen = new Map(); + for (const declaration of declarations) { + const symbol = symbolFromDeclaration(declaration); + if (!symbol) { + continue; + } + const previous = seen.get(symbol.name); + if (previous) { + diagnostics.push(diagnostic("error", "GRL_SYMBOL_DUPLICATE", `Duplicate symbol ${symbol.name}`, symbol.sourceMap)); + } + seen.set(symbol.name, symbol); + symbols.push(symbol); + } + return symbols; +} + +function symbolFromDeclaration(declaration: GrlTopLevelDeclaration): SemanticSymbol | undefined { + if (declaration.kind === "DataDeclaration") { + return { kind: "data", name: declaration.name, typeName: declaration.typeName, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "TargetDeclaration") { + return { kind: "target", name: declaration.name, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "PathDeclaration") { + return { kind: "path", name: declaration.name, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "OperationDeclaration") { + return { kind: "operation", name: declaration.name, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "ProcedureDeclaration") { + return { kind: "procedure", name: declaration.name, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "FunctionDeclaration") { + return { kind: "function", name: declaration.name, typeName: declaration.returnType, sourceMap: rangeSourceMap(declaration.range.start) }; + } + if (declaration.kind === "RawTopLevelDeclaration") { + const name = declaration.tokens[1]?.raw ?? declaration.declarationType; + return { kind: "raw", name, typeName: declaration.declarationType, sourceMap: rangeSourceMap(declaration.range.start) }; + } + return undefined; +} + +function collectPathSourceMaps(path: SemanticProgramIr["paths"][number], sourceMap: SemanticSourceMapEntry[]): void { + for (const segment of path.request.segments) { + if (segment.sourceMap) { + sourceMap.push({ + kind: "path_point", + id: segment.id ?? `${path.pathId}:${segment.motion}`, + pathId: path.pathId, + ...(segment.id ? { pointId: segment.id } : {}), + sourceMap: segment.sourceMap + }); + } + } + for (const event of path.events) { + if (event.sourceMap) { + sourceMap.push({ + kind: "path_event", + id: event.id ?? `${path.pathId}:event`, + pathId: path.pathId, + pointId: event.pointId, + sourceMap: event.sourceMap + }); + } + } +} + +function collectOperationSourceMaps(operation: SemanticProgramIr["operations"][number], sourceMap: SemanticSourceMapEntry[]): void { + for (const action of [...operation.startActions, ...operation.endActions]) { + if (action.sourceMap) { + sourceMap.push({ + kind: "operation_action", + id: `${operation.operationId}:${action.actionKind}`, + operationId: operation.operationId, + sourceMap: action.sourceMap + }); + } + } +} + +function collectExecutableSourceMaps( + instructions: ExecutableInstruction[], + sourceMap: SemanticSourceMapEntry[], + context: { procedureId: string } +): void { + for (const instruction of instructions) { + if (instruction.sourceMap) { + sourceMap.push({ + kind: instruction.kind, + id: `${context.procedureId}:${instruction.kind}:${instruction.sourceMap.line ?? 0}:${instruction.sourceMap.column ?? 0}`, + procedureId: context.procedureId, + sourceMap: instruction.sourceMap + }); + } + if (instruction.kind === "EXEC_IF") { + for (const branch of instruction.branches) { + collectExecutableSourceMaps(branch.body, sourceMap, context); + } + } else if (instruction.kind === "EXEC_WHILE" || instruction.kind === "EXEC_FOR") { + collectExecutableSourceMaps(instruction.body, sourceMap, context); + } else if (instruction.kind === "EXEC_SWITCH") { + for (const switchCase of instruction.cases) { + collectExecutableSourceMaps(switchCase.body, sourceMap, context); + } + } + } +} + +function cloneMotionContextForSemantic(context: ReturnType): ReturnType { + return { + targets: context.targets, + speeds: context.speeds, + zones: context.zones, + tools: context.tools, + frames: context.frames, + ...(context.currentSpeed ? { currentSpeed: context.currentSpeed } : {}), + ...(context.currentZone ? { currentZone: context.currentZone } : {}), + ...(context.currentTool ? { currentTool: context.currentTool } : {}), + ...(context.currentFrame ? { currentFrame: context.currentFrame } : {}) + }; +} + +function sourceOrder(left: MotionSourceMap | undefined, right: MotionSourceMap | undefined): number { + return (left?.line ?? Number.MAX_SAFE_INTEGER) - (right?.line ?? Number.MAX_SAFE_INTEGER) || + (left?.column ?? Number.MAX_SAFE_INTEGER) - (right?.column ?? Number.MAX_SAFE_INTEGER); +} + +function instructionKey(instruction: ExecutableInstruction): string | undefined { + const line = instruction.sourceMap?.line; + const column = instruction.sourceMap?.column; + return line ? `${instruction.kind}:${line}:${column ?? 0}` : undefined; +} + +function tokenSourceMap(token: GrlProcedureDeclaration["bodyTokens"][number]): MotionSourceMap { + return { + line: token.range.start.line, + column: token.range.start.column + }; +} + +function rangeSourceMap(position: { line: number; column: number }): MotionSourceMap { + return { + line: position.line, + column: position.column + }; +} + +function diagnostic( + severity: MotionDiagnostic["severity"], + code: string, + message: string, + sourceMap?: MotionSourceMap +): MotionDiagnostic { + return { + severity, + code, + message, + ...(sourceMap ? { sourceMap } : {}) + }; +} diff --git a/kdl-wasm/web/src/grl/semantic/index.ts b/kdl-wasm/web/src/grl/semantic/index.ts new file mode 100644 index 0000000..d5c619c --- /dev/null +++ b/kdl-wasm/web/src/grl/semantic/index.ts @@ -0,0 +1,49 @@ +export { + compileGrlDataDeclaration, + compileGrlTargetDeclaration, + compileOffsetExpression, + compileSpeedExpression, + compileTargetExpression, + compileZoneExpression, + type CompiledGrlDataDeclaration, + type CompiledGrlDataValue, + type CompiledGrlTargetDeclaration +} from "./compileData.js"; +export { + buildMotionContext, + compileOperation, + compilePathToPlanRequest, + compileMotionToKdlRequest, + expandRunOperation, + parseProcedureMotionInstructions, + parseProcedureRunOperationStatements, + parseProcedureRunPathStatements, + type GrlMotionContext, + type PathCompileOptions, + type MotionRequestOptions +} from "./compileMotion.js"; +export { + compileOperationActionIo, + compilePathEventIo, + parseIoFlowStatements, + type IoMap +} from "./compileIo.js"; +export { + parseControlFlowStatements, + parseProcedureControlFlow +} from "./compileControlFlow.js"; +export { + analyzeProcFunctionSemantics, + compileFunctionSignature, + compileProcedureSignature +} from "./compileProcFunction.js"; +export { + analyzeExceptionSemantics, + parseExceptionFlowStatements, + parseProcedureExceptionFlow, + type ExceptionAnalysis +} from "./compileException.js"; +export { + compileSemanticProgram, + type SemanticCompileOptions +} from "./compileSemantic.js"; diff --git a/kdl-wasm/web/src/kdl/kdl.worker.ts b/kdl-wasm/web/src/kdl/kdl.worker.ts new file mode 100644 index 0000000..8f942b8 --- /dev/null +++ b/kdl-wasm/web/src/kdl/kdl.worker.ts @@ -0,0 +1,16 @@ +import { createDefaultNativeKdlModuleLoader } from "./nativeModule.js"; +import { createKdlWorkerRuntime } from "./runtime.js"; +import { dispatchKdlRpcRequest } from "./workerRpc.js"; +import type { KdlRpcRequest } from "./rpc.js"; + +const runtime = createKdlWorkerRuntime(createDefaultNativeKdlModuleLoader()); +const workerScope = globalThis as unknown as { + onmessage: ((event: MessageEvent>) => void) | null; + postMessage: (message: unknown, transfer?: Transferable[]) => void; +}; + +workerScope.onmessage = (event) => { + void dispatchKdlRpcRequest(runtime, event.data).then((response) => { + workerScope.postMessage(response); + }); +}; diff --git a/kdl-wasm/web/src/kdl/kdlClient.ts b/kdl-wasm/web/src/kdl/kdlClient.ts new file mode 100644 index 0000000..d831da7 --- /dev/null +++ b/kdl-wasm/web/src/kdl/kdlClient.ts @@ -0,0 +1,318 @@ +import { + KdlStructuredError, + rpcErrorToException, + type KdlRpcRequest, + type KdlRpcResponse +} from "./rpc.js"; +import type { + CycleTimeResult, + JointLimits, + FkOptions, + FkResult, + IkOptions, + IkResult, + JacobianOptions, + JacobianResult, + KdlApiMethod, + KdlInitOptions, + KdlRuntimeInfo, + KdlWasmApi, + LinkPoseResult, + LimitCheckResult, + MoveCRequest, + MoveJRequest, + MoveLRequest, + NormalizedRobotModel, + OffsetSpec, + PathPlanRequest, + PathPlanResult, + PathValidationResult, + Pose, + PoseLike, + PoseNormalizeOptions, + PoseTarget, + ReachabilityResult, + RobotHandle, + RobotInfo, + SingularityResult, + TrapProfileOptions, + TrapProfileResult, + TrapSample, + TrajectoryResult, + UrdfLoadOptions +} from "./types.js"; + +export interface KdlWorkerLike { + postMessage(message: KdlRpcRequest, transfer?: Transferable[]): void; + terminate?: () => void; + addEventListener(type: "message", listener: (event: MessageEvent) => void): void; + addEventListener(type: "error", listener: (event: ErrorEvent) => void): void; + removeEventListener(type: "message", listener: (event: MessageEvent) => void): void; + removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void; +} + +interface PendingCall { + method: KdlApiMethod; + resolve: (value: unknown) => void; + reject: (reason?: unknown) => void; +} + +export class KdlWorkerClient + implements + Pick< + KdlWasmApi, + | "init" + | "dispose" + | "loadRobotFromUrdf" + | "createRobotFromModel" + | "destroyRobot" + | "getRobotInfo" + | "getJointLimits" + | "normalizePose" + | "composePose" + | "inversePose" + | "applyToolAndFrame" + | "applyOffset" + | "makeTrapProfile" + | "sampleTrapProfile" + | "fk" + | "fkPose7" + | "fkAllLinks" + | "ik" + | "ikBatch" + | "jacobian" + | "checkSingularity" + | "checkJointLimits" + | "checkVelocityLimits" + | "checkReachability" + | "checkReachabilityBatch" + | "planMoveJ" + | "planMoveL" + | "planMoveC" + | "planPath" + | "validatePath" + | "estimateCycleTime" + | "resampleTrajectory" + > +{ + private nextId = 1; + private worker: KdlWorkerLike | undefined; + private readonly pending = new Map(); + private readonly handleMessage = (event: MessageEvent) => { + this.acceptResponse(event.data); + }; + private readonly handleError = (event: ErrorEvent) => { + this.failWorker(event.error instanceof Error ? event.error : new Error(event.message)); + }; + + constructor(private readonly createWorker: () => KdlWorkerLike) {} + + async init(options?: KdlInitOptions): Promise { + return this.call("init", options) as Promise; + } + + async dispose(): Promise { + if (!this.worker) { + return; + } + + try { + await this.call("dispose"); + } finally { + this.detachWorker(); + } + } + + async loadRobotFromUrdf(urdfXml: string, options: UrdfLoadOptions): Promise { + return this.call("loadRobotFromUrdf", urdfXml, options) as Promise; + } + + async createRobotFromModel(model: NormalizedRobotModel): Promise { + return this.call("createRobotFromModel", model) as Promise; + } + + async destroyRobot(handle: RobotHandle): Promise { + await this.call("destroyRobot", handle); + } + + async getRobotInfo(handle: RobotHandle): Promise { + return this.call("getRobotInfo", handle) as Promise; + } + + async getJointLimits(handle: RobotHandle): Promise { + return this.call("getJointLimits", handle) as Promise; + } + + async normalizePose(input: PoseLike, options?: PoseNormalizeOptions): Promise { + return this.call("normalizePose", input, options) as Promise; + } + + async composePose(a: Pose, b: Pose): Promise { + return this.call("composePose", a, b) as Promise; + } + + async inversePose(pose: Pose): Promise { + return this.call("inversePose", pose) as Promise; + } + + async applyToolAndFrame(target: PoseTarget, tool: Pose, frame: Pose): Promise { + return this.call("applyToolAndFrame", target, tool, frame) as Promise; + } + + async applyOffset(target: PoseTarget, offset: OffsetSpec): Promise { + return this.call("applyOffset", target, offset) as Promise; + } + + async makeTrapProfile(length: number, options: TrapProfileOptions): Promise { + return this.call("makeTrapProfile", length, options) as Promise; + } + + async sampleTrapProfile(length: number, options: TrapProfileOptions): Promise { + return this.call("sampleTrapProfile", length, options) as Promise; + } + + async fk(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise { + return this.call("fk", handle, joints, options) as Promise; + } + + async fkPose7(handle: RobotHandle, joints: Float64Array, out?: Float64Array, options?: FkOptions): Promise { + return this.call("fkPose7", handle, joints, out, options) as Promise; + } + + async fkAllLinks(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise { + return this.call("fkAllLinks", handle, joints, options) as Promise; + } + + async ik(handle: RobotHandle, seed: Float64Array, target: Pose, options?: IkOptions): Promise { + return this.call("ik", handle, seed, target, options) as Promise; + } + + async ikBatch(handle: RobotHandle, seeds: Float64Array[], targets: Pose[], options?: IkOptions): Promise { + return this.call("ikBatch", handle, seeds, targets, options) as Promise; + } + + async jacobian(handle: RobotHandle, joints: Float64Array, options?: JacobianOptions): Promise { + return this.call("jacobian", handle, joints, options) as Promise; + } + + async checkSingularity(handle: RobotHandle, joints: Float64Array): Promise { + return this.call("checkSingularity", handle, joints) as Promise; + } + + async checkJointLimits(handle: RobotHandle, joints: Float64Array): Promise { + return this.call("checkJointLimits", handle, joints) as Promise; + } + + async checkVelocityLimits(handle: RobotHandle, trajectory: TrajectoryResult): Promise { + return this.call("checkVelocityLimits", handle, trajectory) as Promise; + } + + async checkReachability(handle: RobotHandle, target: PoseTarget, options?: IkOptions): Promise { + return this.call("checkReachability", handle, target, options) as Promise; + } + + async checkReachabilityBatch( + handle: RobotHandle, + targets: PoseTarget[], + options?: IkOptions + ): Promise { + return this.call("checkReachabilityBatch", handle, targets, options) as Promise; + } + + async planMoveJ(handle: RobotHandle, request: MoveJRequest): Promise { + return this.call("planMoveJ", handle, request) as Promise; + } + + async planMoveL(handle: RobotHandle, request: MoveLRequest): Promise { + return this.call("planMoveL", handle, request) as Promise; + } + + async planMoveC(handle: RobotHandle, request: MoveCRequest): Promise { + return this.call("planMoveC", handle, request) as Promise; + } + + async planPath(handle: RobotHandle, request: PathPlanRequest): Promise { + return this.call("planPath", handle, request) as Promise; + } + + async validatePath(handle: RobotHandle, request: PathPlanRequest): Promise { + return this.call("validatePath", handle, request) as Promise; + } + + async estimateCycleTime(input: TrajectoryResult | PathPlanResult): Promise { + return this.call("estimateCycleTime", input) as Promise; + } + + async resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number): Promise { + return this.call("resampleTrajectory", trajectory, sampleTime) as Promise; + } + + async call(method: KdlApiMethod, ...args: unknown[]): Promise { + const worker = this.ensureWorker(); + const id = this.nextId++; + const request: KdlRpcRequest = { + id, + method, + payload: args + }; + + return new Promise((resolve, reject) => { + this.pending.set(id, { method, resolve, reject }); + worker.postMessage(request); + }); + } + + private ensureWorker(): KdlWorkerLike { + if (this.worker) { + return this.worker; + } + + const worker = this.createWorker(); + worker.addEventListener("message", this.handleMessage); + worker.addEventListener("error", this.handleError); + this.worker = worker; + return worker; + } + + private acceptResponse(response: KdlRpcResponse): void { + const pending = this.pending.get(response.id); + if (!pending) { + return; + } + + this.pending.delete(response.id); + + if (response.ok) { + pending.resolve(response.result); + } else { + pending.reject( + rpcErrorToException( + response.error ?? { + code: "KDL_RPC_MISSING_ERROR", + message: `KDL worker returned a failed response for ${pending.method} without error details` + } + ) + ); + } + } + + private failWorker(error: Error): void { + const structured = new KdlStructuredError("KDL_WORKER_CRASHED", error.message); + for (const pending of this.pending.values()) { + pending.reject(structured); + } + this.pending.clear(); + this.detachWorker(); + } + + private detachWorker(): void { + if (!this.worker) { + return; + } + + this.worker.removeEventListener("message", this.handleMessage); + this.worker.removeEventListener("error", this.handleError); + this.worker.terminate?.(); + this.worker = undefined; + } +} diff --git a/kdl-wasm/web/src/kdl/nativeAbi.ts b/kdl-wasm/web/src/kdl/nativeAbi.ts new file mode 100644 index 0000000..fc0fc36 --- /dev/null +++ b/kdl-wasm/web/src/kdl/nativeAbi.ts @@ -0,0 +1,118 @@ +import { KdlStructuredError } from "./rpc.js"; +import type { KdlError } from "./types.js"; +import type { NativeKdlModule } from "./nativeModule.js"; + +export const KDL_C_ABI_EXPORTS = [ + "kdl_init", + "kdl_create_robot", + "kdl_destroy_robot", + "kdl_get_robot_info", + "kdl_fk", + "kdl_fk_all_links", + "kdl_jacobian", + "kdl_ik", + "kdl_plan_movej", + "kdl_plan_movel", + "kdl_plan_movec", + "kdl_plan_path", + "kdl_sample_trap", + "kdl_last_error" +] as const; + +export type KdlCAbiExport = (typeof KDL_C_ABI_EXPORTS)[number]; + +export class KdlNativeAbi { + constructor(private readonly module: NativeKdlModule) { + this.assertRuntimeMethods(); + } + + assertExports(names: readonly KdlCAbiExport[] = KDL_C_ABI_EXPORTS): void { + for (const name of names) { + try { + if (typeof this.module.cwrap?.(name, "number", []) === "function") { + continue; + } + } catch { + // Normalized below. + } + { + throw new KdlStructuredError("KDL_C_ABI_EXPORT_MISSING", `Missing C ABI export: ${name}`); + } + } + } + + callNumber(ident: KdlCAbiExport, argTypes: Array, args: unknown[]): number { + return Number(this.module.ccall(ident, "number", argTypes, args)); + } + + checkReturnCode(returnCode: number): void { + if (returnCode >= 0) { + return; + } + + const error = this.lastError(); + throw new KdlStructuredError(error.code, error.message, error.diagnostics); + } + + readJsonCall(ident: KdlCAbiExport, argTypes: Array, args: unknown[], bytes = 16_384): T { + const ptr = this.malloc(bytes); + try { + const returnCode = this.callNumber(ident, [...argTypes, "number", "number"], [...args, ptr, bytes]); + this.checkReturnCode(returnCode); + return JSON.parse(this.module.UTF8ToString?.(ptr) ?? "") as T; + } finally { + this.free(ptr); + } + } + + lastError(bytes = 16_384): KdlError { + const ptr = this.malloc(bytes); + try { + const returnCode = this.callNumber("kdl_last_error", ["number", "number"], [ptr, bytes]); + if (returnCode < 0) { + return { + code: "KDL_LAST_ERROR_FAILED", + message: "kdl_last_error failed", + diagnostics: [ + { + severity: "error", + code: "KDL_LAST_ERROR_FAILED", + message: "kdl_last_error failed" + } + ] + }; + } + return JSON.parse(this.module.UTF8ToString?.(ptr) ?? "") as KdlError; + } finally { + this.free(ptr); + } + } + + private assertRuntimeMethods(): void { + const missing = [ + ["cwrap", this.module.cwrap], + ["UTF8ToString", this.module.UTF8ToString], + ["_malloc", this.module._malloc], + ["_free", this.module._free] + ].flatMap(([name, value]) => (typeof value === "function" ? [] : [name as string])); + + if (missing.length > 0) { + throw new KdlStructuredError( + "KDL_C_ABI_RUNTIME_MISSING", + `KDL native module is missing runtime methods: ${missing.join(", ")}` + ); + } + } + + private malloc(bytes: number): number { + const ptr = this.module._malloc?.(bytes); + if (!ptr) { + throw new KdlStructuredError("KDL_WASM_ALLOC_FAILED", `Failed to allocate ${bytes} bytes`); + } + return ptr; + } + + private free(ptr: number): void { + this.module._free?.(ptr); + } +} diff --git a/kdl-wasm/web/src/kdl/nativeModule.ts b/kdl-wasm/web/src/kdl/nativeModule.ts new file mode 100644 index 0000000..36fb904 --- /dev/null +++ b/kdl-wasm/web/src/kdl/nativeModule.ts @@ -0,0 +1,58 @@ +import type { KdlInitOptions } from "./types.js"; + +export interface NativeKdlModule { + ccall: ( + ident: string, + returnType: string | null, + argTypes: Array, + args: unknown[] + ) => unknown; + cwrap?: ( + ident: string, + returnType: string | null, + argTypes: Array + ) => (...args: unknown[]) => unknown; + UTF8ToString?: (ptr: number) => string; + stringToUTF8?: (value: string, outPtr: number, maxBytesToWrite: number) => void; + lengthBytesUTF8?: (value: string) => number; + _malloc?: (size: number) => number; + _free?: (ptr: number) => void; + HEAPF64?: Float64Array; +} + +export type NativeKdlModuleLoader = (options: KdlInitOptions) => Promise; + +interface NativeKdlModuleFactoryOptions { + locateFile?: (path: string, prefix: string) => string; + print?: (text: string) => void; + printErr?: (text: string) => void; +} + +type NativeKdlModuleFactory = ( + options?: NativeKdlModuleFactoryOptions +) => Promise; + +export function createDefaultNativeKdlModuleLoader(defaultWrapperUrl?: string): NativeKdlModuleLoader { + return async (options) => { + const wrapperUrl = + options.wrapperUrl ?? defaultWrapperUrl ?? new URL("../../../build-wasm/kdl.js", import.meta.url).href; + const imported = (await import(/* @vite-ignore */ wrapperUrl)) as { + default?: NativeKdlModuleFactory; + createKdlModule?: NativeKdlModuleFactory; + }; + const factory = imported.default ?? imported.createKdlModule; + + if (typeof factory !== "function") { + throw new Error(`KDL WASM wrapper did not export a module factory: ${wrapperUrl}`); + } + + return factory({ + locateFile: (path, prefix) => { + if (path.endsWith(".wasm") && options.wasmUrl) { + return options.wasmUrl; + } + return new URL(path, prefix || wrapperUrl).href; + } + }); + }; +} diff --git a/kdl-wasm/web/src/kdl/performanceBaseline.ts b/kdl-wasm/web/src/kdl/performanceBaseline.ts new file mode 100644 index 0000000..26e1355 --- /dev/null +++ b/kdl-wasm/web/src/kdl/performanceBaseline.ts @@ -0,0 +1,256 @@ +import { KdlWorkerRuntime } from "./runtime.js"; +import type { PerformanceBaselineResult, PerformanceMetric, Pose, TrajectoryResult } from "./types.js"; + +const SIX_AXIS_URDF = ` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +`; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +export interface PerformanceBaselineOptions { + fkIterations?: number; + ikIterations?: number; + reachabilityTargets?: number; + sampleTime?: number; + trajectorySeconds?: number; +} + +export async function runPerformanceBaseline( + options: PerformanceBaselineOptions = {} +): Promise { + const fkIterations = options.fkIterations ?? 1_000; + const ikIterations = options.ikIterations ?? 200; + const reachabilityTargets = options.reachabilityTargets ?? 1_000; + const sampleTime = options.sampleTime ?? 0.004; + const trajectorySeconds = options.trajectorySeconds ?? 10; + const runtime = new KdlWorkerRuntime(); + const metrics: PerformanceMetric[] = []; + + const initStart = performance.now(); + await runtime.init({ wasmBuild: "performance-baseline" }); + const sixAxisHandle = await runtime.loadRobotFromUrdf(SIX_AXIS_URDF, { + robotId: "performance_6_axis", + baseLink: "base_link", + tipLink: "tool0" + }); + metrics.push(singleMetric("robot_init_6_axis", performance.now() - initStart, 1_000)); + + const fkInput = new Float64Array([0.1, -0.2, 0.15, 0.05, -0.1, 0.2]); + const fkOutput = new Float64Array(7); + metrics.push(await repeatedMetric("fk_pose7_typed_array", fkIterations, 1, () => { + return runtime.fkPose7(sixAxisHandle, fkInput, fkOutput); + })); + + const planarHandle = await runtime.loadRobotFromUrdf(PLANAR_URDF, { + robotId: "performance_planar", + baseLink: "base_link", + tipLink: "tool0" + }); + + const ikTargets = makeTargets(ikIterations, 0.15, 0.65); + metrics.push(await repeatedMetric("ik_planar_average", ikIterations, 10, (index) => { + return runtime.ik(planarHandle, new Float64Array([0, 0.2]), ikTargets[index]!, { + positionTolerance: 1e-9 + }); + })); + + const reachability = makePoseTargets(reachabilityTargets, 0.05, 0.95); + const reachabilityStart = performance.now(); + const reachabilityResult = await runtime.checkReachabilityBatch(planarHandle, reachability); + const reachabilityMs = performance.now() - reachabilityStart; + metrics.push({ + name: "reachability_batch_1000", + iterations: 1, + totalMs: reachabilityMs, + averageMs: reachabilityMs, + thresholdMs: 500, + points: reachabilityTargets, + ok: reachabilityMs <= 500 && reachabilityResult.length === reachabilityTargets + }); + + const trajectoryStart = performance.now(); + const trajectory = await runtime.planMoveJ(planarHandle, { + startJoints: [0, 0], + target: { + id: "ten_second_goal", + joints: [0, 1] + }, + speed: { + kind: "joint_abs", + velocity: 1 / trajectorySeconds, + acceleration: 1 + }, + zone: { + kind: "fine" + }, + sampleTime + }); + const trajectoryMs = performance.now() - trajectoryStart; + metrics.push(trajectoryMetric("trajectory_10s_4ms", trajectory, trajectoryMs, 500)); + + await runtime.dispose(); + return { + ok: metrics.every((metric) => metric.ok), + metrics, + diagnostics: metrics.flatMap((metric) => + metric.ok + ? [] + : [ + { + severity: "warning" as const, + code: "KDL_PERFORMANCE_BASELINE_MISS", + message: `${metric.name} exceeded ${metric.thresholdMs ?? "unbounded"} ms`, + data: { + metric + } + } + ] + ) + }; +} + +function singleMetric(name: string, totalMs: number, thresholdMs: number): PerformanceMetric { + return { + name, + iterations: 1, + totalMs, + averageMs: totalMs, + thresholdMs, + ok: totalMs <= thresholdMs + }; +} + +async function repeatedMetric( + name: string, + iterations: number, + thresholdMs: number, + fn: (index: number) => unknown | Promise +): Promise { + let maxMs = 0; + const start = performance.now(); + for (let index = 0; index < iterations; index += 1) { + const before = performance.now(); + await fn(index); + maxMs = Math.max(maxMs, performance.now() - before); + } + const totalMs = performance.now() - start; + const averageMs = totalMs / iterations; + return { + name, + iterations, + totalMs, + averageMs, + maxMs, + thresholdMs, + ok: averageMs <= thresholdMs + }; +} + +function trajectoryMetric( + name: string, + trajectory: TrajectoryResult, + totalMs: number, + thresholdMs: number +): PerformanceMetric { + const points = trajectory.points.length; + return { + name, + iterations: 1, + totalMs, + averageMs: totalMs, + thresholdMs, + points, + ok: trajectory.ok && points >= 2_500 && totalMs <= thresholdMs + }; +} + +function makeTargets(count: number, minRadius: number, maxRadius: number): Pose[] { + return Array.from({ length: count }, (_, index) => { + const ratio = count <= 1 ? 0 : index / (count - 1); + const angle = ratio * Math.PI * 2; + const radius = minRadius + (maxRadius - minRadius) * ((index % 97) / 96); + return pose(Math.cos(angle) * radius, Math.sin(angle) * radius); + }); +} + +function makePoseTargets(count: number, minRadius: number, maxRadius: number) { + return makeTargets(count, minRadius, maxRadius).map((poseValue, index) => ({ + id: `target_${index}`, + pose: poseValue + })); +} + +function pose(x: number, y: number): Pose { + return { + position: [x, y, 0], + quaternion: [0, 0, 0, 1] + }; +} diff --git a/kdl-wasm/web/src/kdl/poseApi.ts b/kdl-wasm/web/src/kdl/poseApi.ts new file mode 100644 index 0000000..702597c --- /dev/null +++ b/kdl-wasm/web/src/kdl/poseApi.ts @@ -0,0 +1,99 @@ +import { KdlStructuredError } from "./rpc.js"; +import { + composePose as composePoseMath, + inversePose as inversePoseMath, + normalizeQuaternion, + rpyToQuaternion +} from "../math/poseMath.js"; +import type { OffsetSpec, Pose, PoseLike, PoseTarget } from "./types.js"; + +export function normalizePose(input: PoseLike): Pose { + if (!input || typeof input !== "object") { + throw new KdlStructuredError("KDL_INVALID_POSE", "Pose input must be an object"); + } + + if ("position" in input && "quaternion" in input) { + return { + position: validateVector3(input.position, "position"), + quaternion: normalizeQuaternion(validateVector4(input.quaternion, "quaternion")) + }; + } + + if ("xyz" in input && "rpy" in input) { + return { + position: validateVector3(input.xyz, "xyz"), + quaternion: rpyToQuaternion(validateVector3(input.rpy, "rpy")) + }; + } + + if ("xyz" in input && "quat" in input) { + return { + position: validateVector3(input.xyz, "xyz"), + quaternion: normalizeQuaternion(validateVector4(input.quat, "quat")) + }; + } + + throw new KdlStructuredError("KDL_INVALID_POSE", "Pose input must contain position/quaternion, xyz/rpy, or xyz/quat"); +} + +export function composePose(a: Pose, b: Pose): Pose { + return composePoseMath(normalizePose(a), normalizePose(b)); +} + +export function inversePose(pose: Pose): Pose { + return inversePoseMath(normalizePose(pose)); +} + +export function applyToolAndFrame(target: PoseTarget, tool: Pose, frame: Pose): Pose { + return composePose(composePose(normalizePose(frame), normalizePose(target.pose)), normalizePose(tool)); +} + +export function applyOffset(target: PoseTarget, offset: OffsetSpec): PoseTarget { + const offsetPose = offsetToPose(offset); + const pose = offset.mode === "tool" ? composePose(target.pose, offsetPose) : composePose(offsetPose, target.pose); + + return { + ...target, + pose + }; +} + +function offsetToPose(offset: OffsetSpec): Pose { + const xyz: [number, number, number] = offset.xyz ? validateVector3(offset.xyz, "offset.xyz") : [0, 0, 0]; + if (offset.rpy && offset.quaternion) { + throw new KdlStructuredError("KDL_INVALID_OFFSET", "Offset cannot specify both rpy and quaternion"); + } + + if (offset.rpy) { + return { + position: xyz, + quaternion: rpyToQuaternion(validateVector3(offset.rpy, "offset.rpy")) + }; + } + + if (offset.quaternion) { + return { + position: xyz, + quaternion: normalizeQuaternion(validateVector4(offset.quaternion, "offset.quaternion")) + }; + } + + return { + position: xyz, + quaternion: [0, 0, 0, 1] + }; +} + +function validateVector3(value: unknown, field: string): [number, number, number] { + if (!Array.isArray(value) || value.length !== 3 || value.some((entry) => !Number.isFinite(entry))) { + throw new KdlStructuredError("KDL_INVALID_POSE", `${field} must contain 3 finite numbers`); + } + return [value[0]!, value[1]!, value[2]!]; +} + +function validateVector4(value: unknown, field: string): [number, number, number, number] { + if (!Array.isArray(value) || value.length !== 4 || value.some((entry) => !Number.isFinite(entry))) { + throw new KdlStructuredError("KDL_INVALID_POSE", `${field} must contain 4 finite numbers`); + } + return [value[0]!, value[1]!, value[2]!, value[3]!]; +} diff --git a/kdl-wasm/web/src/kdl/rpc.ts b/kdl-wasm/web/src/kdl/rpc.ts new file mode 100644 index 0000000..52dadbe --- /dev/null +++ b/kdl-wasm/web/src/kdl/rpc.ts @@ -0,0 +1,78 @@ +import type { KdlApiMethod, KdlError, KdlWasmApi, MotionDiagnostic } from "./types.js"; + +export interface KdlRpcRequest { + id: number; + method: KdlApiMethod; + payload: T; +} + +export interface KdlRpcErrorPayload { + code: string; + message: string; + diagnostics?: MotionDiagnostic[]; +} + +export interface KdlRpcResponse { + id: number; + ok: boolean; + result?: T; + error?: KdlRpcErrorPayload; +} + +export class KdlStructuredError extends Error implements KdlError { + readonly code: string; + readonly diagnostics: MotionDiagnostic[]; + + constructor(code: string, message: string, diagnostics?: MotionDiagnostic[]) { + super(message); + this.name = "KdlStructuredError"; + this.code = code; + this.diagnostics = diagnostics ?? [ + { + severity: "error", + code, + message + } + ]; + } +} + +export type KdlRuntimeHandlers = Partial<{ + [Method in keyof KdlWasmApi]: (...args: unknown[]) => Promise | unknown; +}>; + +export function createRpcError( + code: string, + message: string, + diagnostics?: MotionDiagnostic[] +): KdlRpcErrorPayload { + return { + code, + message, + diagnostics: + diagnostics ?? + [ + { + severity: "error", + code, + message + } + ] + }; +} + +export function normalizeThrownError(error: unknown): KdlRpcErrorPayload { + if (error instanceof KdlStructuredError) { + return createRpcError(error.code, error.message, error.diagnostics); + } + + if (error instanceof Error) { + return createRpcError("KDL_WORKER_ERROR", error.message); + } + + return createRpcError("KDL_WORKER_ERROR", String(error)); +} + +export function rpcErrorToException(error: KdlRpcErrorPayload): KdlStructuredError { + return new KdlStructuredError(error.code, error.message, error.diagnostics); +} diff --git a/kdl-wasm/web/src/kdl/runtime.ts b/kdl-wasm/web/src/kdl/runtime.ts new file mode 100644 index 0000000..34ecc8a --- /dev/null +++ b/kdl-wasm/web/src/kdl/runtime.ts @@ -0,0 +1,329 @@ +import { KdlStructuredError, type KdlRuntimeHandlers } from "./rpc.js"; +import type { NativeKdlModule, NativeKdlModuleLoader } from "./nativeModule.js"; +import { + applyOffset as applyOffsetToTarget, + applyToolAndFrame as applyToolAndFrameToTarget, + composePose as composeRuntimePose, + inversePose as inverseRuntimePose, + normalizePose as normalizeRuntimePose +} from "./poseApi.js"; +import { + makeTrapProfile as makeRuntimeTrapProfile, + sampleTrapProfile as sampleRuntimeTrapProfile +} from "./trapProfile.js"; +import { + estimateCycleTime as estimateRuntimeCycleTime, + resampleTrajectory as resampleRuntimeTrajectory +} from "./trajectoryUtils.js"; +import { loadRobotFromUrdfModel } from "../robot/urdfParser.js"; +import { RobotModelRegistry } from "../robot/normalizedRobotModel.js"; +import type { + FkOptions, + IkOptions, + JacobianOptions, + KdlInitOptions, + KdlRuntimeInfo, + MoveCRequest, + MoveJRequest, + MoveLRequest, + NormalizedRobotModel, + OffsetSpec, + PathPlanRequest, + PathPlanResult, + Pose, + PoseLike, + PoseNormalizeOptions, + PoseTarget, + RobotHandle, + TrapProfileOptions, + TrajectoryResult, + UrdfLoadOptions +} from "./types.js"; + +export class KdlWorkerRuntime { + private initialized = false; + private nativeModule: NativeKdlModule | undefined; + private readonly robots = new RobotModelRegistry(); + + constructor(private readonly loadNativeModule?: NativeKdlModuleLoader) {} + + async init(options?: KdlInitOptions): Promise { + if (this.loadNativeModule) { + await this.initNativeModule(options ?? {}); + } + + this.initialized = true; + + return { + version: "0.1.0", + wasmBuild: options?.wasmBuild ?? (this.nativeModule ? "wasm" : "stub"), + supportsThreads: options?.useThreads ?? false, + supportsWasmFs: false + }; + } + + async dispose(): Promise { + this.initialized = false; + this.nativeModule = undefined; + } + + assertInitialized(method: string): void { + if (!this.initialized) { + throw new KdlStructuredError( + "KDL_NOT_INITIALIZED", + `KDL runtime must be initialized before calling ${method}` + ); + } + } + + async loadRobotFromUrdf(urdfXml: string, options: UrdfLoadOptions): Promise { + this.assertInitialized("loadRobotFromUrdf"); + const model = loadRobotFromUrdfModel(urdfXml, options); + return this.createRobotFromModel(model); + } + + async createRobotFromModel(model: NormalizedRobotModel): Promise { + this.assertInitialized("createRobotFromModel"); + return this.robots.create(model); + } + + async destroyRobot(handle: RobotHandle): Promise { + this.assertInitialized("destroyRobot"); + this.robots.destroy(handle); + } + + async getRobotInfo(handle: RobotHandle) { + this.assertInitialized("getRobotInfo"); + return this.robots.getInfo(handle); + } + + async getJointLimits(handle: RobotHandle) { + this.assertInitialized("getJointLimits"); + return this.robots.getJointLimits(handle); + } + + async normalizePose(input: PoseLike, _options?: PoseNormalizeOptions) { + this.assertInitialized("normalizePose"); + return normalizeRuntimePose(input); + } + + async composePose(a: Pose, b: Pose) { + this.assertInitialized("composePose"); + return composeRuntimePose(a, b); + } + + async inversePose(pose: Pose) { + this.assertInitialized("inversePose"); + return inverseRuntimePose(pose); + } + + async applyToolAndFrame(target: PoseTarget, tool: Pose, frame: Pose) { + this.assertInitialized("applyToolAndFrame"); + return applyToolAndFrameToTarget(target, tool, frame); + } + + async applyOffset(target: PoseTarget, offset: OffsetSpec) { + this.assertInitialized("applyOffset"); + return applyOffsetToTarget(target, offset); + } + + async makeTrapProfile(length: number, options: TrapProfileOptions) { + this.assertInitialized("makeTrapProfile"); + return makeRuntimeTrapProfile(length, options); + } + + async sampleTrapProfile(length: number, options: TrapProfileOptions) { + this.assertInitialized("sampleTrapProfile"); + return sampleRuntimeTrapProfile(length, options); + } + + async fk(handle: RobotHandle, joints: Float64Array | number[], options?: FkOptions) { + this.assertInitialized("fk"); + return this.robots.fk(handle, joints, options); + } + + async fkPose7(handle: RobotHandle, joints: Float64Array | number[], out?: Float64Array, options?: FkOptions) { + this.assertInitialized("fkPose7"); + return this.robots.fkPose7(handle, joints, out, options); + } + + async fkAllLinks(handle: RobotHandle, joints: Float64Array | number[], options?: FkOptions) { + this.assertInitialized("fkAllLinks"); + return this.robots.fkAllLinks(handle, joints, options); + } + + async ik(handle: RobotHandle, seed: Float64Array | number[], target: Pose, options?: IkOptions) { + this.assertInitialized("ik"); + return this.robots.ik(handle, seed, target, options); + } + + async ikBatch( + handle: RobotHandle, + seeds: Array, + targets: Pose[], + options?: IkOptions + ) { + this.assertInitialized("ikBatch"); + return this.robots.ikBatch(handle, seeds, targets, options); + } + + async jacobian(handle: RobotHandle, joints: Float64Array | number[], options?: JacobianOptions) { + this.assertInitialized("jacobian"); + return this.robots.jacobian(handle, joints, options); + } + + async checkSingularity(handle: RobotHandle, joints: Float64Array | number[]) { + this.assertInitialized("checkSingularity"); + return this.robots.checkSingularity(handle, joints); + } + + async checkJointLimits(handle: RobotHandle, joints: Float64Array | number[]) { + this.assertInitialized("checkJointLimits"); + return this.robots.checkJointLimits(handle, joints); + } + + async checkVelocityLimits(handle: RobotHandle, trajectory: TrajectoryResult) { + this.assertInitialized("checkVelocityLimits"); + return this.robots.checkVelocityLimits(handle, trajectory); + } + + async checkReachability(handle: RobotHandle, target: PoseTarget, options?: IkOptions) { + this.assertInitialized("checkReachability"); + return this.robots.checkReachability(handle, target, options); + } + + async checkReachabilityBatch(handle: RobotHandle, targets: PoseTarget[], options?: IkOptions) { + this.assertInitialized("checkReachabilityBatch"); + return this.robots.checkReachabilityBatch(handle, targets, options); + } + + async planMoveJ(handle: RobotHandle, request: MoveJRequest) { + this.assertInitialized("planMoveJ"); + return this.robots.planMoveJ(handle, request); + } + + async planMoveL(handle: RobotHandle, request: MoveLRequest) { + this.assertInitialized("planMoveL"); + return this.robots.planMoveL(handle, request); + } + + async planMoveC(handle: RobotHandle, request: MoveCRequest) { + this.assertInitialized("planMoveC"); + return this.robots.planMoveC(handle, request); + } + + async planPath(handle: RobotHandle, request: PathPlanRequest) { + this.assertInitialized("planPath"); + return this.robots.planPath(handle, request); + } + + async validatePath(handle: RobotHandle, request: PathPlanRequest) { + this.assertInitialized("validatePath"); + return this.robots.validatePath(handle, request); + } + + async estimateCycleTime(input: TrajectoryResult | PathPlanResult) { + this.assertInitialized("estimateCycleTime"); + return estimateRuntimeCycleTime(input); + } + + async resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number) { + this.assertInitialized("resampleTrajectory"); + return resampleRuntimeTrajectory(trajectory, sampleTime); + } + + private async initNativeModule(options: KdlInitOptions): Promise { + try { + const nativeModule = await this.loadNativeModule?.(options); + if (!nativeModule) { + throw new Error("No KDL native module was returned"); + } + + const result = nativeModule.ccall("kdl_init", "number", ["string"], [JSON.stringify(options)]); + if (Number(result) !== 0) { + throw new Error(`kdl_init returned ${String(result)}`); + } + + this.nativeModule = nativeModule; + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + throw new KdlStructuredError( + "KDL_WASM_INIT_FAILED", + `Failed to initialize KDL WASM runtime: ${message}` + ); + } + } +} + +export function createKdlWorkerRuntime(loadNativeModule?: NativeKdlModuleLoader): KdlRuntimeHandlers { + const runtime = new KdlWorkerRuntime(loadNativeModule); + + return { + init: (options?: unknown) => runtime.init(options as KdlInitOptions | undefined), + dispose: () => runtime.dispose(), + loadRobotFromUrdf: (urdfXml: unknown, options: unknown) => + runtime.loadRobotFromUrdf(urdfXml as string, options as UrdfLoadOptions), + createRobotFromModel: (model: unknown) => runtime.createRobotFromModel(model as NormalizedRobotModel), + destroyRobot: (handle: unknown) => runtime.destroyRobot(handle as RobotHandle), + getRobotInfo: (handle: unknown) => runtime.getRobotInfo(handle as RobotHandle), + getJointLimits: (handle: unknown) => runtime.getJointLimits(handle as RobotHandle), + normalizePose: (input: unknown, options: unknown) => + runtime.normalizePose(input as PoseLike, options as PoseNormalizeOptions | undefined), + composePose: (a: unknown, b: unknown) => runtime.composePose(a as Pose, b as Pose), + inversePose: (pose: unknown) => runtime.inversePose(pose as Pose), + applyToolAndFrame: (target: unknown, tool: unknown, frame: unknown) => + runtime.applyToolAndFrame(target as PoseTarget, tool as Pose, frame as Pose), + applyOffset: (target: unknown, offset: unknown) => + runtime.applyOffset(target as PoseTarget, offset as OffsetSpec), + makeTrapProfile: (length: unknown, options: unknown) => + runtime.makeTrapProfile(length as number, options as TrapProfileOptions), + sampleTrapProfile: (length: unknown, options: unknown) => + runtime.sampleTrapProfile(length as number, options as TrapProfileOptions), + fk: (handle: unknown, joints: unknown, options: unknown) => + runtime.fk(handle as RobotHandle, joints as Float64Array | number[], options as FkOptions | undefined), + fkPose7: (handle: unknown, joints: unknown, out: unknown, options: unknown) => + runtime.fkPose7( + handle as RobotHandle, + joints as Float64Array | number[], + out as Float64Array | undefined, + options as FkOptions | undefined + ), + fkAllLinks: (handle: unknown, joints: unknown, options: unknown) => + runtime.fkAllLinks(handle as RobotHandle, joints as Float64Array | number[], options as FkOptions | undefined), + ik: (handle: unknown, seed: unknown, target: unknown, options: unknown) => + runtime.ik(handle as RobotHandle, seed as Float64Array | number[], target as Pose, options as IkOptions | undefined), + ikBatch: (handle: unknown, seeds: unknown, targets: unknown, options: unknown) => + runtime.ikBatch( + handle as RobotHandle, + seeds as Array, + targets as Pose[], + options as IkOptions | undefined + ), + jacobian: (handle: unknown, joints: unknown, options: unknown) => + runtime.jacobian(handle as RobotHandle, joints as Float64Array | number[], options as JacobianOptions | undefined), + checkSingularity: (handle: unknown, joints: unknown) => + runtime.checkSingularity(handle as RobotHandle, joints as Float64Array | number[]), + checkJointLimits: (handle: unknown, joints: unknown) => + runtime.checkJointLimits(handle as RobotHandle, joints as Float64Array | number[]), + checkVelocityLimits: (handle: unknown, trajectory: unknown) => + runtime.checkVelocityLimits(handle as RobotHandle, trajectory as TrajectoryResult), + checkReachability: (handle: unknown, target: unknown, options: unknown) => + runtime.checkReachability(handle as RobotHandle, target as PoseTarget, options as IkOptions | undefined), + checkReachabilityBatch: (handle: unknown, targets: unknown, options: unknown) => + runtime.checkReachabilityBatch(handle as RobotHandle, targets as PoseTarget[], options as IkOptions | undefined), + planMoveJ: (handle: unknown, request: unknown) => + runtime.planMoveJ(handle as RobotHandle, request as MoveJRequest), + planMoveL: (handle: unknown, request: unknown) => + runtime.planMoveL(handle as RobotHandle, request as MoveLRequest), + planMoveC: (handle: unknown, request: unknown) => + runtime.planMoveC(handle as RobotHandle, request as MoveCRequest), + planPath: (handle: unknown, request: unknown) => + runtime.planPath(handle as RobotHandle, request as PathPlanRequest), + validatePath: (handle: unknown, request: unknown) => + runtime.validatePath(handle as RobotHandle, request as PathPlanRequest), + estimateCycleTime: (input: unknown) => + runtime.estimateCycleTime(input as TrajectoryResult | PathPlanResult), + resampleTrajectory: (trajectory: unknown, sampleTime: unknown) => + runtime.resampleTrajectory(trajectory as TrajectoryResult, sampleTime as number) + }; +} diff --git a/kdl-wasm/web/src/kdl/trajectoryUtils.ts b/kdl-wasm/web/src/kdl/trajectoryUtils.ts new file mode 100644 index 0000000..71d0cb7 --- /dev/null +++ b/kdl-wasm/web/src/kdl/trajectoryUtils.ts @@ -0,0 +1,163 @@ +import { KdlStructuredError } from "./rpc.js"; +import type { + CycleTimeResult, + MotionDiagnostic, + PathPlanResult, + Pose, + TrajectoryPoint, + TrajectoryResult +} from "./types.js"; + +export function estimateCycleTime(input: TrajectoryResult | PathPlanResult): CycleTimeResult { + const diagnostics: MotionDiagnostic[] = input.diagnostics ?? []; + if (isPathPlanResult(input)) { + const segmentTimes = input.segments.map((segment) => + cycleTimeSegment(segment.motion, segment.duration, segment.points[0]?.segmentId) + ); + return { + ok: input.ok, + motionTime: input.duration, + totalTime: input.duration, + segmentTimes, + diagnostics + }; + } + + return { + ok: input.ok, + motionTime: input.duration, + totalTime: input.duration, + segmentTimes: [cycleTimeSegment(input.motion, input.duration, input.points[0]?.segmentId)], + diagnostics + }; +} + +function cycleTimeSegment( + motion: TrajectoryResult["motion"], + duration: number, + segmentId?: string +): CycleTimeResult["segmentTimes"][number] { + return { + motion, + duration, + ...(segmentId ? { segmentId } : {}) + }; +} + +export function resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number): TrajectoryResult { + if (!Number.isFinite(sampleTime) || sampleTime <= 0) { + throw new KdlStructuredError("KDL_INVALID_SAMPLE_TIME", "sampleTime must be a finite positive number"); + } + if (trajectory.points.length === 0) { + return { + ...trajectory, + sampleTime, + diagnostics: [ + ...trajectory.diagnostics, + { + severity: "warning", + code: "KDL_RESAMPLE_EMPTY_TRAJECTORY", + message: "Cannot resample a trajectory without points" + } + ] + }; + } + + const duration = trajectory.duration; + const times = duration === 0 ? [0] : sampleTimes(duration, sampleTime); + const points = times.map((time, index) => { + const source = interpolatePoint(trajectory.points, time); + const previous = index > 0 ? times[index - 1]! : time; + return { + ...source, + index, + time, + dt: index === 0 ? 0 : time - previous + }; + }); + + return { + ...trajectory, + sampleTime, + points, + diagnostics: [ + ...trajectory.diagnostics, + { + severity: "info", + code: "KDL_TRAJECTORY_RESAMPLED", + message: `Trajectory was resampled to ${sampleTime}s` + } + ] + }; +} + +function isPathPlanResult(input: TrajectoryResult | PathPlanResult): input is PathPlanResult { + return "segments" in input; +} + +function sampleTimes(duration: number, sampleTime: number): number[] { + const times: number[] = [0]; + for (let time = sampleTime; time < duration - 1e-12; time += sampleTime) { + times.push(time); + } + times.push(duration); + return times; +} + +function interpolatePoint(points: TrajectoryPoint[], time: number): TrajectoryPoint { + if (time <= points[0]!.time) { + return { + ...points[0]!, + joints: [...points[0]!.joints], + jointVelocity: [...points[0]!.jointVelocity], + jointAcceleration: [...points[0]!.jointAcceleration] + }; + } + const last = points.at(-1)!; + if (time >= last.time) { + return { + ...last, + joints: [...last.joints], + jointVelocity: [...last.jointVelocity], + jointAcceleration: [...last.jointAcceleration] + }; + } + + const nextIndex = points.findIndex((point) => point.time >= time); + const next = points[nextIndex]!; + const prev = points[nextIndex - 1]!; + const ratio = (time - prev.time) / (next.time - prev.time); + return { + ...next, + time, + s: lerp(prev.s, next.s, ratio), + sd: lerp(prev.sd, next.sd, ratio), + sdd: lerp(prev.sdd, next.sdd, ratio), + joints: lerpArray(prev.joints, next.joints, ratio), + jointVelocity: lerpArray(prev.jointVelocity, next.jointVelocity, ratio), + jointAcceleration: lerpArray(prev.jointAcceleration, next.jointAcceleration, ratio), + flange: lerpPose(prev.flange, next.flange, ratio), + tcp: lerpPose(prev.tcp, next.tcp, ratio), + diagnostics: [] + }; +} + +function lerp(a: number, b: number, ratio: number): number { + return a + (b - a) * ratio; +} + +function lerpArray(a: number[], b: number[], ratio: number): number[] { + const length = Math.max(a.length, b.length); + return Array.from({ length }, (_, index) => lerp(a[index] ?? 0, b[index] ?? 0, ratio)); +} + +function lerpPose(a: Pose, b: Pose, ratio: number): Pose { + return { + position: [ + lerp(a.position[0], b.position[0], ratio), + lerp(a.position[1], b.position[1], ratio), + lerp(a.position[2], b.position[2], ratio) + ], + quaternion: ratio < 0.5 ? a.quaternion : b.quaternion + }; +} diff --git a/kdl-wasm/web/src/kdl/trapProfile.ts b/kdl-wasm/web/src/kdl/trapProfile.ts new file mode 100644 index 0000000..01dc4da --- /dev/null +++ b/kdl-wasm/web/src/kdl/trapProfile.ts @@ -0,0 +1,222 @@ +import { KdlStructuredError } from "./rpc.js"; +import type { MotionDiagnostic, TrapProfileOptions, TrapProfileResult, TrapSample } from "./types.js"; + +export function makeTrapProfile(length: number, options: TrapProfileOptions): TrapProfileResult { + validateTrapInputs(length, options); + + if (length === 0) { + return { + ok: true, + type: "triangle", + length, + duration: 0, + tAccel: 0, + tConst: 0, + tDecel: 0, + vPeak: 0, + samples: [ + { + index: 0, + time: 0, + s: 0, + sd: 0, + sdd: 0 + } + ], + diagnostics: [ + { + severity: "info", + code: "KDL_TRAP_ZERO_LENGTH", + message: "Trap profile length is zero" + } + ] + }; + } + + const startVelocity = options.startVelocity ?? 0; + const endVelocity = options.endVelocity ?? 0; + const maxVelocity = options.maxVelocity; + const maxAcceleration = options.maxAcceleration; + const dAccelToMax = distanceForVelocityChange(startVelocity, maxVelocity, maxAcceleration); + const dDecelFromMax = distanceForVelocityChange(endVelocity, maxVelocity, maxAcceleration); + const diagnostics: MotionDiagnostic[] = []; + let type: TrapProfileResult["type"] = "trapezoid"; + let vPeak = maxVelocity; + let tConst = 0; + + if (dAccelToMax + dDecelFromMax <= length) { + tConst = (length - dAccelToMax - dDecelFromMax) / maxVelocity; + } else { + type = "triangle"; + vPeak = Math.sqrt(Math.max(0, maxAcceleration * length + (startVelocity ** 2 + endVelocity ** 2) / 2)); + if (vPeak + 1e-12 < Math.max(startVelocity, endVelocity)) { + throw new KdlStructuredError( + "KDL_INVALID_TRAP_PROFILE", + "Profile length is too short for the requested startVelocity/endVelocity" + ); + } + tConst = 0; + diagnostics.push({ + severity: "info", + code: "KDL_TRAP_TRIANGLE_PROFILE", + message: "Trap profile length is too short to reach maxVelocity; using triangle profile" + }); + } + + const tAccel = Math.max(0, (vPeak - startVelocity) / maxAcceleration); + const tDecel = Math.max(0, (vPeak - endVelocity) / maxAcceleration); + const duration = tAccel + tConst + tDecel; + const samples = sampleProfile({ + length, + sampleTime: options.sampleTime, + startVelocity, + endVelocity, + maxAcceleration, + tAccel, + tConst, + tDecel, + vPeak, + duration + }); + + return { + ok: true, + type, + length, + duration, + tAccel, + tConst, + tDecel, + vPeak, + samples, + diagnostics + }; +} + +export function sampleTrapProfile(length: number, options: TrapProfileOptions): TrapSample[] { + return makeTrapProfile(length, options).samples; +} + +interface ProfileSegments { + length: number; + sampleTime: number; + startVelocity: number; + endVelocity: number; + maxAcceleration: number; + tAccel: number; + tConst: number; + tDecel: number; + vPeak: number; + duration: number; +} + +function validateTrapInputs(length: number, options: TrapProfileOptions): void { + if (!Number.isFinite(length) || length < 0) { + throw new KdlStructuredError("KDL_INVALID_TRAP_PROFILE", "Trap profile length must be a finite non-negative number"); + } + if (!Number.isFinite(options.maxVelocity) || options.maxVelocity <= 0) { + throw new KdlStructuredError("KDL_INVALID_TRAP_PROFILE", "maxVelocity must be a finite positive number"); + } + if (!Number.isFinite(options.maxAcceleration) || options.maxAcceleration <= 0) { + throw new KdlStructuredError("KDL_INVALID_TRAP_PROFILE", "maxAcceleration must be a finite positive number"); + } + if (!Number.isFinite(options.sampleTime) || options.sampleTime <= 0) { + throw new KdlStructuredError("KDL_INVALID_TRAP_PROFILE", "sampleTime must be a finite positive number"); + } + + const startVelocity = options.startVelocity ?? 0; + const endVelocity = options.endVelocity ?? 0; + if (length === 0 && (startVelocity > 0 || endVelocity > 0)) { + throw new KdlStructuredError( + "KDL_INVALID_TRAP_PROFILE", + "Zero-length trap profile requires zero startVelocity and endVelocity" + ); + } + if (!Number.isFinite(startVelocity) || startVelocity < 0 || startVelocity > options.maxVelocity) { + throw new KdlStructuredError( + "KDL_INVALID_TRAP_PROFILE", + "startVelocity must be finite, non-negative, and no greater than maxVelocity" + ); + } + if (!Number.isFinite(endVelocity) || endVelocity < 0 || endVelocity > options.maxVelocity) { + throw new KdlStructuredError( + "KDL_INVALID_TRAP_PROFILE", + "endVelocity must be finite, non-negative, and no greater than maxVelocity" + ); + } +} + +function distanceForVelocityChange(fromVelocity: number, toVelocity: number, acceleration: number): number { + return Math.max(0, (toVelocity ** 2 - fromVelocity ** 2) / (2 * acceleration)); +} + +function sampleProfile(profile: ProfileSegments): TrapSample[] { + if (profile.duration === 0) { + return [ + { + index: 0, + time: 0, + s: 0, + sd: 0, + sdd: 0 + } + ]; + } + + const times: number[] = [0]; + for (let time = profile.sampleTime; time < profile.duration - 1e-12; time += profile.sampleTime) { + times.push(time); + } + times.push(profile.duration); + + return times.map((time, index) => { + const sample = sampleAtTime(profile, time); + return { + index, + time, + s: index === 0 ? 0 : index === times.length - 1 ? 1 : clamp01(sample.distance / profile.length), + sd: sample.velocity / profile.length, + sdd: sample.acceleration / profile.length + }; + }); +} + +function sampleAtTime(profile: ProfileSegments, time: number): { + distance: number; + velocity: number; + acceleration: number; +} { + const accelDistance = + profile.startVelocity * profile.tAccel + 0.5 * profile.maxAcceleration * profile.tAccel ** 2; + const constDistance = profile.vPeak * profile.tConst; + const accelEnd = profile.tAccel; + const constEnd = profile.tAccel + profile.tConst; + + if (time <= accelEnd) { + return { + distance: profile.startVelocity * time + 0.5 * profile.maxAcceleration * time ** 2, + velocity: profile.startVelocity + profile.maxAcceleration * time, + acceleration: profile.maxAcceleration + }; + } + + if (time <= constEnd) { + const localTime = time - profile.tAccel; + return { + distance: accelDistance + profile.vPeak * localTime, + velocity: profile.vPeak, + acceleration: 0 + }; + } + + const localTime = Math.min(time - constEnd, profile.tDecel); + return { + distance: accelDistance + constDistance + profile.vPeak * localTime - 0.5 * profile.maxAcceleration * localTime ** 2, + velocity: Math.max(profile.endVelocity, profile.vPeak - profile.maxAcceleration * localTime), + acceleration: -profile.maxAcceleration + }; +} + +function clamp01(value: number): number { + return Math.min(1, Math.max(0, value)); +} diff --git a/kdl-wasm/web/src/kdl/types.ts b/kdl-wasm/web/src/kdl/types.ts new file mode 100644 index 0000000..3fb5349 --- /dev/null +++ b/kdl-wasm/web/src/kdl/types.ts @@ -0,0 +1,494 @@ +export type RobotHandle = number; + +export interface MotionSourceMap { + file?: string; + line?: number; + column?: number; + module?: string; +} + +export interface MotionDiagnostic { + severity: "info" | "warning" | "error"; + code: string; + message: string; + time?: number; + pointIndex?: number; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + data?: Record; +} + +export interface KdlError { + code: string; + message: string; + diagnostics: MotionDiagnostic[]; +} + +export interface KdlInitOptions { + wrapperUrl?: string; + wasmUrl?: string; + useThreads?: boolean; + wasmBuild?: string; +} + +export interface KdlRuntimeInfo { + version: string; + kdlVersion?: string; + wasmBuild: string; + supportsThreads: boolean; + supportsWasmFs: boolean; +} + +export interface Pose { + position: [number, number, number]; + quaternion: [number, number, number, number]; +} + +export type PoseLike = + | Pose + | { xyz: [number, number, number]; rpy: [number, number, number] } + | { xyz: [number, number, number]; quat: [number, number, number, number] }; + +export interface RobotConfiguration { + shoulder?: -1 | 0 | 1; + elbow?: -1 | 0 | 1; + wrist?: -1 | 0 | 1; + turnNumbers?: number[]; +} + +export interface PoseTarget { + id?: string; + pose: Pose; + config?: RobotConfiguration; + tool?: Pose; + frame?: Pose; + extAxis?: number[]; + sourceMap?: MotionSourceMap; +} + +export interface JointTarget { + id?: string; + joints: number[]; + extAxis?: number[]; + sourceMap?: MotionSourceMap; +} + +export type SpeedSpec = + | { kind: "joint_percent"; value: number } + | { kind: "joint_abs"; velocity: number; acceleration?: number } + | { kind: "linear"; velocity: number; acceleration?: number; angularVelocity?: number }; + +export type ZoneSpec = + | { kind: "fine" } + | { kind: "distance"; value: number } + | { kind: "cnt"; value: number } + | { kind: "continuous" }; + +export interface JointLimits { + name: string; + lower: number; + upper: number; + velocity: number; + acceleration: number; + jerk?: number; +} + +export interface RobotInfo { + handle: RobotHandle; + robotId: string; + name: string; + baseLink: string; + tipLink: string; + dof: number; + jointNames: string[]; + limits: JointLimits[]; +} + +export type JointType = "revolute" | "continuous" | "prismatic" | "fixed"; + +export interface LinkModel { + name: string; +} + +export interface JointModel { + name: string; + type: JointType; + parent: string; + child: string; + origin: { + xyz: [number, number, number]; + rpy: [number, number, number]; + }; + axis: [number, number, number]; + limit?: JointLimits; +} + +export interface NormalizedRobotModel { + robotId: string; + baseLink: string; + tipLink: string; + name: string; + links: LinkModel[]; + joints: JointModel[]; + activeJointNames: string[]; + limits: JointLimits[]; + source: { + type: "urdf"; + urdfHash: string; + }; +} + +export type JsonObject = Record; +export interface JointLimitOverride { + name: string; + lower?: number; + upper?: number; + velocity?: number; + acceleration?: number; + jerk?: number; +} + +export interface UrdfLoadOptions { + robotId: string; + baseLink: string; + tipLink: string; + tool?: Pose; + base?: Pose; + jointOrder?: string[]; + overrideLimits?: JointLimitOverride[]; +} +export type PoseNormalizeOptions = JsonObject; +export interface OffsetSpec { + mode: "frame" | "tool" | "world"; + frameId?: string; + xyz?: [number, number, number]; + rpy?: [number, number, number]; + quaternion?: [number, number, number, number]; +} +export interface FkOptions { + tool?: Pose; + frame?: Pose; + includeFlange?: boolean; +} + +export interface FkResult { + ok: boolean; + flange: Pose; + tcp: Pose; + joints: number[]; + diagnostics: MotionDiagnostic[]; +} + +export type Pose7Array = Float64Array | [number, number, number, number, number, number, number] | number[]; + +export interface LinkPoseResult { + ok: boolean; + linkPoses: Array<{ link: string; pose: Pose }>; + diagnostics: MotionDiagnostic[]; +} +export type JacobianOptions = JsonObject; +export interface JacobianResult { + ok: boolean; + rows: number; + cols: number; + data: Float64Array | number[]; + diagnostics: MotionDiagnostic[]; +} +export interface IkOptions { + tool?: Pose; + frame?: Pose; + qMin?: number[]; + qMax?: number[]; + maxIterations?: number; + positionTolerance?: number; + orientationTolerance?: number; + seeds?: number[][]; + preferredConfig?: RobotConfiguration; + allowApproximate?: boolean; +} + +export interface IkResult { + ok: boolean; + joints?: number[]; + iterations: number; + residualPosition?: number; + residualOrientation?: number; + configuration?: RobotConfiguration; + reason?: "unreachable" | "joint_limit" | "singularity" | "max_iteration" | "invalid_model"; + diagnostics: MotionDiagnostic[]; +} +export interface LimitCheckResult { + ok: boolean; + diagnostics: MotionDiagnostic[]; + maxJointVelocityRatio?: number; + maxJointAccelerationRatio?: number; +} + +export interface SingularityResult { + ok: boolean; + nearSingularity: boolean; + manipulability?: number; + conditionNumber?: number; + diagnostics: MotionDiagnostic[]; +} + +export interface ReachabilityResult { + ok: boolean; + reachable: boolean; + targetId?: string; + joints?: number[]; + residualPosition?: number; + residualOrientation?: number; + nearestPose?: Pose; + diagnostics: MotionDiagnostic[]; +} +export interface TrapProfileOptions { + maxVelocity: number; + maxAcceleration: number; + sampleTime: number; + startVelocity?: number; + endVelocity?: number; +} + +export interface TrapSample { + index: number; + time: number; + s: number; + sd: number; + sdd: number; +} + +export interface TrapProfileResult { + ok: boolean; + type: "trapezoid" | "triangle"; + length: number; + duration: number; + tAccel: number; + tConst: number; + tDecel: number; + vPeak: number; + samples: TrapSample[]; + diagnostics: MotionDiagnostic[]; +} +export interface MoveJRequest { + startJoints: number[]; + target: JointTarget | PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} + +export interface MoveLRequest { + startJoints: number[]; + target: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + orientationMode?: "fixed" | "slerp" | "tool_z_lock"; + ik?: IkOptions; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} + +export interface MoveCRequest { + startJoints: number[]; + via: PoseTarget; + target: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + orientationMode?: "fixed" | "slerp"; + arcMode?: "via" | "center" | "radius"; + circleDirection?: "short" | "long" | "cw" | "ccw"; + ik?: IkOptions; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} +export type MotionKind = "MOVEJ" | "MOVEL" | "MOVEC"; + +export interface TrajectoryEvent { + id?: string; + time: number; + pointIndex: number; + kind: string; + sourceMap?: MotionSourceMap; + data?: JsonObject; +} + +export interface TrajectoryPoint { + index: number; + time: number; + dt: number; + s: number; + sd: number; + sdd: number; + joints: number[]; + jointVelocity: number[]; + jointAcceleration: number[]; + flange: Pose; + tcp: Pose; + tcpVelocity?: [number, number, number, number, number, number]; + tcpAcceleration?: [number, number, number, number, number, number]; + motion: MotionKind; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + diagnostics: MotionDiagnostic[]; +} + +export interface TrajectoryResult { + ok: boolean; + motion: MotionKind; + duration: number; + sampleTime: number; + points: TrajectoryPoint[]; + events: TrajectoryEvent[]; + diagnostics: MotionDiagnostic[]; + meta?: JsonObject; +} +export interface MotionSegmentRequest { + id: string; + motion: MotionKind; + target?: JointTarget | PoseTarget; + via?: PoseTarget; + targetId?: string; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sourceMap?: MotionSourceMap; + source?: JsonObject; +} + +export interface PathEventRequest { + id?: string; + timing: "before" | "after" | "at"; + pointId: string; + distance?: number; + kind: string; + sourceMap?: MotionSourceMap; + data?: JsonObject; +} + +export interface PathPlanRequest { + pathId?: string; + startJoints: number[]; + segments: MotionSegmentRequest[]; + events?: PathEventRequest[]; + sampleTime: number; + speedOverride?: number; + stopOnError?: boolean; + source?: JsonObject; +} + +export interface PathPlanResult { + ok: boolean; + duration: number; + segments: TrajectoryResult[]; + points: TrajectoryPoint[]; + diagnostics: MotionDiagnostic[]; +} + +export interface SegmentValidationReport { + segmentId: string; + ok: boolean; + motion: MotionKind; + duration?: number; + maxJointVelocityRatio?: number; + maxJointAccelerationRatio?: number; + maxCartesianError?: number; + diagnostics: MotionDiagnostic[]; +} + +export interface PathValidationResult { + ok: boolean; + reachable: boolean; + cycleTime?: number; + segmentReports: SegmentValidationReport[]; + diagnostics: MotionDiagnostic[]; +} +export interface CycleTimeSegment { + segmentId?: string; + motion: MotionKind; + duration: number; +} + +export interface CycleTimeResult { + ok: boolean; + motionTime: number; + waitTime?: number; + ioTime?: number; + totalTime: number; + segmentTimes: CycleTimeSegment[]; + diagnostics: MotionDiagnostic[]; +} + +export interface PerformanceMetric { + name: string; + iterations: number; + totalMs: number; + averageMs: number; + thresholdMs?: number; + maxMs?: number; + points?: number; + ok: boolean; +} + +export interface PerformanceBaselineResult { + ok: boolean; + metrics: PerformanceMetric[]; + diagnostics: MotionDiagnostic[]; +} + +export interface KdlWasmApi { + init(options?: KdlInitOptions): Promise; + dispose(): Promise; + + loadRobotFromUrdf(urdfXml: string, options: UrdfLoadOptions): Promise; + createRobotFromModel(model: NormalizedRobotModel): Promise; + destroyRobot(handle: RobotHandle): Promise; + getRobotInfo(handle: RobotHandle): Promise; + getJointLimits(handle: RobotHandle): Promise; + + normalizePose(input: PoseLike, options?: PoseNormalizeOptions): Promise; + composePose(a: Pose, b: Pose): Promise; + inversePose(pose: Pose): Promise; + applyToolAndFrame(target: PoseTarget, tool: Pose, frame: Pose): Promise; + applyOffset(target: PoseTarget, offset: OffsetSpec): Promise; + + fk(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise; + fkPose7(handle: RobotHandle, joints: Float64Array, out?: Float64Array, options?: FkOptions): Promise; + fkAllLinks(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise; + jacobian(handle: RobotHandle, joints: Float64Array, options?: JacobianOptions): Promise; + ik(handle: RobotHandle, seed: Float64Array, target: Pose, options?: IkOptions): Promise; + ikBatch(handle: RobotHandle, seeds: Float64Array[], targets: Pose[], options?: IkOptions): Promise; + + checkJointLimits(handle: RobotHandle, joints: Float64Array): Promise; + checkVelocityLimits(handle: RobotHandle, trajectory: TrajectoryResult): Promise; + checkSingularity(handle: RobotHandle, joints: Float64Array): Promise; + checkReachability(handle: RobotHandle, target: PoseTarget, options?: IkOptions): Promise; + checkReachabilityBatch(handle: RobotHandle, targets: PoseTarget[], options?: IkOptions): Promise; + + makeTrapProfile(length: number, options: TrapProfileOptions): Promise; + sampleTrapProfile(length: number, options: TrapProfileOptions): Promise; + + planMoveJ(handle: RobotHandle, request: MoveJRequest): Promise; + planMoveL(handle: RobotHandle, request: MoveLRequest): Promise; + planMoveC(handle: RobotHandle, request: MoveCRequest): Promise; + + planPath(handle: RobotHandle, request: PathPlanRequest): Promise; + validatePath(handle: RobotHandle, request: PathPlanRequest): Promise; + estimateCycleTime(input: TrajectoryResult | PathPlanResult): Promise; + resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number): Promise; +} + +export type KdlApiMethod = keyof KdlWasmApi; diff --git a/kdl-wasm/web/src/kdl/workerRpc.ts b/kdl-wasm/web/src/kdl/workerRpc.ts new file mode 100644 index 0000000..d5b02ed --- /dev/null +++ b/kdl-wasm/web/src/kdl/workerRpc.ts @@ -0,0 +1,49 @@ +import { + createRpcError, + normalizeThrownError, + type KdlRpcRequest, + type KdlRpcResponse, + type KdlRuntimeHandlers +} from "./rpc.js"; + +export async function dispatchKdlRpcRequest( + runtime: KdlRuntimeHandlers, + request: KdlRpcRequest +): Promise { + if (!Number.isInteger(request.id)) { + return { + id: Number.isFinite(request.id) ? request.id : -1, + ok: false, + error: createRpcError("KDL_RPC_INVALID_ID", "RPC request id must be an integer") + }; + } + + const handler = runtime[request.method]; + if (typeof handler !== "function") { + return { + id: request.id, + ok: false, + error: createRpcError( + "KDL_METHOD_NOT_IMPLEMENTED", + `${String(request.method)} is not implemented by the KDL worker runtime` + ) + }; + } + + const args = Array.isArray(request.payload) ? request.payload : [request.payload]; + + try { + const result = await handler(...args); + return { + id: request.id, + ok: true, + result + }; + } catch (error) { + return { + id: request.id, + ok: false, + error: normalizeThrownError(error) + }; + } +} diff --git a/kdl-wasm/web/src/math/poseMath.ts b/kdl-wasm/web/src/math/poseMath.ts new file mode 100644 index 0000000..afce1fb --- /dev/null +++ b/kdl-wasm/web/src/math/poseMath.ts @@ -0,0 +1,238 @@ +import type { Pose } from "../kdl/types.js"; + +export type Mat4 = [ + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number, + number +]; + +export function identityMat4(): Mat4 { + return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]; +} + +export function multiplyMat4(a: Mat4, b: Mat4): Mat4 { + const out = new Array(16).fill(0) as Mat4; + for (let row = 0; row < 4; row += 1) { + for (let col = 0; col < 4; col += 1) { + out[row * 4 + col] = + a[row * 4 + 0]! * b[col + 0]! + + a[row * 4 + 1]! * b[col + 4]! + + a[row * 4 + 2]! * b[col + 8]! + + a[row * 4 + 3]! * b[col + 12]!; + } + } + return out; +} + +export function translationMat4(xyz: [number, number, number]): Mat4 { + const [x, y, z] = xyz; + return [1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1]; +} + +export function rotationFromRpyMat4(rpy: [number, number, number]): Mat4 { + const [roll, pitch, yaw] = rpy; + const cr = Math.cos(roll); + const sr = Math.sin(roll); + const cp = Math.cos(pitch); + const sp = Math.sin(pitch); + const cy = Math.cos(yaw); + const sy = Math.sin(yaw); + + return [ + cy * cp, + cy * sp * sr - sy * cr, + cy * sp * cr + sy * sr, + 0, + sy * cp, + sy * sp * sr + cy * cr, + sy * sp * cr - cy * sr, + 0, + -sp, + cp * sr, + cp * cr, + 0, + 0, + 0, + 0, + 1 + ]; +} + +export function axisAngleMat4(axis: [number, number, number], angle: number): Mat4 { + const [nx, ny, nz] = normalizeVector(axis); + const c = Math.cos(angle); + const s = Math.sin(angle); + const t = 1 - c; + + return [ + t * nx * nx + c, + t * nx * ny - s * nz, + t * nx * nz + s * ny, + 0, + t * nx * ny + s * nz, + t * ny * ny + c, + t * ny * nz - s * nx, + 0, + t * nx * nz - s * ny, + t * ny * nz + s * nx, + t * nz * nz + c, + 0, + 0, + 0, + 0, + 1 + ]; +} + +export function mat4ToPose(matrix: Mat4): Pose { + return { + position: [matrix[3], matrix[7], matrix[11]], + quaternion: normalizeQuaternion(rotationMat4ToQuaternion(matrix)) + }; +} + +export function poseToMat4(pose: Pose): Mat4 { + const [x, y, z, w] = normalizeQuaternion(pose.quaternion); + const xx = x * x; + const yy = y * y; + const zz = z * z; + const xy = x * y; + const xz = x * z; + const yz = y * z; + const wx = w * x; + const wy = w * y; + const wz = w * z; + const [px, py, pz] = pose.position; + + return [ + 1 - 2 * (yy + zz), + 2 * (xy - wz), + 2 * (xz + wy), + px, + 2 * (xy + wz), + 1 - 2 * (xx + zz), + 2 * (yz - wx), + py, + 2 * (xz - wy), + 2 * (yz + wx), + 1 - 2 * (xx + yy), + pz, + 0, + 0, + 0, + 1 + ]; +} + +export function composePose(a: Pose, b: Pose): Pose { + return mat4ToPose(multiplyMat4(poseToMat4(a), poseToMat4(b))); +} + +export function inversePose(pose: Pose): Pose { + const matrix = poseToMat4(pose); + const r00 = matrix[0]; + const r01 = matrix[1]; + const r02 = matrix[2]; + const tx = matrix[3]; + const r10 = matrix[4]; + const r11 = matrix[5]; + const r12 = matrix[6]; + const ty = matrix[7]; + const r20 = matrix[8]; + const r21 = matrix[9]; + const r22 = matrix[10]; + const tz = matrix[11]; + + return mat4ToPose([ + r00, + r10, + r20, + -(r00 * tx + r10 * ty + r20 * tz), + r01, + r11, + r21, + -(r01 * tx + r11 * ty + r21 * tz), + r02, + r12, + r22, + -(r02 * tx + r12 * ty + r22 * tz), + 0, + 0, + 0, + 1 + ]); +} + +export function rpyToQuaternion(rpy: [number, number, number]): [number, number, number, number] { + return normalizeQuaternion(rotationMat4ToQuaternion(rotationFromRpyMat4(rpy))); +} + +export function normalizeQuaternion(input: [number, number, number, number]): [number, number, number, number] { + const [x, y, z, w] = input; + const length = Math.hypot(x, y, z, w); + if (length === 0) { + return [0, 0, 0, 1]; + } + return [x / length, y / length, z / length, w / length]; +} + +export function jointMotionMat4(type: string, axis: [number, number, number], value: number): Mat4 { + if (type === "revolute" || type === "continuous") { + return axisAngleMat4(axis, value); + } + if (type === "prismatic") { + const [x, y, z] = normalizeVector(axis); + return translationMat4([x * value, y * value, z * value]); + } + return identityMat4(); +} + +function rotationMat4ToQuaternion(matrix: Mat4): [number, number, number, number] { + const m00 = matrix[0]; + const m01 = matrix[1]; + const m02 = matrix[2]; + const m10 = matrix[4]; + const m11 = matrix[5]; + const m12 = matrix[6]; + const m20 = matrix[8]; + const m21 = matrix[9]; + const m22 = matrix[10]; + const trace = m00 + m11 + m22; + + if (trace > 0) { + const s = Math.sqrt(trace + 1) * 2; + return [(m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s, 0.25 * s]; + } + if (m00 > m11 && m00 > m22) { + const s = Math.sqrt(1 + m00 - m11 - m22) * 2; + return [0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s]; + } + if (m11 > m22) { + const s = Math.sqrt(1 + m11 - m00 - m22) * 2; + return [(m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s]; + } + const s = Math.sqrt(1 + m22 - m00 - m11) * 2; + return [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s]; +} + +function normalizeVector(axis: [number, number, number]): [number, number, number] { + const [x, y, z] = axis; + const length = Math.hypot(x, y, z); + if (length === 0) { + return [1, 0, 0]; + } + return [x / length, y / length, z / length]; +} diff --git a/kdl-wasm/web/src/robot/index.ts b/kdl-wasm/web/src/robot/index.ts new file mode 100644 index 0000000..60d9bb8 --- /dev/null +++ b/kdl-wasm/web/src/robot/index.ts @@ -0,0 +1,2 @@ +export { RobotModelRegistry, validateNormalizedRobotModel, type RobotRegistryRecord } from "./normalizedRobotModel.js"; +export { loadRobotFromUrdfModel } from "./urdfParser.js"; diff --git a/kdl-wasm/web/src/robot/normalizedRobotModel.ts b/kdl-wasm/web/src/robot/normalizedRobotModel.ts new file mode 100644 index 0000000..1c13a7e --- /dev/null +++ b/kdl-wasm/web/src/robot/normalizedRobotModel.ts @@ -0,0 +1,1781 @@ +import { KdlStructuredError } from "../kdl/rpc.js"; +import { makeTrapProfile } from "../kdl/trapProfile.js"; +import { + identityMat4, + jointMotionMat4, + type Mat4, + mat4ToPose, + multiplyMat4, + poseToMat4, + rotationFromRpyMat4, + translationMat4 +} from "../math/poseMath.js"; +import type { + FkOptions, + FkResult, + IkOptions, + IkResult, + JacobianOptions, + JacobianResult, + JointTarget, + JointLimits, + LinkPoseResult, + LimitCheckResult, + MotionDiagnostic, + MoveCRequest, + MoveJRequest, + MoveLRequest, + NormalizedRobotModel, + PathPlanRequest, + PathPlanResult, + PathValidationResult, + Pose, + PoseTarget, + ReachabilityResult, + RobotHandle, + RobotInfo, + SegmentValidationReport, + SpeedSpec, + SingularityResult, + TrajectoryPoint, + TrajectoryResult +} from "../kdl/types.js"; + +export interface RobotRegistryRecord { + handle: RobotHandle; + model: NormalizedRobotModel; +} + +export class RobotModelRegistry { + private nextHandle = 1; + private readonly robots = new Map(); + + create(model: NormalizedRobotModel): RobotHandle { + validateNormalizedRobotModel(model); + const handle = this.nextHandle++; + this.robots.set(handle, { handle, model }); + return handle; + } + + destroy(handle: RobotHandle): void { + this.ensure(handle); + this.robots.delete(handle); + } + + getInfo(handle: RobotHandle): RobotInfo { + const record = this.ensure(handle); + const model = record.model; + + return { + handle, + robotId: model.robotId, + name: model.name, + baseLink: model.baseLink, + tipLink: model.tipLink, + jointNames: model.activeJointNames, + dof: model.activeJointNames.length, + limits: model.limits + }; + } + + getJointLimits(handle: RobotHandle): JointLimits[] { + return this.ensure(handle).model.limits; + } + + fk(handle: RobotHandle, joints: Float64Array | number[], options: FkOptions = {}): FkResult { + const record = this.ensure(handle); + const jointValues = Array.from(joints); + validateJointVector(record.model, jointValues); + const linkPoses = computeLinkPoses(record.model, jointValues); + const flange = linkPoses.at(-1)?.pose ?? identityPose(); + const tcp = options.tool ? composeFkPose(flange, options.tool) : flange; + + return { + ok: true, + flange, + tcp: options.frame ? composeFkPose(options.frame, tcp) : tcp, + joints: jointValues, + diagnostics: [] + }; + } + + fkPose7( + handle: RobotHandle, + joints: Float64Array | number[], + out?: Float64Array, + options: FkOptions = {} + ): Float64Array { + const output = out ?? new Float64Array(7); + if (output.length < 7) { + throw new KdlStructuredError("KDL_OUTPUT_DIMENSION_MISMATCH", "fkPose7 output buffer must have length >= 7"); + } + + const result = this.fk(handle, joints, options); + output[0] = result.tcp.position[0]; + output[1] = result.tcp.position[1]; + output[2] = result.tcp.position[2]; + output[3] = result.tcp.quaternion[0]; + output[4] = result.tcp.quaternion[1]; + output[5] = result.tcp.quaternion[2]; + output[6] = result.tcp.quaternion[3]; + return output; + } + + fkAllLinks(handle: RobotHandle, joints: Float64Array | number[], options: FkOptions = {}): LinkPoseResult { + const record = this.ensure(handle); + const jointValues = Array.from(joints); + validateJointVector(record.model, jointValues); + const linkPoses = computeLinkPoses(record.model, jointValues); + + return { + ok: true, + linkPoses: options.includeFlange === false ? linkPoses.slice(0, -1) : linkPoses, + diagnostics: [] + }; + } + + ik(handle: RobotHandle, seed: Float64Array | number[], target: Pose, options: IkOptions = {}): IkResult { + const record = this.ensure(handle); + const seedValues = Array.from(seed); + validateJointVector(record.model, seedValues); + return solveIk(record.model, seedValues, target, options); + } + + ikBatch( + handle: RobotHandle, + seeds: Array, + targets: Pose[], + options: IkOptions = {} + ): IkResult[] { + const record = this.ensure(handle); + if (seeds.length !== targets.length) { + throw new KdlStructuredError( + "KDL_IK_BATCH_DIMENSION_MISMATCH", + `Expected ${targets.length} seeds, got ${seeds.length}` + ); + } + + let lastSuccessfulSeed: number[] | undefined; + return targets.map((target, index) => { + const seed = lastSuccessfulSeed ?? Array.from(seeds[index] ?? []); + validateJointVector(record.model, seed); + const result = solveIk(record.model, seed, target, options); + if (result.ok && result.joints) { + lastSuccessfulSeed = result.joints; + } + return result; + }); + } + + jacobian( + handle: RobotHandle, + joints: Float64Array | number[], + _options: JacobianOptions = {} + ): JacobianResult { + const record = this.ensure(handle); + const jointValues = Array.from(joints); + validateJointVector(record.model, jointValues); + return computeJacobian(record.model, jointValues); + } + + checkSingularity(handle: RobotHandle, joints: Float64Array | number[]): SingularityResult { + const jacobian = this.jacobian(handle, joints); + const rows = matrixRows(jacobian.data as number[], jacobian.rows, jacobian.cols); + const linearRows = rows.slice(0, 3); + const gram = multiplyMatrix(linearRows, transpose(linearRows)); + const manipulability = Math.sqrt(Math.max(0, determinant3(gram))); + const conditionNumber = estimateConditionNumber(linearRows); + const nearSingularity = manipulability < 1e-6 || conditionNumber > 1e6; + + return { + ok: true, + nearSingularity, + manipulability, + conditionNumber, + diagnostics: nearSingularity + ? [ + { + severity: "warning", + code: "KDL_SINGULARITY", + message: "Jacobian is near singular" + } + ] + : [] + }; + } + + checkJointLimits(handle: RobotHandle, joints: Float64Array | number[]): LimitCheckResult { + const record = this.ensure(handle); + const jointValues = Array.from(joints); + validateJointVector(record.model, jointValues); + const diagnostics = jointValues.flatMap((value, index) => { + const limits = record.model.limits[index]; + if (!limits || (value >= limits.lower && value <= limits.upper)) { + return []; + } + return [ + { + severity: "error" as const, + code: "KDL_JOINT_LIMIT", + message: `Joint ${limits.name}=${value} is outside [${limits.lower}, ${limits.upper}]` + } + ]; + }); + + return { + ok: diagnostics.length === 0, + diagnostics + }; + } + + checkVelocityLimits(handle: RobotHandle, trajectory: TrajectoryResult): LimitCheckResult { + const record = this.ensure(handle); + const points = trajectory.points; + const diagnostics = []; + let maxJointVelocityRatio = 0; + let maxJointAccelerationRatio = 0; + + for (const [pointIndex, point] of points.entries()) { + for (let index = 0; index < record.model.limits.length; index += 1) { + const limit = record.model.limits[index]!; + const velocityRatio = limitRatio(point.jointVelocity[index] ?? 0, limit.velocity); + const accelerationRatio = limitRatio(point.jointAcceleration[index] ?? 0, limit.acceleration); + maxJointVelocityRatio = Math.max(maxJointVelocityRatio, velocityRatio); + maxJointAccelerationRatio = Math.max(maxJointAccelerationRatio, accelerationRatio); + if (velocityRatio > 1) { + diagnostics.push({ + severity: "error" as const, + code: "KDL_VELOCITY_LIMIT", + message: `Point ${pointIndex} joint ${limit.name} velocity exceeds limit`, + pointIndex + }); + } + if (accelerationRatio > 1) { + diagnostics.push({ + severity: "error" as const, + code: "KDL_ACCEL_LIMIT", + message: `Point ${pointIndex} joint ${limit.name} acceleration exceeds limit`, + pointIndex + }); + } + } + } + + return { + ok: diagnostics.length === 0, + diagnostics, + maxJointVelocityRatio, + maxJointAccelerationRatio + }; + } + + checkReachability(handle: RobotHandle, target: PoseTarget, options: IkOptions = {}): ReachabilityResult { + const record = this.ensure(handle); + const seed = options.seeds?.[0] ?? record.model.activeJointNames.map(() => 0); + const result = solveIk(record.model, seed, target.pose, options); + + return { + ok: result.ok, + reachable: result.ok, + ...(target.id ? { targetId: target.id } : {}), + ...(result.joints ? { joints: result.joints } : {}), + ...(result.residualPosition !== undefined ? { residualPosition: result.residualPosition } : {}), + ...(result.residualOrientation !== undefined ? { residualOrientation: result.residualOrientation } : {}), + diagnostics: result.diagnostics + }; + } + + checkReachabilityBatch(handle: RobotHandle, targets: PoseTarget[], options: IkOptions = {}): ReachabilityResult[] { + return targets.map((target, index) => { + const seed = options.seeds?.[index]; + return this.checkReachability(handle, target, { + ...options, + ...(seed ? { seeds: [seed] } : {}) + }); + }); + } + + planMoveJ(handle: RobotHandle, request: MoveJRequest): TrajectoryResult { + const record = this.ensure(handle); + const startJoints = [...request.startJoints]; + validateJointVector(record.model, startJoints); + + const targetResolution = resolveMoveJTarget(record.model, startJoints, request.target); + if (!targetResolution.ok) { + return emptyMoveJResult(request, targetResolution.diagnostics); + } + + const endJoints = targetResolution.joints; + const endpointDiagnostics = [ + ...jointLimitDiagnostics(record.model, startJoints), + ...jointLimitDiagnostics(record.model, endJoints) + ]; + if (endpointDiagnostics.length > 0) { + return emptyMoveJResult(request, endpointDiagnostics); + } + + const dq = endJoints.map((end, index) => end - startJoints[index]!); + const motionScale = Math.max(...dq.map((value) => Math.abs(value)), 0); + const profile = makeTrapProfile(motionScale === 0 ? 0 : 1, { + maxVelocity: normalizedMoveJVelocity(record.model, dq, request.speed, request.speedOverride), + maxAcceleration: normalizedMoveJAcceleration(record.model, dq, request.speed, request.speedOverride), + sampleTime: request.sampleTime + }); + const diagnostics: MotionDiagnostic[] = [ + ...moveJSpeedDiagnostics(request.speed), + ...zoneApproximationDiagnostics(request.zone), + ...profile.diagnostics + ]; + const fkOptions = moveJTargetFkOptions(request); + const targetId = targetIdOf(request.target); + const points: TrajectoryPoint[] = profile.samples.map((sample, index) => { + const joints = dq.map((delta, jointIndex) => startJoints[jointIndex]! + delta * sample.s); + const jointVelocity = dq.map((delta) => delta * sample.sd); + const jointAcceleration = dq.map((delta) => delta * sample.sdd); + const linkPoses = computeLinkPoses(record.model, joints); + const flange = linkPoses.at(-1)?.pose ?? identityPose(); + const tcpWithTool = fkOptions.tool ? composeFkPose(flange, fkOptions.tool) : flange; + const tcp = fkOptions.frame ? composeFkPose(fkOptions.frame, tcpWithTool) : tcpWithTool; + const pointDiagnostics = singularityDiagnostics(record.model, joints); + + return { + index, + time: sample.time, + dt: index === 0 ? 0 : sample.time - profile.samples[index - 1]!.time, + s: sample.s, + sd: sample.sd, + sdd: sample.sdd, + joints, + jointVelocity, + jointAcceleration, + flange, + tcp, + motion: "MOVEJ", + ...(targetId ? { targetId } : {}), + ...(request.sourceMap ? { sourceMap: request.sourceMap } : {}), + diagnostics: pointDiagnostics + }; + }); + + const velocityDiagnostics = velocityLimitDiagnostics(record.model, points); + diagnostics.push(...velocityDiagnostics); + for (const point of points) { + diagnostics.push(...point.diagnostics); + } + + return { + ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"), + motion: "MOVEJ", + duration: profile.duration, + sampleTime: request.sampleTime, + points, + events: [], + diagnostics, + meta: { + targetType: isJointTarget(request.target) ? "joint" : "pose", + qStart: startJoints, + qEnd: endJoints, + profileType: profile.type, + zone: request.zone + } + }; + } + + planMoveL(handle: RobotHandle, request: MoveLRequest): TrajectoryResult { + const record = this.ensure(handle); + const startJoints = [...request.startJoints]; + validateJointVector(record.model, startJoints); + + const startFk = this.fk(handle, startJoints, moveLFkOptions(request)); + const startPose = startFk.tcp; + const targetPose = request.target.pose; + const length = distance(startPose.position, targetPose.position); + const profile = makeTrapProfile(length, { + maxVelocity: linearSpeedValue(request.speed, request.speedOverride), + maxAcceleration: linearAccelerationValue(request.speed, request.speedOverride), + sampleTime: request.sampleTime + }); + const diagnostics: MotionDiagnostic[] = [ + ...moveLSpeedDiagnostics(request.speed), + ...zoneApproximationDiagnostics(request.zone), + ...profile.diagnostics + ]; + const points: TrajectoryPoint[] = []; + let seed = startJoints; + + for (const [index, sample] of profile.samples.entries()) { + const targetSamplePose = interpolateLinearPose(startPose, targetPose, sample.s); + const ikResult = solveIk(record.model, seed, targetSamplePose, { + ...request.ik, + seeds: [seed] + }); + if (!ikResult.ok || !ikResult.joints) { + return { + ok: false, + motion: "MOVEL", + duration: sample.time, + sampleTime: request.sampleTime, + points, + events: [], + diagnostics: [ + ...diagnostics, + ...ikResult.diagnostics.map((diagnostic) => ({ + ...diagnostic, + pointIndex: index + })) + ], + meta: { + length, + failedPointIndex: index, + targetId: request.target.id + } + }; + } + + const joints = ikResult.joints; + const previous = points.at(-1); + const dt = index === 0 ? 0 : sample.time - profile.samples[index - 1]!.time; + const jointVelocity = previous && dt > 0 + ? joints.map((value, jointIndex) => (value - previous.joints[jointIndex]!) / dt) + : joints.map(() => 0); + const jointAcceleration = previous && dt > 0 + ? jointVelocity.map((value, jointIndex) => (value - previous.jointVelocity[jointIndex]!) / dt) + : joints.map(() => 0); + const fk = this.fk(handle, joints, moveLFkOptions(request)); + const pointDiagnostics = [ + ...singularityDiagnostics(record.model, joints), + ...linearErrorDiagnostics(index, fk.tcp, targetSamplePose) + ]; + + points.push({ + index, + time: sample.time, + dt, + s: sample.s, + sd: sample.sd, + sdd: sample.sdd, + joints, + jointVelocity, + jointAcceleration, + flange: fk.flange, + tcp: fk.tcp, + motion: "MOVEL", + ...(request.target.id ? { targetId: request.target.id } : {}), + ...(request.sourceMap ? { sourceMap: request.sourceMap } : {}), + diagnostics: pointDiagnostics + }); + seed = joints; + } + + const velocityDiagnostics = velocityLimitDiagnostics(record.model, points); + diagnostics.push(...velocityDiagnostics); + for (const point of points) { + diagnostics.push(...point.diagnostics); + } + + return { + ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"), + motion: "MOVEL", + duration: profile.duration, + sampleTime: request.sampleTime, + points, + events: [], + diagnostics, + meta: { + length, + targetId: request.target.id, + profileType: profile.type, + orientationMode: request.orientationMode ?? "fixed" + } + }; + } + + planMoveC(handle: RobotHandle, request: MoveCRequest): TrajectoryResult { + const record = this.ensure(handle); + const startJoints = [...request.startJoints]; + validateJointVector(record.model, startJoints); + + const startFk = this.fk(handle, startJoints, moveCFkOptions(request)); + const arc = computeCircleArc(startFk.tcp, request.via.pose, request.target.pose); + if (!arc.ok) { + return { + ok: false, + motion: "MOVEC", + duration: 0, + sampleTime: request.sampleTime, + points: [], + events: [], + diagnostics: arc.diagnostics, + meta: { + viaId: request.via.id, + targetId: request.target.id + } + }; + } + + const profile = makeTrapProfile(arc.meta.length, { + maxVelocity: linearSpeedValue(request.speed, request.speedOverride), + maxAcceleration: linearAccelerationValue(request.speed, request.speedOverride), + sampleTime: request.sampleTime + }); + const diagnostics: MotionDiagnostic[] = [ + ...moveCSpeedDiagnostics(request.speed), + ...zoneApproximationDiagnostics(request.zone), + ...profile.diagnostics + ]; + const points: TrajectoryPoint[] = []; + let seed = startJoints; + let maxArcError = 0; + + for (const [index, sample] of profile.samples.entries()) { + const targetSamplePose = sampleCirclePose(arc, sample.s, request.target.pose.quaternion); + const ikResult = solveIk(record.model, seed, targetSamplePose, { + ...request.ik, + seeds: [seed] + }); + if (!ikResult.ok || !ikResult.joints) { + return { + ok: false, + motion: "MOVEC", + duration: sample.time, + sampleTime: request.sampleTime, + points, + events: [], + diagnostics: [ + ...diagnostics, + ...ikResult.diagnostics.map((diagnostic) => ({ + ...diagnostic, + pointIndex: index + })) + ], + meta: { + circle: { + ...arc.meta, + maxArcError + }, + failedPointIndex: index, + viaId: request.via.id, + targetId: request.target.id + } + }; + } + + const joints = ikResult.joints; + const previous = points.at(-1); + const dt = index === 0 ? 0 : sample.time - profile.samples[index - 1]!.time; + const jointVelocity = previous && dt > 0 + ? joints.map((value, jointIndex) => (value - previous.joints[jointIndex]!) / dt) + : joints.map(() => 0); + const jointAcceleration = previous && dt > 0 + ? jointVelocity.map((value, jointIndex) => (value - previous.jointVelocity[jointIndex]!) / dt) + : joints.map(() => 0); + const fk = this.fk(handle, joints, moveCFkOptions(request)); + const arcError = distance(fk.tcp.position, targetSamplePose.position); + maxArcError = Math.max(maxArcError, arcError); + const pointDiagnostics = [ + ...singularityDiagnostics(record.model, joints), + ...arcErrorDiagnostics(index, arcError) + ]; + + points.push({ + index, + time: sample.time, + dt, + s: sample.s, + sd: sample.sd, + sdd: sample.sdd, + joints, + jointVelocity, + jointAcceleration, + flange: fk.flange, + tcp: fk.tcp, + motion: "MOVEC", + ...(request.target.id ? { targetId: request.target.id } : {}), + ...(request.sourceMap ? { sourceMap: request.sourceMap } : {}), + diagnostics: pointDiagnostics + }); + seed = joints; + } + + const velocityDiagnostics = velocityLimitDiagnostics(record.model, points); + diagnostics.push(...velocityDiagnostics); + for (const point of points) { + diagnostics.push(...point.diagnostics); + } + + return { + ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"), + motion: "MOVEC", + duration: profile.duration, + sampleTime: request.sampleTime, + points, + events: [], + diagnostics, + meta: { + circle: { + ...arc.meta, + maxArcError + }, + viaId: request.via.id, + targetId: request.target.id, + profileType: profile.type, + orientationMode: request.orientationMode ?? "fixed" + } + }; + } + + planPath(handle: RobotHandle, request: PathPlanRequest): PathPlanResult { + validateJointVector(this.ensure(handle).model, request.startJoints); + if (request.segments.length === 0) { + const diagnostics = [pathEmptyDiagnostic()]; + return { + ok: false, + duration: 0, + segments: [], + points: [], + diagnostics + }; + } + + const segments: TrajectoryResult[] = []; + const points: TrajectoryPoint[] = []; + const diagnostics: MotionDiagnostic[] = []; + let currentJoints = [...request.startJoints]; + let timeOffset = 0; + + for (const segment of request.segments) { + const result = this.planPathSegment(handle, request, segment, currentJoints); + const segmentDiagnostics = result.diagnostics.map((diagnostic) => ({ + ...diagnostic, + segmentId: diagnostic.segmentId ?? segment.id, + ...(diagnostic.sourceMap ?? segment.sourceMap ? { sourceMap: diagnostic.sourceMap ?? segment.sourceMap } : {}) + })); + const segmentPoints = result.points.map((point) => ({ + ...point, + segmentId: point.segmentId ?? segment.id, + ...(point.sourceMap ?? segment.sourceMap ? { sourceMap: point.sourceMap ?? segment.sourceMap } : {}), + diagnostics: point.diagnostics.map((diagnostic) => ({ + ...diagnostic, + segmentId: diagnostic.segmentId ?? segment.id, + ...(diagnostic.sourceMap ?? segment.sourceMap ? { sourceMap: diagnostic.sourceMap ?? segment.sourceMap } : {}) + })) + })); + const segmentResult = { + ...result, + points: segmentPoints, + diagnostics: segmentDiagnostics + }; + segments.push(segmentResult); + diagnostics.push(...segmentDiagnostics); + + for (const point of segmentPoints) { + if (points.length > 0 && point.index === 0) { + continue; + } + const previous = points.at(-1); + const time = point.time + timeOffset; + points.push({ + ...point, + index: points.length, + time, + dt: previous ? time - previous.time : 0, + segmentId: segment.id, + ...(point.targetId ? { targetId: point.targetId } : {}), + ...(point.sourceMap ?? segment.sourceMap ? { sourceMap: point.sourceMap ?? segment.sourceMap } : {}), + diagnostics: point.diagnostics.map((diagnostic) => ({ + ...diagnostic, + segmentId: diagnostic.segmentId ?? segment.id, + ...(diagnostic.sourceMap ?? segment.sourceMap ? { sourceMap: diagnostic.sourceMap ?? segment.sourceMap } : {}) + })) + }); + } + + timeOffset += result.duration; + if (result.ok && result.points.at(-1)) { + currentJoints = [...result.points.at(-1)!.joints]; + } + if (!result.ok && request.stopOnError !== false) { + break; + } + } + + return { + ok: segments.length === request.segments.length && segments.every((segment) => segment.ok), + duration: timeOffset, + segments, + points, + diagnostics + }; + } + + validatePath(handle: RobotHandle, request: PathPlanRequest): PathValidationResult { + const plan = this.planPath(handle, request); + const segmentReports: SegmentValidationReport[] = plan.segments.map((segment, index) => { + const segmentRequest = request.segments[index]!; + const velocityCheck = this.checkVelocityLimits(handle, segment); + return { + segmentId: segmentRequest.id, + ok: segment.ok && velocityCheck.ok, + motion: segment.motion, + duration: segment.duration, + maxJointVelocityRatio: velocityCheck.maxJointVelocityRatio ?? 0, + maxJointAccelerationRatio: velocityCheck.maxJointAccelerationRatio ?? 0, + maxCartesianError: maxCartesianError(segment), + diagnostics: [ + ...segment.diagnostics, + ...velocityCheck.diagnostics.map((diagnostic) => ({ + ...diagnostic, + segmentId: diagnostic.segmentId ?? segmentRequest.id + })) + ] + }; + }); + const diagnostics = [ + ...plan.diagnostics, + ...segmentReports.flatMap((report) => report.diagnostics) + ]; + return { + ok: plan.ok && segmentReports.every((report) => report.ok), + reachable: plan.ok && segmentReports.every((report) => report.ok), + ...(plan.ok ? { cycleTime: plan.duration } : {}), + segmentReports, + diagnostics + }; + } + + private ensure(handle: RobotHandle): RobotRegistryRecord { + const record = this.robots.get(handle); + if (!record) { + throw new KdlStructuredError("KDL_INVALID_HANDLE", `RobotHandle ${handle} does not exist`); + } + return record; + } + + private planPathSegment( + handle: RobotHandle, + request: PathPlanRequest, + segment: PathPlanRequest["segments"][number], + startJoints: number[] + ): TrajectoryResult { + const common = { + startJoints, + speed: segment.speed, + zone: segment.zone, + sampleTime: request.sampleTime, + ...(segment.tool ? { tool: segment.tool } : {}), + ...(segment.frame ? { frame: segment.frame } : {}), + ...(request.speedOverride ? { speedOverride: request.speedOverride } : {}), + ...(segment.sourceMap ? { sourceMap: segment.sourceMap } : {}) + }; + + if (segment.motion === "MOVEJ" && segment.target) { + return this.planMoveJ(handle, { + ...common, + target: segment.target + }); + } + if (segment.motion === "MOVEL" && segment.target && isPoseTarget(segment.target)) { + return this.planMoveL(handle, { + ...common, + target: segment.target + }); + } + if (segment.motion === "MOVEC" && segment.via && segment.target && isPoseTarget(segment.target)) { + return this.planMoveC(handle, { + ...common, + via: segment.via, + target: segment.target + }); + } + + return { + ok: false, + motion: segment.motion, + duration: 0, + sampleTime: request.sampleTime, + points: [], + events: [], + diagnostics: [ + { + severity: "error", + code: "KDL_PATH_SEGMENT_INVALID", + message: `Path segment ${segment.id} has invalid target/via for ${segment.motion}`, + segmentId: segment.id, + ...(segment.sourceMap ? { sourceMap: segment.sourceMap } : {}) + } + ] + }; + } +} + +export function validateNormalizedRobotModel(model: NormalizedRobotModel): void { + const linkNames = new Set(model.links.map((link) => link.name)); + if (!linkNames.has(model.baseLink)) { + throw new KdlStructuredError("KDL_INVALID_MODEL", `baseLink does not exist: ${model.baseLink}`); + } + if (!linkNames.has(model.tipLink)) { + throw new KdlStructuredError("KDL_INVALID_MODEL", `tipLink does not exist: ${model.tipLink}`); + } + + const jointNames = new Set(); + for (const joint of model.joints) { + if (jointNames.has(joint.name)) { + throw new KdlStructuredError("KDL_INVALID_MODEL", `Duplicate joint name: ${joint.name}`); + } + jointNames.add(joint.name); + if (!linkNames.has(joint.parent) || !linkNames.has(joint.child)) { + throw new KdlStructuredError("KDL_INVALID_MODEL", `Joint ${joint.name} references an unknown link`); + } + } + + for (const activeJoint of model.activeJointNames) { + if (!jointNames.has(activeJoint)) { + throw new KdlStructuredError("KDL_INVALID_MODEL", `activeJointNames contains an unknown joint: ${activeJoint}`); + } + } +} + +function validateJointVector(model: NormalizedRobotModel, joints: number[]): void { + if (joints.length !== model.activeJointNames.length) { + throw new KdlStructuredError( + "KDL_JOINT_DIMENSION_MISMATCH", + `Expected ${model.activeJointNames.length} joints, got ${joints.length}` + ); + } + + for (let index = 0; index < joints.length; index += 1) { + if (!Number.isFinite(joints[index])) { + throw new KdlStructuredError("KDL_INVALID_JOINTS", `Joint value at index ${index} is not finite`); + } + } +} + +function pathEmptyDiagnostic(): MotionDiagnostic { + return { + severity: "error", + code: "KDL_PATH_EMPTY", + message: "PathPlanRequest.segments must contain at least one segment" + }; +} + +function maxCartesianError(segment: TrajectoryResult): number { + const circle = segment.meta?.circle; + if (isRecord(circle) && typeof circle.maxArcError === "number") { + return circle.maxArcError; + } + + let maxError = 0; + for (const diagnostic of segment.diagnostics) { + const data = diagnostic.data; + if (!data) { + continue; + } + if (typeof data.positionError === "number") { + maxError = Math.max(maxError, data.positionError); + } + if (typeof data.arcError === "number") { + maxError = Math.max(maxError, data.arcError); + } + } + return maxError; +} + +function isRecord(value: unknown): value is Record { + return !!value && typeof value === "object"; +} + +function resolveMoveJTarget( + model: NormalizedRobotModel, + startJoints: number[], + target: JointTarget | PoseTarget +): { ok: true; joints: number[] } | { ok: false; diagnostics: MotionDiagnostic[] } { + if (isJointTarget(target)) { + const joints = [...target.joints]; + validateJointVector(model, joints); + return { + ok: true, + joints + }; + } + + const result = solveIk(model, startJoints, target.pose, { + seeds: [startJoints] + }); + if (result.ok && result.joints) { + return { + ok: true, + joints: result.joints + }; + } + + return { + ok: false, + diagnostics: result.diagnostics.length > 0 + ? result.diagnostics + : [ + { + severity: "error", + code: "KDL_MOVEJ_IK_FAILED", + message: "MOVEJ pose target IK failed" + } + ] + }; +} + +function emptyMoveJResult(request: MoveJRequest, diagnostics: MotionDiagnostic[]): TrajectoryResult { + return { + ok: false, + motion: "MOVEJ", + duration: 0, + sampleTime: request.sampleTime, + points: [], + events: [], + diagnostics, + meta: { + targetType: isJointTarget(request.target) ? "joint" : "pose" + } + }; +} + +function jointLimitDiagnostics(model: NormalizedRobotModel, joints: number[]): MotionDiagnostic[] { + return joints.flatMap((value, index) => { + const limit = model.limits[index]; + if (!limit || (value >= limit.lower && value <= limit.upper)) { + return []; + } + return [ + { + severity: "error" as const, + code: "KDL_JOINT_LIMIT", + message: `Joint ${limit.name}=${value} is outside [${limit.lower}, ${limit.upper}]`, + data: { + joint: limit.name, + value, + lower: limit.lower, + upper: limit.upper + } + } + ]; + }); +} + +function velocityLimitDiagnostics(model: NormalizedRobotModel, points: TrajectoryPoint[]): MotionDiagnostic[] { + return points.flatMap((point) => + model.limits.flatMap((limit, index) => { + const diagnostics: MotionDiagnostic[] = []; + const velocityRatio = limitRatio(point.jointVelocity[index] ?? 0, limit.velocity); + const accelerationRatio = limitRatio(point.jointAcceleration[index] ?? 0, limit.acceleration); + if (velocityRatio > 1 + 1e-9) { + diagnostics.push({ + severity: "error", + code: "KDL_VELOCITY_LIMIT", + message: `Point ${point.index} joint ${limit.name} velocity exceeds limit`, + pointIndex: point.index + }); + } + if (accelerationRatio > 1 + 1e-9) { + diagnostics.push({ + severity: "error", + code: "KDL_ACCEL_LIMIT", + message: `Point ${point.index} joint ${limit.name} acceleration exceeds limit`, + pointIndex: point.index + }); + } + return diagnostics; + }) + ); +} + +function singularityDiagnostics(model: NormalizedRobotModel, joints: number[]): MotionDiagnostic[] { + const jacobian = computeJacobian(model, joints); + const rows = matrixRows(jacobian.data as number[], jacobian.rows, jacobian.cols); + const linearRows = rows.slice(0, 3); + const gram = multiplyMatrix(linearRows, transpose(linearRows)); + const manipulability = Math.sqrt(Math.max(0, determinant3(gram))); + const conditionNumber = estimateConditionNumber(linearRows); + if (manipulability >= 1e-6 && conditionNumber <= 1e6) { + return []; + } + return [ + { + severity: "warning", + code: "KDL_SINGULARITY", + message: "MOVEJ sample is near singular", + data: { + manipulability, + conditionNumber + } + } + ]; +} + +function normalizedMoveJVelocity( + model: NormalizedRobotModel, + dq: number[], + speed: SpeedSpec, + speedOverride = 1 +): number { + const override = validateSpeedOverride(speedOverride); + if (speed.kind === "joint_percent") { + return Math.max(1e-9, speed.value * override); + } + + const requested = speed.kind === "joint_abs" ? speed.velocity : speed.velocity; + const byRequest = normalizedLimitByScalar(dq, requested * override); + const byJointLimits = normalizedLimitByJointLimits(model, dq, "velocity"); + return Math.max(1e-9, Math.min(byRequest, byJointLimits)); +} + +function normalizedMoveJAcceleration( + model: NormalizedRobotModel, + dq: number[], + speed: SpeedSpec, + speedOverride = 1 +): number { + const override = validateSpeedOverride(speedOverride); + const requested = speed.kind === "joint_abs" ? speed.acceleration : undefined; + const byRequest = requested ? normalizedLimitByScalar(dq, requested * override) : Infinity; + const byJointLimits = normalizedLimitByJointLimits(model, dq, "acceleration"); + return Math.max(1e-9, Math.min(byRequest, byJointLimits, 1)); +} + +function normalizedLimitByScalar(dq: number[], scalar: number): number { + if (!Number.isFinite(scalar) || scalar <= 0) { + throw new KdlStructuredError("KDL_INVALID_SPEED", "MOVEJ speed must be a finite positive number"); + } + const maxDelta = Math.max(...dq.map((value) => Math.abs(value)), 0); + if (maxDelta === 0) { + return scalar; + } + return scalar / maxDelta; +} + +function normalizedLimitByJointLimits( + model: NormalizedRobotModel, + dq: number[], + field: "velocity" | "acceleration" +): number { + const ratios = dq.flatMap((delta, index) => { + const absDelta = Math.abs(delta); + const limit = model.limits[index]?.[field] ?? Infinity; + if (absDelta <= 1e-12 || !Number.isFinite(limit)) { + return []; + } + return [limit / absDelta]; + }); + return ratios.length === 0 ? 1 : Math.max(1e-9, Math.min(...ratios)); +} + +function validateSpeedOverride(speedOverride: number): number { + if (!Number.isFinite(speedOverride) || speedOverride <= 0) { + throw new KdlStructuredError("KDL_INVALID_SPEED", "speedOverride must be a finite positive number"); + } + return speedOverride; +} + +function moveJSpeedDiagnostics(speed: SpeedSpec): MotionDiagnostic[] { + if (speed.kind === "linear") { + return [ + { + severity: "warning", + code: "KDL_MOVEJ_LINEAR_SPEED_APPROX", + message: "MOVEJ received linear speed; using its velocity as a joint-space scalar" + } + ]; + } + return []; +} + +function zoneApproximationDiagnostics(zone: MoveJRequest["zone"]): MotionDiagnostic[] { + if (zone.kind === "fine") { + return []; + } + return [ + { + severity: "warning", + code: "KDL_ZONE_APPROX_FINE", + message: "Motion zone is approximated as fine in P0" + } + ]; +} + +function moveLSpeedDiagnostics(speed: SpeedSpec): MotionDiagnostic[] { + if (speed.kind === "linear") { + return []; + } + return [ + { + severity: "warning", + code: "KDL_MOVEL_JOINT_SPEED_APPROX", + message: "MOVEL received joint speed; using its velocity as a linear scalar" + } + ]; +} + +function moveCSpeedDiagnostics(speed: SpeedSpec): MotionDiagnostic[] { + if (speed.kind === "linear") { + return []; + } + return [ + { + severity: "warning", + code: "KDL_MOVEC_JOINT_SPEED_APPROX", + message: "MOVEC received joint speed; using its velocity as a linear scalar" + } + ]; +} + +function linearSpeedValue(speed: SpeedSpec, speedOverride = 1): number { + const override = validateSpeedOverride(speedOverride); + const value = speed.kind === "joint_percent" ? speed.value : speed.velocity; + if (!Number.isFinite(value) || value <= 0) { + throw new KdlStructuredError("KDL_INVALID_SPEED", "MOVEL speed must be a finite positive number"); + } + return Math.max(1e-9, value * override); +} + +function linearAccelerationValue(speed: SpeedSpec, speedOverride = 1): number { + const override = validateSpeedOverride(speedOverride); + const value = speed.kind === "linear" || speed.kind === "joint_abs" ? speed.acceleration : undefined; + if (value !== undefined && (!Number.isFinite(value) || value <= 0)) { + throw new KdlStructuredError("KDL_INVALID_SPEED", "MOVEL acceleration must be a finite positive number"); + } + return Math.max(1e-9, (value ?? linearSpeedValue(speed, 1)) * override); +} + +function moveLFkOptions(request: MoveLRequest): FkOptions { + const options: FkOptions = {}; + const tool = request.tool ?? request.target.tool; + const frame = request.frame ?? request.target.frame; + if (tool) { + options.tool = tool; + } + if (frame) { + options.frame = frame; + } + return options; +} + +function moveCFkOptions(request: MoveCRequest): FkOptions { + const options: FkOptions = {}; + const tool = request.tool ?? request.target.tool; + const frame = request.frame ?? request.target.frame; + if (tool) { + options.tool = tool; + } + if (frame) { + options.frame = frame; + } + return options; +} + +function interpolateLinearPose(start: Pose, target: Pose, s: number): Pose { + return { + position: [ + start.position[0] + (target.position[0] - start.position[0]) * s, + start.position[1] + (target.position[1] - start.position[1]) * s, + start.position[2] + (target.position[2] - start.position[2]) * s + ], + quaternion: target.quaternion + }; +} + +function linearErrorDiagnostics(index: number, actual: Pose, expected: Pose): MotionDiagnostic[] { + const positionError = distance(actual.position, expected.position); + if (positionError <= 1e-6) { + return []; + } + return [ + { + severity: "error", + code: "KDL_TCP_LINE_ERROR", + message: `MOVEL TCP line error ${positionError} exceeds tolerance`, + pointIndex: index, + data: { + positionError + } + } + ]; +} + +interface CircleArc { + start: [number, number, number]; + center: [number, number, number]; + radius: number; + normal: [number, number, number]; + startAngle: number; + angle: number; + meta: { + center: [number, number, number]; + radius: number; + normal: [number, number, number]; + angle: number; + length: number; + direction: "cw" | "ccw"; + }; +} + +function computeCircleArc( + startPose: Pose, + viaPose: Pose, + targetPose: Pose +): { ok: true; meta: CircleArc["meta"]; arc: CircleArc } | { ok: false; diagnostics: MotionDiagnostic[] } { + const start = startPose.position; + const via = viaPose.position; + const target = targetPose.position; + const a = sub3(via, start); + const b = sub3(target, start); + const normalVector = cross3(a, b); + const normalLength = norm3(normalVector); + if (distance(start, via) < 1e-9 || distance(via, target) < 1e-9 || distance(start, target) < 1e-9 || normalLength < 1e-9) { + return { + ok: false, + diagnostics: [ + { + severity: "error", + code: "KDL_ARC_DEGENERATE", + message: "MOVEC requires three distinct non-collinear points" + } + ] + }; + } + + const center = circleCenter3(start, via, target, normalVector); + const radius = distance(center, start); + if (!Number.isFinite(radius) || radius < 1e-9) { + return { + ok: false, + diagnostics: [ + { + severity: "error", + code: "KDL_ARC_DEGENERATE", + message: "MOVEC arc radius is too small" + } + ] + }; + } + + const normal = normalize3(normalVector); + const u = normalize3(sub3(start, center)); + const v = cross3(normal, u); + const startAngle = 0; + const viaAngle = positiveAngle(pointAngle(center, u, v, via)); + const targetAngle = positiveAngle(pointAngle(center, u, v, target)); + const angle = viaAngle <= targetAngle ? targetAngle : targetAngle + Math.PI * 2; + const length = radius * angle; + if (length < 1e-9) { + return { + ok: false, + diagnostics: [ + { + severity: "error", + code: "KDL_ARC_DEGENERATE", + message: "MOVEC arc length is too short" + } + ] + }; + } + + const meta = { + center, + radius, + normal, + angle, + length, + direction: normal[2] >= 0 ? "ccw" as const : "cw" as const + }; + return { + ok: true, + meta, + arc: { + start, + center, + radius, + normal, + startAngle, + angle, + meta + } + }; +} + +function sampleCirclePose( + arcResult: { arc: CircleArc }, + s: number, + quaternion: [number, number, number, number] +): Pose { + const arc = arcResult.arc; + const u = normalize3(sub3(arc.start, arc.center)); + const v = cross3(arc.normal, u); + const angle = arc.startAngle + arc.angle * s; + return { + position: add3( + arc.center, + add3(scale3(u, Math.cos(angle) * arc.radius), scale3(v, Math.sin(angle) * arc.radius)) + ), + quaternion + }; +} + +function arcErrorDiagnostics(index: number, arcError: number): MotionDiagnostic[] { + if (arcError <= 1e-6) { + return []; + } + return [ + { + severity: "error", + code: "KDL_ARC_ERROR", + message: `MOVEC arc error ${arcError} exceeds tolerance`, + pointIndex: index, + data: { + arcError + } + } + ]; +} + +function circleCenter3( + p1: [number, number, number], + p2: [number, number, number], + p3: [number, number, number], + normal: [number, number, number] +): [number, number, number] { + const a = sub3(p2, p1); + const b = sub3(p3, p1); + const a2 = dot3(a, a); + const b2 = dot3(b, b); + const cross = cross3(a, b); + const denom = 2 * dot3(cross, cross); + if (Math.abs(denom) < 1e-18) { + return [NaN, NaN, NaN]; + } + const termA = scale3(cross3(b, normal), a2); + const termB = scale3(cross3(normal, a), b2); + return add3(p1, scale3(add3(termA, termB), 1 / denom)); +} + +function pointAngle( + center: [number, number, number], + u: [number, number, number], + v: [number, number, number], + point: [number, number, number] +): number { + const radial = sub3(point, center); + return Math.atan2(dot3(radial, v), dot3(radial, u)); +} + +function positiveAngle(angle: number): number { + const twoPi = Math.PI * 2; + let result = angle % twoPi; + if (result < 0) { + result += twoPi; + } + return result; +} + +function add3(a: [number, number, number], b: [number, number, number]): [number, number, number] { + return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; +} + +function sub3(a: [number, number, number], b: [number, number, number]): [number, number, number] { + return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; +} + +function scale3(a: [number, number, number], scale: number): [number, number, number] { + return [a[0] * scale, a[1] * scale, a[2] * scale]; +} + +function dot3(a: [number, number, number], b: [number, number, number]): number { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +function cross3(a: [number, number, number], b: [number, number, number]): [number, number, number] { + return [ + a[1] * b[2] - a[2] * b[1], + a[2] * b[0] - a[0] * b[2], + a[0] * b[1] - a[1] * b[0] + ]; +} + +function norm3(a: [number, number, number]): number { + return Math.hypot(a[0], a[1], a[2]); +} + +function normalize3(a: [number, number, number]): [number, number, number] { + const length = norm3(a); + if (length === 0) { + return [0, 0, 0]; + } + return [a[0] / length, a[1] / length, a[2] / length]; +} + +function moveJTargetFkOptions(request: MoveJRequest): FkOptions { + const target = isPoseTarget(request.target) ? request.target : undefined; + const options: FkOptions = {}; + const tool = request.tool ?? target?.tool; + const frame = request.frame ?? target?.frame; + if (tool) { + options.tool = tool; + } + if (frame) { + options.frame = frame; + } + return options; +} + +function targetIdOf(target: JointTarget | PoseTarget): string | undefined { + return target.id; +} + +function isJointTarget(target: JointTarget | PoseTarget): target is JointTarget { + return "joints" in target; +} + +function isPoseTarget(target: JointTarget | PoseTarget): target is PoseTarget { + return "pose" in target; +} + +function limitRatio(value: number, limit: number): number { + if (!Number.isFinite(limit) || limit <= 0) { + return 0; + } + return Math.abs(value) / limit; +} + +function computeLinkPoses( + model: NormalizedRobotModel, + joints: number[] +): Array<{ link: string; pose: Pose }> { + const poses = new Map(); + poses.set(model.baseLink, identityMat4()); + const activeJointIndex = new Map(model.activeJointNames.map((name, index) => [name, index])); + + let progressed = true; + while (progressed) { + progressed = false; + for (const joint of model.joints) { + if (!poses.has(joint.parent) || poses.has(joint.child)) { + continue; + } + + const parentPose = poses.get(joint.parent)!; + const origin = multiplyMat4(translationMat4(joint.origin.xyz), rotationFromRpyMat4(joint.origin.rpy)); + const activeIndex = activeJointIndex.get(joint.name); + const jointValue = activeIndex === undefined ? 0 : joints[activeIndex]!; + const motion = jointMotionMat4(joint.type, joint.axis, jointValue); + poses.set(joint.child, multiplyMat4(parentPose, multiplyMat4(origin, motion))); + progressed = true; + } + } + + const orderedLinks = chainLinkOrder(model); + return orderedLinks.map((link) => ({ + link, + pose: mat4ToPose(poses.get(link) ?? identityMat4()) + })); +} + +function computeJacobian(model: NormalizedRobotModel, joints: number[]): JacobianResult { + const basePose = computeLinkPoses(model, joints).at(-1)?.pose ?? identityPose(); + const rows = 6; + const cols = joints.length; + const data = new Array(rows * cols).fill(0); + const epsilon = 1e-6; + + for (let col = 0; col < cols; col += 1) { + const perturbed = [...joints]; + perturbed[col] = (perturbed[col] ?? 0) + epsilon; + const pose = computeLinkPoses(model, perturbed).at(-1)?.pose ?? identityPose(); + data[col] = (pose.position[0] - basePose.position[0]) / epsilon; + data[cols + col] = (pose.position[1] - basePose.position[1]) / epsilon; + data[cols * 2 + col] = (pose.position[2] - basePose.position[2]) / epsilon; + data[cols * 3 + col] = (pose.quaternion[0] - basePose.quaternion[0]) / epsilon; + data[cols * 4 + col] = (pose.quaternion[1] - basePose.quaternion[1]) / epsilon; + data[cols * 5 + col] = (pose.quaternion[2] - basePose.quaternion[2]) / epsilon; + } + + return { + ok: true, + rows, + cols, + data, + diagnostics: [] + }; +} + +function solveIk( + model: NormalizedRobotModel, + seed: number[], + target: Pose, + options: IkOptions +): IkResult { + const chainJoints = model.joints.filter((joint) => model.activeJointNames.includes(joint.name)); + + if (chainJoints.length === 1 && chainJoints[0]?.type === "prismatic") { + return solveSinglePrismaticIk(model, chainJoints[0], seed, target, options); + } + + if ( + chainJoints.length === 2 && + (chainJoints[0]?.type === "revolute" || chainJoints[0]?.type === "continuous") && + chainJoints[1]?.type === "prismatic" && + isAxis(chainJoints[0].axis, [0, 0, 1]) && + isAxis(chainJoints[1].axis, [1, 0, 0]) + ) { + return solvePlanarRzPxIk(model, seed, target, options); + } + + return { + ok: false, + iterations: 0, + reason: "invalid_model", + diagnostics: [ + { + severity: "error", + code: "KDL_IK_UNSUPPORTED_MODEL", + message: "Current TypeScript IK baseline supports only single-prismatic or Rz+Px chains" + } + ] + }; +} + +function solveSinglePrismaticIk( + model: NormalizedRobotModel, + joint: NormalizedRobotModel["joints"][number], + seed: number[], + target: Pose, + options: IkOptions +): IkResult { + const zero = computeLinkPoses(model, [0]).at(-1)?.pose.position ?? [0, 0, 0]; + const axisIndex = dominantAxisIndex(joint.axis); + const q = target.position[axisIndex]! - zero[axisIndex]!; + return finishIkCandidate(model, seed, [q], target, options); +} + +function solvePlanarRzPxIk( + model: NormalizedRobotModel, + seed: number[], + target: Pose, + options: IkOptions +): IkResult { + const [x, y] = target.position; + const q2 = Math.hypot(x, y); + const q1Candidates = [Math.atan2(y, x), Math.atan2(y, x) + Math.PI]; + const candidates = q1Candidates.map((q1, index) => [normalizeAngleNear(q1, seed[0] ?? 0), index === 0 ? q2 : -q2]); + + let best: IkResult | undefined; + for (const candidate of candidates) { + const result = finishIkCandidate(model, seed, candidate, target, options); + if (result.ok) { + return result; + } + if (!best || (result.residualPosition ?? Infinity) < (best.residualPosition ?? Infinity)) { + best = result; + } + } + + return best ?? { + ok: false, + iterations: 1, + reason: "unreachable", + diagnostics: [ + { + severity: "error", + code: "KDL_TARGET_UNREACHABLE", + message: "No IK candidate found" + } + ] + }; +} + +function finishIkCandidate( + model: NormalizedRobotModel, + seed: number[], + candidate: number[], + target: Pose, + options: IkOptions +): IkResult { + const limited = applyOptionLimits(model, candidate, options); + if (!limited.ok) { + return limited.result; + } + + const fkPose = computeLinkPoses(model, candidate).at(-1)?.pose ?? identityPose(); + const residualPosition = distance(fkPose.position, target.position); + const tolerance = options.positionTolerance ?? 1e-6; + const baseResult = { + joints: candidate, + iterations: 1, + residualPosition, + residualOrientation: quaternionDistance(fkPose.quaternion, target.quaternion), + diagnostics: [] + }; + + if (residualPosition <= tolerance || options.allowApproximate) { + return { + ok: true, + ...baseResult + }; + } + + return { + ok: false, + ...baseResult, + reason: "unreachable", + diagnostics: [ + { + severity: "error", + code: "KDL_TARGET_UNREACHABLE", + message: `IK residual ${residualPosition} exceeds tolerance ${tolerance}` + } + ] + }; +} + +function applyOptionLimits( + model: NormalizedRobotModel, + candidate: number[], + options: IkOptions +): { ok: true } | { ok: false; result: IkResult } { + for (let index = 0; index < candidate.length; index += 1) { + const value = candidate[index]!; + const limits = model.limits[index]; + const lower = options.qMin?.[index] ?? limits?.lower ?? -Infinity; + const upper = options.qMax?.[index] ?? limits?.upper ?? Infinity; + if (value < lower || value > upper) { + return { + ok: false, + result: { + ok: false, + iterations: 1, + joints: candidate, + reason: "joint_limit", + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_LIMIT", + message: `IK candidate joint ${index}=${value} is outside [${lower}, ${upper}]` + } + ] + } + }; + } + } + return { ok: true }; +} + +function chainLinkOrder(model: NormalizedRobotModel): string[] { + const order = [model.baseLink]; + let current = model.baseLink; + const visited = new Set([current]); + + while (current !== model.tipLink) { + const nextJoint = model.joints.find((joint) => joint.parent === current && !visited.has(joint.child)); + if (!nextJoint) { + break; + } + current = nextJoint.child; + visited.add(current); + order.push(current); + } + + return order; +} + +function composeFkPose(a: Pose, b: Pose): Pose { + return mat4ToPose(multiplyMat4(poseToMat4(a), poseToMat4(b))); +} + +function identityPose(): Pose { + return { + position: [0, 0, 0], + quaternion: [0, 0, 0, 1] + }; +} + +function isAxis(actual: [number, number, number], expected: [number, number, number]): boolean { + return actual.every((value, index) => Math.abs(value - expected[index]!) < 1e-9); +} + +function dominantAxisIndex(axis: [number, number, number]): 0 | 1 | 2 { + const absolute = axis.map((value) => Math.abs(value)); + if (absolute[1]! > absolute[0]! && absolute[1]! >= absolute[2]!) { + return 1; + } + if (absolute[2]! > absolute[0]! && absolute[2]! > absolute[1]!) { + return 2; + } + return 0; +} + +function normalizeAngleNear(angle: number, seed: number): number { + const twoPi = Math.PI * 2; + let normalized = angle; + while (normalized - seed > Math.PI) { + normalized -= twoPi; + } + while (normalized - seed < -Math.PI) { + normalized += twoPi; + } + return normalized; +} + +function distance(a: [number, number, number], b: [number, number, number]): number { + return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]); +} + +function quaternionDistance(a: [number, number, number, number], b: [number, number, number, number]): number { + return Math.min( + Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]), + Math.hypot(a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]) + ); +} + +function matrixRows(data: number[], rows: number, cols: number): number[][] { + return Array.from({ length: rows }, (_, row) => + Array.from({ length: cols }, (_, col) => data[row * cols + col] ?? 0) + ); +} + +function transpose(matrix: number[][]): number[][] { + const rows = matrix.length; + const cols = matrix[0]?.length ?? 0; + return Array.from({ length: cols }, (_, col) => Array.from({ length: rows }, (_, row) => matrix[row]?.[col] ?? 0)); +} + +function multiplyMatrix(a: number[][], b: number[][]): number[][] { + const rows = a.length; + const cols = b[0]?.length ?? 0; + const inner = b.length; + return Array.from({ length: rows }, (_, row) => + Array.from({ length: cols }, (_, col) => { + let sum = 0; + for (let index = 0; index < inner; index += 1) { + sum += (a[row]?.[index] ?? 0) * (b[index]?.[col] ?? 0); + } + return sum; + }) + ); +} + +function determinant3(matrix: number[][]): number { + const a = matrix[0]?.[0] ?? 0; + const b = matrix[0]?.[1] ?? 0; + const c = matrix[0]?.[2] ?? 0; + const d = matrix[1]?.[0] ?? 0; + const e = matrix[1]?.[1] ?? 0; + const f = matrix[1]?.[2] ?? 0; + const g = matrix[2]?.[0] ?? 0; + const h = matrix[2]?.[1] ?? 0; + const i = matrix[2]?.[2] ?? 0; + return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g); +} + +function estimateConditionNumber(matrix: number[][]): number { + const columnNorms = transpose(matrix).map((column) => Math.hypot(...column)); + const nonZero = columnNorms.filter((value) => value > 1e-12); + if (nonZero.length === 0) { + return Infinity; + } + return Math.max(...nonZero) / Math.min(...nonZero); +} diff --git a/kdl-wasm/web/src/robot/urdfParser.ts b/kdl-wasm/web/src/robot/urdfParser.ts new file mode 100644 index 0000000..51d8f45 --- /dev/null +++ b/kdl-wasm/web/src/robot/urdfParser.ts @@ -0,0 +1,277 @@ +import { createHash } from "node:crypto"; +import { XMLParser } from "fast-xml-parser"; +import { KdlStructuredError } from "../kdl/rpc.js"; +import type { + JointLimitOverride, + JointLimits, + JointModel, + JointType, + LinkModel, + NormalizedRobotModel, + UrdfLoadOptions +} from "../kdl/types.js"; + +type XmlNode = Record; + +const SUPPORTED_JOINT_TYPES = new Set(["revolute", "continuous", "prismatic", "fixed"]); + +export function loadRobotFromUrdfModel(urdfXml: string, options: UrdfLoadOptions): NormalizedRobotModel { + const robot = parseUrdfRoot(urdfXml); + const robotName = stringAttr(robot["@_name"]) ?? options.robotId; + const links = asArray(robot.link).map(parseLink); + const joints = asArray(robot.joint).map(parseJoint); + + const linkNames = new Set(links.map((link) => link.name)); + if (!linkNames.has(options.baseLink)) { + throw invalidModel(`URDF baseLink does not exist: ${options.baseLink}`); + } + if (!linkNames.has(options.tipLink)) { + throw invalidModel(`URDF tipLink does not exist: ${options.tipLink}`); + } + + const chain = buildChain(joints, options.baseLink, options.tipLink); + const activeJointNames = resolveActiveJointOrder(chain, options.jointOrder); + const limits = activeJointNames.map((name) => { + const joint = joints.find((candidate) => candidate.name === name); + if (!joint) { + throw invalidModel(`Joint order references an unknown joint: ${name}`); + } + return limitForJoint(joint, options.overrideLimits ?? []); + }); + + return { + robotId: options.robotId, + name: robotName, + baseLink: options.baseLink, + tipLink: options.tipLink, + links, + joints, + activeJointNames, + limits, + source: { + type: "urdf", + urdfHash: createHash("sha256").update(urdfXml).digest("hex") + } + }; +} + +function parseUrdfRoot(urdfXml: string): XmlNode { + const parser = new XMLParser({ + ignoreAttributes: false, + attributeNamePrefix: "@_", + trimValues: true, + parseAttributeValue: false, + parseTagValue: false, + allowBooleanAttributes: true + }); + const parsed = parser.parse(urdfXml) as XmlNode; + const robot = parsed.robot; + + if (!isObject(robot)) { + throw invalidModel("URDF document must contain a robot root element"); + } + + return robot; +} + +function parseLink(node: XmlNode): LinkModel { + const name = stringAttr(node["@_name"]); + if (!name) { + throw invalidModel("URDF link is missing name"); + } + return { name }; +} + +function parseJoint(node: XmlNode): JointModel { + const name = stringAttr(node["@_name"]); + const type = stringAttr(node["@_type"]); + if (!name || !type) { + throw invalidModel("URDF joint is missing name or type"); + } + if (!SUPPORTED_JOINT_TYPES.has(type as JointType)) { + throw invalidModel(`Unsupported joint type for ${name}: ${type}`); + } + + const parent = parseLinkRef(node.parent, "parent", name); + const child = parseLinkRef(node.child, "child", name); + const originNode = isObject(node.origin) ? node.origin : {}; + const axisNode = isObject(node.axis) ? node.axis : {}; + const jointType = type as JointType; + + return { + name, + type: jointType, + parent, + child, + origin: { + xyz: parseTriple(stringAttr(originNode["@_xyz"]), [0, 0, 0], `joint ${name} origin xyz`), + rpy: parseTriple(stringAttr(originNode["@_rpy"]), [0, 0, 0], `joint ${name} origin rpy`) + }, + axis: parseTriple(stringAttr(axisNode["@_xyz"]), [1, 0, 0], `joint ${name} axis xyz`), + ...(jointType === "fixed" ? {} : { limit: parseJointLimit(node.limit, name, jointType) }) + }; +} + +function parseJointLimit(node: unknown, jointName: string, jointType: JointType): JointLimits { + const limitNode = isObject(node) ? node : {}; + const continuous = jointType === "continuous"; + const lower = continuous ? -Infinity : numberAttr(limitNode["@_lower"], `joint ${jointName} lower limit`); + const upper = continuous ? Infinity : numberAttr(limitNode["@_upper"], `joint ${jointName} upper limit`); + + return { + name: jointName, + lower, + upper, + velocity: optionalNumberAttr(limitNode["@_velocity"], `joint ${jointName} velocity limit`) ?? Infinity, + acceleration: optionalNumberAttr(limitNode["@_acceleration"], `joint ${jointName} acceleration limit`) ?? Infinity, + ...optionalJerk(limitNode, jointName) + }; +} + +function parseLinkRef(node: unknown, field: "parent" | "child", jointName: string): string { + if (!isObject(node)) { + throw invalidModel(`URDF joint ${jointName} is missing ${field}`); + } + const link = stringAttr(node["@_link"]); + if (!link) { + throw invalidModel(`URDF joint ${jointName} ${field} is missing link`); + } + return link; +} + +function buildChain(joints: JointModel[], baseLink: string, tipLink: string): JointModel[] { + const byParent = new Map(); + for (const joint of joints) { + const children = byParent.get(joint.parent) ?? []; + children.push(joint); + byParent.set(joint.parent, children); + } + + const queue: Array<{ link: string; chain: JointModel[] }> = [{ link: baseLink, chain: [] }]; + const visited = new Set([baseLink]); + + while (queue.length > 0) { + const current = queue.shift(); + if (!current) { + break; + } + if (current.link === tipLink) { + return current.chain; + } + + for (const joint of byParent.get(current.link) ?? []) { + if (visited.has(joint.child)) { + continue; + } + visited.add(joint.child); + queue.push({ link: joint.child, chain: [...current.chain, joint] }); + } + } + + throw invalidModel(`URDF baseLink ${baseLink} is not connected to tipLink ${tipLink}`); +} + +function resolveActiveJointOrder(chain: JointModel[], jointOrder?: string[]): string[] { + const defaultOrder = chain + .filter((joint) => joint.type !== "fixed") + .map((joint) => joint.name); + + if (!jointOrder || jointOrder.length === 0) { + return defaultOrder; + } + + const chainActive = new Set(defaultOrder); + for (const jointName of jointOrder) { + if (!chainActive.has(jointName)) { + throw invalidModel(`jointOrder contains a joint outside the base-tip chain: ${jointName}`); + } + } + + if (jointOrder.length !== defaultOrder.length) { + throw invalidModel("jointOrder must contain every active joint in the base-tip chain exactly once"); + } + + return [...jointOrder]; +} + +function limitForJoint(joint: JointModel, overrides: JointLimitOverride[]): JointLimits { + const base = joint.limit; + if (!base) { + throw invalidModel(`Active joint ${joint.name} is missing limits`); + } + const override = overrides.find((candidate) => candidate.name === joint.name); + if (!override) { + return base; + } + + return { + name: joint.name, + lower: override.lower ?? base.lower, + upper: override.upper ?? base.upper, + velocity: override.velocity ?? base.velocity, + acceleration: override.acceleration ?? base.acceleration, + ...mergedOptionalJerk(override, base) + }; +} + +function optionalJerk(limitNode: XmlNode, jointName: string): Pick | Record { + const jerk = optionalNumberAttr(limitNode["@_jerk"], `joint ${jointName} jerk limit`); + return jerk === undefined ? {} : { jerk }; +} + +function mergedOptionalJerk( + override: JointLimitOverride, + base: JointLimits +): Pick | Record { + const jerk = override.jerk ?? base.jerk; + return jerk === undefined ? {} : { jerk }; +} + +function parseTriple(value: string | undefined, fallback: [number, number, number], context: string): [number, number, number] { + if (!value) { + return fallback; + } + const parts = value.trim().split(/\s+/).map((part) => Number(part)); + if (parts.length !== 3 || parts.some((part) => !Number.isFinite(part))) { + throw invalidModel(`Invalid ${context}: ${value}`); + } + return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0]; +} + +function numberAttr(value: unknown, context: string): number { + const numberValue = optionalNumberAttr(value, context); + if (numberValue === undefined) { + throw invalidModel(`Missing ${context}`); + } + return numberValue; +} + +function optionalNumberAttr(value: unknown, context: string): number | undefined { + if (value === undefined || value === null || value === "") { + return undefined; + } + const numberValue = Number(value); + if (!Number.isFinite(numberValue)) { + throw invalidModel(`Invalid ${context}: ${String(value)}`); + } + return numberValue; +} + +function stringAttr(value: unknown): string | undefined { + return typeof value === "string" && value.length > 0 ? value : undefined; +} + +function asArray(value: unknown): T[] { + if (value === undefined || value === null) { + return []; + } + return Array.isArray(value) ? (value as T[]) : [value as T]; +} + +function isObject(value: unknown): value is XmlNode { + return typeof value === "object" && value !== null && !Array.isArray(value); +} + +function invalidModel(message: string): KdlStructuredError { + return new KdlStructuredError("KDL_INVALID_MODEL", message); +} diff --git a/kdl-wasm/web/tests/grl/controlFlow.test.ts b/kdl-wasm/web/tests/grl/controlFlow.test.ts new file mode 100644 index 0000000..a9d4be4 --- /dev/null +++ b/kdl-wasm/web/tests/grl/controlFlow.test.ts @@ -0,0 +1,197 @@ +import { describe, expect, it } from "vitest"; +import type { GrlProcedureDeclaration } from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { parseProcedureControlFlow } from "../../src/grl/semantic/index.js"; + +function procedure(source: string): GrlProcedureDeclaration { + return parseGrl(source).module.declarations.find( + (decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration" + )!; +} + +describe("GRL control-flow compilation", () => { + it("compiles if, elseif, else, while, for, switch, labels, and jumps", () => { + const proc = procedure(`language grl 0.1 +module Main + proc main() + label retry + if ready == true + wait io.di[1] == true + elseif fault == true + jump recovery + else + jump retry + end + while all(io.di[1] == true, io.di[2] == false) + continue + end + for i = 1 to 3 step 1 + movej home + end + switch mode + case 1 + break + case 2 + jump done + default + jump recovery + end + label recovery + label done + end +end +`); + + const flow = parseProcedureControlFlow(proc); + + expect(flow).toEqual([ + expect.objectContaining({ kind: "LABEL", name: "retry", scopePath: [] }), + expect.objectContaining({ + kind: "IF", + branches: [ + expect.objectContaining({ + branchKind: "if", + condition: expect.objectContaining({ text: "ready == true" }), + body: [expect.objectContaining({ kind: "RAW_STATEMENT", text: "wait io . di [ 1 ] == true" })] + }), + expect.objectContaining({ + branchKind: "elseif", + condition: expect.objectContaining({ text: "fault == true" }), + body: [expect.objectContaining({ kind: "JUMP", label: "recovery" })] + }), + expect.objectContaining({ + branchKind: "else", + body: [expect.objectContaining({ kind: "JUMP", label: "retry" })] + }) + ] + }), + expect.objectContaining({ + kind: "WHILE", + condition: expect.objectContaining({ + text: "all ( io . di [ 1 ] == true , io . di [ 2 ] == false )" + }), + body: [expect.objectContaining({ kind: "CONTINUE" })] + }), + expect.objectContaining({ + kind: "FOR", + iterator: "i", + from: expect.objectContaining({ text: "1" }), + to: expect.objectContaining({ text: "3" }), + step: expect.objectContaining({ text: "1" }), + body: [expect.objectContaining({ kind: "RAW_STATEMENT", text: "movej home" })] + }), + expect.objectContaining({ + kind: "SWITCH", + expression: expect.objectContaining({ text: "mode" }), + cases: [ + expect.objectContaining({ caseKind: "case", value: 1, body: [expect.objectContaining({ kind: "BREAK" })] }), + expect.objectContaining({ caseKind: "case", value: 2, body: [expect.objectContaining({ kind: "JUMP", label: "done" })] }), + expect.objectContaining({ caseKind: "default", body: [expect.objectContaining({ kind: "JUMP", label: "recovery" })] }) + ] + }), + expect.objectContaining({ kind: "LABEL", name: "recovery", scopePath: [] }), + expect.objectContaining({ kind: "LABEL", name: "done", scopePath: [] }) + ]); + }); + + it("reports non-boolean control conditions", () => { + const proc = procedure(`language grl 0.1 +module Main + proc main() + if 1 + end + end +end +`); + + expect(() => parseProcedureControlFlow(proc)).toThrowError( + expect.objectContaining({ code: "GRL_CONTROL_CONDITION_NOT_BOOL" }) + ); + }); + + it("reports break and continue outside valid blocks", () => { + const breakProc = procedure(`language grl 0.1 +module Main + proc main() + break + end +end +`); + const continueProc = procedure(`language grl 0.1 +module Main + proc main() + switch mode + case 1 + continue + end + end +end +`); + + expect(() => parseProcedureControlFlow(breakProc)).toThrowError( + expect.objectContaining({ code: "GRL_BREAK_OUTSIDE_FLOW" }) + ); + expect(() => parseProcedureControlFlow(continueProc)).toThrowError( + expect.objectContaining({ code: "GRL_CONTINUE_OUTSIDE_LOOP" }) + ); + }); + + it("reports duplicate or non-constant switch cases", () => { + const duplicateProc = procedure(`language grl 0.1 +module Main + proc main() + switch mode + case 1 + break + case 1 + break + end + end +end +`); + const nonConstantProc = procedure(`language grl 0.1 +module Main + proc main() + switch mode + case mode + 1 + break + end + end +end +`); + + expect(() => parseProcedureControlFlow(duplicateProc)).toThrowError( + expect.objectContaining({ code: "GRL_SWITCH_CASE_DUPLICATE" }) + ); + expect(() => parseProcedureControlFlow(nonConstantProc)).toThrowError( + expect.objectContaining({ code: "GRL_SWITCH_CASE_NOT_CONSTANT" }) + ); + }); + + it("reports labels that cannot be reached by jump", () => { + const intoBlockProc = procedure(`language grl 0.1 +module Main + proc main() + jump inner + if ready == true + label inner + end + end +end +`); + const missingLabelProc = procedure(`language grl 0.1 +module Main + proc main() + jump missing + end +end +`); + + expect(() => parseProcedureControlFlow(intoBlockProc)).toThrowError( + expect.objectContaining({ code: "GRL_JUMP_INTO_BLOCK" }) + ); + expect(() => parseProcedureControlFlow(missingLabelProc)).toThrowError( + expect.objectContaining({ code: "GRL_LABEL_NOT_FOUND" }) + ); + }); +}); diff --git a/kdl-wasm/web/tests/grl/dataDeclarations.test.ts b/kdl-wasm/web/tests/grl/dataDeclarations.test.ts new file mode 100644 index 0000000..040e8ab --- /dev/null +++ b/kdl-wasm/web/tests/grl/dataDeclarations.test.ts @@ -0,0 +1,151 @@ +import { describe, expect, it } from "vitest"; +import type { GrlDataDeclaration, GrlTargetDeclaration } from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + compileGrlDataDeclaration, + compileGrlTargetDeclaration, + compileOffsetExpression +} from "../../src/grl/semantic/index.js"; + +function dataDeclarations(source: string): GrlDataDeclaration[] { + return parseGrl(source).module.declarations.filter( + (declaration): declaration is GrlDataDeclaration => declaration.kind === "DataDeclaration" + ); +} + +function targetDeclarations(source: string): GrlTargetDeclaration[] { + return parseGrl(source).module.declarations.filter( + (declaration): declaration is GrlTargetDeclaration => declaration.kind === "TargetDeclaration" + ); +} + +describe("GRL data declarations and target compilation", () => { + it("compiles tool and frame declarations into shared structures", () => { + const [toolDecl, frameDecl] = dataDeclarations(`language grl 0.1 +module Main + persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 180 mm, 0 deg, 0 deg, 0 deg), + mass: 2.5 kg, + cog: [0 mm, 0 mm, 80 mm] + } + persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 200 mm, 0 deg, 0 deg, 0 deg) + } +end +`); + + expect(toolDecl).toMatchObject({ + storage: "persistent", + typeName: "tool", + name: "gripper", + initializer: { kind: "ObjectExpression", typeName: "tool" } + }); + expect(compileGrlDataDeclaration(toolDecl!)).toMatchObject({ + name: "gripper", + value: { + tcp: { + position: [0, 0, 0.18], + quaternion: [0, 0, 0, 1] + }, + mass: 2.5, + cog: [0, 0, 0.08] + } + }); + expect(compileGrlDataDeclaration(frameDecl!)).toMatchObject({ + name: "fixture", + value: { + origin: { + position: [0.8, 0, 0.2], + quaternion: [0, 0, 0, 1] + } + } + }); + }); + + it("compiles speed and zone declarations", () => { + const declarations = dataDeclarations(`language grl 0.1 +module Main + const speed v_joint = joint(80 %) + const speed v_pick = linear(300 mm/s) + const speed v_slow = linear(100 mm/s, acc 500 mm/s2) + const zone z_fine = fine + const zone z10 = z(10 mm) + const zone z_cnt = cnt(30) + const zone z_cont = continuous +end +`); + const compiled = declarations.map(compileGrlDataDeclaration); + + expect(compiled).toMatchObject([ + { name: "v_joint", value: { kind: "joint_percent", value: 0.8 } }, + { name: "v_pick", value: { kind: "linear", velocity: 0.3 } }, + { name: "v_slow", value: { kind: "linear", velocity: 0.1, acceleration: 0.5 } }, + { name: "z_fine", value: { kind: "fine" } }, + { name: "z10", value: { kind: "distance", value: 0.01 } }, + { name: "z_cnt", value: { kind: "cnt", value: 30 } }, + { name: "z_cont", value: { kind: "continuous" } } + ]); + }); + + it("compiles joint_target and pose_target declarations", () => { + const [home, pick] = targetDeclarations(`language grl 0.1 +module Main + target home = joint_target { + joints: [0 deg, -30 deg, 60 deg, 0 deg, 60 deg, 0 deg] + } + target pick = pose_target { + pose: pose(500 mm, 120 mm, 300 mm, 180 deg, 0 deg, 90 deg), + config: robot_config(0, 0, 1), + tool: gripper, + frame: fixture + } +end +`); + + expect(compileGrlTargetDeclaration(home!)).toMatchObject({ + name: "home", + target: { + joints: [0, -Math.PI / 6, Math.PI / 3, 0, Math.PI / 3, 0] + } + }); + + const compiledPick = compileGrlTargetDeclaration(pick!); + expect(compiledPick.name).toBe("pick"); + expect("pose" in compiledPick.target).toBe(true); + if ("pose" in compiledPick.target) { + expect(compiledPick.target.pose.position).toEqual([0.5, 0.12, 0.3]); + expect(compiledPick.target.config).toEqual({ shoulder: 0, elbow: 0, wrist: 1 }); + } + }); + + it("parses and compiles offset expressions", () => { + const [declFrame, declTool] = dataDeclarations(`language grl 0.1 +module Main + var pose_target p2 = pick offset x 20 mm y -10 mm z 50 mm + var pose_target p3 = pick offset_in tool z -50 mm +end +`); + + expect(declFrame?.initializer).toMatchObject({ + kind: "OffsetExpression", + mode: "frame", + axes: [ + { axis: "x" }, + { axis: "y" }, + { axis: "z" } + ] + }); + if (declFrame?.initializer.kind === "OffsetExpression") { + expect(compileOffsetExpression(declFrame.initializer)).toEqual({ + mode: "frame", + xyz: [0.02, -0.01, 0.05] + }); + } + if (declTool?.initializer.kind === "OffsetExpression") { + expect(compileOffsetExpression(declTool.initializer)).toEqual({ + mode: "tool", + xyz: [0, 0, -0.05] + }); + } + }); +}); diff --git a/kdl-wasm/web/tests/grl/exceptionCompile.test.ts b/kdl-wasm/web/tests/grl/exceptionCompile.test.ts new file mode 100644 index 0000000..b595d4a --- /dev/null +++ b/kdl-wasm/web/tests/grl/exceptionCompile.test.ts @@ -0,0 +1,125 @@ +import { describe, expect, it } from "vitest"; +import type { GrlProcedureDeclaration, GrlRawTopLevelDeclaration } from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + analyzeExceptionSemantics, + parseProcedureExceptionFlow +} from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + trap recover_trap() + raise E_STOP + end + task background cycle 10 ms + call monitor() + end + proc main() + alarm E_STOP "Emergency stop" severity fatal + try + raise E_STOP + catch E_STOP + alarm RECOVER "Recovering" severity warning + finally + alarm CLEANUP "Cleanup" + end + enable interrupt guard + disable interrupt guard + end +end +`; + +function declarations() { + return parseGrl(PROGRAM).module.declarations; +} + +describe("GRL alarm, raise, try/catch, interrupt, and task semantics", () => { + it("keeps trap and task as parsed raw declarations for P1 diagnostics", () => { + const raw = declarations().filter( + (decl): decl is GrlRawTopLevelDeclaration => decl.kind === "RawTopLevelDeclaration" + ); + + expect(raw[0]?.declarationType).toBe("trap"); + expect(raw[0]?.tokens[0]).toMatchObject({ raw: "trap" }); + expect(raw[0]?.tokens[1]).toMatchObject({ raw: "recover_trap" }); + expect(raw[1]?.declarationType).toBe("task"); + expect(raw[1]?.tokens[0]).toMatchObject({ raw: "task" }); + expect(raw[1]?.tokens[1]).toMatchObject({ raw: "background" }); + }); + + it("compiles alarm, raise, try/catch/finally, and interrupt diagnostics from procedure body", () => { + const procedure = declarations().find( + (decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration" + )!; + + expect(parseProcedureExceptionFlow(procedure)).toEqual([ + expect.objectContaining({ + kind: "ALARM", + alarmId: "E_STOP", + message: "Emergency stop", + severity: "fatal" + }), + expect.objectContaining({ + kind: "TRY", + body: [expect.objectContaining({ kind: "RAISE", alarmId: "E_STOP" })], + catches: [ + expect.objectContaining({ + alarmId: "E_STOP", + body: [ + expect.objectContaining({ + kind: "ALARM", + alarmId: "RECOVER", + message: "Recovering", + severity: "warning" + }) + ] + }) + ], + finally: expect.objectContaining({ + body: [expect.objectContaining({ kind: "ALARM", alarmId: "CLEANUP", message: "Cleanup" })] + }) + }), + expect.objectContaining({ kind: "UNSUPPORTED_RUNTIME", feature: "interrupt" }), + expect.objectContaining({ kind: "UNSUPPORTED_RUNTIME", feature: "interrupt" }) + ]); + }); + + it("reports P1 trap/task semantics as explicit unsupported diagnostics", () => { + const analysis = analyzeExceptionSemantics(declarations()); + + expect(analysis.unsupported).toEqual([ + expect.objectContaining({ kind: "UNSUPPORTED_RUNTIME", feature: "trap" }), + expect.objectContaining({ kind: "UNSUPPORTED_RUNTIME", feature: "task" }) + ]); + expect(analysis.diagnostics).toEqual([ + expect.objectContaining({ severity: "warning", code: "GRL_P1_UNIMPLEMENTED" }), + expect.objectContaining({ severity: "warning", code: "GRL_P1_UNIMPLEMENTED" }) + ]); + }); + + it("reports missing alarm ids and try blocks without handlers", () => { + const missingAlarmId = parseGrl(`language grl 0.1 +module Main + proc main() + alarm + end +end +`).module.declarations.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + const tryWithoutHandler = parseGrl(`language grl 0.1 +module Main + proc main() + try + raise E_STOP + end + end +end +`).module.declarations.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + + expect(() => parseProcedureExceptionFlow(missingAlarmId)).toThrowError( + expect.objectContaining({ code: "GRL_ALARM_ID_MISSING" }) + ); + expect(() => parseProcedureExceptionFlow(tryWithoutHandler)).toThrowError( + expect.objectContaining({ code: "GRL_TRY_HANDLER_MISSING" }) + ); + }); +}); diff --git a/kdl-wasm/web/tests/grl/generator/roundtrip.test.ts b/kdl-wasm/web/tests/grl/generator/roundtrip.test.ts new file mode 100644 index 0000000..fefe791 --- /dev/null +++ b/kdl-wasm/web/tests/grl/generator/roundtrip.test.ts @@ -0,0 +1,149 @@ +import { describe, expect, it } from "vitest"; +import { generateGrlProgram, type GrlProgramGenerationSpec } from "../../../src/grl/generator/index.js"; +import { postProcessAllBrands } from "../../../src/grl/post/index.js"; +import type { GrlOperationDeclaration, GrlPathDeclaration, GrlTargetDeclaration } from "../../../src/grl/ast/index.js"; +import { parseGrl } from "../../../src/grl/parser/index.js"; +import { compileSemanticProgram } from "../../../src/grl/semantic/index.js"; + +const SPEC: GrlProgramGenerationSpec = { + moduleName: "GeneratedCell", + speeds: { + v_linear: "linear(200 mm/s)", + v_joint: "joint(50 %)" + }, + zones: { + z10: "z(10 mm)", + zf: "fine" + }, + targets: [ + { name: "pick", kind: "pose", values: [500, 0, 0, 0, 0, 0] }, + { name: "home", kind: "joint", values: [0] }, + { name: "place", kind: "pose", values: [600, 0, 0, 0, 0, 0] } + ], + path: { + name: "generated_path", + source: { + type: "cad_curve", + id: "edge_001", + sample_distance: 5 + }, + defaults: { + speed: "v_linear", + zone: "z10" + }, + points: [ + { motion: "movej", target: "home", speed: "v_joint", zone: "zf" }, + { motion: "movel", target: "pick" }, + { id: "place_point", motion: "movel", target: "place", zone: "zf" } + ] + }, + operation: { + name: "generated_op", + kind: "handling", + path: "generated_path", + startAction: "io.do[1] = true", + endAction: "io.do[1] = false" + } +}; + +describe("GRL generator and roundtrip", () => { + it("generates stable expanded GRL with target/path/operation first", () => { + const first = generateGrlProgram(SPEC, "expanded"); + const second = generateGrlProgram(SPEC, "expanded"); + + expect(first).toEqual(second); + expect(first.stableIds).toEqual({ + targets: ["home", "pick", "place"], + points: ["p00", "p01", "place_point"], + path: "generated_path", + operation: "generated_op" + }); + expect(first.text).toBe(`language grl 0.1 +module GeneratedCell + const speed v_joint = joint(50 %) + const speed v_linear = linear(200 mm/s) + const zone z10 = z(10 mm) + const zone zf = fine + target home = joint_target { + joints: [0 deg] + } + target pick = pose_target { + pose: pose(500 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + target place = pose_target { + pose: pose(600 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + path generated_path { + source { + id: "edge_001" + sample_distance: 5 + type: cad_curve + } + defaults { + speed: v_linear + zone: z10 + } + point p00 movej home speed v_joint zone zf + point p01 movel pick + point place_point movel place zone zf + } + operation generated_op { + kind: handling + path: generated_path + start_action: + io.do[1] = true + end_action: + io.do[1] = false + } + proc main() + run_operation generated_op + end +end`); + }); + + it("supports compact output that remains parseable", () => { + const compact = generateGrlProgram(SPEC, "compact"); + + expect(compact.text).toContain("path generated_path { source { id: \"edge_001\""); + expect(parseGrl(compact.text).module.name).toBe("GeneratedCell"); + }); + + it("roundtrips through parser, semantic IR, and postprocessors", () => { + const generated = generateGrlProgram(SPEC, "expanded"); + const ast = parseGrl(generated.text); + const declarations = ast.module.declarations; + const targets = declarations.filter((decl): decl is GrlTargetDeclaration => decl.kind === "TargetDeclaration"); + const path = declarations.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + const operation = declarations.find((decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration")!; + const ir = compileSemanticProgram(ast, { + startJoints: [0], + sampleTime: 0.004 + }); + const post = postProcessAllBrands(ir); + + expect(targets.map((target) => target.name)).toEqual(["home", "pick", "place"]); + expect(path.items).toEqual( + expect.arrayContaining([ + expect.objectContaining({ kind: "PathSourceBlock" }), + expect.objectContaining({ kind: "PathDefaultsBlock" }), + expect.objectContaining({ kind: "PathPoint", id: "p00" }), + expect.objectContaining({ kind: "PathPoint", id: "p01" }), + expect.objectContaining({ kind: "PathPoint", id: "place_point" }) + ]) + ); + expect(operation).toMatchObject({ + name: "generated_op", + operationKind: "handling", + pathName: "generated_path" + }); + expect(ir.symbols).toEqual( + expect.arrayContaining([ + expect.objectContaining({ kind: "path", name: "generated_path" }), + expect.objectContaining({ kind: "operation", name: "generated_op" }) + ]) + ); + expect(post.outputs.abb.text).toContain("MODULE GeneratedCell"); + expect(post.outputs.fanuc.text).toContain("/PROG MAIN"); + expect(post.outputs.kuka.text).toContain("DEF Main()"); + }); +}); diff --git a/kdl-wasm/web/tests/grl/ioCompile.test.ts b/kdl-wasm/web/tests/grl/ioCompile.test.ts new file mode 100644 index 0000000..d95b0dd --- /dev/null +++ b/kdl-wasm/web/tests/grl/ioCompile.test.ts @@ -0,0 +1,205 @@ +import { describe, expect, it } from "vitest"; +import type { + GrlDataDeclaration, + GrlOperationDeclaration, + GrlPathDeclaration, + GrlProcedureDeclaration, + GrlTargetDeclaration +} from "../../src/grl/ast/index.js"; +import type { PathEventInstruction } from "../../src/grl/ir/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + buildMotionContext, + compileOperation, + compileOperationActionIo, + compilePathEventIo, + compilePathToPlanRequest, + parseIoFlowStatements, + type IoMap +} from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } + path io_path { + defaults { speed: v, zone: zf } + point p0 movej home + event at p0 distance 0 mm pulse io.do[20] duration 100 ms + } + operation io_op { + kind: handling + path: io_path + start_action: + wait io.di[4] == true timeout 500 ms on_timeout alarm "part missing" + end_action: + pulse io.do[5] duration 250 ms + } + proc main() + io.do[1] = true + io.go[2] = 16 + io.alias.grip_close = false + wait all(io.di[1] == true, io.di[2] == false) timeout 2 s on_timeout alarm "Clamp close timeout" + wait any(rising(io.di[3]), falling(io.di[4]), changed(io.ai[1])) + wait io.di[5] == true timeout 1 s on_timeout call recover + pulse io.do[3] duration 200 ms + end +end +`; + +const IO_MAP: IoMap = { + aliases: { + grip_close: { domain: "do", index: 6, raw: "io.do[6]" } + }, + allowedRanges: { + ai: { min: 1, max: 8 }, + di: { min: 1, max: 16 }, + do: { min: 1, max: 32 }, + go: { min: 1, max: 4 } + } +}; + +function declarations() { + return parseGrl(PROGRAM).module.declarations; +} + +function motionContext(decls = declarations()) { + return buildMotionContext( + decls.filter( + (decl): decl is GrlDataDeclaration | GrlTargetDeclaration => + decl.kind === "DataDeclaration" || decl.kind === "TargetDeclaration" + ) + ); +} + +function pathsByName(paths: GrlPathDeclaration[]) { + return new Map(paths.map((path) => [path.name, path])); +} + +describe("GRL IO, wait, and pulse compilation", () => { + it("compiles procedure IO writes, wait conditions, timeout actions, and pulse traces", () => { + const procedure = declarations().find( + (decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration" + )!; + + const instructions = parseIoFlowStatements(procedure.bodyTokens, IO_MAP); + + expect(instructions).toHaveLength(7); + expect(instructions[0]).toMatchObject({ + kind: "IO_WRITE", + target: { domain: "do", index: 1, raw: "io.do[1]" }, + value: true + }); + expect(instructions[1]).toMatchObject({ + kind: "IO_WRITE", + target: { domain: "go", index: 2, raw: "io.go[2]" }, + value: 16 + }); + expect(instructions[2]).toMatchObject({ + kind: "IO_WRITE", + target: { domain: "do", index: 6, raw: "io.do[6]" }, + value: false + }); + expect(instructions[3]).toMatchObject({ + kind: "WAIT", + condition: "all ( io . di [ 1 ] == true , io . di [ 2 ] == false )", + timeout: 2, + onTimeout: { kind: "alarm", value: "Clamp close timeout" } + }); + expect(instructions[4]).toMatchObject({ + kind: "WAIT", + condition: "any ( rising ( io . di [ 3 ] ) , falling ( io . di [ 4 ] ) , changed ( io . ai [ 1 ] ) )" + }); + expect(instructions[5]).toMatchObject({ + kind: "WAIT", + condition: "io . di [ 5 ] == true", + timeout: 1, + onTimeout: { kind: "call", value: "recover" } + }); + expect(instructions[6]).toMatchObject({ + kind: "PULSE", + target: { domain: "do", index: 3, raw: "io.do[3]" }, + duration: 0.2, + trace: [ + { time: 0, action: "set", target: { domain: "do", index: 3 }, value: true }, + { time: 0.2, action: "reset", target: { domain: "do", index: 3 }, value: false } + ] + }); + }); + + it("validates IO addresses against configured ranges", () => { + const procedure = parseGrl(`language grl 0.1 +module Main + proc main() + io.do[99] = true + end +end +`).module.declarations.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + + expect(() => + parseIoFlowStatements(procedure.bodyTokens, { allowedRanges: { do: { min: 1, max: 16 } } }) + ).toThrowError(expect.objectContaining({ code: "GRL_IO_ADDRESS_NOT_FOUND" })); + }); + + it("expands path event IO metadata into pulse IR without entering KDL motion segments", () => { + const decls = declarations(); + const path = decls.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + const compiled = compilePathToPlanRequest(path, motionContext(decls), { + startJoints: [0], + sampleTime: 0.004 + }); + + expect(compiled.request.segments).toHaveLength(1); + expect(compiled.request.events).toHaveLength(1); + expect(compilePathEventIo(compiled.events[0]!, IO_MAP)).toEqual([ + expect.objectContaining({ + kind: "PULSE", + target: { domain: "do", index: 20, raw: "io.do[20]" }, + duration: 0.1 + }) + ]); + }); + + it("expands operation action metadata into wait and pulse IR with preserved units", () => { + const decls = declarations(); + const operation = decls.find( + (decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration" + )!; + const paths = decls.filter((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration"); + const compiled = compileOperation(operation, pathsByName(paths)); + + expect(compileOperationActionIo(compiled.startActions[0]!, IO_MAP)).toEqual([ + expect.objectContaining({ + kind: "WAIT", + condition: "io . di [ 4 ] == true", + timeout: 0.5, + onTimeout: { kind: "alarm", value: "part missing" } + }) + ]); + expect(compileOperationActionIo(compiled.endActions[0]!, IO_MAP)).toEqual([ + expect.objectContaining({ + kind: "PULSE", + target: { domain: "do", index: 5, raw: "io.do[5]" }, + duration: 0.25 + }) + ]); + }); + + it("lexes statement fallback metadata so unit literals and booleans remain typed", () => { + const event: PathEventInstruction = { + timing: "at", + pointId: "p0", + kind: "pulse", + data: { statement: "pulse io.do[7] duration 125 ms" } + }; + + expect(compilePathEventIo(event, IO_MAP)).toEqual([ + expect.objectContaining({ + kind: "PULSE", + target: { domain: "do", index: 7, raw: "io.do[7]" }, + duration: 0.125 + }) + ]); + }); +}); diff --git a/kdl-wasm/web/tests/grl/lexer.test.ts b/kdl-wasm/web/tests/grl/lexer.test.ts new file mode 100644 index 0000000..a0351b2 --- /dev/null +++ b/kdl-wasm/web/tests/grl/lexer.test.ts @@ -0,0 +1,94 @@ +import { describe, expect, it } from "vitest"; +import { GRL_KEYWORDS, lexGrl, normalizeUnitLiteral, normalizeUnitValue } from "../../src/grl/lexer/index.js"; +import type { GrlNumberToken } from "../../src/grl/lexer/index.js"; + +function numbers(source: string): GrlNumberToken[] { + return lexGrl(source).filter((token): token is GrlNumberToken => token.kind === "number"); +} + +describe("GRL lexer", () => { + it("recognizes comments, keywords, identifiers, and source positions", () => { + const tokens = lexGrl(`// generated\nlanguage grl 0.1\nmodule Main\n proc main()\n end\nend\n`); + + expect(tokens[0]).toMatchObject({ + kind: "comment", + style: "line", + value: " generated", + range: { + start: { line: 1, column: 1 }, + end: { line: 1, column: 13 } + } + }); + expect(tokens.filter((token) => token.kind === "keyword").map((token) => token.raw)).toEqual([ + "language", + "module", + "proc", + "end", + "end" + ]); + expect(tokens.find((token) => token.raw === "Main")).toMatchObject({ + kind: "identifier", + range: { + start: { line: 3, column: 8 } + } + }); + expect(tokens.at(-1)).toMatchObject({ kind: "eof" }); + }); + + it("normalizes numeric literals with GRL units into SI values", () => { + const found = numbers("100 mm 0.25 m 180 deg 3.14159 rad 300 mm/s 50 % 200 ms 2.5 kg 500 mm/s2"); + + expect(found.map((token) => token.unit?.raw)).toEqual([ + "mm", + "m", + "deg", + "rad", + "mm/s", + "%", + "ms", + "kg", + "mm/s2" + ]); + expect(found[0]?.unit?.normalizedValue).toBeCloseTo(0.1); + expect(found[1]?.unit?.normalizedValue).toBeCloseTo(0.25); + expect(found[2]?.unit?.normalizedValue).toBeCloseTo(Math.PI); + expect(found[3]?.unit?.normalizedValue).toBeCloseTo(3.14159); + expect(found[4]?.unit?.normalizedValue).toBeCloseTo(0.3); + expect(found[5]?.unit?.normalizedValue).toBeCloseTo(0.5); + expect(found[6]?.unit?.normalizedValue).toBeCloseTo(0.2); + expect(found[7]?.unit?.normalizedValue).toBeCloseTo(2.5); + expect(found[8]?.unit?.normalizedValue).toBeCloseTo(0.5); + }); + + it("keeps unit raw text on number tokens", () => { + const [token] = numbers("linear(300 mm/s)"); + + expect(token).toMatchObject({ + kind: "number", + raw: "300 mm/s", + value: 300, + unit: { + raw: "mm/s", + kind: "linear_velocity", + siUnit: "m/s" + } + }); + }); + + it("exposes the full reserved keyword set from the specification", () => { + expect(GRL_KEYWORDS).toContain("movej"); + expect(GRL_KEYWORDS).toContain("run_operation"); + expect(GRL_KEYWORDS).toContain("post_hint"); + expect(GRL_KEYWORDS).toContain("continuous"); + expect(GRL_KEYWORDS).toHaveLength(85); + }); + + it("provides direct unit helpers for parser and semantic layers", () => { + expect(normalizeUnitLiteral("deg/s")).toMatchObject({ + kind: "angular_velocity", + siUnit: "rad/s" + }); + expect(normalizeUnitValue(90, "deg/s")).toBeCloseTo(Math.PI / 2); + expect(() => normalizeUnitLiteral("inch")).toThrow("Unknown GRL unit"); + }); +}); diff --git a/kdl-wasm/web/tests/grl/motionCompile.test.ts b/kdl-wasm/web/tests/grl/motionCompile.test.ts new file mode 100644 index 0000000..5ed31e4 --- /dev/null +++ b/kdl-wasm/web/tests/grl/motionCompile.test.ts @@ -0,0 +1,124 @@ +import { describe, expect, it } from "vitest"; +import type { GrlDataDeclaration, GrlProcedureDeclaration, GrlTargetDeclaration } from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + buildMotionContext, + compileMotionToKdlRequest, + parseProcedureMotionInstructions +} from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 100 mm, 0 deg, 0 deg, 0 deg), + mass: 1 kg + } + persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + const speed v_joint = joint(60 %) + const speed v_linear = linear(300 mm/s) + const zone z10 = z(10 mm) + target home = joint_target { + joints: [0 deg, 0 deg] + } + target pick = pose_target { + pose: pose(500 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg), + tool: gripper, + frame: fixture + } + target mid = pose_target { + pose: pose(550 mm, 50 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + target arc_end = pose_target { + pose: pose(600 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + proc main() + set_tool gripper + set_frame fixture + set_speed v_linear + set_zone z10 + movej home speed v_joint zone fine + movel pick + movec via mid target arc_end speed linear(150 mm/s) zone fine + end +end +`; + +function declarations() { + return parseGrl(PROGRAM).module.declarations; +} + +describe("GRL motion instruction compilation", () => { + it("parses movej, movel, and movec from procedure body tokens", () => { + const decls = declarations(); + const context = buildMotionContext( + decls.filter( + (decl): decl is GrlDataDeclaration | GrlTargetDeclaration => + decl.kind === "DataDeclaration" || decl.kind === "TargetDeclaration" + ) + ); + const procedure = decls.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + const instructions = parseProcedureMotionInstructions(procedure, context); + + expect(instructions.map((instruction) => instruction.kind)).toEqual(["MOVEJ", "MOVEL", "MOVEC"]); + expect(instructions[0]).toMatchObject({ + kind: "MOVEJ", + speed: { kind: "joint_percent", value: 0.6 }, + zone: { kind: "fine" }, + target: { joints: [0, 0] }, + sourceMap: { line: 32 } + }); + expect(instructions[1]).toMatchObject({ + kind: "MOVEL", + speed: { kind: "linear", velocity: 0.3 }, + zone: { kind: "distance", value: 0.01 } + }); + expect(instructions[1]?.tool?.position).toEqual([0, 0, 0.1]); + expect(instructions[1]?.frame?.position).toEqual([0.8, 0, 0]); + expect(instructions[2]).toMatchObject({ + kind: "MOVEC", + speed: { kind: "linear", velocity: 0.15 }, + zone: { kind: "fine" } + }); + }); + + it("compiles motion instructions to KDL request shapes", () => { + const decls = declarations(); + const context = buildMotionContext( + decls.filter( + (decl): decl is GrlDataDeclaration | GrlTargetDeclaration => + decl.kind === "DataDeclaration" || decl.kind === "TargetDeclaration" + ) + ); + const procedure = decls.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + const [movej, movel, movec] = parseProcedureMotionInstructions(procedure, context); + + expect(compileMotionToKdlRequest(movej!, { startJoints: [0, 0], sampleTime: 0.004 })).toMatchObject({ + startJoints: [0, 0], + target: { joints: [0, 0] }, + speed: { kind: "joint_percent", value: 0.6 }, + zone: { kind: "fine" }, + sampleTime: 0.004 + }); + + expect(compileMotionToKdlRequest(movel!, { startJoints: [0, 0], sampleTime: 0.004 })).toMatchObject({ + startJoints: [0, 0], + target: { pose: { position: [0.5, 0, 0] } }, + speed: { kind: "linear", velocity: 0.3 }, + zone: { kind: "distance", value: 0.01 }, + tool: { position: [0, 0, 0.1] }, + frame: { position: [0.8, 0, 0] }, + sampleTime: 0.004 + }); + + expect(compileMotionToKdlRequest(movec!, { startJoints: [0, 0], sampleTime: 0.004 })).toMatchObject({ + startJoints: [0, 0], + via: { pose: { position: [0.55, 0.05, 0] } }, + target: { pose: { position: [0.6, 0, 0] } }, + speed: { kind: "linear", velocity: 0.15 }, + zone: { kind: "fine" }, + sampleTime: 0.004 + }); + }); +}); diff --git a/kdl-wasm/web/tests/grl/operationCompile.test.ts b/kdl-wasm/web/tests/grl/operationCompile.test.ts new file mode 100644 index 0000000..c01c12f --- /dev/null +++ b/kdl-wasm/web/tests/grl/operationCompile.test.ts @@ -0,0 +1,153 @@ +import { describe, expect, it } from "vitest"; +import type { + GrlOperationDeclaration, + GrlPathDeclaration, + GrlProcedureDeclaration +} from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + compileOperation, + expandRunOperation, + parseProcedureRunOperationStatements +} from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } + path weld_path { + defaults { speed: v, zone: zf } + point p0 movej home + } + operation weld_op_01 { + kind: arc_welding + path: weld_path + process { + weld_id: "WELD_1" + voltage: 24.0 + current: 180.0 + weave: none + } + start_action: + io.do[20] = true + end_action: + io.do[20] = false + } + proc main() + run_operation weld_op_01 + end +end +`; + +function declarations() { + return parseGrl(PROGRAM).module.declarations; +} + +function pathsByName(paths: GrlPathDeclaration[]) { + return new Map(paths.map((path) => [path.name, path])); +} + +describe("GRL operation compilation", () => { + it("parses operation kind, path, process, and action blocks", () => { + const operation = declarations().find( + (decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration" + )!; + + expect(operation).toMatchObject({ + kind: "OperationDeclaration", + name: "weld_op_01", + operationKind: "arc_welding", + pathName: "weld_path", + items: [ + { kind: "OperationProcessBlock" }, + { kind: "OperationActionBlock", actionKind: "start_action" }, + { kind: "OperationActionBlock", actionKind: "end_action" } + ] + }); + }); + + it("compiles operation process metadata and action statements", () => { + const decls = declarations(); + const operation = decls.find((decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration")!; + const paths = decls.filter((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration"); + const compiled = compileOperation(operation, pathsByName(paths)); + + expect(compiled).toMatchObject({ + operationId: "weld_op_01", + kind: "arc_welding", + pathId: "weld_path", + process: { + weld_id: "WELD_1", + voltage: 24, + current: 180, + weave: "none" + }, + startActions: [ + { + kind: "ACTION", + actionKind: "start_action", + operationId: "weld_op_01", + statement: "io . do [ 20 ] = true" + } + ], + endActions: [ + { + kind: "ACTION", + actionKind: "end_action", + operationId: "weld_op_01", + statement: "io . do [ 20 ] = false" + } + ] + }); + }); + + it("extracts run_operation and expands to start action, path, and end action", () => { + const decls = declarations(); + const procedure = decls.find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + const operation = decls.find((decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration")!; + const paths = decls.filter((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration"); + const compiled = compileOperation(operation, pathsByName(paths)); + const [run] = parseProcedureRunOperationStatements(procedure); + + expect(run).toEqual({ + kind: "RUN_OPERATION", + operationId: "weld_op_01", + sourceMap: { + line: 25, + column: 5 + } + }); + expect(expandRunOperation(run!, new Map([[compiled.operationId, compiled]]))).toEqual([ + expect.objectContaining({ kind: "ACTION", actionKind: "start_action" }), + { + kind: "RUN_PATH", + pathId: "weld_path", + sourceMap: { + line: 25, + column: 5 + } + }, + expect.objectContaining({ kind: "ACTION", actionKind: "end_action" }) + ]); + }); + + it("reports operations that reference missing paths and missing run_operation targets", () => { + const missingPathOperation = parseGrl(`language grl 0.1 +module Main + operation bad_op { + kind: handling + path: missing_path + } +end +`).module.declarations.find((decl): decl is GrlOperationDeclaration => decl.kind === "OperationDeclaration")!; + + expect(() => compileOperation(missingPathOperation, new Map())).toThrowError( + expect.objectContaining({ code: "GRL_OPERATION_PATH_NOT_FOUND" }) + ); + + expect(() => + expandRunOperation({ kind: "RUN_OPERATION", operationId: "missing_op" }, new Map()) + ).toThrowError(expect.objectContaining({ code: "GRL_OPERATION_NOT_FOUND" })); + }); +}); diff --git a/kdl-wasm/web/tests/grl/parser.test.ts b/kdl-wasm/web/tests/grl/parser.test.ts new file mode 100644 index 0000000..63f2d93 --- /dev/null +++ b/kdl-wasm/web/tests/grl/parser.test.ts @@ -0,0 +1,103 @@ +import { describe, expect, it } from "vitest"; +import { GrlParseError, parseGrl } from "../../src/grl/parser/index.js"; + +describe("GRL parser", () => { + it("parses the minimal language/module/proc skeleton with source ranges", () => { + const ast = parseGrl(`language grl 0.1 + +module Main + proc main() + // body comment should not affect parser + end +end +`); + + expect(ast).toMatchObject({ + kind: "Program", + language: { + kind: "LanguageDeclaration", + language: "grl", + version: "0.1", + range: { + start: { line: 1, column: 1 }, + end: { line: 1, column: 17 } + } + }, + module: { + kind: "ModuleDeclaration", + name: "Main", + declarations: [ + { + kind: "ProcedureDeclaration", + name: "main", + params: [] + } + ] + } + }); + expect(ast.module.range.start).toMatchObject({ line: 3, column: 1 }); + expect(ast.module.range.end).toMatchObject({ line: 7, column: 4 }); + }); + + it("parses imports, data declarations, targets, and procedure body tokens", () => { + const ast = parseGrl(`language grl 0.1 +module Main + import CommonTools + const speed v_pick = linear(300 mm/s) + target home = joint_target { + joints: [0 deg, 0 deg] + } + proc main() + movej home + end +end +`); + + expect(ast.module.declarations.map((decl) => decl.kind)).toEqual([ + "ImportDeclaration", + "DataDeclaration", + "TargetDeclaration", + "ProcedureDeclaration" + ]); + expect(ast.module.declarations[0]).toMatchObject({ + kind: "ImportDeclaration", + moduleName: "CommonTools" + }); + expect(ast.module.declarations[1]).toMatchObject({ + kind: "DataDeclaration", + storage: "const", + typeName: "speed", + name: "v_pick", + initializer: { + kind: "CallExpression", + callee: "linear" + } + }); + expect(ast.module.declarations[2]).toMatchObject({ + kind: "TargetDeclaration", + name: "home", + target: { + kind: "ObjectExpression", + typeName: "joint_target" + } + }); + expect(ast.module.declarations[3]).toMatchObject({ + kind: "ProcedureDeclaration", + bodyTokens: [ + { + kind: "keyword", + raw: "movej" + }, + { + kind: "identifier", + raw: "home" + } + ] + }); + }); + + it("reports stable line and column on invalid syntax", () => { + expect(() => parseGrl("language grl\nmodule Main\nend\n")).toThrow(GrlParseError); + expect(() => parseGrl("language grl\nmodule Main\nend\n")).toThrow("Expected GRL language version at 2:1"); + }); +}); diff --git a/kdl-wasm/web/tests/grl/pathCompile.test.ts b/kdl-wasm/web/tests/grl/pathCompile.test.ts new file mode 100644 index 0000000..ff39212 --- /dev/null +++ b/kdl-wasm/web/tests/grl/pathCompile.test.ts @@ -0,0 +1,251 @@ +import { describe, expect, it } from "vitest"; +import type { + GrlDataDeclaration, + GrlPathDeclaration, + GrlProcedureDeclaration, + GrlTargetDeclaration +} from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { + buildMotionContext, + compilePathToPlanRequest, + parseProcedureRunPathStatements +} from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 100 mm, 0 deg, 0 deg, 0 deg) + } + persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + const speed v_joint = joint(60 %) + const speed v_linear = linear(300 mm/s) + const zone z10 = z(10 mm) + target home = joint_target { + joints: [0 deg, 0 deg] + } + target pick = pose_target { + pose: pose(500 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + target mid = pose_target { + pose: pose(550 mm, 50 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + target arc_end = pose_target { + pose: pose(600 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) + } + path pick_path { + source { + type: cad_curve + id: "edge_032" + sample_distance: 5 mm + } + defaults { + tool: gripper, + frame: fixture, + speed: v_linear, + zone: z10 + } + point approach movej home speed v_joint zone fine + point p1 movel pick offset z 100 mm + point p2 movec via mid target arc_end speed linear(150 mm/s) zone fine + event before p1 io.do[10] = true + event after p2 io.do[10] = false + event at p1 distance -20 mm pulse io.do[20] duration 100 ms + } + proc main() + run_path pick_path + end +end +`; + +function declarations() { + return parseGrl(PROGRAM).module.declarations; +} + +function motionContext(decls = declarations()) { + return buildMotionContext( + decls.filter( + (decl): decl is GrlDataDeclaration | GrlTargetDeclaration => + decl.kind === "DataDeclaration" || decl.kind === "TargetDeclaration" + ) + ); +} + +describe("GRL path compilation", () => { + it("parses path defaults, source metadata, points, and events as AST nodes", () => { + const path = declarations().find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + + expect(path).toMatchObject({ + kind: "PathDeclaration", + name: "pick_path", + items: [ + { kind: "PathSourceBlock" }, + { kind: "PathDefaultsBlock" }, + { kind: "PathPoint", id: "approach" }, + { kind: "PathPoint", id: "p1" }, + { kind: "PathPoint", id: "p2" }, + { kind: "PathEvent", timing: "before", pointId: "p1" }, + { kind: "PathEvent", timing: "after", pointId: "p2" }, + { kind: "PathEvent", timing: "at", pointId: "p1" } + ] + }); + expect(path.items[0]).toMatchObject({ + properties: [ + { key: "type", value: { kind: "IdentifierExpression", name: "cad_curve" } }, + { key: "id", value: { kind: "StringLiteral", value: "edge_032" } }, + { key: "sample_distance", value: { kind: "NumberLiteral" } } + ] + }); + }); + + it("compiles a path to PathPlanRequest with defaults, source map, source metadata, and events", () => { + const decls = declarations(); + const path = decls.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + const compiled = compilePathToPlanRequest(path, motionContext(decls), { + startJoints: [0, 0], + sampleTime: 0.004 + }); + + expect(compiled.pathId).toBe("pick_path"); + expect(compiled.request).toMatchObject({ + pathId: "pick_path", + startJoints: [0, 0], + sampleTime: 0.004, + source: { + type: "cad_curve", + id: "edge_032", + sample_distance: 0.005 + }, + segments: [ + { + id: "approach", + motion: "MOVEJ", + targetId: "home", + speed: { kind: "joint_percent", value: 0.6 }, + zone: { kind: "fine" } + }, + { + id: "p1", + motion: "MOVEL", + targetId: "pick", + speed: { kind: "linear", velocity: 0.3 }, + zone: { kind: "distance", value: 0.01 }, + tool: { position: [0, 0, 0.1] }, + frame: { position: [0.8, 0, 0] }, + sourceMap: { line: 37 } + }, + { + id: "p2", + motion: "MOVEC", + targetId: "arc_end", + speed: { kind: "linear", velocity: 0.15 }, + zone: { kind: "fine" } + } + ], + events: [ + { + timing: "before", + pointId: "p1", + kind: "io", + data: { statement: "io . do [ 10 ] = true" } + }, + { + timing: "after", + pointId: "p2", + kind: "io" + }, + { + timing: "at", + pointId: "p1", + distance: -0.02, + kind: "pulse" + } + ] + }); + expect(compiled.request.segments[1]?.target).toMatchObject({ + pose: { + position: [0.5, 0, 0.1] + } + }); + }); + + it("extracts run_path statements from procedure body tokens", () => { + const procedure = declarations().find((decl): decl is GrlProcedureDeclaration => decl.kind === "ProcedureDeclaration")!; + + expect(parseProcedureRunPathStatements(procedure)).toEqual([ + { + kind: "RUN_PATH", + pathId: "pick_path", + sourceMap: { + line: 44, + column: 5 + } + } + ]); + }); + + it("reports empty paths and duplicate point names", () => { + const emptyPath = parseGrl(`language grl 0.1 +module Main + path empty_path { + } +end +`).module.declarations.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + + expect(() => + compilePathToPlanRequest(emptyPath, motionContext([]), { startJoints: [], sampleTime: 0.004 }) + ).toThrowError(expect.objectContaining({ code: "GRL_PATH_EMPTY" })); + + const duplicatePath = parseGrl(`language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } + path dup_path { + defaults { speed: v, zone: zf } + point p movej home + point p movej home + } +end +`).module.declarations.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + const duplicateContext = motionContext(parseGrl(`language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } +end +`).module.declarations); + + expect(() => + compilePathToPlanRequest(duplicatePath, duplicateContext, { startJoints: [0], sampleTime: 0.004 }) + ).toThrowError(expect.objectContaining({ code: "GRL_PATH_POINT_DUPLICATE" })); + }); + + it("reports events that reference missing points", () => { + const path = parseGrl(`language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } + path bad_event { + defaults { speed: v, zone: zf } + point p movej home + event after missing io.do[1] = true + } +end +`).module.declarations.find((decl): decl is GrlPathDeclaration => decl.kind === "PathDeclaration")!; + const context = motionContext(parseGrl(`language grl 0.1 +module Main + const speed v = joint(50 %) + const zone zf = fine + target home = joint_target { joints: [0 deg] } +end +`).module.declarations); + + expect(() => + compilePathToPlanRequest(path, context, { startJoints: [0], sampleTime: 0.004 }) + ).toThrowError(expect.objectContaining({ code: "GRL_PATH_EVENT_POINT_NOT_FOUND" })); + }); +}); diff --git a/kdl-wasm/web/tests/grl/procFunction.test.ts b/kdl-wasm/web/tests/grl/procFunction.test.ts new file mode 100644 index 0000000..32476aa --- /dev/null +++ b/kdl-wasm/web/tests/grl/procFunction.test.ts @@ -0,0 +1,201 @@ +import { describe, expect, it } from "vitest"; +import type { GrlFunctionDeclaration, GrlProcedureDeclaration } from "../../src/grl/ast/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { analyzeProcFunctionSemantics } from "../../src/grl/semantic/index.js"; + +function declarations(source: string) { + return parseGrl(source).module.declarations; +} + +describe("GRL proc, func, call, return, and scope semantics", () => { + it("parses function declarations and analyzes proc/func signatures, calls, returns, and warnings", () => { + const decls = declarations(`language grl 0.1 +module Main + var int global_count = 0 + proc read_sensor(out bool ok) + ok = true + end + proc main(in bool start, out bool done, inout int count) + call read_sensor(done) + call helper(count) + call self_check() + return + end + proc self_check() + call self_check() + end + func int helper(inout int value) + var int global_count = 1 + return value + end +end +`); + const func = decls.find((decl): decl is GrlFunctionDeclaration => decl.kind === "FunctionDeclaration")!; + + expect(func).toMatchObject({ + kind: "FunctionDeclaration", + returnType: "int", + name: "helper", + bodyTokens: [ + { raw: "var" }, + { raw: "int" }, + { raw: "global_count" }, + { raw: "=" }, + { raw: "1" }, + { raw: "return" }, + { raw: "value" } + ] + }); + + const analysis = analyzeProcFunctionSemantics(decls); + + expect(analysis.procedures).toEqual([ + expect.objectContaining({ + name: "read_sensor", + parameters: [expect.objectContaining({ name: "ok", typeName: "bool", direction: "out" })] + }), + expect.objectContaining({ + name: "main", + parameters: [ + expect.objectContaining({ name: "start", typeName: "bool", direction: "in" }), + expect.objectContaining({ name: "done", typeName: "bool", direction: "out" }), + expect.objectContaining({ name: "count", typeName: "int", direction: "inout" }) + ] + }), + expect.objectContaining({ name: "self_check", parameters: [] }) + ]); + expect(analysis.functions).toEqual([ + expect.objectContaining({ + name: "helper", + returnType: "int", + parameters: [expect.objectContaining({ name: "value", typeName: "int", direction: "inout" })] + }) + ]); + expect(analysis.calls).toEqual([ + expect.objectContaining({ kind: "CALL", target: "read_sensor", args: [expect.objectContaining({ text: "done" })] }), + expect.objectContaining({ kind: "CALL", target: "helper", args: [expect.objectContaining({ text: "count" })] }), + expect.objectContaining({ kind: "CALL", target: "self_check", args: [] }), + expect.objectContaining({ kind: "CALL", target: "self_check", args: [] }) + ]); + expect(analysis.returns).toEqual([ + expect.objectContaining({ kind: "RETURN" }), + expect.objectContaining({ kind: "RETURN", value: expect.objectContaining({ text: "value" }) }) + ]); + expect(analysis.diagnostics).toEqual([ + expect.objectContaining({ severity: "warning", code: "GRL_RECURSIVE_CALL" }), + expect.objectContaining({ severity: "warning", code: "GRL_NAME_SHADOWS_OUTER_SCOPE" }) + ]); + }); + + it("reports out parameters that are not assigned on all normal return paths", () => { + const decls = declarations(`language grl 0.1 +module Main + proc main(out bool done) + if ready == true + done = true + end + return + end +end +`); + + expect(() => analyzeProcFunctionSemantics(decls)).toThrowError( + expect.objectContaining({ code: "GRL_OUT_PARAM_NOT_ASSIGNED" }) + ); + }); + + it("reports out and inout call arguments that are not lvalues", () => { + const decls = declarations(`language grl 0.1 +module Main + proc set_done(out bool done) + done = true + end + proc main() + call set_done(true) + end +end +`); + + expect(() => analyzeProcFunctionSemantics(decls)).toThrowError( + expect.objectContaining({ code: "GRL_ARGUMENT_NOT_LVALUE" }) + ); + }); + + it("reports missing or incompatible function returns", () => { + const missingReturn = declarations(`language grl 0.1 +module Main + func int bad(in bool ready) + if ready == true + return 1 + end + end +end +`); + const wrongReturn = declarations(`language grl 0.1 +module Main + func bool bad() + return 1 + end +end +`); + + expect(() => analyzeProcFunctionSemantics(missingReturn)).toThrowError( + expect.objectContaining({ code: "GRL_FUNC_MISSING_RETURN" }) + ); + expect(() => analyzeProcFunctionSemantics(wrongReturn)).toThrowError( + expect.objectContaining({ code: "GRL_RETURN_TYPE_MISMATCH" }) + ); + }); + + it("reports illegal function side effects and procedure return values", () => { + const functionSideEffect = declarations(`language grl 0.1 +module Main + func bool bad() + wait io.di[1] == true + return true + end +end +`); + const procedureReturnValue = declarations(`language grl 0.1 +module Main + proc main() + return true + end +end +`); + + expect(() => analyzeProcFunctionSemantics(functionSideEffect)).toThrowError( + expect.objectContaining({ code: "GRL_FUNC_SIDE_EFFECT" }) + ); + expect(() => analyzeProcFunctionSemantics(procedureReturnValue)).toThrowError( + expect.objectContaining({ code: "GRL_RETURN_VALUE_IN_PROC" }) + ); + }); + + it("reports call target and argument type errors", () => { + const missingCall = declarations(`language grl 0.1 +module Main + proc main() + call missing() + end +end +`); + const typeMismatch = declarations(`language grl 0.1 +module Main + proc expects_int(in int value) + return + end + proc main() + call expects_int("bad") + end +end +`); + + expect(() => analyzeProcFunctionSemantics(missingCall)).toThrowError( + expect.objectContaining({ code: "GRL_CALL_TARGET_NOT_FOUND" }) + ); + expect(() => analyzeProcFunctionSemantics(typeMismatch)).toThrowError( + expect.objectContaining({ code: "GRL_CALL_ARGUMENT_TYPE" }) + ); + }); +}); diff --git a/kdl-wasm/web/tests/grl/semanticIr.test.ts b/kdl-wasm/web/tests/grl/semanticIr.test.ts new file mode 100644 index 0000000..41f0686 --- /dev/null +++ b/kdl-wasm/web/tests/grl/semanticIr.test.ts @@ -0,0 +1,148 @@ +import { describe, expect, it } from "vitest"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { compileSemanticProgram } from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module Main + const speed vj = joint(50 %) + const speed vl = linear(200 mm/s) + const zone zf = fine + target home = joint_target { joints: [0 deg] } + target pick = pose_target { pose: pose(500 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) } + path pick_path { + defaults { speed: vl, zone: zf } + point p0 movej home speed vj zone fine + point p1 movel pick + event before p1 io.do[1] = true + } + operation pick_op { + kind: handling + path: pick_path + start_action: + io.do[2] = true + end_action: + io.do[2] = false + } + proc set_done(out bool done) + done = true + end + proc main(out bool done) + set_speed vl + set_zone zf + movej home speed vj zone fine + io.do[3] = true + wait io.di[1] == true timeout 1 s + if done == false + pulse io.do[4] duration 100 ms + else + alarm DONE "Already done" + end + call set_done(done) + run_path pick_path + run_operation pick_op + return + end +end +`; + +describe("GRL semantic analyzer, executable IR, and source map", () => { + it("compiles a complete program into unified executable IR and KDL bridge requests", () => { + const ir = compileSemanticProgram(parseGrl(PROGRAM), { + startJoints: [0], + sampleTime: 0.004 + }); + + expect(ir.moduleName).toBe("Main"); + expect(ir.semanticChecks).toHaveLength(22); + expect(ir.symbols).toEqual([ + expect.objectContaining({ kind: "data", name: "vj", typeName: "speed" }), + expect.objectContaining({ kind: "data", name: "vl", typeName: "speed" }), + expect.objectContaining({ kind: "data", name: "zf", typeName: "zone" }), + expect.objectContaining({ kind: "target", name: "home" }), + expect.objectContaining({ kind: "target", name: "pick" }), + expect.objectContaining({ kind: "path", name: "pick_path" }), + expect.objectContaining({ kind: "operation", name: "pick_op" }), + expect.objectContaining({ kind: "procedure", name: "set_done" }), + expect.objectContaining({ kind: "procedure", name: "main" }) + ]); + expect(ir.paths).toHaveLength(1); + expect(ir.operations).toHaveLength(1); + expect(ir.kdlBridge.pathRequests).toEqual([ + expect.objectContaining({ + pathId: "pick_path", + segments: [ + expect.objectContaining({ id: "p0", motion: "MOVEJ" }), + expect.objectContaining({ id: "p1", motion: "MOVEL" }) + ] + }) + ]); + expect(ir.kdlBridge.motionRequests).toEqual([ + expect.objectContaining({ + startJoints: [0], + speed: { kind: "joint_percent", value: 0.5 }, + zone: { kind: "fine" }, + sampleTime: 0.004 + }) + ]); + + const main = ir.procedures.find((procedure) => procedure.name === "main")!; + expect(main.instructions).toEqual([ + expect.objectContaining({ kind: "MOVEJ" }), + expect.objectContaining({ kind: "IO_WRITE", target: expect.objectContaining({ domain: "do", index: 3 }) }), + expect.objectContaining({ kind: "WAIT", timeout: 1 }), + expect.objectContaining({ + kind: "EXEC_IF", + branches: [ + expect.objectContaining({ + branchKind: "if", + body: expect.arrayContaining([expect.objectContaining({ kind: "PULSE", duration: 0.1 })]) + }), + expect.objectContaining({ + branchKind: "else", + body: expect.arrayContaining([expect.objectContaining({ kind: "ALARM", alarmId: "DONE" })]) + }) + ] + }), + expect.objectContaining({ kind: "CALL", target: "set_done" }), + expect.objectContaining({ kind: "RUN_PATH", pathId: "pick_path" }), + expect.objectContaining({ kind: "RUN_OPERATION", operationId: "pick_op" }), + expect.objectContaining({ kind: "RETURN" }) + ]); + }); + + it("exposes source map entries for GRL procedure lines, path points, and operation actions", () => { + const ir = compileSemanticProgram(parseGrl(PROGRAM), { + startJoints: [0], + sampleTime: 0.004 + }); + + expect(ir.sourceMap).toEqual( + expect.arrayContaining([ + expect.objectContaining({ kind: "path_point", pathId: "pick_path", pointId: "p0" }), + expect.objectContaining({ kind: "path_point", pathId: "pick_path", pointId: "p1" }), + expect.objectContaining({ kind: "operation_action", operationId: "pick_op" }), + expect.objectContaining({ kind: "MOVEJ", procedureId: "main", sourceMap: expect.objectContaining({ line: 28 }) }), + expect.objectContaining({ kind: "EXEC_IF", procedureId: "main" }), + expect.objectContaining({ kind: "RUN_OPERATION", procedureId: "main" }) + ]) + ); + }); + + it("reports duplicate symbols through semantic diagnostics", () => { + const ir = compileSemanticProgram(parseGrl(`language grl 0.1 +module Main + const speed v = joint(10 %) + const speed v = joint(20 %) + proc main() + end +end +`), { + startJoints: [], + sampleTime: 0.004 + }); + + expect(ir.diagnostics).toEqual([ + expect.objectContaining({ severity: "error", code: "GRL_SYMBOL_DUPLICATE" }) + ]); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/cAbi.test.ts b/kdl-wasm/web/tests/kdl/cAbi.test.ts new file mode 100644 index 0000000..e064e44 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/cAbi.test.ts @@ -0,0 +1,224 @@ +import { access } from "node:fs/promises"; +import { fileURLToPath } from "node:url"; +import { describe, expect, it } from "vitest"; +import { KDL_C_ABI_EXPORTS, KdlNativeAbi } from "../../src/kdl/nativeAbi.js"; +import type { NativeKdlModule } from "../../src/kdl/nativeModule.js"; +import { loadRobotFromUrdfModel } from "../../src/robot/urdfParser.js"; + +const BUILD_DIR = new URL("../../../build-wasm/", import.meta.url); +const WRAPPER_URL = new URL("kdl.js", BUILD_DIR); + +type NativeFactory = (options?: { + locateFile?: (path: string, prefix: string) => string; +}) => Promise; + +async function loadNativeModule(): Promise { + await access(fileURLToPath(WRAPPER_URL)); + const imported = (await import(/* @vite-ignore */ WRAPPER_URL.href)) as { + default?: NativeFactory; + createKdlModule?: NativeFactory; + }; + const factory = imported.default ?? imported.createKdlModule; + if (!factory) { + throw new Error("kdl.js did not export createKdlModule"); + } + return factory({ + locateFile: (path) => fileURLToPath(new URL(path, BUILD_DIR)) + }); +} + +const NATIVE_SOLVER_URDF = ` + + + + + + + + + + + + + + + + + +`; + +function writeFloat64Array(native: NativeKdlModule, values: number[]): number { + const bytes = values.length * Float64Array.BYTES_PER_ELEMENT; + const ptr = native._malloc?.(bytes); + if (!ptr) { + throw new Error(`Failed to allocate ${bytes} bytes`); + } + native.HEAPF64?.set(values, ptr / Float64Array.BYTES_PER_ELEMENT); + return ptr; +} + +function readFloat64Array(native: NativeKdlModule, ptr: number, length: number): number[] { + return Array.from(native.HEAPF64?.subarray( + ptr / Float64Array.BYTES_PER_ELEMENT, + ptr / Float64Array.BYTES_PER_ELEMENT + length + ) ?? []); +} + +describe("KDL C ABI", () => { + it("exports the stable P0 ABI names", async () => { + const abi = new KdlNativeAbi(await loadNativeModule()); + + expect(() => abi.assertExports()).not.toThrow(); + expect(KDL_C_ABI_EXPORTS).toEqual([ + "kdl_init", + "kdl_create_robot", + "kdl_destroy_robot", + "kdl_get_robot_info", + "kdl_fk", + "kdl_fk_all_links", + "kdl_jacobian", + "kdl_ik", + "kdl_plan_movej", + "kdl_plan_movel", + "kdl_plan_movec", + "kdl_plan_path", + "kdl_sample_trap", + "kdl_last_error" + ]); + }); + + it("initializes, caches model handles, returns JSON info, and destroys handles", async () => { + const abi = new KdlNativeAbi(await loadNativeModule()); + const model = loadRobotFromUrdfModel(NATIVE_SOLVER_URDF, { + robotId: "abi", + baseLink: "base_link", + tipLink: "tool0" + }); + + expect(abi.callNumber("kdl_init", ["string"], ["{}"])).toBe(0); + const handle = abi.callNumber("kdl_create_robot", ["string"], [JSON.stringify(model)]); + expect(handle).toBeGreaterThan(0); + + const info = abi.readJsonCall<{ handle: number; nativeState: string; dof: number }>( + "kdl_get_robot_info", + ["number"], + [handle] + ); + expect(info).toMatchObject({ + handle, + dof: 2, + nativeState: "kdl_chain" + }); + + expect(abi.callNumber("kdl_destroy_robot", ["number"], [handle])).toBe(0); + }); + + it("constructs a native KDL chain and returns real FK and Jacobian data", async () => { + const native = await loadNativeModule(); + const abi = new KdlNativeAbi(native); + const model = loadRobotFromUrdfModel(NATIVE_SOLVER_URDF, { + robotId: "native", + baseLink: "base_link", + tipLink: "tool0" + }); + + expect(abi.callNumber("kdl_init", ["string"], ["{}"])).toBe(0); + const handle = abi.callNumber("kdl_create_robot", ["string"], [JSON.stringify(model)]); + expect(handle).toBeGreaterThan(0); + expect(abi.readJsonCall("kdl_get_robot_info", ["number"], [handle])).toMatchObject({ + handle, + dof: 2, + jointNames: ["joint_1", "joint_2"], + nativeState: "kdl_chain" + }); + + const joints = writeFloat64Array(native, [Math.PI / 2, 0.4]); + const pose = native._malloc?.(7 * Float64Array.BYTES_PER_ELEMENT); + const jacobian = native._malloc?.(12 * Float64Array.BYTES_PER_ELEMENT); + expect(pose).toBeTruthy(); + expect(jacobian).toBeTruthy(); + + try { + expect(abi.callNumber("kdl_fk", ["number", "number", "number", "number"], [handle, joints, 2, pose])).toBe(0); + const pose7 = readFloat64Array(native, pose!, 7); + expect(pose7[0]).toBeCloseTo(0); + expect(pose7[1]).toBeCloseTo(0.4); + expect(pose7[2]).toBeCloseTo(0); + expect(pose7[5]).toBeCloseTo(Math.SQRT1_2); + expect(pose7[6]).toBeCloseTo(Math.SQRT1_2); + + expect(abi.callNumber("kdl_jacobian", ["number", "number", "number", "number"], [handle, joints, 2, jacobian])).toBe(0); + const jac = readFloat64Array(native, jacobian!, 12); + expect(jac[0]).toBeCloseTo(-0.4, 4); + expect(jac[1]).toBeCloseTo(0, 4); + expect(jac[2]).toBeCloseTo(0, 4); + expect(jac[3]).toBeCloseTo(1, 4); + expect(jac[10]).toBeCloseTo(1, 4); + } finally { + native._free?.(joints); + if (pose) { + native._free?.(pose); + } + if (jacobian) { + native._free?.(jacobian); + } + abi.callNumber("kdl_destroy_robot", ["number"], [handle]); + } + }); + + it("normalizes C ABI failures through kdl_last_error", async () => { + const abi = new KdlNativeAbi(await loadNativeModule()); + + expect(abi.callNumber("kdl_init", ["string"], ["{}"])).toBe(0); + const returnCode = abi.callNumber("kdl_ik", ["number", "number", "number", "number", "string", "number"], [1, 0, 0, 0, "{}", 0]); + + expect(returnCode).toBe(-1); + expect(abi.lastError()).toMatchObject({ + code: "KDL_NOT_IMPLEMENTED", + diagnostics: [ + { + severity: "error", + code: "KDL_NOT_IMPLEMENTED" + } + ] + }); + expect(() => abi.checkReturnCode(returnCode)).toThrowError( + expect.objectContaining({ + code: "KDL_NOT_IMPLEMENTED" + }) + ); + }); + + it("reports JSON output buffer errors without raw strings", async () => { + const native = await loadNativeModule(); + const abi = new KdlNativeAbi(native); + const model = loadRobotFromUrdfModel(NATIVE_SOLVER_URDF, { + robotId: "abi", + baseLink: "base_link", + tipLink: "tool0" + }); + + expect(abi.callNumber("kdl_init", ["string"], ["{}"])).toBe(0); + const handle = abi.callNumber("kdl_create_robot", ["string"], [JSON.stringify(model)]); + const ptr = native._malloc?.(4); + expect(ptr).toBeTruthy(); + + try { + const returnCode = abi.callNumber("kdl_get_robot_info", ["number", "number", "number"], [handle, ptr, 4]); + expect(returnCode).toBe(-1); + expect(abi.lastError()).toMatchObject({ + code: "KDL_BUFFER_TOO_SMALL", + diagnostics: [ + { + severity: "error", + code: "KDL_BUFFER_TOO_SMALL" + } + ] + }); + } finally { + if (ptr) { + native._free?.(ptr); + } + } + }); +}); diff --git a/kdl-wasm/web/tests/kdl/checks.test.ts b/kdl-wasm/web/tests/kdl/checks.test.ts new file mode 100644 index 0000000..5c92b52 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/checks.test.ts @@ -0,0 +1,178 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { JacobianResult, PoseTarget, ReachabilityResult } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +async function createRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + PLANAR_URDF, + { + robotId: "checks", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +function poseTarget(id: string, x: number, y: number): PoseTarget { + return { + id, + pose: { + position: [x, y, 0], + quaternion: [0, 0, 0, 1] + } + }; +} + +describe("Jacobian, singularity, limits, and reachability checks", () => { + it("computes a 6xdof Jacobian with expected linear components", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "jacobian", + payload: [handle, [Math.PI / 2, 0.4]] + }); + + expect(response.ok).toBe(true); + const jacobian = response.result as JacobianResult; + expect(jacobian.rows).toBe(6); + expect(jacobian.cols).toBe(2); + expect(jacobian.data).toHaveLength(12); + expect(jacobian.data[0]).toBeCloseTo(-0.4, 4); + expect(jacobian.data[1]).toBeCloseTo(0, 4); + expect(jacobian.data[2]).toBeCloseTo(0, 4); + expect(jacobian.data[3]).toBeCloseTo(1, 4); + }); + + it("reports singularity warning for collapsed planar reach", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "checkSingularity", + payload: [handle, [0, 0]] + }); + + expect(response.result).toMatchObject({ + ok: true, + nearSingularity: true, + diagnostics: [ + { + severity: "warning", + code: "KDL_SINGULARITY" + } + ] + }); + }); + + it("checks joint and velocity limits with structured diagnostics", async () => { + const { runtime, handle } = await createRobot(); + const jointResponse = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "checkJointLimits", + payload: [handle, [0, 2]] + }); + expect(jointResponse.result).toMatchObject({ + ok: false, + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_LIMIT" + } + ] + }); + + const velocityResponse = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "checkVelocityLimits", + payload: [ + handle, + { + points: [ + { + jointVelocity: [1, 0.75], + jointAcceleration: [1, 1.5] + } + ] + } + ] + }); + expect(velocityResponse.result).toMatchObject({ + ok: false, + maxJointVelocityRatio: 1.5, + maxJointAccelerationRatio: 1.5, + diagnostics: [ + { + severity: "error", + code: "KDL_VELOCITY_LIMIT", + pointIndex: 0 + }, + { + severity: "error", + code: "KDL_ACCEL_LIMIT", + pointIndex: 0 + } + ] + }); + }); + + it("checks reachability and preserves batch order", async () => { + const { runtime, handle } = await createRobot(); + const reachable = await dispatchKdlRpcRequest(runtime, { + id: 7, + method: "checkReachability", + payload: [handle, poseTarget("ok", 0, 0.3), { positionTolerance: 1e-9 }] + }); + expect(reachable.result).toMatchObject({ + ok: true, + reachable: true, + targetId: "ok", + joints: [Math.PI / 2, 0.3] + }); + + const batch = await dispatchKdlRpcRequest(runtime, { + id: 8, + method: "checkReachabilityBatch", + payload: [handle, [poseTarget("a", 0.2, 0), poseTarget("b", 2, 0)], {}] + }); + const results = batch.result as ReachabilityResult[]; + expect(results.map((result) => result.targetId)).toEqual(["a", "b"]); + expect(results[0]?.reachable).toBe(true); + expect(results[1]).toMatchObject({ + reachable: false, + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_LIMIT" + } + ] + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/fk.test.ts b/kdl-wasm/web/tests/kdl/fk.test.ts new file mode 100644 index 0000000..79d1d37 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/fk.test.ts @@ -0,0 +1,198 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; + +const SIMPLE_URDF = ` + + + + + + + + + + + + + + + + + + + + + + + + + +`; + +async function createRuntimeRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + SIMPLE_URDF, + { + robotId: "fk", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +describe("FK and fkAllLinks", () => { + it("computes flange and tcp poses for the zero joint state", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "fk", + payload: [handle, [0, 0]] + }); + + expect(response.ok).toBe(true); + const result = response.result as { + ok: boolean; + joints: number[]; + diagnostics: unknown[]; + flange: { position: number[]; quaternion: number[] }; + tcp: { position: number[]; quaternion: number[] }; + }; + expect(result.ok).toBe(true); + expect(result.joints).toEqual([0, 0]); + expect(result.diagnostics).toEqual([]); + expect(result.flange.position[0]).toBeCloseTo(0); + expect(result.flange.position[1]).toBeCloseTo(0); + expect(result.flange.position[2]).toBeCloseTo(0.35); + expect(result.flange.quaternion).toEqual([0, 0, 0, 1]); + expect(result.tcp.position[0]).toBeCloseTo(0); + expect(result.tcp.position[1]).toBeCloseTo(0); + expect(result.tcp.position[2]).toBeCloseTo(0.35); + expect(result.tcp.quaternion).toEqual([0, 0, 0, 1]); + }); + + it("applies revolute and prismatic joint motion in chain order", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "fk", + payload: [handle, [Math.PI / 2, 0.2]] + }); + + expect(response.ok).toBe(true); + const result = response.result as { flange: { position: number[]; quaternion: number[] } }; + expect(result.flange.position[0]).toBeCloseTo(0); + expect(result.flange.position[1]).toBeCloseTo(0.2); + expect(result.flange.position[2]).toBeCloseTo(0.35); + expect(result.flange.quaternion[2]).toBeCloseTo(Math.SQRT1_2); + expect(result.flange.quaternion[3]).toBeCloseTo(Math.SQRT1_2); + }); + + it("returns link poses in base-to-tip order", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "fkAllLinks", + payload: [handle, [0, 0.1]] + }); + + expect(response.ok).toBe(true); + const result = response.result as { + linkPoses: Array<{ link: string; pose: { position: number[] } }>; + }; + expect(result.linkPoses.map((entry) => entry.link)).toEqual(["base_link", "link_1", "link_2", "tool0"]); + expect(result.linkPoses[0]?.pose.position).toEqual([0, 0, 0]); + expect(result.linkPoses[3]?.pose.position[0]).toBeCloseTo(0.1); + expect(result.linkPoses[3]?.pose.position[2]).toBeCloseTo(0.35); + }); + + it("applies tool offset to tcp without changing flange", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "fk", + payload: [ + handle, + [0, 0], + { + tool: { + position: [0, 0, 0.1], + quaternion: [0, 0, 0, 1] + } + } + ] + }); + + expect(response.ok).toBe(true); + const result = response.result as { + flange: { position: number[] }; + tcp: { position: number[] }; + }; + expect(result.flange.position[2]).toBeCloseTo(0.35); + expect(result.tcp.position[2]).toBeCloseTo(0.45); + }); + + it("writes tcp pose into a reusable Float64Array", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const out = new Float64Array(7); + const response = await dispatchKdlRpcRequest(runtime, { + id: 51, + method: "fkPose7", + payload: [handle, new Float64Array([Math.PI / 2, 0.2]), out] + }); + + expect(response.ok).toBe(true); + expect(response.result).toBe(out); + expect(out[0]).toBeCloseTo(0); + expect(out[1]).toBeCloseTo(0.2); + expect(out[2]).toBeCloseTo(0.35); + expect(out[5]).toBeCloseTo(Math.SQRT1_2); + expect(out[6]).toBeCloseTo(Math.SQRT1_2); + }); + + it("returns a structured error for undersized fkPose7 output buffers", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 52, + method: "fkPose7", + payload: [handle, [0, 0], new Float64Array(6)] + }); + + expect(response).toMatchObject({ + ok: false, + error: { + code: "KDL_OUTPUT_DIMENSION_MISMATCH" + } + }); + }); + + it("returns a structured dimension diagnostic", async () => { + const { runtime, handle } = await createRuntimeRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "fk", + payload: [handle, [0]] + }); + + expect(response).toMatchObject({ + ok: false, + error: { + code: "KDL_JOINT_DIMENSION_MISMATCH", + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_DIMENSION_MISMATCH" + } + ] + } + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/ik.test.ts b/kdl-wasm/web/tests/kdl/ik.test.ts new file mode 100644 index 0000000..4f53202 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/ik.test.ts @@ -0,0 +1,166 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { IkResult, Pose } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + + + +`; + +const UNSUPPORTED_URDF = ` + + + + + + + + + + + + + + + + + +`; + +function pose(x: number, y: number, z = 0): Pose { + return { + position: [x, y, z], + quaternion: [0, 0, 0, 1] + }; +} + +async function createRobot(urdf = PLANAR_URDF) { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + urdf, + { + robotId: "ik", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +describe("IK and ikBatch", () => { + it("solves a reachable planar target and FK back-substitution is within tolerance", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "ik", + payload: [handle, [0, 0], pose(0, 0.4), { positionTolerance: 1e-9 }] + }); + + expect(response.ok).toBe(true); + const result = response.result as IkResult; + expect(result.ok).toBe(true); + expect(result.joints?.[0]).toBeCloseTo(Math.PI / 2); + expect(result.joints?.[1]).toBeCloseTo(0.4); + expect(result.residualPosition).toBeLessThan(1e-9); + + const fk = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "fk", + payload: [handle, result.joints] + }); + const fkResult = fk.result as { tcp: { position: number[] } }; + expect(fkResult.tcp.position[0]).toBeCloseTo(0); + expect(fkResult.tcp.position[1]).toBeCloseTo(0.4); + }); + + it("keeps ikBatch results in input order", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "ikBatch", + payload: [ + handle, + [ + [0, 0], + [0, 0] + ], + [pose(0.2, 0), pose(0, 0.3)], + {} + ] + }); + + expect(response.ok).toBe(true); + const results = response.result as IkResult[]; + expect(results).toHaveLength(2); + expect(results[0]?.joints?.[0]).toBeCloseTo(0); + expect(results[0]?.joints?.[1]).toBeCloseTo(0.2); + expect(results[1]?.joints?.[0]).toBeCloseTo(Math.PI / 2); + expect(results[1]?.joints?.[1]).toBeCloseTo(0.3); + }); + + it("returns joint_limit reason when the candidate exceeds limits", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "ik", + payload: [handle, [0, 0], pose(2, 0), {}] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ + ok: false, + reason: "joint_limit", + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_LIMIT" + } + ] + }); + }); + + it("returns invalid_model reason for unsupported IK chains", async () => { + const { runtime, handle } = await createRobot(UNSUPPORTED_URDF); + const response = await dispatchKdlRpcRequest(runtime, { + id: 7, + method: "ik", + payload: [handle, [0, 0], pose(0.2, 0), {}] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ + ok: false, + reason: "invalid_model", + diagnostics: [ + { + severity: "error", + code: "KDL_IK_UNSUPPORTED_MODEL" + } + ] + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/path.test.ts b/kdl-wasm/web/tests/kdl/path.test.ts new file mode 100644 index 0000000..8977590 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/path.test.ts @@ -0,0 +1,167 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { PathPlanRequest, PathPlanResult, PathValidationResult } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +async function createRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + PLANAR_URDF, + { + robotId: "path", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +function pathRequest(overrides: Partial = {}): PathPlanRequest { + return { + startJoints: [0, 0], + sampleTime: 0.05, + segments: [ + { + id: "move-home", + motion: "MOVEJ", + target: { + id: "joint_goal", + joints: [Math.PI / 2, 0.2] + }, + speed: { kind: "joint_abs", velocity: 1, acceleration: 4 }, + zone: { kind: "fine" }, + sourceMap: { line: 10, column: 5 } + }, + { + id: "line-out", + motion: "MOVEL", + target: { + id: "line_goal", + pose: { + position: [0, 0.4, 0], + quaternion: [0, 0, 0, 1] + } + }, + speed: { kind: "linear", velocity: 0.2, acceleration: 1 }, + zone: { kind: "fine" }, + sourceMap: { line: 11, column: 5 } + } + ], + ...overrides + }; +} + +describe("planPath and validatePath", () => { + it("plans multiple motion segments and merges points with segment metadata", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "planPath", + payload: [handle, pathRequest()] + }); + + expect(response.ok).toBe(true); + const result = response.result as PathPlanResult; + expect(result.ok).toBe(true); + expect(result.segments).toHaveLength(2); + expect(result.points.length).toBeGreaterThan(result.segments[0]!.points.length); + expect(result.points[0]).toMatchObject({ + index: 0, + time: 0, + segmentId: "move-home", + targetId: "joint_goal", + sourceMap: { line: 10 } + }); + expect(result.points.at(-1)).toMatchObject({ + segmentId: "line-out", + targetId: "line_goal", + sourceMap: { line: 11 } + }); + expect(result.points.at(-1)?.tcp.position[0]).toBeCloseTo(0, 5); + expect(result.points.at(-1)?.tcp.position[1]).toBeCloseTo(0.4, 5); + expect(result.duration).toBeCloseTo(result.segments[0]!.duration + result.segments[1]!.duration); + for (let index = 1; index < result.points.length; index += 1) { + expect(result.points[index]!.time).toBeGreaterThan(result.points[index - 1]!.time); + expect(result.points[index]!.index).toBe(index); + } + }); + + it("validates a path and returns per-segment reports", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "validatePath", + payload: [handle, pathRequest()] + }); + + expect(response.ok).toBe(true); + const result = response.result as PathValidationResult; + expect(result.ok).toBe(true); + expect(result.reachable).toBe(true); + expect(result.cycleTime).toBeGreaterThan(0); + expect(result.segmentReports.map((report) => report.segmentId)).toEqual(["move-home", "line-out"]); + expect(result.segmentReports[0]).toMatchObject({ + ok: true, + motion: "MOVEJ" + }); + expect(result.segmentReports[1]).toMatchObject({ + ok: true, + motion: "MOVEL", + maxCartesianError: 0 + }); + }); + + it("returns KDL_PATH_EMPTY for empty path requests", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "planPath", + payload: [ + handle, + pathRequest({ + segments: [] + }) + ] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ + ok: false, + duration: 0, + segments: [], + points: [], + diagnostics: [ + { + severity: "error", + code: "KDL_PATH_EMPTY" + } + ] + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/performance.test.ts b/kdl-wasm/web/tests/kdl/performance.test.ts new file mode 100644 index 0000000..e497157 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/performance.test.ts @@ -0,0 +1,23 @@ +import { describe, expect, it } from "vitest"; +import { runPerformanceBaseline } from "../../src/kdl/performanceBaseline.js"; + +describe("KDL performance baseline", () => { + it("records TypedArray and batch baseline metrics", async () => { + const result = await runPerformanceBaseline(); + const metrics = Object.fromEntries(result.metrics.map((metric) => [metric.name, metric])); + + expect(result.ok).toBe(true); + expect(result.diagnostics).toEqual([]); + expect(metrics.robot_init_6_axis?.totalMs).toBeLessThanOrEqual(1_000); + expect(metrics.fk_pose7_typed_array?.averageMs).toBeLessThanOrEqual(1); + expect(metrics.ik_planar_average?.averageMs).toBeLessThanOrEqual(10); + expect(metrics.reachability_batch_1000).toMatchObject({ + points: 1_000, + ok: true + }); + expect(metrics.trajectory_10s_4ms).toMatchObject({ + ok: true + }); + expect(metrics.trajectory_10s_4ms?.points).toBeGreaterThanOrEqual(2_500); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/planMoveC.test.ts b/kdl-wasm/web/tests/kdl/planMoveC.test.ts new file mode 100644 index 0000000..4dfc4f5 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/planMoveC.test.ts @@ -0,0 +1,193 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { MoveCRequest, TrajectoryResult } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +async function createRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + PLANAR_URDF, + { + robotId: "movec", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +function request(overrides: Partial): MoveCRequest { + return { + startJoints: [0, 0.5], + via: { + id: "via", + pose: { + position: [0.5, 0.5, 0], + quaternion: [0, 0, 0, 1] + } + }, + target: { + id: "arc_goal", + pose: { + position: [0, 0.5, 0], + quaternion: [0, 0, 0, 1] + } + }, + speed: { + kind: "linear", + velocity: 0.25, + acceleration: 1 + }, + zone: { + kind: "fine" + }, + sampleTime: 0.05, + ...overrides + }; +} + +describe("planMoveC", () => { + it("plans a circular TCP arc with circle metadata", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "planMoveC", + payload: [handle, request({})] + }); + + expect(response.ok).toBe(true); + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.motion).toBe("MOVEC"); + expect(trajectory.points.length).toBeGreaterThan(2); + expect(trajectory.points[0]).toMatchObject({ + index: 0, + time: 0, + s: 0, + motion: "MOVEC", + targetId: "arc_goal" + }); + expect(trajectory.points.at(-1)?.s).toBe(1); + expect(trajectory.points.at(-1)?.tcp.position[0]).toBeCloseTo(0, 5); + expect(trajectory.points.at(-1)?.tcp.position[1]).toBeCloseTo(0.5, 5); + + const circle = trajectory.meta?.circle as { + center: number[]; + radius: number; + angle: number; + length: number; + direction: "cw" | "ccw"; + maxArcError: number; + }; + expect(circle.center[0]).toBeCloseTo(0.25); + expect(circle.center[1]).toBeCloseTo(0.25); + expect(circle.radius).toBeCloseTo(Math.SQRT1_2 / 2); + expect(circle.angle).toBeCloseTo(Math.PI); + expect(circle.length).toBeCloseTo((Math.SQRT1_2 / 2) * Math.PI); + expect(circle.direction).toBe("ccw"); + expect(circle.maxArcError).toBeLessThan(1e-6); + }); + + it("returns KDL_ARC_DEGENERATE for collinear points", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "planMoveC", + payload: [ + handle, + request({ + via: { + id: "line_mid", + pose: { + position: [0.25, 0, 0], + quaternion: [0, 0, 0, 1] + } + }, + target: { + id: "line_end", + pose: { + position: [0.75, 0, 0], + quaternion: [0, 0, 0, 1] + } + } + }) + ] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ + ok: false, + motion: "MOVEC", + points: [], + diagnostics: [ + { + severity: "error", + code: "KDL_ARC_DEGENERATE" + } + ] + }); + }); + + it("reports zone approximation and joint-speed approximation warnings", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "planMoveC", + payload: [ + handle, + request({ + speed: { + kind: "joint_abs", + velocity: 0.25, + acceleration: 1 + }, + zone: { + kind: "distance", + value: 0.01 + } + }) + ] + }); + + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "warning", + code: "KDL_MOVEC_JOINT_SPEED_APPROX" + }) + ); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "warning", + code: "KDL_ZONE_APPROX_FINE" + }) + ); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/planMoveJ.test.ts b/kdl-wasm/web/tests/kdl/planMoveJ.test.ts new file mode 100644 index 0000000..a5a3a0f --- /dev/null +++ b/kdl-wasm/web/tests/kdl/planMoveJ.test.ts @@ -0,0 +1,192 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { MoveJRequest, PoseTarget, TrajectoryResult } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +async function createRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + PLANAR_URDF, + { + robotId: "movej", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +function baseRequest(overrides: Partial): MoveJRequest { + return { + startJoints: [0, 0], + target: { + id: "joint_goal", + joints: [0.5, 0.25] + }, + speed: { + kind: "joint_abs", + velocity: 0.5, + acceleration: 1 + }, + zone: { + kind: "fine" + }, + sampleTime: 0.1, + ...overrides + }; +} + +describe("planMoveJ", () => { + it("plans a synchronized joint trajectory to a joint target", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "planMoveJ", + payload: [handle, baseRequest({})] + }); + + expect(response.ok).toBe(true); + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.motion).toBe("MOVEJ"); + expect(trajectory.points.length).toBeGreaterThan(2); + expect(trajectory.points[0]).toMatchObject({ + index: 0, + time: 0, + s: 0, + joints: [0, 0], + motion: "MOVEJ", + targetId: "joint_goal" + }); + expect(trajectory.points.at(-1)?.s).toBe(1); + expect(trajectory.points.at(-1)?.joints[0]).toBeCloseTo(0.5); + expect(trajectory.points.at(-1)?.joints[1]).toBeCloseTo(0.25); + expect(trajectory.points.at(-1)?.jointVelocity[0]).toBeCloseTo(0); + expect(trajectory.points.at(-1)?.tcp.position[0]).toBeCloseTo(0.25 * Math.cos(0.5)); + expect(trajectory.points.at(-1)?.tcp.position[1]).toBeCloseTo(0.25 * Math.sin(0.5)); + expect(trajectory.meta).toMatchObject({ + targetType: "joint", + qStart: [0, 0], + qEnd: [0.5, 0.25] + }); + }); + + it("uses IK for pose targets and warns when zone is approximated as fine", async () => { + const { runtime, handle } = await createRobot(); + const target: PoseTarget = { + id: "pose_goal", + pose: { + position: [0, 0.3, 0], + quaternion: [0, 0, 0, 1] + } + }; + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "planMoveJ", + payload: [ + handle, + baseRequest({ + target, + zone: { kind: "distance", value: 0.01 } + }) + ] + }); + + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.points.at(-1)?.joints[0]).toBeCloseTo(Math.PI / 2); + expect(trajectory.points.at(-1)?.joints[1]).toBeCloseTo(0.3); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "warning", + code: "KDL_ZONE_APPROX_FINE" + }) + ); + expect(trajectory.meta).toMatchObject({ + targetType: "pose" + }); + }); + + it("returns a failed trajectory result for endpoint joint limit violations", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "planMoveJ", + payload: [ + handle, + baseRequest({ + target: { + id: "bad_goal", + joints: [0, 2] + } + }) + ] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ + ok: false, + motion: "MOVEJ", + points: [], + diagnostics: [ + { + severity: "error", + code: "KDL_JOINT_LIMIT" + } + ] + }); + }); + + it("keeps velocity and acceleration within joint limits", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "planMoveJ", + payload: [ + handle, + baseRequest({ + speed: { kind: "joint_percent", value: 1 }, + target: { + id: "limit_goal", + joints: [1, 0.5] + } + }) + ] + }); + + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + for (const point of trajectory.points) { + expect(Math.abs(point.jointVelocity[0]!)).toBeLessThanOrEqual(1 + 1e-9); + expect(Math.abs(point.jointVelocity[1]!)).toBeLessThanOrEqual(0.5 + 1e-9); + expect(Math.abs(point.jointAcceleration[0]!)).toBeLessThanOrEqual(2 + 1e-9); + expect(Math.abs(point.jointAcceleration[1]!)).toBeLessThanOrEqual(1 + 1e-9); + } + }); +}); diff --git a/kdl-wasm/web/tests/kdl/planMoveL.test.ts b/kdl-wasm/web/tests/kdl/planMoveL.test.ts new file mode 100644 index 0000000..1234547 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/planMoveL.test.ts @@ -0,0 +1,175 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { MoveLRequest, TrajectoryResult } from "../../src/kdl/types.js"; + +const PLANAR_URDF = ` + + + + + + + + + + + + + + + + + +`; + +async function createRobot() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + PLANAR_URDF, + { + robotId: "movel", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + expect(response.ok).toBe(true); + return { runtime, handle: response.result as number }; +} + +function request(overrides: Partial): MoveLRequest { + return { + startJoints: [Math.PI / 2, 0.2], + target: { + id: "line_goal", + pose: { + position: [0, 0.6, 0], + quaternion: [0, 0, 0, 1] + } + }, + speed: { + kind: "linear", + velocity: 0.2, + acceleration: 1 + }, + zone: { + kind: "fine" + }, + sampleTime: 0.05, + ...overrides + }; +} + +describe("planMoveL", () => { + it("plans a TCP straight-line trajectory with continuous IK seeds", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "planMoveL", + payload: [handle, request({})] + }); + + expect(response.ok).toBe(true); + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.motion).toBe("MOVEL"); + expect(trajectory.points.length).toBeGreaterThan(2); + expect(trajectory.points[0]).toMatchObject({ + index: 0, + time: 0, + s: 0, + motion: "MOVEL", + targetId: "line_goal" + }); + expect(trajectory.points.at(-1)?.s).toBe(1); + expect(trajectory.points.at(-1)?.tcp.position[0]).toBeCloseTo(0, 6); + expect(trajectory.points.at(-1)?.tcp.position[1]).toBeCloseTo(0.6, 6); + expect(trajectory.meta).toMatchObject({ + targetId: "line_goal", + orientationMode: "fixed" + }); + expect(trajectory.meta?.length as number).toBeCloseTo(0.4); + + for (const point of trajectory.points) { + expect(point.tcp.position[0]).toBeCloseTo(0, 5); + expect(point.tcp.position[2]).toBeCloseTo(0, 5); + expect(point.tcp.position[1]).toBeGreaterThanOrEqual(0.2 - 1e-9); + expect(point.tcp.position[1]).toBeLessThanOrEqual(0.6 + 1e-9); + } + }); + + it("returns a failed trajectory when a sampled pose is unreachable", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "planMoveL", + payload: [ + handle, + request({ + target: { + id: "far_goal", + pose: { + position: [0, 2, 0], + quaternion: [0, 0, 0, 1] + } + } + }) + ] + }); + + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(false); + expect(trajectory.motion).toBe("MOVEL"); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "error", + code: "KDL_JOINT_LIMIT" + }) + ); + expect(trajectory.meta).toMatchObject({ + targetId: "far_goal" + }); + }); + + it("reports zone approximation and joint-speed approximation warnings", async () => { + const { runtime, handle } = await createRobot(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "planMoveL", + payload: [ + handle, + request({ + speed: { + kind: "joint_abs", + velocity: 0.2, + acceleration: 1 + }, + zone: { + kind: "distance", + value: 0.01 + } + }) + ] + }); + + const trajectory = response.result as TrajectoryResult; + expect(trajectory.ok).toBe(true); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "warning", + code: "KDL_MOVEL_JOINT_SPEED_APPROX" + }) + ); + expect(trajectory.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "warning", + code: "KDL_ZONE_APPROX_FINE" + }) + ); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/poseApi.test.ts b/kdl-wasm/web/tests/kdl/poseApi.test.ts new file mode 100644 index 0000000..ba6c050 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/poseApi.test.ts @@ -0,0 +1,152 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { Pose, PoseTarget } from "../../src/kdl/types.js"; + +async function createRuntime() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + return runtime; +} + +function pose(x: number, y: number, z: number): Pose { + return { + position: [x, y, z], + quaternion: [0, 0, 0, 1] + }; +} + +describe("pose transform and offset API", () => { + it("normalizes pose inputs from rpy and quaternion forms", async () => { + const runtime = await createRuntime(); + const rpyResponse = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "normalizePose", + payload: [{ xyz: [1, 2, 3], rpy: [0, 0, Math.PI / 2] }] + }); + const quatResponse = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "normalizePose", + payload: [{ xyz: [0, 0, 0], quat: [0, 0, 0, 2] }] + }); + + expect(rpyResponse.ok).toBe(true); + expect((rpyResponse.result as Pose).position).toEqual([1, 2, 3]); + expect((rpyResponse.result as Pose).quaternion[2]).toBeCloseTo(Math.SQRT1_2); + expect((rpyResponse.result as Pose).quaternion[3]).toBeCloseTo(Math.SQRT1_2); + expect(quatResponse.result).toMatchObject({ + position: [0, 0, 0], + quaternion: [0, 0, 0, 1] + }); + }); + + it("composes poses and computes an inverse pose", async () => { + const runtime = await createRuntime(); + const composeResponse = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "composePose", + payload: [pose(1, 0, 0), pose(0, 2, 0)] + }); + expect(composeResponse.result).toMatchObject({ + position: [1, 2, 0], + quaternion: [0, 0, 0, 1] + }); + + const inverseResponse = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "inversePose", + payload: [pose(1, 2, 3)] + }); + expect(inverseResponse.result).toMatchObject({ + position: [-1, -2, -3], + quaternion: [0, 0, 0, 1] + }); + + const identityResponse = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "composePose", + payload: [pose(1, 2, 3), inverseResponse.result] + }); + expect((identityResponse.result as Pose).position[0]).toBeCloseTo(0); + expect((identityResponse.result as Pose).position[1]).toBeCloseTo(0); + expect((identityResponse.result as Pose).position[2]).toBeCloseTo(0); + }); + + it("applies frame, target, and tool using the same order as FK", async () => { + const runtime = await createRuntime(); + const target: PoseTarget = { + id: "pick", + pose: pose(0.5, 0.1, 0.2) + }; + const response = await dispatchKdlRpcRequest(runtime, { + id: 7, + method: "applyToolAndFrame", + payload: [target, pose(0, 0, 0.18), pose(0.8, 0, 0.2)] + }); + + const result = response.result as Pose; + expect(result.position[0]).toBeCloseTo(1.3); + expect(result.position[1]).toBeCloseTo(0.1); + expect(result.position[2]).toBeCloseTo(0.58); + expect(result.quaternion).toEqual([0, 0, 0, 1]); + }); + + it("applies offset in frame/world by left composition and tool by right composition", async () => { + const runtime = await createRuntime(); + const target: PoseTarget = { + id: "pick", + pose: { + position: [1, 2, 3], + quaternion: [0, 0, Math.SQRT1_2, Math.SQRT1_2] + }, + frame: pose(10, 0, 0) + }; + + const frameOffset = await dispatchKdlRpcRequest(runtime, { + id: 8, + method: "applyOffset", + payload: [target, { mode: "frame", xyz: [0.1, 0, 0] }] + }); + const worldOffset = await dispatchKdlRpcRequest(runtime, { + id: 9, + method: "applyOffset", + payload: [target, { mode: "world", xyz: [0, 0.2, 0] }] + }); + const toolOffset = await dispatchKdlRpcRequest(runtime, { + id: 10, + method: "applyOffset", + payload: [target, { mode: "tool", xyz: [0.1, 0, 0] }] + }); + + expect((frameOffset.result as PoseTarget).id).toBe("pick"); + expect((frameOffset.result as PoseTarget).frame).toEqual(target.frame); + expect((frameOffset.result as PoseTarget).pose.position[0]).toBeCloseTo(1.1); + expect((frameOffset.result as PoseTarget).pose.position[1]).toBeCloseTo(2); + expect((worldOffset.result as PoseTarget).pose.position[0]).toBeCloseTo(1); + expect((worldOffset.result as PoseTarget).pose.position[1]).toBeCloseTo(2.2); + expect((toolOffset.result as PoseTarget).pose.position[0]).toBeCloseTo(1); + expect((toolOffset.result as PoseTarget).pose.position[1]).toBeCloseTo(2.1); + }); + + it("returns structured diagnostics for invalid pose inputs", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 11, + method: "normalizePose", + payload: [{ xyz: [1, 2], rpy: [0, 0, 0] }] + }); + + expect(response).toMatchObject({ + ok: false, + error: { + code: "KDL_INVALID_POSE", + diagnostics: [ + { + severity: "error", + code: "KDL_INVALID_POSE" + } + ] + } + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/rpc.test.ts b/kdl-wasm/web/tests/kdl/rpc.test.ts new file mode 100644 index 0000000..96e12f7 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/rpc.test.ts @@ -0,0 +1,206 @@ +import { describe, expect, it } from "vitest"; +import { KdlWorkerClient, type KdlWorkerLike } from "../../src/kdl/kdlClient.js"; +import type { NativeKdlModule } from "../../src/kdl/nativeModule.js"; +import { KdlStructuredError, type KdlRpcRequest, type KdlRpcResponse } from "../../src/kdl/rpc.js"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; + +class FakeWorker implements KdlWorkerLike { + readonly sent: Array> = []; + terminated = false; + private messageListeners = new Set<(event: MessageEvent) => void>(); + private errorListeners = new Set<(event: ErrorEvent) => void>(); + + postMessage(message: KdlRpcRequest): void { + this.sent.push(message); + } + + terminate(): void { + this.terminated = true; + } + + addEventListener(type: "message", listener: (event: MessageEvent) => void): void; + addEventListener(type: "error", listener: (event: ErrorEvent) => void): void; + addEventListener(type: "message" | "error", listener: unknown): void { + if (type === "message") { + this.messageListeners.add(listener as (event: MessageEvent) => void); + return; + } + this.errorListeners.add(listener as (event: ErrorEvent) => void); + } + + removeEventListener(type: "message", listener: (event: MessageEvent) => void): void; + removeEventListener(type: "error", listener: (event: ErrorEvent) => void): void; + removeEventListener(type: "message" | "error", listener: unknown): void { + if (type === "message") { + this.messageListeners.delete(listener as (event: MessageEvent) => void); + return; + } + this.errorListeners.delete(listener as (event: ErrorEvent) => void); + } + + emitResponse(response: KdlRpcResponse): void { + const event = { data: response } as MessageEvent; + for (const listener of this.messageListeners) { + listener(event); + } + } + + emitError(message: string): void { + const event = { message, error: new Error(message) } as ErrorEvent; + for (const listener of this.errorListeners) { + listener(event); + } + } +} + +describe("KDL Worker RPC", () => { + it("loads the native WASM module during init when a loader is configured", async () => { + const calls: unknown[][] = []; + const native: NativeKdlModule = { + ccall: (...args) => { + calls.push(args); + return 0; + } + }; + const runtime = createKdlWorkerRuntime(async () => native); + + const response = await dispatchKdlRpcRequest(runtime, { + id: 1, + method: "init", + payload: [{ wasmBuild: "native-test" }] + }); + + expect(response.ok).toBe(true); + expect(response.result).toMatchObject({ wasmBuild: "native-test" }); + expect(calls).toEqual([["kdl_init", "number", ["string"], ['{"wasmBuild":"native-test"}']]]); + }); + + it("normalizes native WASM initialization failures", async () => { + const runtime = createKdlWorkerRuntime(async () => { + throw new Error("cannot load kdl.js"); + }); + + const response = await dispatchKdlRpcRequest(runtime, { + id: 11, + method: "init", + payload: [{}] + }); + + expect(response.ok).toBe(false); + expect(response.error).toMatchObject({ + code: "KDL_WASM_INIT_FAILED", + diagnostics: [ + { + severity: "error", + code: "KDL_WASM_INIT_FAILED" + } + ] + }); + }); + + it("dispatches init and dispose through structured responses", async () => { + const runtime = createKdlWorkerRuntime(); + const initResponse = await dispatchKdlRpcRequest(runtime, { + id: 1, + method: "init", + payload: [{ wasmBuild: "test", useThreads: true }] + }); + + expect(initResponse.ok).toBe(true); + expect(initResponse.result).toMatchObject({ + version: "0.1.0", + wasmBuild: "test", + supportsThreads: true + }); + + const disposeResponse = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "dispose", + payload: [] + }); + + expect(disposeResponse).toMatchObject({ id: 2, ok: true }); + }); + + it("returns a structured error when an implemented method is called before init", async () => { + const response = await dispatchKdlRpcRequest(createKdlWorkerRuntime(), { + id: 7, + method: "fk", + payload: [1, new Float64Array([0])] + }); + + expect(response.ok).toBe(false); + expect(response.error).toMatchObject({ + code: "KDL_NOT_INITIALIZED", + diagnostics: [ + { + severity: "error", + code: "KDL_NOT_INITIALIZED" + } + ] + }); + }); + + it("uses unique request ids and resolves responses by id", async () => { + const workers: FakeWorker[] = []; + const client = new KdlWorkerClient(() => { + const worker = new FakeWorker(); + workers.push(worker); + return worker; + }); + + const first = client.call("init", { wasmBuild: "a" }); + const second = client.call("dispose"); + + expect(workers).toHaveLength(1); + expect(workers[0]?.sent.map((request) => request.id)).toEqual([1, 2]); + + workers[0]?.emitResponse({ id: 2, ok: true }); + workers[0]?.emitResponse({ + id: 1, + ok: true, + result: { + version: "0.1.0", + wasmBuild: "a", + supportsThreads: false, + supportsWasmFs: false + } + }); + + await expect(second).resolves.toBeUndefined(); + await expect(first).resolves.toMatchObject({ wasmBuild: "a" }); + }); + + it("rejects pending requests on worker failure and can create a fresh worker", async () => { + const workers: FakeWorker[] = []; + const client = new KdlWorkerClient(() => { + const worker = new FakeWorker(); + workers.push(worker); + return worker; + }); + + const pending = client.init(); + workers[0]?.emitError("boom"); + + await expect(pending).rejects.toMatchObject({ + code: "KDL_WORKER_CRASHED" + }); + expect(workers[0]?.terminated).toBe(true); + + const restarted = client.init({ wasmBuild: "restart" }); + expect(workers).toHaveLength(2); + workers[1]?.emitResponse({ + id: 2, + ok: true, + result: { + version: "0.1.0", + wasmBuild: "restart", + supportsThreads: false, + supportsWasmFs: false + } + }); + + await expect(restarted).resolves.toMatchObject({ wasmBuild: "restart" }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/trajectoryUtils.test.ts b/kdl-wasm/web/tests/kdl/trajectoryUtils.test.ts new file mode 100644 index 0000000..d3c077f --- /dev/null +++ b/kdl-wasm/web/tests/kdl/trajectoryUtils.test.ts @@ -0,0 +1,179 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { CycleTimeResult, PathPlanResult, TrajectoryResult } from "../../src/kdl/types.js"; + +function pose(x: number, y: number, z: number) { + return { + position: [x, y, z] as [number, number, number], + quaternion: [0, 0, 0, 1] as [number, number, number, number] + }; +} + +function trajectory(overrides: Partial = {}): TrajectoryResult { + return { + ok: true, + motion: "MOVEJ", + duration: 1, + sampleTime: 0.5, + events: [], + diagnostics: [], + points: [ + { + index: 0, + time: 0, + dt: 0, + s: 0, + sd: 0, + sdd: 0, + joints: [0, 0], + jointVelocity: [0, 0], + jointAcceleration: [0, 0], + flange: pose(0, 0, 0), + tcp: pose(0, 0, 0), + motion: "MOVEJ", + segmentId: "s1", + diagnostics: [] + }, + { + index: 1, + time: 1, + dt: 1, + s: 1, + sd: 0, + sdd: 0, + joints: [1, 2], + jointVelocity: [0, 0], + jointAcceleration: [0, 0], + flange: pose(1, 0, 0), + tcp: pose(1, 2, 0), + motion: "MOVEJ", + segmentId: "s1", + diagnostics: [] + } + ], + ...overrides + }; +} + +async function createRuntime() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + return runtime; +} + +describe("cycle-time, resample, and diagnostics utilities", () => { + it("estimates cycle time for a trajectory and a path plan", async () => { + const runtime = await createRuntime(); + const singleResponse = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "estimateCycleTime", + payload: [trajectory()] + }); + expect(singleResponse.result).toMatchObject({ + ok: true, + motionTime: 1, + totalTime: 1, + segmentTimes: [ + { + segmentId: "s1", + motion: "MOVEJ", + duration: 1 + } + ], + diagnostics: [] + }); + + const path: PathPlanResult = { + ok: true, + duration: 3, + segments: [ + trajectory(), + trajectory({ + motion: "MOVEL", + duration: 2, + points: trajectory().points.map((point) => ({ ...point, motion: "MOVEL", segmentId: "s2" })) + }) + ], + points: [], + diagnostics: [] + }; + const pathResponse = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "estimateCycleTime", + payload: [path] + }); + expect(pathResponse.result).toMatchObject({ + ok: true, + motionTime: 3, + totalTime: 3, + segmentTimes: [ + { segmentId: "s1", motion: "MOVEJ", duration: 1 }, + { segmentId: "s2", motion: "MOVEL", duration: 2 } + ] + }); + }); + + it("resamples a trajectory with stable time and point ordering", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "resampleTrajectory", + payload: [trajectory(), 0.25] + }); + + expect(response.ok).toBe(true); + const result = response.result as TrajectoryResult; + expect(result.sampleTime).toBe(0.25); + expect(result.points.map((point) => point.time)).toEqual([0, 0.25, 0.5, 0.75, 1]); + expect(result.points.map((point) => point.index)).toEqual([0, 1, 2, 3, 4]); + expect(result.points[2]?.joints).toEqual([0.5, 1]); + expect(result.points[2]?.tcp.position).toEqual([0.5, 1, 0]); + expect(result.diagnostics).toContainEqual( + expect.objectContaining({ + severity: "info", + code: "KDL_TRAJECTORY_RESAMPLED" + }) + ); + }); + + it("keeps structured diagnostics for warning and error cases", async () => { + const runtime = await createRuntime(); + const emptyResponse = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "resampleTrajectory", + payload: [ + trajectory({ + points: [] + }), + 0.1 + ] + }); + expect(emptyResponse.result).toMatchObject({ + diagnostics: [ + { + severity: "warning", + code: "KDL_RESAMPLE_EMPTY_TRAJECTORY" + } + ] + }); + + const invalidResponse = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "resampleTrajectory", + payload: [trajectory(), 0] + }); + expect(invalidResponse).toMatchObject({ + ok: false, + error: { + code: "KDL_INVALID_SAMPLE_TIME", + diagnostics: [ + { + severity: "error", + code: "KDL_INVALID_SAMPLE_TIME" + } + ] + } + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/trapProfile.test.ts b/kdl-wasm/web/tests/kdl/trapProfile.test.ts new file mode 100644 index 0000000..3863108 --- /dev/null +++ b/kdl-wasm/web/tests/kdl/trapProfile.test.ts @@ -0,0 +1,138 @@ +import { describe, expect, it } from "vitest"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import type { TrapProfileResult, TrapSample } from "../../src/kdl/types.js"; + +async function createRuntime() { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + return runtime; +} + +function expectMonotonic(samples: TrapSample[]) { + for (let index = 1; index < samples.length; index += 1) { + expect(samples[index]!.time).toBeGreaterThan(samples[index - 1]!.time); + expect(samples[index]!.s).toBeGreaterThanOrEqual(samples[index - 1]!.s); + } +} + +describe("trapezoid velocity profile API", () => { + it("creates a trapezoid profile when the path can reach max velocity", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "makeTrapProfile", + payload: [ + 2, + { + maxVelocity: 1, + maxAcceleration: 1, + sampleTime: 0.25 + } + ] + }); + + expect(response.ok).toBe(true); + const profile = response.result as TrapProfileResult; + expect(profile).toMatchObject({ + ok: true, + type: "trapezoid", + length: 2, + duration: 3, + tAccel: 1, + tConst: 1, + tDecel: 1, + vPeak: 1, + diagnostics: [] + }); + expect(profile.samples[0]).toMatchObject({ index: 0, time: 0, s: 0 }); + expect(profile.samples.at(-1)).toMatchObject({ time: 3, s: 1 }); + expect(profile.samples.find((sample) => sample.time === 1)?.s).toBeCloseTo(0.25); + expect(profile.samples.find((sample) => sample.time === 1)?.sd).toBeCloseTo(0.5); + expectMonotonic(profile.samples); + }); + + it("falls back to a triangle profile for short paths", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "makeTrapProfile", + payload: [ + 0.5, + { + maxVelocity: 2, + maxAcceleration: 1, + sampleTime: 0.1 + } + ] + }); + + expect(response.ok).toBe(true); + const profile = response.result as TrapProfileResult; + expect(profile.type).toBe("triangle"); + expect(profile.tConst).toBe(0); + expect(profile.vPeak).toBeCloseTo(Math.sqrt(0.5)); + expect(profile.duration).toBeCloseTo(2 * Math.sqrt(0.5)); + expect(profile.samples[0]?.s).toBe(0); + expect(profile.samples.at(-1)?.s).toBe(1); + expect(profile.diagnostics).toMatchObject([ + { + severity: "info", + code: "KDL_TRAP_TRIANGLE_PROFILE" + } + ]); + expectMonotonic(profile.samples); + }); + + it("returns samples from sampleTrapProfile with strict endpoint samples", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "sampleTrapProfile", + payload: [ + 1, + { + maxVelocity: 1, + maxAcceleration: 2, + sampleTime: 0.2 + } + ] + }); + + expect(response.ok).toBe(true); + const samples = response.result as TrapSample[]; + expect(samples[0]).toMatchObject({ index: 0, time: 0, s: 0 }); + expect(samples.at(-1)?.s).toBe(1); + expect(samples.at(-1)?.time).toBeCloseTo(1.5); + expectMonotonic(samples); + }); + + it("returns a structured diagnostic for invalid trap profile inputs", async () => { + const runtime = await createRuntime(); + const response = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "makeTrapProfile", + payload: [ + 1, + { + maxVelocity: 0, + maxAcceleration: 1, + sampleTime: 0.01 + } + ] + }); + + expect(response).toMatchObject({ + ok: false, + error: { + code: "KDL_INVALID_TRAP_PROFILE", + diagnostics: [ + { + severity: "error", + code: "KDL_INVALID_TRAP_PROFILE" + } + ] + } + }); + }); +}); diff --git a/kdl-wasm/web/tests/kdl/urdf.test.ts b/kdl-wasm/web/tests/kdl/urdf.test.ts new file mode 100644 index 0000000..8e7712a --- /dev/null +++ b/kdl-wasm/web/tests/kdl/urdf.test.ts @@ -0,0 +1,182 @@ +import { describe, expect, it } from "vitest"; +import { KdlStructuredError } from "../../src/kdl/rpc.js"; +import { createKdlWorkerRuntime } from "../../src/kdl/runtime.js"; +import { dispatchKdlRpcRequest } from "../../src/kdl/workerRpc.js"; +import { loadRobotFromUrdfModel } from "../../src/robot/urdfParser.js"; + +const SIMPLE_URDF = ` + + + + + + + + + + + + + + + + + + + + + + + + + +`; + +describe("URDF to NormalizedRobotModel", () => { + it("parses links, joints, origins, axes, limits, stable active joint names, and source hash", () => { + const model = loadRobotFromUrdfModel(SIMPLE_URDF, { + robotId: "r1", + baseLink: "base_link", + tipLink: "tool0" + }); + + expect(model).toMatchObject({ + robotId: "r1", + name: "simple6", + baseLink: "base_link", + tipLink: "tool0", + activeJointNames: ["joint_1", "joint_2"], + source: { type: "urdf" } + }); + expect(model.source.urdfHash).toHaveLength(64); + expect(model.links.map((link) => link.name)).toEqual(["base_link", "link_1", "link_2", "tool0"]); + expect(model.joints[0]).toMatchObject({ + name: "joint_1", + type: "revolute", + parent: "base_link", + child: "link_1", + origin: { xyz: [0, 0, 0.1], rpy: [0, 0, 0] }, + axis: [0, 0, 1] + }); + expect(model.limits).toEqual([ + { name: "joint_1", lower: -3.14, upper: 3.14, velocity: 2.5, acceleration: 5 }, + { name: "joint_2", lower: 0, upper: 0.4, velocity: 0.3, acceleration: 1.2 } + ]); + }); + + it("applies joint order and limit overrides", () => { + const model = loadRobotFromUrdfModel(SIMPLE_URDF, { + robotId: "r1", + baseLink: "base_link", + tipLink: "tool0", + jointOrder: ["joint_2", "joint_1"], + overrideLimits: [{ name: "joint_2", velocity: 0.2 }] + }); + + expect(model.activeJointNames).toEqual(["joint_2", "joint_1"]); + expect(model.limits[0]).toMatchObject({ name: "joint_2", velocity: 0.2 }); + }); + + it("returns structured diagnostics for disconnected base and tip links", () => { + let thrown: unknown; + try { + loadRobotFromUrdfModel(SIMPLE_URDF, { + robotId: "r1", + baseLink: "tool0", + tipLink: "base_link" + }); + } catch (error) { + thrown = error; + } + + expect(thrown).toBeInstanceOf(KdlStructuredError); + expect(thrown).toMatchObject({ + code: "KDL_INVALID_MODEL", + diagnostics: [ + { + severity: "error", + code: "KDL_INVALID_MODEL" + } + ] + }); + }); + + it("rejects unsupported joint types", () => { + const urdf = SIMPLE_URDF.replace('type="prismatic"', 'type="floating"'); + let thrown: unknown; + try { + loadRobotFromUrdfModel(urdf, { + robotId: "r1", + baseLink: "base_link", + tipLink: "tool0" + }); + } catch (error) { + thrown = error; + } + + expect(thrown).toBeInstanceOf(KdlStructuredError); + expect(thrown).toMatchObject({ + code: "KDL_INVALID_MODEL", + message: expect.stringContaining("Unsupported joint type") + }); + }); + + it("supports RobotHandle lifecycle through the worker runtime", async () => { + const runtime = createKdlWorkerRuntime(); + await dispatchKdlRpcRequest(runtime, { id: 1, method: "init", payload: [{}] }); + const createResponse = await dispatchKdlRpcRequest(runtime, { + id: 2, + method: "loadRobotFromUrdf", + payload: [ + SIMPLE_URDF, + { + robotId: "r1", + baseLink: "base_link", + tipLink: "tool0" + } + ] + }); + + expect(createResponse).toMatchObject({ ok: true, result: 1 }); + + const infoResponse = await dispatchKdlRpcRequest(runtime, { + id: 3, + method: "getRobotInfo", + payload: [1] + }); + expect(infoResponse.result).toMatchObject({ + handle: 1, + robotId: "r1", + name: "simple6", + dof: 2, + jointNames: ["joint_1", "joint_2"] + }); + + const limitsResponse = await dispatchKdlRpcRequest(runtime, { + id: 4, + method: "getJointLimits", + payload: [1] + }); + expect(limitsResponse.result).toEqual([ + { name: "joint_1", lower: -3.14, upper: 3.14, velocity: 2.5, acceleration: 5 }, + { name: "joint_2", lower: 0, upper: 0.4, velocity: 0.3, acceleration: 1.2 } + ]); + + const destroyResponse = await dispatchKdlRpcRequest(runtime, { + id: 5, + method: "destroyRobot", + payload: [1] + }); + expect(destroyResponse.ok).toBe(true); + + const afterDestroy = await dispatchKdlRpcRequest(runtime, { + id: 6, + method: "getRobotInfo", + payload: [1] + }); + expect(afterDestroy).toMatchObject({ + ok: false, + error: { code: "KDL_INVALID_HANDLE" } + }); + }); +}); diff --git a/kdl-wasm/web/tests/post/postProcessor.test.ts b/kdl-wasm/web/tests/post/postProcessor.test.ts new file mode 100644 index 0000000..2c8ba97 --- /dev/null +++ b/kdl-wasm/web/tests/post/postProcessor.test.ts @@ -0,0 +1,88 @@ +import { describe, expect, it } from "vitest"; +import { postProcessAllBrands } from "../../src/grl/post/index.js"; +import { parseGrl } from "../../src/grl/parser/index.js"; +import { compileSemanticProgram } from "../../src/grl/semantic/index.js"; + +const PROGRAM = `language grl 0.1 +module PostDemo + post_hint abb + const speed vj = joint(50 %) + const speed vl = linear(200 mm/s) + const zone z10 = z(10 mm) + target home = joint_target { joints: [0 deg] } + target pick = pose_target { pose: pose(500 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) } + target mid = pose_target { pose: pose(550 mm, 50 mm, 0 mm, 0 deg, 0 deg, 0 deg) } + target place = pose_target { pose: pose(600 mm, 0 mm, 0 mm, 0 deg, 0 deg, 0 deg) } + proc main() + set_speed vl + set_zone z10 + movej home speed vj zone fine + movel pick speed vl zone z10 + movec via mid target place speed vl zone fine + io.do[1] = true + wait io.di[1] == true timeout 1 s + pulse io.do[2] duration 100 ms + alarm DONE "done" + end +end +`; + +function postAll() { + const ir = compileSemanticProgram(parseGrl(PROGRAM), { + startJoints: [0], + sampleTime: 0.004 + }); + return postProcessAllBrands(ir); +} + +describe("GRL multi-brand postprocessor", () => { + it("emits stable ABB, FANUC, and KUKA golden text", () => { + const result = postAll(); + + expect(result.outputs.abb.text).toBe(`MODULE PostDemo + PROC main() + MoveJ home,v50,fine,tool0; + MoveL pick,v200,z10,tool0; + MoveC mid,place,v200,fine,tool0; + SetDO io.do[1],TRUE; + WaitUntil io . di [ 1 ] == true; + PulseDO io.do[2],0.100; + ! unsupported ALARM + ENDPROC +ENDMODULE`); + expect(result.outputs.fanuc.text).toBe(`/PROG MAIN +/MN + 1: J home 50% FINE ; + 2: L pick 200mm/sec CNT10 ; + 3: C mid place 200mm/sec FINE ; + 4: DO[1]=TRUE ; + 5: WAIT (io . di [ 1 ] == true) ; + 6: PULSE DO[2] 100ms ; + 7: ! unsupported ALARM ; +/END`); + expect(result.outputs.kuka.text).toBe(`DEF Main() + PTP home Vel=50% + LIN pick Vel=0.200m/s C_DIS + CIRC mid, place Vel=0.200m/s + $OUT[1] = TRUE + WAIT FOR io . di [ 1 ] == true + PULSE $OUT[2] 0.100 + ! unsupported ALARM +END`); + }); + + it("reports unsupported semantics and ignored brand hints", () => { + const result = postAll(); + + expect(result.outputs.abb.filename).toBe("PostDemo.mod"); + expect(result.outputs.fanuc.filename).toBe("PostDemo.ls"); + expect(result.outputs.kuka.filename).toBe("PostDemo.src"); + expect(result.report).toEqual([ + expect.objectContaining({ brand: "abb", code: "GRL_POST_UNSUPPORTED", message: expect.stringContaining("ALARM") }), + expect.objectContaining({ brand: "fanuc", code: "GRL_POST_HINT_IGNORED" }), + expect.objectContaining({ brand: "fanuc", code: "GRL_POST_UNSUPPORTED", message: expect.stringContaining("ALARM") }), + expect.objectContaining({ brand: "kuka", code: "GRL_POST_HINT_IGNORED" }), + expect.objectContaining({ brand: "kuka", code: "GRL_POST_UNSUPPORTED", message: expect.stringContaining("ALARM") }) + ]); + }); +}); diff --git a/kdl-wasm/web/tsconfig.json b/kdl-wasm/web/tsconfig.json new file mode 100644 index 0000000..ab52ff5 --- /dev/null +++ b/kdl-wasm/web/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "NodeNext", + "moduleResolution": "NodeNext", + "strict": true, + "noUncheckedIndexedAccess": true, + "exactOptionalPropertyTypes": true, + "esModuleInterop": true, + "forceConsistentCasingInFileNames": true, + "skipLibCheck": true, + "types": ["node", "vitest/globals"], + "lib": ["ES2022", "DOM"] + }, + "include": ["src/**/*.ts", "tests/**/*.ts"] +} diff --git a/kdl-wasm/web/vitest.config.ts b/kdl-wasm/web/vitest.config.ts new file mode 100644 index 0000000..533ebe4 --- /dev/null +++ b/kdl-wasm/web/vitest.config.ts @@ -0,0 +1,9 @@ +import { defineConfig } from "vitest/config"; + +export default defineConfig({ + test: { + environment: "node", + include: ["kdl-wasm/web/tests/**/*.test.ts"], + globals: true + } +}); diff --git a/orocos_kinematics_dynamics b/orocos_kinematics_dynamics new file mode 160000 index 0000000..5c78749 --- /dev/null +++ b/orocos_kinematics_dynamics @@ -0,0 +1 @@ +Subproject commit 5c787496c9c57460c0eb076f300afd8ac7412f68 diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..9449803 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,1741 @@ +{ + "name": "kdl-work", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "kdl-work", + "version": "0.1.0", + "dependencies": { + "fast-xml-parser": "^5.9.3" + }, + "devDependencies": { + "@types/node": "^22.15.30", + "typescript": "^5.8.3", + "vitest": "^3.2.4" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz", + "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz", + "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz", + "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz", + "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz", + "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz", + "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz", + "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz", + "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz", + "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz", + "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz", + "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz", + "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz", + "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz", + "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz", + "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz", + "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz", + "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz", + "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz", + "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz", + "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz", + "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz", + "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz", + "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz", + "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz", + "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz", + "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@nodable/entities": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-9uGyhaQavEUMC8AIddIjau4NsnsXhou+j5sBAGojCM1oxmQpVKTWR/9JxABD6UAv12vpIms55fPZKFQEhG6uBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/nodable" + } + ], + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz", + "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz", + "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz", + "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz", + "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz", + "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz", + "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz", + "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz", + "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz", + "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz", + "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz", + "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz", + "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz", + "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz", + "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz", + "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz", + "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz", + "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz", + "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz", + "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz", + "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz", + "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz", + "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz", + "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz", + "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz", + "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.20.0", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.0.tgz", + "integrity": "sha512-QWlFW2wf3nTjC13/DqRnBpR4ZO36VJH/JVBkA/vcnmbTBNQIlnObqyqZE1tUR7+Ni23Lda8R1BxMfbXRpCUx5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@vitest/expect": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.6.tgz", + "integrity": "sha512-1+7q9BtaKzEmO+fmNT3kYvoNn5Y71XWAx2Q5HRim4tTVRQVRv4uJFAQ5FbK0OPUeNP/WmVCpxYxoJdvuHVjzBQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.6", + "@vitest/utils": "3.2.6", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/mocker": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.6.tgz", + "integrity": "sha512-EZOrpDbkKotFAP7wPAQV1UIyoGOk4oX7ynWhBhLB7v+meMHbQhU16oPpIYGTTe4oFlhpryGpgpcZP/sin3hYuw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "3.2.6", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.17" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.6.tgz", + "integrity": "sha512-lb7XXXzmm2h2ASzFnRvQpDo6onT1NmMJA3tkGTWiBFtRJ9lxGY3d3mm/Apt36gej2bkkOVLL/yTOtufDaFa/jA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.6.tgz", + "integrity": "sha512-HYcoSj1w5tcgUnzoF0HcyaAQjpA1gj9ftUJ7iSJSuipc02jW9gKkigwZbjFldAfYHA1fa8UZVRftdMY5msWM9Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "3.2.6", + "pathe": "^2.0.3", + "strip-literal": "^3.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.6.tgz", + "integrity": "sha512-H+ZjNTWGpObenh0YnlBctAPnJSI20P81PL8BPzWpx54YXLLTm8hEsWawtcYLMrwvpK48hGxLLbCS+1KRXhsKhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.6", + "magic-string": "^0.30.17", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.6.tgz", + "integrity": "sha512-oq6BbH68WzcWmwtBrU9nqLeaXTR4XwJF7FSLkKEZo4i6eoXcrxjcwSuTvWBIRUTC6VC72nXYunzqgZA+IKdtxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.6.tgz", + "integrity": "sha512-lI23nIs4bnT3T8NIoh+vFaz5s2/DdP0Jgt2jxwgWljvwn82cLJtyi/If+fjFyoLMGIOz0U/fKvWE0d4jsNQEfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.6", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/anynum": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz", + "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz", + "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fast-xml-builder": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.2.0.tgz", + "integrity": "sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "path-expression-matcher": "^1.5.0", + "xml-naming": "^0.1.0" + } + }, + "node_modules/fast-xml-parser": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.9.3.tgz", + "integrity": "sha512-brCNCeScma/kqa54J4PIDriSSSLssRkuYaUCpvHJulGc3HGI/xxKUCTDcYkAdqJsyb//ydpbxecjC3hB9+tb/g==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "@nodable/entities": "^2.2.0", + "fast-xml-builder": "^1.2.0", + "is-unsafe": "^1.0.1", + "path-expression-matcher": "^1.5.0", + "strnum": "^2.4.1", + "xml-naming": "^0.1.0" + }, + "bin": { + "fxparser": "src/cli/cli.js" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/is-unsafe": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-1.0.1.tgz", + "integrity": "sha512-CLK2+VdgERgD96EYm5lUQssZYlRg2tkZnbsxZoacmSiRxiFJ4Nk4SzjCl+Ur+v3kXIY9dTIdb3IH22y1mZ56LA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, + "node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.15", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz", + "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/path-expression-matcher": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.1.tgz", + "integrity": "sha512-h7bxdzhHk8Knyc4Tj+jMaa7fEEoUJy7p1qtbVgkYg1Uhpe5Np5VuGXCRZnkZvU+Q42M1vStt0ifa3ueykRJPmQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.15", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz", + "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.12", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/rollup": { + "version": "4.62.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz", + "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.62.2", + "@rollup/rollup-android-arm64": "4.62.2", + "@rollup/rollup-darwin-arm64": "4.62.2", + "@rollup/rollup-darwin-x64": "4.62.2", + "@rollup/rollup-freebsd-arm64": "4.62.2", + "@rollup/rollup-freebsd-x64": "4.62.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.62.2", + "@rollup/rollup-linux-arm-musleabihf": "4.62.2", + "@rollup/rollup-linux-arm64-gnu": "4.62.2", + "@rollup/rollup-linux-arm64-musl": "4.62.2", + "@rollup/rollup-linux-loong64-gnu": "4.62.2", + "@rollup/rollup-linux-loong64-musl": "4.62.2", + "@rollup/rollup-linux-ppc64-gnu": "4.62.2", + "@rollup/rollup-linux-ppc64-musl": "4.62.2", + "@rollup/rollup-linux-riscv64-gnu": "4.62.2", + "@rollup/rollup-linux-riscv64-musl": "4.62.2", + "@rollup/rollup-linux-s390x-gnu": "4.62.2", + "@rollup/rollup-linux-x64-gnu": "4.62.2", + "@rollup/rollup-linux-x64-musl": "4.62.2", + "@rollup/rollup-openbsd-x64": "4.62.2", + "@rollup/rollup-openharmony-arm64": "4.62.2", + "@rollup/rollup-win32-arm64-msvc": "4.62.2", + "@rollup/rollup-win32-ia32-msvc": "4.62.2", + "@rollup/rollup-win32-x64-gnu": "4.62.2", + "@rollup/rollup-win32-x64-msvc": "4.62.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" + }, + "node_modules/strip-literal": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz", + "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/strnum": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.4.1.tgz", + "integrity": "sha512-M9eUSMT2dCB2cTNPG7UYj6KuK7RJR2SN2+yCV/fTW3xzTCS6EaGZ5pSMgDIjB7r8zSfTGk+dvvn9rTjpVS9Mwg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "anynum": "^1.0.1" + } + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz", + "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/vite": { + "version": "7.3.6", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz", + "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0 || ^0.28.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-node": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz", + "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.4.1", + "es-module-lexer": "^1.7.0", + "pathe": "^2.0.3", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vitest": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.6.tgz", + "integrity": "sha512-xejya+bT/j/+R/AGa1XOfRxLmNUlLtlwjRsFUILF+xHfzElmGcmFydy2gqqIrd62ptIEfwVMofd19uNWD9L7Nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/expect": "3.2.6", + "@vitest/mocker": "3.2.6", + "@vitest/pretty-format": "^3.2.6", + "@vitest/runner": "3.2.6", + "@vitest/snapshot": "3.2.6", + "@vitest/spy": "3.2.6", + "@vitest/utils": "3.2.6", + "chai": "^5.2.0", + "debug": "^4.4.1", + "expect-type": "^1.2.1", + "magic-string": "^0.30.17", + "pathe": "^2.0.3", + "picomatch": "^4.0.2", + "std-env": "^3.9.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.14", + "tinypool": "^1.1.1", + "tinyrainbow": "^2.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", + "vite-node": "3.2.4", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/debug": "^4.1.12", + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "@vitest/browser": "3.2.6", + "@vitest/ui": "3.2.6", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/debug": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/xml-naming": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.1.0.tgz", + "integrity": "sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "engines": { + "node": ">=16.0.0" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..9f10aab --- /dev/null +++ b/package.json @@ -0,0 +1,18 @@ +{ + "name": "kdl-work", + "version": "0.1.0", + "private": true, + "type": "module", + "scripts": { + "test": "vitest run --config kdl-wasm/web/vitest.config.ts", + "typecheck": "tsc -p kdl-wasm/web/tsconfig.json --noEmit" + }, + "devDependencies": { + "@types/node": "^22.15.30", + "typescript": "^5.8.3", + "vitest": "^3.2.4" + }, + "dependencies": { + "fast-xml-parser": "^5.9.3" + } +} diff --git a/work/doc/KDL_WASM计算接口设计.md b/work/doc/KDL_WASM计算接口设计.md new file mode 100644 index 0000000..5b225ec --- /dev/null +++ b/work/doc/KDL_WASM计算接口设计.md @@ -0,0 +1,1032 @@ +# KDL WASM 计算接口设计 + +版本：0.1 +适用范围：GRL 通用机器人程序、虚拟控制器、离线编程、路径验证、轨迹回放 +运行环境：浏览器 TypeScript + Web Worker + Orocos KDL WebAssembly + +## 1. 目标 + +本文定义 KDL WASM 需要暴露给 TypeScript 虚拟控制器和通用机器人程序 GRL 使用的计算函数。接口设计从 GRL 语法反推，而不是简单暴露 KDL C++ 类。 + +GRL 中直接依赖 KDL WASM 的语义包括： + +1. `joint_target`、`pose_target` 的目标点解析和可达性验证。 +2. `tool`、`frame`、`offset`、`offset_in` 的位姿变换。 +3. `movej` 关节角度差分运行。 +4. `movel` TCP 直线运行。 +5. `movec` TCP 圆弧运行。 +6. `path`、`run_path`、`operation` 的批量轨迹生成和批量诊断。 +7. 速度、加速度、zone、采样周期、节拍估算。 +8. 虚拟控制器运行时的当前 TCP、当前关节、轨迹采样点、报警诊断。 + +KDL WASM 不负责： + +1. GRL 词法和语法解析。 +2. 程序流程控制、变量、IO、wait、子程序调用。 +3. 碰撞检测和几何布尔运算。 +4. 真实品牌控制器的完整 look-ahead 和伺服细节。 +5. OPFS 项目文件管理。 + +这些由 TypeScript 层、虚拟控制器、碰撞模块和 OPFS Workspace 实现。 + +## 2. 总体架构 + +```text +GRL Source / OLP Model / Brand Import + | +TypeScript Parser + Semantic Analyzer + | +Executable IR / MotionSegmentRequest + | +KdlWorkerClient + | +kdl.worker.ts + | +KDL WASM C ABI / Embind Wrapper + | +Orocos KDL +``` + +设计原则： + +1. KDL WASM 运行在 Worker 中，避免阻塞 UI 主线程。 +2. TypeScript 业务层只使用稳定接口，不直接操作 KDL C++ 对象。 +3. WASM 内部使用 `RobotHandle` 管理机器人链、求解器和缓存。 +4. 机器人结构源数据为 URDF，TypeScript 层负责解析 XML 并生成标准模型，WASM 层负责构造 KDL `Tree/Chain`。 +5. 高频数据使用 `Float64Array`，结构化配置使用 JSON。 +6. 所有计算函数返回统一诊断，不只返回成功/失败。 + +## 3. KDL 能力映射 + +| GRL/虚拟控制器能力 | KDL 或包装层能力 | 说明 | +| --- | --- | --- | +| URDF 串联链 | `Tree`、`Chain`、`Segment`、`Joint` | 包装层从标准模型构造 | +| `movej` 终点 FK | `ChainFkSolverPos_recursive` | 关节到法兰/TCP | +| `movel/movec` 逐点 IK | `ChainIkSolverPos_NR_JL`、`ChainIkSolverPos_LMA` | 带关节限位和诊断 | +| 雅可比和奇异性 | `ChainJntToJacSolver` | 输出 Jacobian 和指标 | +| TCP 直线路径 | `Path_Line` 或包装层等价实现 | MOVEL 采样 | +| TCP 圆弧路径 | `Path_Circle` 或包装层等价实现 | MOVEC 采样 | +| 梯形速度 | `VelocityProfile_Trap` | 生成 `s/sd/sdd` | +| 轨迹段 | `Trajectory_Segment` | 路径 + 速度曲线 | +| zone/blend | `Path_RoundedComposite` 或自研 blend | P1 阶段 | + +## 4. TypeScript 顶层 API + +建议对外提供一个异步客户端： + +```ts +interface KdlWasmApi { + init(options?: KdlInitOptions): Promise; + dispose(): Promise; + + loadRobotFromUrdf(urdfXml: string, options: UrdfLoadOptions): Promise; + createRobotFromModel(model: NormalizedRobotModel): Promise; + destroyRobot(handle: RobotHandle): Promise; + getRobotInfo(handle: RobotHandle): Promise; + getJointLimits(handle: RobotHandle): Promise; + + normalizePose(input: PoseLike, options?: PoseNormalizeOptions): Promise; + composePose(a: Pose, b: Pose): Promise; + inversePose(pose: Pose): Promise; + applyToolAndFrame(target: PoseTarget, tool: Pose, frame: Pose): Promise; + applyOffset(target: PoseTarget, offset: OffsetSpec): Promise; + + fk(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise; + fkAllLinks(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise; + jacobian(handle: RobotHandle, joints: Float64Array, options?: JacobianOptions): Promise; + ik(handle: RobotHandle, seed: Float64Array, target: Pose, options?: IkOptions): Promise; + ikBatch(handle: RobotHandle, seeds: Float64Array[], targets: Pose[], options?: IkOptions): Promise; + + checkJointLimits(handle: RobotHandle, joints: Float64Array): Promise; + checkVelocityLimits(handle: RobotHandle, trajectory: TrajectoryResult): Promise; + checkSingularity(handle: RobotHandle, joints: Float64Array): Promise; + checkReachability(handle: RobotHandle, target: PoseTarget, options?: IkOptions): Promise; + checkReachabilityBatch(handle: RobotHandle, targets: PoseTarget[], options?: IkOptions): Promise; + + makeTrapProfile(length: number, options: TrapProfileOptions): Promise; + sampleTrapProfile(length: number, options: TrapProfileOptions): Promise; + + planMoveJ(handle: RobotHandle, request: MoveJRequest): Promise; + planMoveL(handle: RobotHandle, request: MoveLRequest): Promise; + planMoveC(handle: RobotHandle, request: MoveCRequest): Promise; + + planPath(handle: RobotHandle, request: PathPlanRequest): Promise; + validatePath(handle: RobotHandle, request: PathPlanRequest): Promise; + estimateCycleTime(input: TrajectoryResult | PathPlanResult): Promise; + resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number): Promise; +} +``` + +API 命名使用 `planMoveJ/planMoveL/planMoveC`，避免与 GRL 语句名混淆。GRL 编译器把 `movej/movel/movec` 解析成 IR 后，由虚拟控制器调用这些函数。 + +## 5. 基础数据类型 + +### 5.1 句柄和运行信息 + +```ts +type RobotHandle = number; + +interface KdlRuntimeInfo { + version: string; + kdlVersion?: string; + wasmBuild: string; + supportsThreads: boolean; + supportsWasmFs: boolean; +} +``` + +### 5.2 位姿 + +内部统一使用位置 + 四元数： + +```ts +interface Pose { + position: [number, number, number]; // meter + quaternion: [number, number, number, number]; // x, y, z, w +} + +type PoseLike = + | Pose + | { xyz: [number, number, number]; rpy: [number, number, number] } + | { xyz: [number, number, number]; quat: [number, number, number, number] }; +``` + +GRL 中 `pose(x, y, z, rx, ry, rz)` 由 TypeScript 编译器规范化为 `Pose` 后传给 KDL WASM。 + +### 5.3 目标点 + +```ts +interface PoseTarget { + id?: string; + pose: Pose; + config?: RobotConfiguration; + tool?: Pose; + frame?: Pose; + extAxis?: number[]; + sourceMap?: MotionSourceMap; +} + +interface JointTarget { + id?: string; + joints: number[]; + extAxis?: number[]; + sourceMap?: MotionSourceMap; +} + +interface RobotConfiguration { + shoulder?: -1 | 0 | 1; + elbow?: -1 | 0 | 1; + wrist?: -1 | 0 | 1; + turnNumbers?: number[]; +} +``` + +### 5.4 速度和 zone + +```ts +type SpeedSpec = + | { kind: "joint_percent"; value: number } + | { kind: "joint_abs"; velocity: number; acceleration?: number } + | { kind: "linear"; velocity: number; acceleration?: number; angularVelocity?: number }; + +type ZoneSpec = + | { kind: "fine" } + | { kind: "distance"; value: number } + | { kind: "cnt"; value: number } + | { kind: "continuous" }; +``` + +首版 `zone` 可只用于诊断和后处理，运动规划先按 `fine` 到点执行。P1 阶段再实现连续 blend。 + +### 5.5 诊断 + +```ts +interface MotionDiagnostic { + severity: "info" | "warning" | "error"; + code: string; + message: string; + time?: number; + pointIndex?: number; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + data?: Record; +} + +interface MotionSourceMap { + file?: string; + line?: number; + column?: number; + module?: string; + proc?: string; + pathId?: string; + pathPointId?: string; + operationId?: string; + brandSource?: "abb" | "fanuc" | "kuka" | "grl"; +} +``` + +诊断 code 建议固定： + +| code | 含义 | +| --- | --- | +| `KDL_INVALID_MODEL` | 机器人模型非法 | +| `KDL_TARGET_UNREACHABLE` | 目标不可达 | +| `KDL_IK_FAILED` | IK 求解失败 | +| `KDL_JOINT_LIMIT` | 关节超限 | +| `KDL_VELOCITY_LIMIT` | 速度超限 | +| `KDL_ACCEL_LIMIT` | 加速度超限 | +| `KDL_SINGULARITY` | 接近奇异 | +| `KDL_ARC_DEGENERATE` | 圆弧退化 | +| `KDL_PATH_EMPTY` | 空路径 | +| `KDL_ZONE_APPROXIMATED` | zone 被近似处理 | + +## 6. 机器人模型 API + +### 6.1 URDF 加载 + +```ts +interface UrdfLoadOptions { + robotId: string; + baseLink: string; + tipLink: string; + tool?: Pose; + base?: Pose; + jointOrder?: string[]; + overrideLimits?: JointLimitOverride[]; +} + +interface NormalizedRobotModel { + robotId: string; + name: string; + baseLink: string; + tipLink: string; + links: LinkModel[]; + joints: JointModel[]; + activeJointNames: string[]; + limits: JointLimits[]; + source: { + type: "urdf"; + urdfHash: string; + }; +} +``` + +推荐实现分工： + +1. TypeScript 解析 URDF XML，检查 link/joint 连通性和单位。 +2. TypeScript 生成 `NormalizedRobotModel`。 +3. WASM 根据标准模型构造 KDL `Tree` 和从 `baseLink` 到 `tipLink` 的 `Chain`。 +4. WASM 创建 FK、IK、Jacobian 求解器并绑定到 `RobotHandle`。 + +### 6.2 机器人信息 + +```ts +interface RobotInfo { + handle: RobotHandle; + robotId: string; + name: string; + baseLink: string; + tipLink: string; + jointNames: string[]; + dof: number; + limits: JointLimits[]; +} + +interface JointLimits { + name: string; + lower: number; + upper: number; + velocity: number; + acceleration: number; + jerk?: number; +} +``` + +GRL 编译器在编译 `joint_target` 时应检查数组长度与 `dof` 一致。 + +## 7. 位姿和坐标变换 API + +GRL 中 `tool`、`frame`、`offset`、`offset_in` 都需要位姿变换。虽然 TypeScript 也可实现这些基础变换，但建议 KDL WASM 提供一致的计算函数，避免数值约定不一致。 + +```ts +interface OffsetSpec { + mode: "frame" | "tool" | "world"; + xyz?: [number, number, number]; + rpy?: [number, number, number]; + quaternion?: [number, number, number, number]; +} +``` + +函数要求： + +1. `normalizePose`：把欧拉角或四元数输入规范化。 +2. `composePose`：计算 `a * b`。 +3. `inversePose`：计算位姿逆。 +4. `applyToolAndFrame`：把目标点、工具、工件坐标转换为机器人基坐标下 TCP 目标。 +5. `applyOffset`：实现 GRL `pick offset z 100 mm` 和 `offset_in tool z -50 mm`。 + +## 8. FK、IK、Jacobian API + +### 8.1 正解 FK + +```ts +interface FkOptions { + tool?: Pose; + frame?: Pose; + includeFlange?: boolean; +} + +interface FkResult { + ok: boolean; + flange: Pose; + tcp: Pose; + joints: number[]; + diagnostics: MotionDiagnostic[]; +} +``` + +用途： + +1. 虚拟控制器显示当前 TCP。 +2. `movel/movec` 计算当前 TCP 起点。 +3. 轨迹采样点生成 TCP 位姿。 +4. 3D 机器人 link 位姿显示。 + +### 8.2 全 link 正解 + +```ts +interface LinkPoseResult { + ok: boolean; + linkPoses: Array<{ link: string; pose: Pose }>; + diagnostics: MotionDiagnostic[]; +} +``` + +用途： + +1. 机器人模型显示。 +2. 未来碰撞检测前置数据。 +3. 轨迹回放时显示每个连杆。 + +### 8.3 逆解 IK + +```ts +interface IkOptions { + tool?: Pose; + frame?: Pose; + qMin?: number[]; + qMax?: number[]; + maxIterations?: number; + positionTolerance?: number; + orientationTolerance?: number; + seeds?: number[][]; + preferredConfig?: RobotConfiguration; + allowApproximate?: boolean; +} + +interface IkResult { + ok: boolean; + joints?: number[]; + iterations: number; + residualPosition?: number; + residualOrientation?: number; + configuration?: RobotConfiguration; + reason?: "unreachable" | "joint_limit" | "singularity" | "max_iteration" | "invalid_model"; + diagnostics: MotionDiagnostic[]; +} +``` + +IK 使用规则： + +1. `movej pose_target` 需要 IK 一次，求终点关节。 +2. `movel` 每个 TCP 采样点需要 IK。 +3. `movec` 每个圆弧采样点需要 IK。 +4. `ikBatch` 用于批量路径可达性检查。 +5. 连续轨迹中每个采样点的 seed 使用上一采样点关节，减少姿态跳变。 + +### 8.4 Jacobian 和奇异性 + +```ts +interface JacobianResult { + ok: boolean; + rows: number; + cols: number; + data: Float64Array; + diagnostics: MotionDiagnostic[]; +} + +interface SingularityResult { + ok: boolean; + nearSingularity: boolean; + manipulability?: number; + conditionNumber?: number; + diagnostics: MotionDiagnostic[]; +} +``` + +用途： + +1. 运动前诊断。 +2. MOVEL/MOVEC 采样点奇异性警告。 +3. 可达性报告和路径优化提示。 + +## 9. 梯形速度 API + +GRL 速度和加速度需要转换为轨迹采样的路径参数。P0 阶段实现梯形速度曲线。 + +```ts +interface TrapProfileOptions { + maxVelocity: number; + maxAcceleration: number; + sampleTime: number; + startVelocity?: number; + endVelocity?: number; +} + +interface TrapSample { + index: number; + time: number; + s: number; + sd: number; + sdd: number; +} + +interface TrapProfileResult { + ok: boolean; + type: "trapezoid" | "triangle"; + length: number; + duration: number; + tAccel: number; + tConst: number; + tDecel: number; + vPeak: number; + samples: TrapSample[]; + diagnostics: MotionDiagnostic[]; +} +``` + +规则： + +1. `length` 为路径长度，单位 meter、radian 或归一化长度，由调用方按运动类型决定。 +2. 距离足够长时生成梯形速度曲线。 +3. 距离不足时自动退化为三角速度曲线。 +4. 首末采样点必须严格对应 `s=0` 和 `s=1`。 +5. 所有 `TrajectoryResult` 必须保留实际速度曲线采样，便于节拍报告。 + +## 10. 轨迹数据结构 + +```ts +interface TrajectoryPoint { + index: number; + time: number; + dt: number; + s: number; + sd: number; + sdd: number; + joints: number[]; + jointVelocity: number[]; + jointAcceleration: number[]; + flange: Pose; + tcp: Pose; + tcpVelocity?: [number, number, number, number, number, number]; + tcpAcceleration?: [number, number, number, number, number, number]; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + diagnostics: MotionDiagnostic[]; +} + +interface TrajectoryResult { + ok: boolean; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + duration: number; + sampleTime: number; + points: TrajectoryPoint[]; + events: TrajectoryEvent[]; + diagnostics: MotionDiagnostic[]; + meta?: Record; +} +``` + +轨迹点用于： + +1. 虚拟控制器 Motion Queue。 +2. 3D 仿真回放。 +3. 可达性报告。 +4. 节拍报告。 +5. 轨迹导出和 OPFS trace。 + +## 11. MOVEJ 计算函数 + +### 11.1 请求 + +```ts +interface MoveJRequest { + startJoints: number[]; + target: JointTarget | PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} +``` + +### 11.2 计算语义 + +`planMoveJ` 对应 GRL： + +```text +movej TargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +``` + +算法： + +1. 校验 `startJoints` 长度和关节限位。 +2. 如果 target 是 `joint_target`，直接得到 `qEnd`。 +3. 如果 target 是 `pose_target`，先调用 IK 得到 `qEnd`。 +4. 计算每个关节角度差 `dq[i] = qEnd[i] - qStart[i]`。 +5. 根据关节速度、加速度限制计算同步运动时长。 +6. 生成梯形速度曲线。 +7. 对每个采样点计算关节位置、速度、加速度。 +8. 对每个采样点 FK，输出 TCP。 +9. 检查关节限位、速度、加速度和奇异性。 + +### 11.3 必须返回的诊断 + +1. 目标 IK 失败。 +2. 起点或终点关节超限。 +3. 采样点速度或加速度超限。 +4. 接近奇异点。 +5. `zone` 在 P0 阶段被近似为 fine。 + +## 12. MOVEL 计算函数 + +### 12.1 请求 + +```ts +interface MoveLRequest { + startJoints: number[]; + target: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + orientationMode?: "fixed" | "slerp" | "tool_z_lock"; + ik?: IkOptions; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} +``` + +### 12.2 计算语义 + +`planMoveL` 对应 GRL： + +```text +movel TargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +``` + +算法： + +1. 对 `startJoints` 做 FK，得到起点 TCP。 +2. 将目标点应用 tool/frame/offset，得到终点 TCP。 +3. 计算直线长度。 +4. 使用 `linear` 速度生成梯形速度曲线。 +5. 对每个采样点计算直线位置和姿态插补。 +6. 对每个采样点 IK，seed 使用上一采样点关节。 +7. 检查 IK 连续性、关节限位、速度、加速度、奇异性。 +8. 输出轨迹和 TCP 直线误差。 + +### 12.3 必须返回的诊断 + +1. 目标不可达。 +2. 某个采样点 IK 失败。 +3. TCP 直线误差超过容差。 +4. 姿态误差超过容差。 +5. 关节配置突变。 +6. 速度或加速度超限。 + +## 13. MOVEC 计算函数 + +### 13.1 请求 + +```ts +interface MoveCRequest { + startJoints: number[]; + via: PoseTarget; + target: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sampleTime: number; + orientationMode?: "fixed" | "slerp"; + arcMode?: "via" | "center" | "radius"; + circleDirection?: "short" | "long" | "cw" | "ccw"; + ik?: IkOptions; + speedOverride?: number; + sourceMap?: MotionSourceMap; +} +``` + +### 13.2 计算语义 + +`planMoveC` 对应 GRL： + +```text +movec via ViaTargetExpr target EndTargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +``` + +算法： + +1. 对 `startJoints` 做 FK，得到起点 TCP。 +2. 将 via 和 target 应用 tool/frame/offset。 +3. 检查三点是否重合或共线。 +4. 计算圆心、半径、法向量、圆弧角度和圆弧长度。 +5. 使用 `linear` 速度按圆弧长度生成梯形速度曲线。 +6. 对每个采样点计算圆弧 TCP 位姿。 +7. 对每个采样点 IK，seed 使用上一采样点关节。 +8. 检查圆弧误差、IK 连续性、关节限位、速度、加速度、奇异性。 + +### 13.3 圆弧元数据 + +```ts +interface CirclePlanMeta { + center: [number, number, number]; + radius: number; + normal: [number, number, number]; + angle: number; + length: number; + direction: "cw" | "ccw"; + maxArcError: number; +} +``` + +`TrajectoryResult.meta.circle` 必须包含 `CirclePlanMeta`。 + +### 13.4 必须返回的诊断 + +1. via 或 target 不可达。 +2. 三点重合、近似重合或近似共线。 +3. 半径过小或圆弧长度过短。 +4. 某个采样点 IK 失败。 +5. 圆弧误差超过容差。 +6. 速度或加速度超限。 + +## 14. Path 和 Operation 批量接口 + +### 14.1 Path 请求 + +```ts +interface MotionSegmentRequest { + id: string; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + target?: JointTarget | PoseTarget; + via?: PoseTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool?: Pose; + frame?: Pose; + sourceMap?: MotionSourceMap; +} + +interface PathPlanRequest { + startJoints: number[]; + segments: MotionSegmentRequest[]; + sampleTime: number; + speedOverride?: number; + stopOnError?: boolean; +} +``` + +### 14.2 `planPath` + +`planPath` 用于 `run_path` 展开后的整条路径轨迹生成： + +1. 按 segment 顺序调用 `planMoveJ/planMoveL/planMoveC`。 +2. 每段终点关节作为下一段起点。 +3. 合并所有轨迹点，重新编号和更新时间。 +4. 保留每段 `sourceMap`。 +5. 生成整条路径的总时长。 + +```ts +interface PathPlanResult { + ok: boolean; + duration: number; + segments: TrajectoryResult[]; + points: TrajectoryPoint[]; + diagnostics: MotionDiagnostic[]; +} +``` + +### 14.3 `validatePath` + +`validatePath` 用于离线编程路径验证，不要求必须返回完整轨迹点，可按配置只返回诊断： + +```ts +interface PathValidationResult { + ok: boolean; + reachable: boolean; + cycleTime?: number; + segmentReports: SegmentValidationReport[]; + diagnostics: MotionDiagnostic[]; +} + +interface SegmentValidationReport { + segmentId: string; + ok: boolean; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + duration?: number; + maxJointVelocityRatio?: number; + maxJointAccelerationRatio?: number; + maxCartesianError?: number; + diagnostics: MotionDiagnostic[]; +} +``` + +`run_operation` 不需要 KDL WASM 单独理解工艺，只需要 TypeScript 把 operation 展开为 start action、path、end action。KDL WASM 只处理其中的 motion segment。 + +## 15. 可达性和批量检查 + +### 15.1 单点可达性 + +```ts +interface ReachabilityResult { + ok: boolean; + reachable: boolean; + targetId?: string; + joints?: number[]; + residualPosition?: number; + residualOrientation?: number; + nearestPose?: Pose; + diagnostics: MotionDiagnostic[]; +} +``` + +### 15.2 批量可达性 + +`checkReachabilityBatch` 用于： + +1. Path 编辑器批量目标点检查。 +2. CAD 曲线采样点预检查。 +3. 自动编程生成后快速诊断。 +4. 品牌程序导入后的目标点检查。 + +批量函数必须保持输入顺序，返回结果与输入 target 一一对应。 + +## 16. 节拍估算 + +```ts +interface CycleTimeResult { + ok: boolean; + motionTime: number; + waitTime?: number; + ioTime?: number; + totalTime: number; + segmentTimes: Array<{ + segmentId?: string; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + duration: number; + }>; + diagnostics: MotionDiagnostic[]; +} +``` + +KDL WASM 只估算运动时间。`waitTime`、IO 脚本延迟、工艺设备延迟由虚拟控制器补充。 + +## 17. Worker RPC 协议 + +主线程和 Worker 建议使用统一消息格式： + +```ts +interface KdlRpcRequest { + id: number; + method: keyof KdlWasmApi; + payload: T; +} + +interface KdlRpcResponse { + id: number; + ok: boolean; + result?: T; + error?: { + code: string; + message: string; + diagnostics?: MotionDiagnostic[]; + }; +} +``` + +要求： + +1. 大数组使用 Transferable 或共享内存策略，避免频繁复制。 +2. 每个请求必须有唯一 id。 +3. Worker 崩溃或 WASM 初始化失败时，主线程能恢复并重新初始化。 +4. 对长路径计算提供进度回调或分块计算，避免 Worker 长时间无响应。 + +## 18. C ABI / Embind 暴露建议 + +不建议把 KDL C++ 类完整暴露给 TypeScript。建议底层导出少量稳定函数： + +```cpp +extern "C" { + int kdl_init(const char* options_json); + int kdl_create_robot(const char* model_json); + int kdl_destroy_robot(int robot_handle); + int kdl_get_robot_info(int robot_handle, char* out_json, int out_len); + + int kdl_fk(int robot_handle, const double* joints, int n, double* out_pose7); + int kdl_fk_all_links(int robot_handle, const double* joints, int n, char* out_json, int out_len); + int kdl_jacobian(int robot_handle, const double* joints, int n, double* out_matrix); + int kdl_ik(int robot_handle, const double* seed, int n, const double* target_pose7, const char* options_json, double* out_joints); + + int kdl_plan_movej(int robot_handle, const char* request_json, char* out_json, int out_len); + int kdl_plan_movel(int robot_handle, const char* request_json, char* out_json, int out_len); + int kdl_plan_movec(int robot_handle, const char* request_json, char* out_json, int out_len); + int kdl_plan_path(int robot_handle, const char* request_json, char* out_json, int out_len); + + int kdl_sample_trap(double length, const char* options_json, char* out_json, int out_len); + int kdl_last_error(char* out_json, int out_len); +} +``` + +说明： + +1. P0 可用 JSON 输入输出实现，简单可靠。 +2. 高频 FK/IK 批量计算可增加 TypedArray 版本，减少 JSON 开销。 +3. TypeScript API 层负责把 C ABI 包装成 Promise。 +4. 所有 C ABI 返回 `0` 表示成功，非 `0` 表示错误，错误详情通过 `kdl_last_error` 获取。 + +## 19. 内存和性能要求 + +首版目标： + +1. 单机器人 6 轴模型初始化小于 1 秒。 +2. 单次 FK 小于 1 ms。 +3. 单次 IK 平均小于 10 ms，复杂点允许更长但必须有超时。 +4. 1000 个目标点批量可达性检查可在可接受交互时间内完成。 +5. 10 秒轨迹按 4 ms 采样约 2500 点，必须能稳定生成和回放。 + +实现建议： + +1. `RobotHandle` 内缓存 FK、IK、Jacobian solver。 +2. `ikBatch` 中复用上一点结果作为 seed。 +3. 对长路径分段计算，及时返回进度。 +4. 避免每个采样点跨 Worker 往返，轨迹整段在 Worker 内完成。 +5. 大轨迹 trace 写 OPFS 由 TypeScript 层完成，WASM 不直接管理项目文件。 + +## 20. 错误处理 + +所有 API 不抛裸字符串错误，必须返回结构化错误： + +```ts +interface KdlError { + code: string; + message: string; + diagnostics: MotionDiagnostic[]; +} +``` + +错误分级： + +1. `error`：不能生成可执行轨迹，例如 IK 失败、模型非法。 +2. `warning`：可生成轨迹但存在风险，例如接近限位、zone 被近似。 +3. `info`：辅助信息，例如使用了三角速度曲线。 + +虚拟控制器处理规则： + +1. `error`：进入 alarm 或 hold。 +2. `warning`：允许仿真继续，但报告中必须显示。 +3. `info`：写入 trace 或调试面板。 + +## 21. 与 GRL 的调用关系 + +| GRL 语法 | TypeScript 编译结果 | KDL WASM 函数 | +| --- | --- | --- | +| `target home = joint_target` | `JointTarget` | `checkJointLimits` | +| `target pick = pose_target` | `PoseTarget` | `checkReachability` | +| `pick offset z 100 mm` | `OffsetSpec` | `applyOffset` | +| `movej home` | `MoveJRequest` | `planMoveJ` | +| `movel pick` | `MoveLRequest` | `planMoveL` | +| `movec via mid target end` | `MoveCRequest` | `planMoveC` | +| `run_path pick_path` | `PathPlanRequest` | `planPath` | +| Path 可达性检查 | `PathPlanRequest` | `validatePath` | +| 节拍报告 | `TrajectoryResult/PathPlanResult` | `estimateCycleTime` | + +`if/for/switch/call/wait/io` 不直接调用 KDL WASM，但它们会影响何时调用运动函数和当前运行上下文。 + +### 21.1 不应暴露给 KDL WASM 的 GRL 语义 + +以下 GRL 语义由 TypeScript 虚拟控制器执行，不进入 KDL WASM： + +| GRL 语义 | 执行位置 | 说明 | +| --- | --- | --- | +| `if/elseif/else` | 虚拟控制器 | 判断分支，决定是否执行后续运动 | +| `while/for/switch` | 虚拟控制器 | 控制程序流，可能多次触发运动函数 | +| `proc/func/call/return` | 虚拟控制器 | 调用栈、参数、作用域不属于 KDL | +| `io.do/di/ai/ao` | IO Service | KDL 不管理 IO 状态 | +| `wait/pulse/timer` | 虚拟控制器 + IO Service | KDL 不阻塞等待 IO | +| `alarm/raise/try/catch` | 虚拟控制器 | KDL 只返回诊断，不执行异常流程 | +| `operation.process` | 工艺模块 | KDL 只处理 operation 展开后的 motion segment | + +边界原则：KDL WASM 只接收已经解析好的运动请求，不读取 GRL 源码，不维护程序变量，不执行子程序。 + +## 22. P0 必须暴露的函数 + +P0 阶段必须完成以下函数： + +1. `init` +2. `loadRobotFromUrdf` +3. `createRobotFromModel` +4. `destroyRobot` +5. `getRobotInfo` +6. `getJointLimits` +7. `normalizePose` +8. `composePose` +9. `inversePose` +10. `applyOffset` +11. `applyToolAndFrame` +12. `fk` +13. `fkAllLinks` +14. `jacobian` +15. `ik` +16. `ikBatch` +17. `checkJointLimits` +18. `checkSingularity` +19. `checkReachability` +20. `checkReachabilityBatch` +21. `makeTrapProfile` +22. `sampleTrapProfile` +23. `planMoveJ` +24. `planMoveL` +25. `planMoveC` +26. `planPath` +27. `validatePath` +28. `estimateCycleTime` +29. `resampleTrajectory` + +P1 扩展： + +1. `planBlendPath` +2. `planMoveSpline` +3. `checkCollisionInputPoses`，只提供 link poses，不做碰撞本身。 +4. `optimizeSeedSequence` +5. `compareTrajectory` +6. 外部轴协调相关函数。 + +## 23. 测试要求 + +### 23.1 单元测试 + +1. URDF 到 KDL Chain 的 joint 顺序测试。 +2. FK 与原生 KDL 结果对比。 +3. IK 后再 FK，误差小于容差。 +4. Jacobian 尺寸和数值测试。 +5. 梯形速度曲线长距离/短距离测试。 +6. `applyOffset` 在 frame/tool/world 三种模式下测试。 + +### 23.2 运动测试 + +1. `planMoveJ` 关节同起同停。 +2. `planMoveL` TCP 直线误差小于容差。 +3. `planMoveC` 圆心、半径、弧长和圆弧误差正确。 +4. `planMoveC` 三点共线时返回 `KDL_ARC_DEGENERATE`。 +5. 每种运动都检查速度、加速度、限位和 source map。 + +### 23.3 集成测试 + +1. 从 GRL `movej/movel/movec` 编译为请求并生成轨迹。 +2. 从 GRL `path` 编译为 `PathPlanRequest` 并生成整条路径。 +3. 轨迹写入 OPFS 后重新加载回放。 +4. 长路径批量验证性能测试。 +5. Worker 初始化、崩溃恢复和取消请求测试。 + +## 24. 实施顺序 + +建议按以下顺序开发： + +1. WASM 工程骨架和 Worker RPC。 +2. `NormalizedRobotModel` 到 KDL Chain。 +3. FK、fkAllLinks。 +4. IK、ikBatch。 +5. Jacobian 和奇异性。 +6. 位姿变换和 offset。 +7. 梯形速度曲线。 +8. planMoveJ。 +9. planMoveL。 +10. planMoveC。 +11. planPath、validatePath。 +12. 节拍估算和诊断报告。 +13. 性能优化和 TypedArray 批量接口。 + +## 25. 结论 + +KDL WASM 对 GRL 的定位是“运动学和轨迹计算内核”。它不解释完整机器人程序，也不处理 IO/Wait/流程控制。TypeScript 虚拟控制器负责执行 GRL/IR，当遇到运动相关语义时，把已经解析好的机器人模型、当前关节、目标点、速度、zone、tool、frame 传给 KDL WASM。 + +P0 阶段只要稳定实现 URDF 模型加载、FK/IK/Jacobian、MOVEJ/MOVEL/MOVEC、梯形速度、Path 批量验证和诊断，就可以支撑通用机器人程序的离线编程、虚拟运行、轨迹回放和多品牌后处理。 diff --git a/work/doc/通用机器人离线编程虚拟控制器技术方案.md b/work/doc/通用机器人离线编程虚拟控制器技术方案.md new file mode 100644 index 0000000..f5478c1 --- /dev/null +++ b/work/doc/通用机器人离线编程虚拟控制器技术方案.md @@ -0,0 +1,3578 @@ +# 通用机器人离线编程与虚拟控制器技术方案 + +版本：0.1 +日期：2026-06-26 +目标：为 Web 端离线编程、虚拟调试、通用机器人程序解析、仿真执行和品牌后处理建立技术要求与实现路线。 + +说明：本文中的 FANUC 指发那科机器人品牌。用户原始描述中的 “FUNAC” 按 FANUC 理解。 + +## 1. 项目目标 + +本项目最终目标是实现一套可在 Web 端运行的机器人离线编程与虚拟调试系统： + +1. 定义一种通用机器人程序语言，语法和功能对标 ABB RAPID、FANUC TP/KAREL、KUKA KRL。 +2. 使用 TypeScript 编写虚拟控制器、程序解析器、运行时、后处理框架和 Web 应用逻辑。 +3. 使用 HTML 构建虚拟控制器界面，面向离线编程、运行监控、调试和后处理导出。 +4. 将 Orocos KDL 编译为 WebAssembly，在 TypeScript 中调用 KDL WASM 完成机器人正解、逆解、雅可比、轨迹插补等核心计算。 +5. Web 端文件系统使用 OPFS，支持项目文件、机器人模型、程序、轨迹、日志、后处理输出的本地持久化。 +6. 通过后处理器，将通用机器人程序转换为 ABB、FANUC、KUKA 等品牌机器人程序。 + +系统定位不是简单代码编辑器，而是“虚拟机器人控制器 + 通用程序编译器 + 运动学内核 + 离线调试环境”。 + +## 1.1 商业离线编程软件对标定位 + +主流商业离线编程和虚拟调试软件，例如 ABB RobotStudio、RoboDK、Siemens Process Simulate、Visual Components、DELMIA Robotics 等，通常不是只围绕某一门机器人脚本语言工作，而是围绕“工作站、机器人、工具、坐标系、目标点、路径、工艺操作、仿真执行、后处理输出”建立项目模型。 + +因此，本项目的通用机器人程序不应设计成单纯模仿 ABB RAPID、FANUC TP 或 KUKA KRL 的文本语言，而应设计为商业 OLP 软件常见的双层模型： + +1. 上层是离线编程对象模型 + - Robot：机器人和运动组。 + - Tool：工具、TCP、负载。 + - Frame：工件坐标、夹具坐标、用户坐标。 + - Target：目标点。 + - Path：路径，由目标点序列、工艺参数、速度、过渡、姿态策略组成。 + - Operation：工艺操作，例如搬运、焊接、喷涂、打磨、码垛。 + - Program：程序流程，引用路径和操作。 + - PostProfile：品牌后处理配置。 + +2. 下层是可执行通用程序 + - 使用 GRL 文本语法表达流程逻辑、运动指令、IO 和异常。 + - 由目标点、路径和操作树自动生成。 + - 可由用户手工编辑。 + - 可编译为统一 IR，由虚拟控制器执行。 + - 可后处理为 ABB、FANUC、KUKA 等品牌程序。 + +这样设计有 4 个直接收益： + +1. 方便从 CAD 曲线、示教点、规划路径、工艺模板自动生成通用机器人程序。 +2. 方便把同一个路径用不同品牌后处理器导出，而不丢失路径语义。 +3. 方便虚拟控制器在不依赖真实品牌控制器的情况下执行统一 IR。 +4. 方便导入 ABB、FANUC、KUKA 程序后，反解析为统一 IR 和 OLP 对象模型，进行跨品牌仿真与迁移。 + +## 2. 设计原则 + +1. 通用语言优先，品牌语言兼容 + + 通用程序语言应抽象出工业机器人共同语义：运动、坐标系、工具、目标点、速度、过渡、IO、变量、流程控制、子程序、异常、任务和中断。ABB、FANUC、KUKA 的差异通过品牌配置和后处理器处理。 + + 语法风格应贴近商业离线编程软件导出的“中性机器人程序”：清晰的运动语句、稳定的目标点引用、显式速度/过渡/工具/坐标系参数、可读的流程结构。不要把通用语言设计得过度像某一家品牌的控制器语言。 + +2. 运行语义可解释、可调试 + + 程序不能只做文本转换，必须先解析为 AST，再生成统一 IR，由虚拟控制器执行。这样才能支持断点、单步、暂停、恢复、变量监控、运动队列检查、报警追踪和路径回放。 + +3. 运动学内核独立 + + TypeScript 负责业务调度、程序解释、仿真状态和 UI；KDL WASM 负责高性能数值计算。二者通过稳定 API 交互，避免把 C++ 对象模型直接泄漏到业务层。 + +4. Web 本地优先 + + 项目数据默认存储在 OPFS 中，不依赖服务器。需要提供导入、导出、备份、版本迁移和项目压缩包交换能力。 + +5. 可扩展到多品牌、多机器人、多工艺 + + 初期支持 6 轴串联工业机器人。架构上预留外部轴、变位机、导轨、多机器人、多任务、焊接、搬运、码垛、视觉偏移等扩展点。 + +6. 安全边界明确 + + 虚拟控制器用于离线编程与虚拟调试，不能直接替代真实控制器的安全功能。导出的品牌程序必须经过真实控制器校验、现场低速试运行和安全确认。 + +7. 路径对象优先 + + 商业 OLP 软件的核心不是单条 `MoveL`，而是可管理、可重算、可后处理的 Path 和 Operation。GRL 必须允许程序引用路径对象，也必须允许路径展开为显式运动指令。 + +8. 导入和导出同等重要 + + 虚拟控制器不仅要执行 GRL，也要能够解析主流品牌程序的可读文本形态，并转换为统一 IR。这样才能服务已有产线程序的虚拟调试、迁移和改造。 + +## 2.1 商业 OLP 的典型工作流 + +系统应支持以下典型工作流： + +1. 新建工作站 + - 选择机器人模型。 + - 定义工具 TCP。 + - 定义工件坐标系。 + - 配置 IO 和后处理 profile。 + +2. 创建目标点 + - 手动输入关节或笛卡尔位姿。 + - 通过虚拟示教器 jog 生成点。 + - 从 CAD 点、曲线、边界、孔位、焊缝导入点。 + - 从已有品牌程序反解析目标点。 + +3. 创建路径 + - 选择目标点序列。 + - 设置默认运动类型、速度、过渡、工具、坐标系。 + - 设置姿态保持、法向跟随、切向跟随、固定姿态等姿态策略。 + - 自动检查可达性、关节限位、奇异点和路径连续性。 + +4. 创建操作 + - 搬运操作：接近、抓取、抬起、移动、放置、退出。 + - 焊接操作：引弧、焊接路径、收弧、清枪。 + - 喷涂操作：开喷、路径、关喷、重叠检查。 + - 打磨操作：接触、恒速路径、退出。 + +5. 生成 GRL 程序 + - 根据路径和操作模板自动生成程序。 + - 用户可查看和编辑 GRL。 + - 程序可重新编译为 IR。 + +6. 虚拟调试 + - 单步执行。 + - 断点。 + - IO 仿真。 + - 轨迹回放。 + - 检查报警、奇异点、越限、不可达点。 + +7. 后处理导出 + - 选择 ABB、FANUC、KUKA 等品牌。 + - 生成品牌程序和数据文件。 + - 生成转换报告。 + +8. 品牌程序导入 + - 导入 ABB RAPID、KUKA KRL、FANUC LS 等可读文本。 + - 解析为 Brand AST。 + - 转换为统一 IR 和 GRL。 + - 尽量恢复目标点、路径和操作结构。 + +## 2.2 商业级 OLP 能力矩阵 + +对标成熟离线编程商业软件，本项目应把能力分为“基础可用、商业可交付、产线级虚拟调试”三个层次。 + +| 能力域 | 基础可用 | 商业可交付 | 产线级虚拟调试 | +| --- | --- | --- | --- | +| 工作站建模 | 单机器人、工具、工件坐标 | 机器人库、工具库、夹具、输送线、工件、工位布局 | 多机器人、多工位、外部轴、PLC/HMI/安全设备 | +| 程序生成 | 手写 GRL、目标点运动 | Path/Operation 自动生成程序 | 从 CAD/工艺数据批量生成并版本化 | +| 机器人运动 | FK/IK、MoveJ/MoveL/MoveC | 可达性、关节限位、奇异点、姿态策略 | 品牌近似轨迹、节拍优化、外部轴协调 | +| 仿真验证 | 轨迹回放 | 碰撞检测、干涉区、工艺事件、IO trace | 真实 PLC/虚拟 PLC 联调、设备顺序验证 | +| 后处理 | ABB/FANUC/KUKA 文本输出 | 可配置 post profile、转换报告、品牌数据文件 | 程序上传/下载、品牌语义回读、现场差异追踪 | +| 调试 | 运行、暂停、单步、报警 | 断点、变量 watch、IO 面板、Wait 诊断 | 多任务、多设备、时间线、产线事件回放 | +| 数据管理 | OPFS 保存 | 项目包、资源库、模板、版本迁移 | 团队协作、权限、审阅、发布基线 | +| Sim-to-Real | 离线轨迹 | TCP/工件坐标标定、基准点偏差补偿 | 现场回传校准、程序差异比对、闭环修正 | + +商业级产品的关键不是“能生成几行机器人代码”，而是能形成完整闭环： + +```text +导入资源 -> 建站 -> 生成路径 -> 仿真验证 -> 虚拟调试 -> 后处理 -> 现场校准 -> 回读修正 +``` + +## 2.3 商业级对象模型 + +现有 OLP Object Model 需要进一步扩展为商业软件常见的工作站资源模型： + +```text +Station + Cell + RobotGroup + Robot + ExternalAxis + Tool + BaseFrame + Fixture + Part + Conveyor + SafetyZone + InterferenceZone + ProcessResource + Programs + GRL Program + Imported Brand Program + Generated Brand Program + Planning + Targets + Paths + Operations + ProcessTemplates + Validation + CollisionSets + ReachabilityReports + CycleTimeReports + IOTrace + SimulationTrace +``` + +核心对象说明： + +| 对象 | 说明 | +| --- | --- | +| `Station` | 一个完整离线编程项目，对应商业软件中的 station/cell/study | +| `Cell` | 工作站布局，包含机器人、工装、设备、工件 | +| `RobotGroup` | 机器人运动组，未来支持机器人 + 外部轴 | +| `Fixture` | 夹具或工装，带 IO 和运动状态 | +| `Part` | 工件模型、工艺曲线、孔位、焊缝、喷涂区域 | +| `Conveyor` | 输送线或变位输送设备 | +| `SafetyZone` | 安全区域、禁入区域、软限位区域 | +| `InterferenceZone` | 干涉区，用于多机器人互锁或等待 | +| `ProcessTemplate` | 搬运、焊接、喷涂、涂胶、打磨等工艺模板 | +| `ValidationReport` | 碰撞、可达性、节拍、IO、后处理报告 | + +## 2.4 商业级功能模块 + +### 2.4.1 机器人与资源库 + +需要建立资源库机制，类似商业软件的机器人库、工具库、夹具库： + +1. 机器人库 + - 品牌、型号、负载、臂展、轴数。 + - DH/URDF/自定义运动学参数。 + - 关节限位、速度、加速度。 + - 默认 tool/base。 + - 品牌后处理 profile。 + +2. 工具库 + - TCP。 + - 负载。 + - 3D 模型。 + - 工艺类型，例如夹爪、焊枪、喷枪、主轴。 + - IO 接口，例如夹紧、松开、到位反馈。 + +3. 工装与设备库 + - 夹具状态。 + - 运动机构。 + - IO 行为脚本。 + - 碰撞几何。 + +4. 工艺模板库 + - Pick and place。 + - Arc welding。 + - Spot welding。 + - Gluing/dispensing。 + - Painting/spraying。 + - Grinding/polishing。 + - Machining。 + +### 2.4.2 CAD 与几何导入 + +商业 OLP 软件通常围绕 CAD/几何创建路径。本项目应预留以下能力： + +1. 导入格式 + - MVP：OBJ、STL、glTF。 + - 商业级：STEP、IGES、JT、3DXML 等可通过插件或服务端转换支持。 + +2. 几何提取 + - 点。 + - 边。 + - 曲线。 + - 面法向。 + - 孔位。 + - 焊缝。 + - 喷涂区域边界。 + +3. 路径生成 + - 曲线采样。 + - 等距采样。 + - 面法向姿态。 + - 切向姿态。 + - 路径平滑。 + - 接近/离开路径。 + - 自动避让偏移。 + +4. 数据保留 + - 每个 Path 应保留 CAD source ID。 + - 每个 Target 应保留来源曲线、采样序号、法向、切向。 + - CAD 更新后应能重建路径并保留用户覆盖参数。 + +### 2.4.3 可达性、碰撞和干涉验证 + +商业 OLP 的核心价值是提前发现问题。系统应设计以下验证层： + +1. 可达性检查 + - IK 是否有解。 + - 是否有多解。 + - 是否符合配置约束。 + - 是否接近关节限位。 + - 是否接近奇异点。 + +2. 碰撞检测 + - 机器人自身碰撞。 + - 机器人与工件碰撞。 + - 工具与夹具碰撞。 + - 工件搬运过程碰撞。 + - 多机器人碰撞。 + +3. 干涉区 + - 定义区域。 + - 机器人进入/离开事件。 + - 与 IO/互锁结合。 + - 多机器人共享区域互锁。 + +4. 节拍分析 + - 单路径时间。 + - 单 Operation 时间。 + - 程序总周期。 + - wait 消耗时间。 + - IO/PLC 响应时间。 + - 瓶颈识别。 + +MVP 可以先做可达性、限位、奇异点和基础包围盒碰撞；商业级再做网格级碰撞、 swept volume、干涉区和节拍优化。 + +### 2.4.4 虚拟调试与虚拟调试联调 + +商业虚拟调试通常不仅运行机器人程序，还验证 PLC、HMI、夹具、输送线和安全逻辑。Web 版本可分阶段实现： + +1. 内置逻辑仿真 + - IO 脚本。 + - 设备状态机。 + - 夹具/输送线/传感器仿真。 + +2. 外部协议联调 + - OPC UA。 + - MQTT。 + - WebSocket bridge。 + - 后续扩展 Modbus TCP、EtherNet/IP、Profinet 网关。 + +3. PLC 联调 + - 初期通过 WebSocket/OPC UA 接入外部模拟 PLC。 + - 商业级支持真实 PLC 或虚拟 PLC 的信号映射。 + - 所有外部信号进入统一 IO Service。 + +4. 时间线调试 + - Robot motion timeline。 + - IO timeline。 + - Wait timeline。 + - PLC event timeline。 + - Alarm timeline。 + +### 2.4.5 校准与 Sim-to-Real + +商业离线编程必须考虑仿真到现场的偏差： + +1. TCP 校准 + - 记录理论 TCP。 + - 支持现场测量 TCP 回填。 + - 对路径重新计算。 + +2. 工件坐标校准 + - 三点法/多点法。 + - 基准点拟合。 + - 工件偏移应用到 Path。 + +3. 机器人基座校准 + - 机器人相对工作站的位置修正。 + - 多机器人之间的基准统一。 + +4. 程序回读 + - 从现场控制器导回品牌程序。 + - 与离线版本比对。 + - 识别现场修改。 + +5. 补偿报告 + - TCP 偏差。 + - Frame 偏差。 + - Target 偏差。 + - 程序差异。 + +### 2.4.6 商业级报告 + +每次仿真和导出应能生成报告： + +| 报告 | 内容 | +| --- | --- | +| Reachability Report | 不可达点、接近限位点、IK 解 | +| Collision Report | 碰撞对象、时间、路径点、严重程度 | +| Cycle Time Report | 总节拍、路径节拍、wait 时间、瓶颈 | +| IO Report | IO 映射、wait、pulse、脚本触发 | +| Post Report | 品牌映射、近似处理、不支持项 | +| Calibration Report | TCP、Frame、Base 偏差 | +| Import Report | 品牌程序导入结果、丢失语义、恢复对象 | + +报告应可导出为 JSON 和 HTML。后续可增加 PDF。 + +## 3. 总体架构 + +系统分为 8 个核心层： + +```text +HTML UI + | +TypeScript App Shell + | +Project Service / OPFS Workspace + | +Program Parser / Semantic Analyzer / IR Compiler + | +Virtual Controller Runtime + | +Motion Planner / KDL WASM Adapter + | +Robot Model / Scene Model / IO Model + | +Post Processor: ABB RAPID / FANUC / KUKA KRL +``` + +### 3.1 主要模块 + +| 模块 | 职责 | 建议实现 | +| --- | --- | --- | +| UI Shell | 页面布局、编辑器、虚拟示教器、监控面板 | HTML + TypeScript | +| Workspace | 项目文件、索引、版本、导入导出 | OPFS + TypeScript | +| Station Model | 工作站、机器人、工具、工装、工件、设备对象 | TypeScript | +| Resource Library | 机器人库、工具库、夹具库、工艺模板库 | JSON + OPFS | +| Geometry Service | 几何导入、路径采样、碰撞几何 | TypeScript + Worker | +| Parser | 通用程序词法、语法解析 | TypeScript grammar-first parser | +| Semantic Analyzer | 类型检查、符号表、坐标系和目标点检查 | TypeScript | +| IR Compiler | AST 转可执行中间表示 | TypeScript | +| Virtual Controller | 程序执行、任务状态、变量、IO、报警、调试 | TypeScript | +| Motion Engine | 运动队列、插补、速度规划、过渡处理 | TypeScript + KDL WASM | +| KDL WASM Adapter | 正解、逆解、雅可比、轨迹基础计算 | C++ KDL 编译 WASM，TS 封装 | +| Validation Engine | 可达性、限位、奇异点、碰撞、节拍验证 | TypeScript + Worker | +| Post Processor | 通用 IR 转品牌程序 | TypeScript | +| Report Engine | 可达性、碰撞、节拍、IO、后处理报告 | TypeScript | +| Test Harness | 语法、语义、运动、后处理一致性测试 | TypeScript test runner | + +### 3.2 推荐线程模型 + +Web 主线程只负责 UI 交互和轻量状态更新。以下模块建议放入 Web Worker： + +1. KDL WASM 计算。 +2. 程序解析和语义检查。 +3. 长程序的虚拟执行和轨迹预计算。 +4. OPFS 大文件读写，尤其是使用同步访问句柄时。 +5. 碰撞检测和几何采样。 +6. 长路径节拍分析和报告生成。 + +推荐结构： + +```text +Main Thread + - UI + - editor + - controller panel + +Parser Worker + - tokenize + - parse + - semantic check + - diagnostics + +Controller Worker + - interpreter + - execution clock + - variable state + - IO simulation + - motion queue + +KDL Worker + - wasm initialization + - FK/IK/Jacobian + - trajectory sampling + +Storage Worker + - OPFS read/write + - project snapshot + - import/export +``` + +## 4. 技术要求 + +### 4.1 语言与平台 + +1. 虚拟控制器核心使用 TypeScript。 +2. Web 界面使用 HTML，样式可使用 CSS，交互逻辑使用 TypeScript。 +3. KDL 使用 C++ 编译为 WebAssembly，通过 TypeScript 调用。 +4. 项目文件使用 OPFS 持久化。 +5. 系统应能在现代 Chromium 系浏览器中稳定运行，后续再验证 Firefox、Safari 的兼容性。 + +### 4.2 数值与单位 + +系统内部统一单位： + +| 类型 | 内部单位 | +| --- | --- | +| 长度 | meter | +| 角度 | radian | +| 线速度 | meter/second | +| 角速度 | radian/second | +| 时间 | second | +| 质量 | kilogram | + +UI 和程序语言可以支持 `mm`、`deg`、`m/s`、`mm/s` 等显示和输入单位，但进入 IR 和 KDL 前必须规范化。 + +### 4.3 实时性要求 + +这是 Web 虚拟控制器，不追求真实伺服周期实时性，但需要可重复、可暂停、可回放： + +1. 仿真逻辑周期建议默认 `4 ms` 或 `8 ms`，可配置。 +2. UI 刷新周期不应绑定仿真周期，建议 `requestAnimationFrame` 渲染。 +3. 运动轨迹采样应支持固定步长采样，例如 `4 ms`、`8 ms`、`12 ms`。 +4. 同一输入项目、同一版本算法，应产生可重复的轨迹结果。 + +### 4.4 浏览器存储要求 + +1. 项目默认保存在 OPFS。 +2. 支持导入导出 zip 项目包。 +3. 支持自动保存、手动保存、快照、恢复。 +4. 存储结构必须有 schema version，便于后续迁移。 +5. 不能只依赖浏览器缓存，必须提供用户可导出的备份文件。 + +### 4.5 可测试性要求 + +1. 解析器必须有语法快照测试。 +2. 语义分析必须有错误诊断测试。 +3. 运动学必须有数值回归测试。 +4. 后处理必须有 golden file 测试。 +5. 虚拟控制器必须有程序执行状态机测试。 + +## 5. 通用机器人程序语言设计 + +通用机器人程序语言暂定名为 GRL，Generic Robot Language。名称可后续调整。 + +GRL 的目标不是复制某一家品牌语法，而是建立一个稳定的中间语言，能覆盖 ABB、FANUC、KUKA 的共同能力，并保留品牌扩展元数据。 + +### 5.1 对标对象 + +| 能力 | ABB RAPID | FANUC TP/KAREL | KUKA KRL | GRL 对应设计 | +| --- | --- | --- | --- | --- | +| 程序组织 | `MODULE`、`PROC`、`FUNC`、`TRAP` | TP 程序、`CALL`、标签；KAREL 程序 | `.src/.dat`、`DEF`、函数、数据文件 | `module`、`proc`、`func`、`trap` | +| 关节运动 | `MoveJ` | `J P[...]` | `PTP` | `movej` | +| 直线运动 | `MoveL` | `L P[...]` | `LIN` | `movel` | +| 圆弧运动 | `MoveC` | `C P[...]` | `CIRC` | `movec` | +| 目标点 | `robtarget`、`jointtarget` | `P[]`、`PR[]` | `E6POS`、`E6AXIS` | `PoseTarget`、`JointTarget` | +| 工具 | `tooldata` | Tool Frame / UTOOL | `$TOOL` | `Tool` | +| 工件/基坐标 | `wobjdata` | User Frame / UFRAME | `$BASE` | `Frame` | +| 速度 | `speeddata` | 百分比、`mm/sec` 等 | `$VEL`、`$ACC` | `Speed` | +| 过渡 | `zonedata`、`fine` | `FINE`、`CNT` | `C_DIS`、`C_PTP`、`APO` | `Zone` | +| IO | `SetDO`、`WaitDI` | `DO[]`、`DI[]`、`WAIT` | `$OUT[]`、`$IN[]`、`WAIT FOR` | `io.write`、`wait` | +| 条件 | `IF`、`TEST` | `IF`、`SELECT`、`LBL/JMP` | `IF`、`SWITCH`、`LOOP` | `if`、`switch`、`while`、`for`、`label` | +| 中断 | `TRAP`、interrupt | 条件监控和后台逻辑 | `INTERRUPT`、`BRAKE`、`RESUME` | `interrupt`、`trap` | +| 错误处理 | `ERROR`、`RAISE`、`UNDO` | Alarm、异常处理依版本而异 | `HALT`、`RESUME`、消息/中断 | `try`、`catch`、`raise`、`alarm` | + +### 5.1.1 对标商业 OLP 的中性程序风格 + +商业 OLP 软件生成程序时，一般具有以下特征： + +1. 目标点和运动语句分离 + + 目标点作为数据保存，程序中通过名称或编号引用。这样便于点位重算、批量修改、路径优化和后处理。 + +2. 路径和程序流程分离 + + 路径是可编辑对象，程序流程负责调用路径、控制 IO、处理条件。这样便于从 CAD 曲线、规划点、示教点生成路径，再自动生成程序。 + +3. 运动参数显式 + + 每条运动或路径段都能明确给出运动类型、速度、过渡、工具、坐标系。默认值可存在，但展开到 IR 时必须解析为确定值。 + +4. 工艺语义保留 + + 焊接、喷涂、打磨、搬运等不应只变成一串 MoveL。通用程序需要保留 operation 类型、工艺参数和路径引用，后处理器才能生成品牌特定工艺指令或注释。 + +5. 可展开、可回写 + + `run_path weld_path` 可以展开为多条 `movel`/`movec`，也可以后处理为品牌程序。反过来，导入品牌程序时也应尽量恢复为 `path` 和 `target`。 + +因此，GRL 应同时支持两种写法： + +1. 面向人类调试的显式运动语句。 +2. 面向自动规划和后处理的路径/操作对象语句。 + +### 5.2 程序工程结构 + +推荐一个项目包含如下文件： + +```text +project.json +robots/ + robot_1.robot.json + tool_gripper.tool.json + frame_fixture.frame.json +programs/ + main.grl + weld.grl +targets/ + main.targets.json +paths/ + weld_path.path.json +operations/ + op_pick_place.operation.json +io/ + io_map.json +post/ + abb.profile.json + fanuc.profile.json + kuka.profile.json +generated/ + abb/ + fanuc/ + kuka/ +logs/ + controller.log + simulation.trace.jsonl +``` + +### 5.3 GRL 文件结构 + +示例： + +```text +module Main + + persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 180 mm, 0 deg, 0 deg, 0 deg), + mass: 2.5 kg + } + + persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 200 mm, 0 deg, 0 deg, 0 deg) + } + + target home = joint_target { + joints: [0 deg, -30 deg, 60 deg, 0 deg, 60 deg, 0 deg] + } + + target pick = pose_target { + pose: pose(500 mm, 120 mm, 300 mm, 180 deg, 0 deg, 90 deg), + config: robot_config(0, 0, 1), + tool: gripper, + frame: fixture + } + + path pick_path { + defaults { + tool: gripper, + frame: fixture, + speed: linear(300 mm/s), + zone: z10 + } + + point approach movej target home speed joint(50%) zone fine + point p1 movel target pick offset z 100 mm + point p2 movel target pick zone fine + } + + operation pick_place { + kind: handling + path: pick_path + before p2: + io.do[1] = true + after p2: + wait io.di[1] == true timeout 2 s + } + + proc main() + set_tool gripper + set_frame fixture + + run_path pick_path + + wait io.di[1] == true timeout 2 s + io.do[2] = true + + call place() + end + + proc place() + var pose_target p2 = pick offset z 100 mm + movel p2 speed linear(200 mm/s) zone fine + end + +end +``` + +该示例体现两种程序形态： + +1. `path pick_path` 适合由规划点、CAD 曲线、工艺模板自动生成。 +2. `proc main()` 适合虚拟调试和流程控制。 + +### 5.4 顶层语法要求 + +GRL 至少支持以下顶层结构： + +1. `module`：程序模块。 +2. `import`：导入其他模块。 +3. `persistent`：持久变量，类似 ABB `PERS`、KUKA `.dat` 中的持久数据、FANUC 寄存器/位置数据。 +4. `const`：常量。 +5. `var`：局部变量。 +6. `target`：目标点。 +7. `proc`：无返回值过程。 +8. `func`：有返回值函数。 +9. `trap`：中断处理例程。 +10. `task`：多任务或后台任务定义，初期可只设计语义，不立即完整实现。 +11. `path`：路径对象，由路径点、运动类型、姿态策略和工艺参数组成。 +12. `operation`：工艺操作对象，引用 path 并绑定工艺行为。 +13. `post_hint`：后处理提示，用于声明品牌输出偏好。 + +### 5.4.1 Path 语法 + +路径对象用于承载规划点和规划路径，是连接“自动路径规划”和“机器人程序生成”的核心结构。 + +```text +path weld_seam_01 { + defaults { + tool: weld_gun, + frame: part_frame, + speed: linear(120 mm/s), + zone: z5, + posture: follow_tangent, + blend: continuous + } + + point p_start movej target t_start speed joint(30%) zone fine + point p001 movel target t001 + point p002 movel target t002 + point p003 movec via t_mid target t003 + event before p001 io.do[10] = true + event after p003 io.do[10] = false +} +``` + +Path 语法要求： + +1. 每个 `path` 有唯一名称。 +2. `defaults` 定义默认工具、坐标系、速度、过渡、姿态策略。 +3. `point` 定义路径点，可引用已有 target，也可内联 pose。 +4. `event before/after` 用于绑定路径点附近的 IO 或工艺动作。 +5. Path 可以在程序中通过 `run_path` 执行。 +6. Path 可以在编译阶段展开为运动 IR。 +7. Path 可以在后处理阶段展开为品牌运动指令和数据点。 + +### 5.4.2 Operation 语法 + +Operation 表达工艺语义，比 path 更高一层： + +```text +operation weld_op_01 { + kind: arc_welding + path: weld_seam_01 + process { + weld_id: "WELD_1" + voltage: 24.0 + current: 180.0 + weave: none + } + start_action: + io.do[20] = true + end_action: + io.do[20] = false +} +``` + +Operation 用途： + +1. 保存工艺参数。 +2. 驱动仿真时的工艺状态显示。 +3. 生成品牌程序时映射到对应品牌的工艺包、IO 或注释。 +4. 支持未来工艺库扩展。 + +首版 Operation 类型： + +| 类型 | 用途 | +| --- | --- | +| `handling` | 搬运、上下料、抓取放置 | +| `arc_welding` | 弧焊 | +| `spot_welding` | 点焊 | +| `dispensing` | 涂胶 | +| `spraying` | 喷涂 | +| `grinding` | 打磨 | +| `generic_path` | 通用路径 | + +### 5.4.3 自动路径生成到 GRL 的要求 + +从规划点和规划路径生成 GRL 时，应遵循以下规则： + +1. 每个规划点生成稳定 target 名称，例如 `P001`、`P002`，或基于工艺语义命名。 +2. 路径整体生成 `path` 对象，而不是直接散落在 `proc main()` 中。 +3. 路径默认参数写入 `defaults`，单点差异写在对应 `point` 上。 +4. 接近点、离开点、工艺开始点、工艺结束点必须明确标注。 +5. IO、焊接开关、夹爪动作等应生成 `event before/after` 或 Operation action。 +6. 若路径来自 CAD 曲线，应保留来源引用，例如曲线 ID、采样距离、法向策略。 +7. 编译器应能把 path 展开为确定的运动 IR，保证虚拟控制器不依赖 UI 对象也能运行。 + +示例： + +```text +path curve_032_generated { + source { + type: cad_curve + id: "edge_032" + sample_distance: 5 mm + normal_strategy: surface_normal + } + defaults { + tool: spray_gun + frame: part_frame + speed: linear(500 mm/s) + zone: z20 + posture: follow_normal + } + point p000 movel target T_curve_032_000 zone fine + point p001 movel target T_curve_032_001 + point p002 movel target T_curve_032_002 +} +``` + +### 5.4.4 `run_path` 和 `run_operation` + +程序流程中建议优先调用路径或操作： + +```text +proc main() + run_operation weld_op_01 + run_path retract_path +end +``` + +编译语义： + +1. `run_path path_name` 展开为 path 中的 point 和 event。 +2. `run_operation op_name` 展开为 start action、path、end action。 +3. 展开后的 IR 保留 source mapping，调试时仍能定位到 path 点和 operation。 +4. 后处理器可选择直接展开，也可以按品牌能力生成更紧凑的结构。 + +### 5.4.5 显式运动和路径调用的关系 + +GRL 同时允许： + +```text +movel pick speed linear(300 mm/s) zone z10 +run_path pick_path +``` + +约束： + +1. 手写程序、调试程序、短逻辑程序可直接写 `movej/movel/movec`。 +2. 自动规划、CAD-to-path、批量目标点应生成 `path`。 +3. 后处理器对两者生成的品牌运动语句应一致。 +4. 虚拟控制器执行时二者最终都进入同一 Motion IR。 + +### 5.5 类型系统 + +基础类型： + +| 类型 | 说明 | +| --- | --- | +| `bool` | 布尔 | +| `int` | 整数 | +| `real` | 浮点数 | +| `string` | 字符串 | +| `time` | 时间 | +| `length` | 长度 | +| `angle` | 角度 | + +机器人类型： + +| 类型 | 说明 | +| --- | --- | +| `Pose` | 位置和姿态 | +| `JointArray` | 关节角数组 | +| `PoseTarget` | 笛卡尔目标点 | +| `JointTarget` | 关节目标点 | +| `Tool` | 工具数据 | +| `Frame` | 基坐标/工件坐标 | +| `Speed` | 速度数据 | +| `Zone` | 过渡/逼近数据 | +| `Load` | 负载数据 | +| `RobotConfig` | 姿态配置，如肩、肘、腕配置 | +| `ExtAxis` | 外部轴数据 | +| `Path` | 路径对象 | +| `PathPoint` | 路径点 | +| `Operation` | 工艺操作 | +| `ProcessParam` | 工艺参数 | + +### 5.6 运动指令 + +必须支持： + +```text +movej target speed Speed zone Zone [tool Tool] [frame Frame] +movel target speed Speed zone Zone [tool Tool] [frame Frame] +movec via target speed Speed zone Zone [tool Tool] [frame Frame] +stop_motion +hold +resume +run_path path_name +run_operation operation_name +``` + +运动语义要求： + +1. `movej` 表示关节空间运动：机器人按各轴关节角度差分运行，关节同起同停，TCP 轨迹不要求是直线。 +2. `movel` 表示 TCP 直线运动：TCP 沿起点到终点的空间直线运行，关节角由每个采样点 IK 求解。 +3. `movec` 表示 TCP 圆弧运动：TCP 经过 via 点并沿圆弧运行，关节角由每个圆弧采样点 IK 求解。 +4. `zone fine` 表示精确到点，不做过渡。 +5. `zone z10` 表示允许在目标点附近按半径或品牌等价参数过渡。 +6. 每条运动必须绑定当前 `tool`、当前 `frame`、速度、过渡方式。 +7. 如果目标点本身指定了 `tool` 或 `frame`，需要定义优先级。建议：指令显式参数最高，其次目标点属性，最后控制器当前状态。 + +### 5.7 逻辑与流程控制 + +必须支持： + +```text +if condition + ... +elseif condition + ... +else + ... +end + +while condition + ... +end + +for i = 0 to 10 + ... +end + +switch value + case 1 + ... + default + ... +end + +label retry +jump retry +call sub() +return +``` + +FANUC TP 程序常见标签跳转模型必须能映射到 GRL，但 GRL 新程序建议优先使用结构化控制流。 + +### 5.8 IO 与等待 + +示例： + +```text +io.do[1] = true +io.go[1] = 16 +wait io.di[1] == true +wait io.ai[2] > 3.5 timeout 1.5 s +pulse io.do[3] duration 200 ms +wait rising(io.di[4]) timeout 5 s +wait all(io.di[1] == true, io.di[2] == false) +wait any(io.di[10] == true, timer.done("T_PICK")) +``` + +要求： + +1. 支持 DI、DO、AI、AO、GI、GO。 +2. 支持别名，例如 `clamp_closed` 映射到 `di[5]`。 +3. 支持等待超时。 +4. 支持虚拟 IO 脚本和手动面板输入。 +5. 后处理时映射到 ABB、FANUC、KUKA 对应 IO 表达。 + +### 5.8.1 IO 点类型 + +通用 IO 类型： + +| 类型 | 说明 | 常见品牌映射 | +| --- | --- | --- | +| `DI` | 数字输入 | ABB `DI`、FANUC `DI[]`、KUKA `$IN[]` | +| `DO` | 数字输出 | ABB `DO`、FANUC `DO[]`、KUKA `$OUT[]` | +| `AI` | 模拟输入 | ABB `AI`、FANUC `AI[]`、KUKA analog input | +| `AO` | 模拟输出 | ABB `AO`、FANUC `AO[]`、KUKA analog output | +| `GI` | 组输入，整数 | FANUC `GI[]`、品牌寄存器组合 | +| `GO` | 组输出，整数 | FANUC `GO[]`、品牌寄存器组合 | +| `RI` | 机器人输入，可选 | FANUC `RI[]`，初期可映射为 DI | +| `RO` | 机器人输出，可选 | FANUC `RO[]`，初期可映射为 DO | + +推荐 GRL IO 访问形式： + +```text +io.di[1] +io.do[2] +io.ai[1] +io.ao[1] +io.gi[1] +io.go[1] +io.alias.clamp_closed +``` + +其中 `io.alias.xxx` 由 IO map 映射到实际点位，便于后处理和跨品牌迁移。 + +### 5.8.2 IO 映射文件 + +项目应包含 `io/io_map.json`： + +```json +{ + "schemaVersion": 1, + "signals": [ + { + "name": "clamp_close_cmd", + "type": "DO", + "index": 1, + "initial": false, + "description": "Close clamp command", + "brand": { + "abb": "doClampClose", + "fanuc": "DO[1]", + "kuka": "$OUT[1]" + } + }, + { + "name": "clamp_closed", + "type": "DI", + "index": 1, + "initial": false, + "description": "Clamp closed sensor", + "brand": { + "abb": "diClampClosed", + "fanuc": "DI[1]", + "kuka": "$IN[1]" + } + } + ], + "groups": [ + { + "name": "part_id", + "type": "GI", + "index": 1, + "bits": ["DI[10]", "DI[11]", "DI[12]", "DI[13]"], + "initial": 0 + } + ] +} +``` + +要求： + +1. `name` 在项目内唯一。 +2. `type + index` 组合唯一。 +3. `initial` 定义仿真启动默认值。 +4. `brand` 定义后处理映射。 +5. `groups` 定义组信号与 bit 信号的关系。 + +### 5.8.3 Wait 语义 + +`wait` 是虚拟调试的关键指令，必须可暂停、可恢复、可超时、可诊断。 + +语法： + +```text +wait condition [timeout duration] [on_timeout label_or_proc] +``` + +示例： + +```text +wait io.di[1] == true +wait io.alias.clamp_closed == true timeout 2 s +wait io.ai[1] >= 3.5 timeout 500 ms on_timeout clamp_timeout +wait rising(io.di[4]) timeout 5 s +wait falling(io.di[5]) +wait changed(io.gi[1]) +wait all(io.di[1], !io.di[2], io.gi[1] == 7) +wait any(io.di[10], io.di[11]) +``` + +执行要求： + +1. 如果条件当前为真，`wait` 立即完成。 +2. 如果条件当前为假，虚拟控制器进入 `Waiting` 子状态，但控制器总状态仍可显示为 `Running/Waiting`。 +3. 等待期间程序计数器停留在 wait 指令。 +4. 等待期间运动队列默认应已停止在上一条同步点；如果允许后台运动与等待并行，必须显式设计异步语义，首版不建议支持。 +5. 超时后产生结构化报警或跳转到 `on_timeout`。 +6. 用户在 IO 面板手动改变输入时，wait 应在下一个 controller tick 被重新评估。 +7. `hold` 暂停时，wait 的超时计时器也暂停；`resume` 后继续计时。 +8. `stop` 停止时，wait 被取消。 +9. trace 中必须记录 wait 开始、完成、超时、取消。 + +### 5.8.4 Wait 条件表达式限制 + +为了保证可预测性，首版 wait 条件建议只允许： + +1. IO 读值。 +2. 变量读值。 +3. 常量。 +4. 比较运算：`==`、`!=`、`>`、`>=`、`<`、`<=`。 +5. 逻辑运算：`and`、`or`、`not`。 +6. 边沿函数：`rising()`、`falling()`、`changed()`。 +7. 组合函数：`all()`、`any()`。 +8. 定时器状态，例如 `timer.done("T1")`。 + +不建议在 wait 条件中允许： + +1. 修改变量。 +2. 调用可能有副作用的函数。 +3. 调用 KDL 运动学计算。 +4. 文件读写。 +5. 网络请求。 + +### 5.8.5 IO 脚本 + +为了虚拟调试，系统需要支持 IO 脚本模拟外部夹具、PLC、传感器。 + +示例： + +```text +io_script clamp_sim { + when io.do[1] == true delay 300 ms: + io.di[1] = true + + when io.do[1] == false delay 200 ms: + io.di[1] = false +} +``` + +用途： + +1. 模拟夹爪闭合反馈。 +2. 模拟传感器到位信号。 +3. 模拟 PLC 对机器人 DO 的响应。 +4. 自动完成测试，不需要人工点 IO。 + +执行要求： + +1. IO 脚本运行在 Controller Worker 或独立 IO Worker。 +2. IO 脚本只能修改被标记为 virtual/simulated 的输入信号，避免混淆真实输出。 +3. IO 脚本触发和写入必须进入 IO event log。 +4. IO 脚本可以启停。 +5. IO 脚本必须可重置。 + +### 5.8.6 Pulse 语义 + +`pulse` 用于输出一个短脉冲： + +```text +pulse io.do[3] duration 200 ms +``` + +执行语义： + +1. 立即将 DO 置为 true。 +2. 注册一个定时事件，在 duration 后置回 false。 +3. 如果程序被 hold，pulse 定时器是否暂停需要可配置。建议首版随控制器虚拟时间暂停。 +4. 如果 stop，未完成 pulse 应恢复为安全默认值，通常为 false。 +5. trace 记录 pulse start 和 pulse end。 + +### 5.8.7 IO 与 Wait 的品牌映射 + +后处理时必须将 GRL IO 和 wait 语义转换到品牌语法： + +| GRL | ABB RAPID | FANUC LS/TP 风格 | KUKA KRL | +| --- | --- | --- | --- | +| `io.do[1] = true` | `SetDO do1, 1;` | `DO[1]=ON ;` | `$OUT[1]=TRUE` | +| `io.do[1] = false` | `SetDO do1, 0;` | `DO[1]=OFF ;` | `$OUT[1]=FALSE` | +| `wait io.di[1] == true` | `WaitDI di1, 1;` 或 `WaitUntil di1=1;` | `WAIT DI[1]=ON ;` | `WAIT FOR $IN[1]` | +| `wait ... timeout 2 s` | 品牌支持时使用超时语义，否则生成计时循环 | 生成 timer/register 逻辑或报警跳转 | 生成计时逻辑或 `WAIT FOR` 近似 | +| `pulse io.do[3] duration 200 ms` | `PulseDO do3, 0.2;` 或展开 | `PULSE DO[3]` 或展开 | `$OUT[3]=TRUE; WAIT SEC 0.2; $OUT[3]=FALSE` | + +要求： + +1. 简单 IO 写入必须直接映射为品牌原生 IO。 +2. 简单 wait 必须直接映射为品牌原生等待。 +3. 复杂 wait 表达式如果目标品牌不支持，应展开为条件循环、计时器和报警逻辑。 +4. 边沿 wait 如果品牌不支持，应生成前值缓存逻辑或给出不支持诊断。 +5. 后处理报告必须说明哪些 wait/pulse 被原生映射，哪些被展开或近似处理。 + +### 5.9 中断与异常 + +通用语义： + +```text +interrupt clamp_lost when io.di[5] == false do trap_clamp_lost + +trap trap_clamp_lost() + stop_motion + alarm 1001 "Clamp lost" +end +``` + +初期实现建议： + +1. 支持条件中断注册。 +2. 支持中断触发后暂停当前程序。 +3. 支持报警产生。 +4. 暂不模拟真实品牌控制器全部中断细节，但 IR 中保留中断元数据，便于后处理。 + +### 5.10 品牌扩展 + +GRL 需要允许品牌扩展属性，不能为了通用性丢失信息： + +```text +@brand.abb { + conf_l: true +} + +@brand.kuka { + advance: 3 +} + +@brand.fanuc { + group: 1 +} +``` + +扩展属性只影响对应品牌后处理，不应破坏通用仿真。 + +## 6. 解析器与编译流程 + +### 6.1 编译管线 + +```text +Source Text + -> Lexer + -> Parser + -> AST + -> Symbol Table + -> Semantic Analyzer + -> IR + -> Virtual Controller Runtime + -> Post Processor +``` + +完整商业 OLP 管线建议扩展为： + +```text +OLP Object Model + - robots + - tools + - frames + - targets + - paths + - operations + | + v +GRL Source + | + v +GRL AST + | + v +Executable IR + | + +--> Virtual Controller Runtime + | + +--> Post Processor + +--> ABB RAPID + +--> FANUC LS/TP-compatible text + +--> KUKA KRL SRC/DAT +``` + +品牌程序导入管线： + +```text +ABB/FANUC/KUKA Source + -> Brand Lexer + -> Brand Parser + -> Brand AST + -> Brand Semantic Normalizer + -> Executable IR + -> Reconstructed GRL / OLP Object Model + -> Virtual Controller Runtime +``` + +### 6.2 AST 要求 + +AST 必须保留： + +1. 源文件路径。 +2. 起止行列号。 +3. 注释位置，便于格式化和后处理保留注释。 +4. 原始单位文本和规范化数值。 +5. 品牌扩展元数据。 + +### 6.2.1 三类 AST + +系统需要区分三类 AST： + +1. GRL AST + - 表示通用机器人程序。 + - 用于语义检查、格式化、诊断和编译 IR。 + +2. Brand AST + - 表示 ABB RAPID、FANUC LS、KUKA KRL 等品牌源程序。 + - 尽量忠实保留品牌语法和源代码位置。 + - 用于品牌程序导入、诊断、转换报告。 + +3. OLP Model AST + - 表示工作站对象、路径、操作、工艺参数。 + - 可来自 UI 创建、CAD 生成、GRL 解析或品牌程序反解析。 + +不要用一个 AST 同时承担三种职责，否则后续导入导出和路径重算会变得难维护。 + +### 6.3 语义检查 + +必须检查： + +1. 变量是否声明。 +2. 目标点类型是否匹配运动指令。 +3. 工具、坐标系是否存在。 +4. 单位是否正确。 +5. IO 地址是否越界。 +6. 子程序参数数量和类型是否匹配。 +7. 运动指令是否缺失速度或过渡参数。 +8. 圆弧运动中起点、过渡点、终点是否退化。 +9. 逆解是否有可行解。 +10. 关节是否超过软限位。 +11. 是否存在不可到达目标点。 +12. 是否存在未处理的后处理限制。 +13. Path 是否存在空路径、重复点名、非法事件绑定。 +14. Operation 是否引用不存在的 path。 +15. 自动生成路径是否保留必要的 source metadata。 +16. 品牌程序导入后是否存在无法恢复的语义。 + +### 6.4 IR 设计 + +IR 不应是品牌文本，而应是可执行指令对象： + +```ts +type IrInstruction = + | MotionInstruction + | AssignInstruction + | WaitInstruction + | CallInstruction + | BranchInstruction + | IoInstruction + | AlarmInstruction + | ReturnInstruction; +``` + +运动 IR 示例： + +```ts +interface MotionInstruction { + kind: "motion"; + motionType: "joint" | "linear" | "circular"; + target: TargetRef | ResolvedTarget; + via?: TargetRef | ResolvedTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool: ToolRef; + frame: FrameRef; + sourceRange: SourceRange; + brandMeta?: Record; +} +``` + +### 6.5 OLP 对象模型 + +商业离线编程软件通常以对象树组织程序，而不是只以文本文件组织。建议内部定义 OLP Object Model： + +```ts +interface OlpProjectModel { + robots: RobotModel[]; + tools: ToolModel[]; + frames: FrameModel[]; + targets: TargetModel[]; + paths: PathModel[]; + operations: OperationModel[]; + programs: ProgramModel[]; + postProfiles: PostProfile[]; +} + +interface PathModel { + id: string; + name: string; + robotId: string; + defaultToolId?: string; + defaultFrameId?: string; + defaultSpeed?: SpeedSpec; + defaultZone?: ZoneSpec; + postureStrategy?: PostureStrategy; + source?: PathSource; + points: PathPointModel[]; + events: PathEventModel[]; +} + +interface PathPointModel { + id: string; + name: string; + motionType: "joint" | "linear" | "circular"; + targetId?: string; + target?: ResolvedTarget; + viaTargetId?: string; + speed?: SpeedSpec; + zone?: ZoneSpec; + toolId?: string; + frameId?: string; + process?: Record; +} +``` + +该模型的用途： + +1. UI 文件树和路径编辑器直接操作它。 +2. 从规划点生成程序时先生成它。 +3. GRL 编译前可由它生成 GRL。 +4. 品牌程序导入后可尽量恢复它。 +5. 后处理和虚拟控制器最终仍以 IR 为准。 + +### 6.6 品牌程序导入解析 + +虚拟控制器应能解析多品牌机器人的可读程序文本，并统一执行。首版建议支持以下输入： + +| 品牌 | 首版导入格式 | 说明 | +| --- | --- | --- | +| ABB | RAPID `.mod/.sys` 文本 | 解析 `MODULE`、`PROC`、`MoveJ`、`MoveL`、`MoveC`、`robtarget`、`tooldata`、`wobjdata` | +| KUKA | KRL `.src/.dat` 文本 | 解析 `DEF`、`PTP`、`LIN`、`CIRC`、`E6POS`、`E6AXIS`、`$TOOL`、`$BASE` | +| FANUC | LS 风格文本或可读 TP 导出 | 解析 `J`、`L`、`C`、`P[]`、`PR[]`、`UTOOL`、`UFRAME`、`CALL`、`LBL/JMP` | + +导入目标不是 100% 还原真实控制器所有行为，而是： + +1. 能提取目标点。 +2. 能提取运动序列。 +3. 能提取工具和坐标系引用。 +4. 能提取速度和过渡。 +5. 能提取主要 IO 和流程控制。 +6. 能转换为统一 IR，在虚拟控制器中执行。 +7. 能生成转换报告，标明不支持或近似处理的语义。 + +### 6.6.1 品牌导入转换示例 + +ABB RAPID： + +```text +MoveL pick, v300, z10, gripper\WObj:=fixture; +``` + +转换为 GRL： + +```text +movel pick speed linear(300 mm/s) zone z10 tool gripper frame fixture +``` + +KUKA KRL： + +```text +$VEL.CP = 0.3 +LIN XPICK C_DIS +``` + +转换为 GRL： + +```text +movel XPICK speed linear(300 mm/s) zone continuous +``` + +FANUC LS： + +```text +L P[10] 300mm/sec CNT10 ; +``` + +转换为 GRL： + +```text +movel P10 speed linear(300 mm/s) zone cnt(10) +``` + +### 6.6.2 品牌程序导入限制 + +必须明确处理以下限制： + +1. 品牌控制器内部系统变量不能全部等价映射。 +2. 品牌工艺包指令可能需要插件解析。 +3. FANUC 二进制 TP 不能直接作为首版目标，优先处理 LS 或文本导出。 +4. KUKA `$ADVANCE`、逼近、异步运动等语义需要近似或专项实现。 +5. ABB RAPID 的复杂错误处理和多任务需要分阶段支持。 +6. 导入后的程序必须附带转换报告，不能假装完全等价。 + +### 6.7 GRL 生成器 + +从 OLP Model 生成 GRL 的组件称为 GRL Generator： + +```text +OlpProjectModel + -> GrlGenerator + -> .grl source files +``` + +要求： + +1. 生成稳定、可读、可 diff 的文本。 +2. 保留路径和操作结构，不要默认全部展开成散乱运动语句。 +3. 生成的 target 名称稳定。 +4. 生成的程序可以再次解析回同等 OLP Model。 +5. 支持配置生成风格： + - compact：多用 `run_path`。 + - expanded：展开为 `movej/movel/movec`。 + - debug：保留更多注释和 source metadata。 + +## 7. 虚拟控制器设计 + +虚拟控制器需要支持两类输入： + +1. GRL 程序 + - 由用户手写。 + - 由 OLP 对象模型自动生成。 + - 由路径和操作模板生成。 + +2. 品牌程序 + - ABB RAPID 文本。 + - KUKA KRL 文本。 + - FANUC LS 或可读导出文本。 + - 先解析为 Brand AST，再转换为统一 IR。 + +虚拟控制器真正执行的是统一 IR，而不是直接解释某个品牌文本。这样才能保证虚拟调试、路径重算、跨品牌后处理和报警诊断使用同一套运行时。 + +### 7.1 控制器状态机 + +建议状态： + +```text +PowerOff + -> Booting + -> MotorsOff + -> Ready + -> Manual + -> Auto + -> Running + -> Hold + -> Fault + -> EmergencyStop +``` + +基础命令： + +| 命令 | 说明 | +| --- | --- | +| `powerOn` | 上电 | +| `powerOff` | 下电 | +| `motorsOn` | 电机上使能 | +| `motorsOff` | 电机下使能 | +| `loadProgram` | 加载程序 | +| `start` | 启动 | +| `hold` | 暂停 | +| `resume` | 继续 | +| `stop` | 停止 | +| `resetFault` | 复位报警 | +| `stepInto` | 单步进入 | +| `stepOver` | 单步越过 | +| `stepMotion` | 单条运动执行 | + +### 7.2 执行模型 + +虚拟控制器包含： + +1. Program Counter：当前执行位置。 +2. Call Stack：调用栈。 +3. Scope Stack：变量作用域。 +4. Motion Queue：运动队列。 +5. IO Image：IO 镜像。 +6. Timer Table：定时器。 +7. Interrupt Table：中断表。 +8. Alarm Queue：报警队列。 +9. Trace Buffer：执行轨迹。 +10. Source Map：IR 到 GRL、Path、Operation 或品牌源程序的映射。 +11. Brand Context：当输入来自品牌程序时，保存品牌语义上下文和转换警告。 +12. IO Service：IO 点表、别名表、事件队列、边沿检测、等待条件调度。 + +### 7.3 任务模型 + +初期支持单主任务： + +```text +Task MAIN + - program: Main.main + - motion group: robot_1 +``` + +后续扩展： + +1. 后台任务，例如 PLC-like 逻辑。 +2. 多机器人任务。 +3. 独立 IO 任务。 +4. 监控任务。 +5. 协作运动任务。 + +### 7.4 运动队列 + +虚拟控制器不能执行一条运动就结束，而要模拟真实控制器的 look-ahead： + +1. 程序解释器将运动指令推入 Motion Queue。 +2. Motion Planner 根据速度、过渡、当前姿态生成轨迹。 +3. Controller Tick 按仿真时间推进。 +4. UI 读取当前关节、TCP、目标点、轨迹和状态。 + +运动队列字段： + +```ts +interface MotionQueueItem { + id: string; + instructionId: string; + pathId?: string; + pathPointId?: string; + operationId?: string; + type: "joint" | "linear" | "circular"; + startJoint: number[]; + endJoint: number[]; + startPose: Pose; + endPose: Pose; + viaPose?: Pose; + speed: SpeedSpec; + zone: ZoneSpec; + samples?: TrajectorySample[]; + status: "pending" | "planned" | "running" | "done" | "failed"; +} +``` + +当运动来自 `path` 或 `operation` 时，运动队列必须保留路径点来源。UI 才能在路径表、程序文本、3D 轨迹之间联动定位。 + +### 7.4.1 Path 执行语义 + +`run_path` 执行过程： + +1. 读取 PathModel。 +2. 合并 path defaults 和 point overrides。 +3. 解析每个目标点的 tool、frame、speed、zone。 +4. 触发 `event before`。 +5. 将运动点展开为 MotionQueueItem。 +6. 运动完成后触发 `event after`。 +7. 记录 trace，包含 pathId 和 pathPointId。 + +`run_operation` 执行过程： + +1. 读取 OperationModel。 +2. 执行 start action。 +3. 执行引用 path。 +4. 执行 end action。 +5. 将工艺状态写入 trace。 + +### 7.4.2 品牌程序执行语义 + +品牌程序导入后执行过程： + +1. Brand AST 转统一 IR。 +2. 每条 IR 保留品牌源程序行号。 +3. 品牌特有语义被转换为： + - 等价 IR。 + - 近似 IR。 + - 不支持诊断。 +4. 虚拟控制器执行 IR。 +5. UI 调试时可以显示品牌源代码当前行，也可以显示转换后的 GRL/IR。 + +示例： + +```text +KUKA LIN XPICK C_DIS + -> Brand AST + -> MotionInstruction(linear, target=XPICK, zone=continuous) + -> MotionQueueItem +``` + +### 7.5 报警与诊断 + +报警必须结构化： + +```ts +interface ControllerAlarm { + code: number; + severity: "info" | "warning" | "error" | "fatal"; + message: string; + sourceRange?: SourceRange; + timestamp: number; + detail?: unknown; +} +``` + +常见报警： + +1. 程序语法错误。 +2. 类型错误。 +3. 未定义目标点。 +4. IK 求解失败。 +5. 目标点超限。 +6. 奇异点风险。 +7. 圆弧退化。 +8. IO 等待超时。 +9. 后处理不支持某指令。 +10. 品牌程序导入语义不完整。 +11. Path 展开失败。 +12. Operation 工艺参数缺失。 + +### 7.6 虚拟 IO 实施方案 + +虚拟 IO 是虚拟调试的核心能力。它用于模拟机器人控制器与夹具、PLC、安全门、传感器、工艺设备之间的信号交互。 + +#### 7.6.1 IO 架构 + +```text +Controller Runtime + | + +-- IO Service + | + +-- IO Image + +-- IO Alias Table + +-- IO Event Queue + +-- Wait Registry + +-- Edge Detector + +-- IO Script Engine + +-- IO Trace Logger +``` + +IO Service 职责： + +1. 保存当前 IO 镜像。 +2. 提供读写接口。 +3. 管理 IO 别名。 +4. 检测边沿和变化。 +5. 调度 wait 条件。 +6. 执行 pulse 定时恢复。 +7. 执行 IO 脚本。 +8. 记录 IO 事件日志。 +9. 向 UI 推送 IO 变化。 + +#### 7.6.2 IO Image 数据结构 + +```ts +type IoSignalType = "DI" | "DO" | "AI" | "AO" | "GI" | "GO" | "RI" | "RO"; + +interface IoSignalDef { + id: string; + name: string; + type: IoSignalType; + index: number; + initial: boolean | number; + writableByProgram: boolean; + writableByUser: boolean; + writableByScript: boolean; + description?: string; + brand?: Record; +} + +interface IoSignalState { + id: string; + type: IoSignalType; + index: number; + value: boolean | number; + previousValue: boolean | number; + updatedAt: number; + source: "program" | "user" | "script" | "import" | "reset"; +} + +interface IoImage { + signals: Map; + byAddress: Map; + aliases: Map; +} +``` + +地址规范： + +```text +DI[1] -> io.di[1] +DO[1] -> io.do[1] +AI[1] -> io.ai[1] +AO[1] -> io.ao[1] +GI[1] -> io.gi[1] +GO[1] -> io.go[1] +``` + +#### 7.6.3 IO 读写规则 + +1. 程序可写 DO、AO、GO、RO。 +2. 程序默认不可写 DI、AI、GI、RI，除非该信号配置为 simulated writable。 +3. 用户可在 IO 面板手动修改虚拟输入 DI、AI、GI、RI。 +4. IO 脚本可修改配置允许的虚拟输入。 +5. 所有写入必须经过 IO Service，不能直接改 Map。 +6. 每次写入都生成 IoEvent。 +7. 重复写入相同值可配置是否记录。建议默认记录程序写入，但 UI 可折叠显示。 + +```ts +interface IoWriteRequest { + addressOrAlias: string; + value: boolean | number; + source: "program" | "user" | "script" | "import" | "reset"; + timestamp: number; + instructionId?: string; +} + +interface IoEvent { + id: string; + signalId: string; + oldValue: boolean | number; + newValue: boolean | number; + source: "program" | "user" | "script" | "import" | "reset"; + timestamp: number; + instructionId?: string; +} +``` + +#### 7.6.4 WaitInstruction IR + +```ts +interface WaitInstruction { + kind: "wait"; + condition: ExpressionNode; + timeoutMs?: number; + onTimeout?: { + kind: "alarm" | "jump" | "call" | "continue"; + target?: string; + alarmCode?: number; + message?: string; + }; + sourceRange: SourceRange; +} +``` + +执行状态： + +```ts +interface ActiveWait { + id: string; + instructionId: string; + condition: CompiledExpression; + startedAtVirtualTime: number; + timeoutAtVirtualTime?: number; + status: "waiting" | "completed" | "timeout" | "cancelled"; +} +``` + +#### 7.6.5 Wait 调度流程 + +控制器执行到 wait： + +```text +1. 编译或读取 WaitInstruction 条件表达式。 +2. 立即评估一次 condition。 +3. 若为 true，PC 前进，记录 wait completed immediate。 +4. 若为 false，创建 ActiveWait，控制器进入 Running/Waiting。 +5. 每个 controller tick 或 IO 变化事件触发重新评估。 +6. 条件为 true 时，ActiveWait completed，PC 前进。 +7. 虚拟时间超过 timeout 时，执行 onTimeout 或产生报警。 +8. hold 时暂停 timeout 虚拟时间。 +9. stop/reset 时取消 ActiveWait。 +``` + +伪代码： + +```ts +function executeWait(instruction: WaitInstruction): StepResult { + if (evalCondition(instruction.condition)) { + traceWait("completed-immediate", instruction); + return { pc: "next" }; + } + + waitRegistry.add({ + id: newId(), + instructionId: instruction.id, + condition: compileExpression(instruction.condition), + startedAtVirtualTime: clock.now(), + timeoutAtVirtualTime: instruction.timeoutMs + ? clock.now() + instruction.timeoutMs + : undefined, + status: "waiting", + }); + + return { pc: "stay", state: "waiting" }; +} +``` + +#### 7.6.6 边沿检测 + +边沿函数： + +```text +rising(io.di[1]) +falling(io.di[1]) +changed(io.gi[1]) +``` + +实现要求： + +1. IO Service 在每次 tick 开始保存 previousValue。 +2. IO 写入发生后更新 current value。 +3. wait 条件评估时可读取 previous/current。 +4. 边沿只在一个 tick 内有效。 +5. 如果多个 IO 事件在同一 tick 内发生，按事件顺序处理，并在 trace 中保留顺序。 + +#### 7.6.7 IO 与虚拟时间 + +虚拟调试必须使用 controller virtual time，而不是直接使用 wall-clock： + +1. `wait timeout` 基于虚拟时间。 +2. `pulse duration` 基于虚拟时间。 +3. IO 脚本 `delay` 基于虚拟时间。 +4. hold 时虚拟时间暂停。 +5. 单步模式下虚拟时间按 step 推进。 +6. 快进回放时虚拟时间可加速，但事件顺序必须保持。 + +#### 7.6.8 Wait 与运动同步 + +首版建议采用同步语义： + +1. `movel/movej/movec` 完成后才执行下一条 wait。 +2. `wait` 完成后才执行后续运动。 +3. 不支持品牌控制器中的复杂并行 advance run 行为。 + +后续可扩展： + +1. 允许提前规划运动队列。 +2. 支持路径事件触发 IO。 +3. 支持运动中 wait 或 sensor search。 +4. 支持品牌特定 advance run 近似。 + +#### 7.6.9 IO Trace + +IO trace 需要记录： + +```ts +interface IoTraceRecord { + time: number; + kind: "read" | "write" | "wait-start" | "wait-done" | "wait-timeout" | "pulse-start" | "pulse-end"; + signal?: string; + value?: boolean | number; + source?: string; + instructionId?: string; + programLine?: number; +} +``` + +用途： + +1. 回放虚拟调试过程。 +2. 分析 wait 卡住原因。 +3. 生成调试报告。 +4. 帮助后处理验证 IO 映射。 + +#### 7.6.10 Wait 卡住诊断 + +当程序停在 wait 时，UI 和报警系统应显示： + +1. 当前等待表达式。 +2. 当前表达式求值结果。 +3. 每个子表达式的当前值。 +4. 已等待时间。 +5. 剩余超时时间。 +6. 相关 IO 点的最近变化记录。 +7. 是否存在 IO 脚本会触发该输入。 + +示例诊断： + +```text +Waiting at line 42: + wait io.alias.clamp_closed == true timeout 2 s + +Current: + io.alias.clamp_closed -> DI[1] = false + waited: 1.24 s + timeout in: 0.76 s + last write: DO[1] = true by program at 12.380 s + script: clamp_sim enabled, scheduled DI[1] = true at 12.680 s +``` + +## 8. KDL WASM 设计 + +### 8.1 KDL 使用边界 + +KDL 适合用于： + +1. 3D 向量、位姿、旋转、坐标变换。 +2. 串联机器人运动链建模。 +3. 正向运动学。 +4. 逆向运动学。 +5. 雅可比计算。 +6. 速度级运动学。 +7. 基础轨迹与速度曲线能力。 + +需要注意：KDL 本身不是完整的碰撞检测、工艺仿真或全局路径搜索框架。避障、碰撞检测、节拍优化、工艺参数模拟需要另行设计。 + +### 8.2 总体落地架构 + +KDL WASM 不是 UI 组件，而是虚拟控制器和离线编程规划器共用的计算内核。推荐架构如下： + +```text +HTML UI / Program Editor / Path Editor + | +TypeScript Virtual Controller / OLP Planner + | +KdlWorkerClient + | +kdl.worker.ts + | +KDL WASM Module +``` + +设计要求： + +1. UI 主线程不得直接执行大批量 FK、IK、轨迹采样，应通过 Worker 调用 KDL WASM。 +2. KDL C++ 类不直接暴露给业务层，业务层只使用稳定 TypeScript API。 +3. WASM 内部可以保存 `RobotHandle`、KDL `Chain`、求解器和缓存，主线程只保存 handle。 +4. 机器人结构以 URDF 为源数据，OPFS 保存原始 URDF 和转换后的标准模型缓存。 +5. 运动函数必须面向商业离线编程工作流，不只提供单点 FK/IK，还要提供批量可达性、轨迹采样、节拍估算和诊断。 +6. 对外运动指令只保留 `MOVEJ`、`MOVEL`、`MOVEC` 三类，分别对应关节角度差分、TCP 直线、TCP 圆弧。 + +### 8.3 URDF 机器人结构定义 + +机器人结构统一使用 URDF 定义。每个机器人资源建议包含： + +```text +robots/ + {robotId}/ + robot.urdf + robot.meta.json + limits.override.json + default_tool.json + meshes/ +``` + +URDF 使用规则： + +1. `robot.urdf` 是机器人运动链的源文件。 +2. 支持 `revolute`、`continuous`、`prismatic`、`fixed` joint。 +3. 首版不支持 `planar`、`floating` joint；导入时生成明确诊断。 +4. 所有长度单位统一为 meter，角度统一为 radian，时间统一为 second。 +5. 关节限位优先使用 URDF `limit`；缺少加速度、jerk、厂商速度等级时由 `limits.override.json` 补齐。 +6. URDF mesh 只用于显示和碰撞模块，KDL WASM 只消费运动链、关节轴、origin 和 limit。 +7. 导入 ABB、FANUC、KUKA 机器人库时，也应转换为 URDF + 元数据，而不是直接把品牌模型写入运动内核。 + +URDF 到 KDL 的转换分两层实现： + +1. TypeScript 层解析 XML，生成标准 `NormalizedRobotModel`，便于浏览器诊断、缓存、版本迁移和 UI 展示。 +2. WASM 层接收标准模型，构造 KDL `Tree`/`Chain` 和求解器。 + +对业务层仍提供 `loadRobotFromUrdf`，避免上层关心解析位置： + +```ts +interface UrdfLoadOptions { + robotId: string; + baseLink: string; + tipLink: string; + tool?: Pose; + base?: Pose; + jointOrder?: string[]; + overrideLimits?: JointLimitOverride[]; +} + +interface NormalizedRobotModel { + robotId: string; + name: string; + baseLink: string; + tipLink: string; + links: LinkModel[]; + joints: JointModel[]; + activeJointNames: string[]; + limits: JointLimits[]; + source: { + type: "urdf"; + urdfHash: string; + }; +} +``` + +### 8.4 KDL WASM 计算 API 清单 + +KDL WASM 首版至少应完成以下函数。TypeScript API 使用 camelCase，GRL/品牌指令层使用大写或小写指令名均可映射。 + +```ts +interface KdlWasmApi { + init(options?: KdlInitOptions): Promise; + + loadRobotFromUrdf(urdfXml: string, options: UrdfLoadOptions): Promise; + createRobotFromModel(model: NormalizedRobotModel): Promise; + destroyRobot(handle: RobotHandle): Promise; + getRobotInfo(handle: RobotHandle): Promise; + getJointLimits(handle: RobotHandle): Promise; + + fk(handle: RobotHandle, joints: Float64Array, options?: FkOptions): Promise; + fkAllLinks(handle: RobotHandle, joints: Float64Array): Promise; + jacobian(handle: RobotHandle, joints: Float64Array, options?: JacobianOptions): Promise; + ik(handle: RobotHandle, seed: Float64Array, target: Pose, options?: IkOptions): Promise; + ikBatch(handle: RobotHandle, seeds: Float64Array[], targets: Pose[], options?: IkOptions): Promise; + + checkJointLimits(handle: RobotHandle, joints: Float64Array): Promise; + checkSingularity(handle: RobotHandle, joints: Float64Array): Promise; + checkReachability(handle: RobotHandle, target: Pose, options?: IkOptions): Promise; + + moveJ(handle: RobotHandle, start: Float64Array, target: JointTarget | PoseTarget, options: MoveJOptions): Promise; + moveL(handle: RobotHandle, start: Float64Array, target: PoseTarget, options: MoveLOptions): Promise; + moveC(handle: RobotHandle, start: Float64Array, via: PoseTarget, target: PoseTarget, options: MoveCOptions): Promise; + + planPath(handle: RobotHandle, start: Float64Array, segments: MotionSegmentRequest[], options: PathPlanOptions): Promise; + validatePath(handle: RobotHandle, start: Float64Array, segments: MotionSegmentRequest[], options: PathPlanOptions): Promise; + estimateCycleTime(trajectory: TrajectoryResult | PathPlanResult): Promise; + + makeTrapProfile(length: number, options: TrapProfileOptions): Promise; + sampleTrapProfile(length: number, options: TrapProfileOptions): Promise; + resampleTrajectory(trajectory: TrajectoryResult, sampleTime: number): Promise; +} +``` + +首版 C++/WASM 内核建议直接使用或封装这些 KDL 能力： + +| 功能 | KDL 能力 | 包装层职责 | +| --- | --- | --- | +| 串联链 | `Tree`、`Chain`、`Segment`、`Joint` | 从 URDF 标准模型构造链 | +| 正解 | `ChainFkSolverPos_recursive` | 输出法兰、TCP、各 link 位姿 | +| 雅可比 | `ChainJntToJacSolver` | 输出矩阵和奇异性指标 | +| 逆解 | `ChainIkSolverPos_NR_JL`、`ChainIkSolverPos_LMA` | seed、多解尝试、限位、失败诊断 | +| 直线路径 | `Path_Line` | 生成 MOVEL TCP 采样 | +| 圆弧路径 | `Path_Circle` | 生成 MOVEC TCP 采样 | +| 梯形速度 | `VelocityProfile_Trap` | 生成 `s/sd/sdd` 采样 | +| 轨迹段 | `Trajectory_Segment` | 组合路径与速度曲线 | +| 圆角过渡 | `Path_RoundedComposite` | 第二阶段用于 zone/blend | + +### 8.5 通用数据结构 + +位姿在内部统一使用位置 + 四元数，避免欧拉角奇异；导入导出 ABB/FANUC/KUKA 时再转换为品牌格式。 + +```ts +type RobotHandle = number; + +interface Pose { + position: [number, number, number]; + quaternion: [number, number, number, number]; +} + +interface JointLimits { + name: string; + lower: number; + upper: number; + velocity: number; + acceleration: number; + jerk?: number; +} + +interface MotionOptionsBase { + sampleTime: number; + profile: "trap" | "s_curve"; + speedOverride: number; + sourceMap?: MotionSourceMap; + tcp?: Pose; + base?: Pose; +} + +interface MoveJOptions extends MotionOptionsBase { + jointVelocity?: number[]; + jointAcceleration?: number[]; + blend?: ZoneData; +} + +interface MoveLOptions extends MotionOptionsBase { + tcpVelocity: number; + tcpAcceleration: number; + orientationMode: "fixed" | "slerp" | "tool_z_lock"; + ik: IkOptions; + blend?: ZoneData; +} + +interface MoveCOptions extends MoveLOptions { + arcMode: "via" | "center" | "radius"; + circleDirection?: "short" | "long" | "cw" | "ccw"; +} +``` + +轨迹输出点是虚拟控制器、3D 回放、节拍报告、可达性报告和后处理预览共用的数据结构： + +```ts +interface TrajectoryPoint { + index: number; + time: number; + dt: number; + s: number; + sd: number; + sdd: number; + joints: number[]; + jointVelocity: number[]; + jointAcceleration: number[]; + flange: Pose; + tcp: Pose; + tcpVelocity?: [number, number, number, number, number, number]; + tcpAcceleration?: [number, number, number, number, number, number]; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + diagnostics: MotionDiagnostic[]; +} + +interface TrajectoryResult { + ok: boolean; + motion: "MOVEJ" | "MOVEL" | "MOVEC"; + duration: number; + sampleTime: number; + points: TrajectoryPoint[]; + events: TrajectoryEvent[]; + diagnostics: MotionDiagnostic[]; +} +``` + +区分两类点： + +1. 规划点：用户在 OLP 路径编辑器中创建的稀疏目标点，例如 `P10`、`P20`、`P30`。 +2. 轨迹采样点：KDL WASM 根据运动方式、速度、加速度和采样周期生成的密集点，用于仿真执行和报告。 + +### 8.6 正解、逆解、雅可比和可达性 + +正解输入： + +1. 机器人句柄。 +2. 关节数组。 +3. 工具坐标。 +4. 基坐标或工件坐标。 + +正解输出： + +1. 法兰位姿。 +2. TCP 位姿。 +3. 每个连杆位姿。 +4. 是否越限。 + +IK 要求： + +1. 支持 seed joint。 +2. 支持关节限位。 +3. 支持最大迭代次数。 +4. 支持位置和姿态容差。 +5. 支持多 seed 尝试。 +6. 支持多解候选排序。 +7. 支持按配置选择解，例如肩、肘、腕配置。 +8. 支持失败原因返回。 + +IK 返回： + +```ts +interface IkResult { + ok: boolean; + joints?: number[]; + iterations: number; + residualPosition?: number; + residualOrientation?: number; + configuration?: RobotConfiguration; + reason?: "unreachable" | "joint_limit" | "singularity" | "max_iteration" | "invalid_model"; + diagnostics: MotionDiagnostic[]; +} +``` + +可达性检查不应只返回 true/false，还要返回商业软件常见的诊断内容： + +1. 最近可达解。 +2. 超限关节名称、当前值、上下限。 +3. IK 残差。 +4. 奇异性指标。 +5. 推荐处理方式，例如换姿态、改 seed、改工具、换配置。 + +### 8.7 MOVEJ 轨迹规划 + +`MOVEJ` 是关节空间运动，机器人按各轴关节角度差分运行。TCP 轨迹由关节差分后的 FK 结果自然形成，不要求是直线。目标可以是关节目标，也可以是位姿目标： + +1. 如果目标是关节数组，直接作为 `qEnd`。 +2. 如果目标是位姿，先用 IK 从 `start` 附近求解 `qEnd`。 +3. 对每个关节检查位置、速度、加速度限位。 +4. 使用同步梯形速度曲线生成归一化路径参数 `s(t)`。 +5. 每个采样点计算 `q(t) = qStart + s(t) * (qEnd - qStart)`。 +6. 每个采样点执行 FK，得到法兰和 TCP 位姿。 +7. 输出完整 `TrajectoryPoint[]`。 + +MOVEJ 的关键要求： + +1. 所有关节同起同停。 +2. 采样周期可配置，首版建议默认 `0.004 s` 或 `0.008 s`。 +3. 速度倍率 `override` 只影响规划速度，不改变目标点。 +4. 对接近限位、超过限位、奇异点附近要产生 warning 或 error。 +5. 轨迹必须可重复：同一输入、同一算法版本、同一采样周期输出一致。 + +### 8.8 MOVEL 轨迹规划 + +`MOVEL` 是 TCP 直线运动，机器人 TCP 沿起点到终点的空间直线运行。关节角不做简单差分，而是由每个 TCP 采样点 IK 求解。 + +算法流程： + +1. 用 `start` 关节做 FK，得到起点 TCP。 +2. 根据目标点、工具、工件坐标得到终点 TCP。 +3. 使用 KDL `Path_Line` 或等价实现生成 TCP 直线路径。 +4. 姿态按 `orientationMode` 插补，首版推荐四元数 slerp。 +5. 使用梯形速度曲线生成路径参数 `s(t)`。 +6. 对每个 TCP 采样点执行 IK，seed 使用上一采样点关节值。 +7. 检查每个采样点的关节限位、速度、加速度、奇异性和 IK 残差。 +8. 输出轨迹点，并保留每个点对应的原始规划点和程序行 source map。 + +MOVEL 的商业级诊断要求： + +1. TCP 直线误差最大值。 +2. 姿态误差最大值。 +3. 失败采样点的时间、路径比例、TCP 位姿和 IK 失败原因。 +4. 关节翻转或配置突变检测。 +5. 速度超限点列表。 +6. 建议降低速度、调整姿态、插入中间点或切换配置。 + +### 8.9 MOVEC 轨迹规划 + +`MOVEC` 是 TCP 圆弧运动，机器人 TCP 经过 via 点并沿圆弧方式运行，关节角由每个圆弧采样点 IK 求解。输入至少包含： + +1. 起点：由当前关节 FK 得到。 +2. 经由点 `via`。 +3. 终点 `target`。 + +算法流程： + +1. 将起点、经由点、终点转换到同一基坐标。 +2. 检查三点是否重合或近似共线。 +3. 计算圆心、半径、法向量、圆弧角度。 +4. 使用 KDL `Path_Circle` 或等价实现生成圆弧 TCP 路径。 +5. 使用梯形速度曲线按圆弧长度采样。 +6. 姿态按策略插补：首版使用起点到终点 slerp，经由点只约束位置；第二阶段支持经由点姿态约束。 +7. 对每个采样 TCP 执行 IK，seed 使用上一采样点关节值。 +8. 生成轨迹点、圆弧几何诊断和可达性诊断。 + +MOVEC 必须返回这些附加信息： + +```ts +interface CirclePlanMeta { + center: [number, number, number]; + radius: number; + normal: [number, number, number]; + angle: number; + length: number; + direction: "cw" | "ccw"; + maxArcError: number; +} +``` + +### 8.10 梯形速度曲线 + +用户提到的“梯形图运动方式”，在运动规划上下文中按梯形速度曲线理解。PLC 梯形图属于虚拟 PLC/IO 联调模块，不放在 KDL 运动内核中。 + +梯形速度曲线用于 MOVEJ、MOVEL、MOVEC 的路径参数采样。统一输出： + +```ts +interface TrapSample { + index: number; + time: number; + s: number; + sd: number; + sdd: number; +} + +interface TrapProfileResult { + type: "trapezoid" | "triangle"; + length: number; + duration: number; + tAccel: number; + tConst: number; + tDecel: number; + vPeak: number; + samples: TrapSample[]; +} +``` + +基本规则： + +1. 输入路径长度 `L`、最大速度 `vMax`、最大加速度 `aMax`、采样周期 `dt`。 +2. 如果距离足够长，生成加速、匀速、减速三段梯形速度曲线。 +3. 如果距离不足以达到 `vMax`，自动退化为三角速度曲线。 +4. `s` 表示归一化路径比例，范围 `[0, 1]`。 +5. `sd`、`sdd` 表示归一化速度和加速度。 +6. KDL WASM 内核可以使用 `VelocityProfile_Trap`，包装层负责转换为统一 `TrapSample[]`。 +7. 所有运动函数必须把实际使用的速度曲线写入 `TrajectoryResult`，便于节拍报告和调试。 + +MOVEJ 中的路径长度建议定义为满足所有关节限位的归一化长度，而不是简单欧氏长度： + +```text +jointRatio_i = abs(qEnd_i - qStart_i) / maxAllowedDelta_i +pathRatio = max(jointRatio_i) +``` + +实际实现时应根据每个关节的速度、加速度约束计算所需时间，取最大时间作为同步运动时间，再反算每个关节的采样速度和加速度。 + +### 8.11 多段路径、zone 和商业 OLP 批量能力 + +商业离线编程软件通常不是一次只算一条运动，而是对整条路径做批量验证。因此 KDL WASM 需要提供 `planPath` 和 `validatePath`： + +1. 输入当前关节和多个 `MotionSegmentRequest`。 +2. 按程序顺序生成每段 MOVEJ/MOVEL/MOVEC 轨迹。 +3. 段间继承上一段末尾关节作为下一段起点。 +4. `fine` 表示必须精确到点。 +5. `zone` 表示允许过渡，首版可先做减速到点但保留 zone 信息；第二阶段用 `Path_RoundedComposite` 或自研 blend 算法实现连续过渡。 +6. 输出整条 path 的总节拍、每段节拍、失败点、警告点、source map。 + +批量验证结果应支持 UI 直接定位： + +```ts +interface MotionDiagnostic { + severity: "info" | "warning" | "error"; + code: string; + message: string; + time?: number; + pointIndex?: number; + segmentId?: string; + targetId?: string; + sourceMap?: MotionSourceMap; + data?: Record; +} +``` + +### 8.12 和虚拟控制器的关系 + +虚拟控制器执行运动指令时不直接写机器人关节，而是走统一运动队列： + +1. 解释器读到 `movej/movel/movec`。 +2. 把当前关节、目标点、速度、zone、tool、frame 解析成 `MotionSegmentRequest`。 +3. 调用 KDL WASM 生成 `TrajectoryResult`。 +4. Motion Queue 按虚拟时间消费 `TrajectoryPoint`。 +5. UI 根据当前点更新 3D 机器人、程序当前行、路径当前点、节拍统计。 +6. 如果 KDL 返回 error，虚拟控制器进入 alarm 或 hold 状态。 + +这样可以保证从规划点生成程序、手写 GRL、多品牌导入程序都走同一套运动学和轨迹采样逻辑。 + +### 8.13 实施优先级 + +P0 必须完成： + +1. URDF 文件加载、解析、诊断和标准模型缓存。 +2. 从 URDF 标准模型创建 KDL Chain。 +3. FK、fkAllLinks、Jacobian。 +4. IK、ikBatch、关节限位和失败原因。 +5. 梯形速度曲线 `makeTrapProfile`、`sampleTrapProfile`。 +6. `moveJ` 轨迹点生成。 +7. `moveL` 轨迹点生成。 +8. `moveC` 基础圆弧轨迹点生成。 +9. `validatePath` 批量可达性和诊断。 +10. 轨迹结果可写入 OPFS trace，并可被 UI 回放。 + +P1 扩展： + +1. zone/blend 连续过渡。 +2. S 曲线速度规划。 +3. 多 IK 解稳定排序。 +4. 外部轴和变位机。 +5. 多机器人协调。 +6. 碰撞检测联动。 +7. 与真实品牌控制器轨迹差异对比。 + +## 9. OPFS 工作区设计 + +### 9.1 文件系统布局 + +OPFS 内部推荐布局： + +```text +/projects/ + /{projectId}/ + project.json + station/ + station.json + cells/ + fixtures/ + parts/ + devices/ + libraries/ + robots/ + tools/ + fixtures/ + process_templates/ + geometry/ + meshes/ + cad_sources/ + collision/ + robots/ + programs/ + targets/ + tools/ + frames/ + io/ + io_map.json + io_scripts/ + generated/ + logs/ + io_trace.jsonl + simulation_trace.jsonl + reports/ + reachability/ + collision/ + cycle_time/ + post/ + calibration/ + calibration/ + tcp/ + frames/ + bases/ + snapshots/ + .index.json + .lock +``` + +### 9.2 Project Manifest + +```json +{ + "schemaVersion": 1, + "projectId": "demo-cell", + "name": "Demo Cell", + "createdAt": "2026-06-26T00:00:00.000Z", + "updatedAt": "2026-06-26T00:00:00.000Z", + "robots": ["robots/robot_1.robot.json"], + "mainProgram": "programs/main.grl", + "postProfiles": { + "abb": "post/abb.profile.json", + "fanuc": "post/fanuc.profile.json", + "kuka": "post/kuka.profile.json" + } +} +``` + +### 9.3 Storage API + +```ts +interface WorkspaceStorage { + listProjects(): Promise; + openProject(projectId: string): Promise; + createProject(input: CreateProjectInput): Promise; + readText(path: string): Promise; + writeText(path: string, content: string): Promise; + readJson(path: string): Promise; + writeJson(path: string, value: T): Promise; + delete(path: string): Promise; + snapshot(projectId: string): Promise; + exportZip(projectId: string): Promise; + importZip(file: File): Promise; +} +``` + +### 9.4 存储安全与备份 + +OPFS 是浏览器 Origin 私有文件系统，用户通常不能像普通目录一样直接看到这些文件。因此必须提供： + +1. 显式导出项目包。 +2. 显式导入项目包。 +3. 自动快照。 +4. 项目迁移工具。 +5. 存储占用显示。 +6. 数据损坏检测。 + +### 9.5 IO 文件 + +虚拟 IO 相关文件建议放在： + +```text +io/ + io_map.json + io_scripts/ + clamp_sim.ioscript + fixture_sim.ioscript +logs/ + io_trace.jsonl +``` + +要求： + +1. `io_map.json` 保存 IO 点定义、别名、品牌映射、初始值。 +2. `io_scripts/*.ioscript` 保存虚拟 IO 脚本。 +3. `io_trace.jsonl` 保存调试过程中 IO 事件，可按运行会话分文件。 +4. 项目导出 zip 时必须包含 IO map 和 IO scripts。 +5. trace 文件可选导出，避免项目包过大。 + +### 9.6 商业级项目交付物 + +商业 OLP 项目不仅保存程序，还应保存完整交付物： + +```text +reports/ + reachability/report.json + collision/report.json + cycle_time/report.json + post/abb_export_report.json + calibration/tcp_report.json +generated/ + abb/ + fanuc/ + kuka/ +packages/ + project_export.zip + customer_delivery.zip +``` + +客户交付包建议包含： + +1. GRL 源程序。 +2. 品牌后处理程序。 +3. 目标点和路径数据。 +4. IO map。 +5. 后处理报告。 +6. 可达性报告。 +7. 碰撞报告。 +8. 节拍报告。 +9. 校准数据。 +10. 仿真 trace，可选。 + +## 10. 后处理设计 + +### 10.1 后处理目标 + +后处理器输入统一 IR 和 OLP 对象模型，输出目标品牌程序文件： + +```text +OLP Object Model + Executable IR + -> ABB RAPID generator + -> FANUC LS/TP-compatible text generator + -> KUKA KRL SRC/DAT generator +``` + +注意：FANUC 二进制 TP 文件通常需要官方工具或控制器环境转换，Web 端应优先生成可读的 LS 风格文本或中间格式，具体落地方式需按现场 FANUC 工具链确认。 + +### 10.2 品牌映射示例 + +GRL： + +```text +movel pick speed linear(300 mm/s) zone z10 tool gripper frame fixture +``` + +ABB RAPID 目标： + +```text +MoveL pick, v300, z10, gripper\WObj:=fixture; +``` + +FANUC 目标： + +```text +L P[10] 300mm/sec CNT10 ; +``` + +KUKA KRL 目标： + +```text +$VEL.CP = 0.3 +LIN XPICK C_DIS +``` + +Path 后处理示例： + +```text +run_path weld_seam_01 +``` + +后处理器应展开为目标品牌的一组运动语句，并输出对应目标点数据。若目标品牌支持工艺包，可同时生成工艺指令；若不支持，则生成 IO 和注释。 + +### 10.3 后处理配置 + +每个品牌一个 profile： + +```json +{ + "brand": "abb", + "controller": "irc5", + "robot": "irb_1200", + "units": { + "length": "mm", + "angle": "deg" + }, + "motion": { + "defaultSpeed": "v300", + "defaultZone": "z10" + }, + "ioMap": { + "clamp_closed": "di1", + "clamp_open": "do1" + } +} +``` + +### 10.4 后处理必须处理的差异 + +1. 目标点数据格式。 +2. 姿态表示方式。 +3. 构型参数。 +4. 外部轴表示。 +5. 工具和工件坐标声明。 +6. 速度和过渡等级。 +7. IO 地址格式。 +8. 程序文件组织。 +9. 行号和标签。 +10. 不支持指令的降级或报错。 +11. Path 默认参数和单点覆盖参数。 +12. Operation 工艺参数到品牌工艺包或 IO 的映射。 +13. 品牌程序数据文件拆分，例如 KUKA `.src/.dat`。 +14. 目标点命名规则和长度限制。 +15. FANUC 点位编号、寄存器、程序行号和 LS 格式限制。 + +### 10.5 后处理质量要求 + +1. 不能静默丢弃语义。 +2. 不支持的指令必须给出明确诊断。 +3. 输出程序必须格式化稳定。 +4. 每个后处理器必须有 golden file 测试。 +5. 必须能生成转换报告，列出警告、限制、映射表和人工确认项。 + +### 10.6 反向后处理：品牌程序导入 + +为了虚拟控制器可以解析多品牌机器人程序，需要建立 Brand Importer： + +```text +ABB RAPID / FANUC LS / KUKA KRL + -> Brand Importer + -> Brand AST + -> Normalized IR + -> Reconstructed GRL + -> Optional OLP Path/Operation Model +``` + +Brand Importer 输出： + +1. `brandAst`：品牌语法树。 +2. `ir`：可执行统一 IR。 +3. `grlSource`：尽量恢复的 GRL 文本。 +4. `olpModelPatch`：恢复出的目标点、路径和操作。 +5. `report`：转换报告。 + +转换报告必须列出： + +1. 成功解析的程序、目标点、工具、坐标系。 +2. 无法识别的品牌指令。 +3. 近似转换的语义。 +4. 丢失或需要人工确认的信息。 +5. 后续导出到其他品牌时的风险。 + +## 11. 虚拟控制器界面设计 + +界面目标是“离线编程和虚拟调试”，不是营销页面。第一屏应直接进入工作台。 + +### 11.1 主界面布局 + +推荐五区布局： + +```text +┌─────────────────────────────────────────────────────────────┐ +│ 顶部工具栏：项目、保存、运行、暂停、停止、单步、后处理 │ +├───────────────┬──────────────────────────┬──────────────────┤ +│ 项目对象树 │ 程序编辑器 / 路径编辑器 │ 虚拟示教器 │ +│ 机器人/路径 │ AST/IR/诊断/日志 tabs │ 状态/坐标/速度 │ +├───────────────┴──────────────────────────┴──────────────────┤ +│ 底部面板：报警、变量、IO、运动队列、调用栈、后处理报告 │ +└─────────────────────────────────────────────────────────────┘ +``` + +项目对象树应按商业 OLP 软件方式组织，而不是只显示文件： + +```text +Station + Cell Layout + Robots + Tools + Frames + Fixtures + Parts + Devices + Geometry + Targets + Paths + Operations + Programs + Brand Imports + Generated Programs + Validation Reports + Calibration +``` + +### 11.2 必须页面 + +1. 项目管理 + - 新建项目 + - 打开项目 + - 导入 zip + - 导出 zip + - 项目设置 + - 生成客户交付包 + - 项目版本快照 + +2. 工作站布局 + - 机器人放置 + - 工具和夹具放置 + - 工件放置 + - 设备和安全区放置 + - 坐标系显示 + - 干涉区显示 + +3. 资源库 + - 机器人库 + - 工具库 + - 夹具库 + - 工艺模板库 + - 后处理 profile 库 + - 资源导入导出 + +4. 几何与 CAD + - 导入 mesh 或 CAD 转换文件 + - 提取点、边、曲线、面法向 + - 从曲线生成 Path + - 显示 CAD source metadata + - 更新 CAD 后重建路径 + +5. 程序编辑 + - GRL 代码编辑 + - 语法高亮 + - 自动补全 + - 错误诊断 + - 跳转定义 + - 格式化 + - 从 Path/Operation 生成 GRL + - 从品牌程序导入后查看恢复的 GRL + +6. 虚拟示教器 + - 控制器状态 + - 手动/自动模式 + - 运行、暂停、停止、复位 + - 单步执行 + - 当前关节值 + - 当前 TCP + - 当前 Tool / Frame + - Override 速度倍率 + +7. IO 面板 + - DI/DO/AI/AO/GI/GO + - IO 别名 + - 手动切换虚拟输入 + - IO 事件日志 + - Wait 条件监控 + - Pulse 状态 + - IO 脚本启停 + - IO trace 回放 + +8. 运动监控 + - 当前运动指令 + - Motion Queue + - 目标点列表 + - 路径点列表 + - Operation 状态 + - IK 状态 + - 奇异点/限位警告 + - 轨迹采样查看 + +9. 路径编辑器 + - 路径点表格 + - 批量设置速度、zone、tool、frame + - 接近点/离开点生成 + - 路径方向反转 + - 点位重命名 + - 姿态策略设置 + - 可达性检查 + - 展开为 GRL 预览 + - 碰撞检查结果 + - 节拍估算 + +10. Operation 编辑器 + - 工艺类型选择 + - 工艺参数编辑 + - start/end action + - before/after path point event + - 工艺 trace 显示 + +11. 验证与报告 + - 可达性报告 + - 碰撞报告 + - 节拍报告 + - IO/Wait 报告 + - 后处理报告 + - 报告导出 JSON/HTML + +12. 校准与现场回读 + - TCP 校准数据 + - 工件坐标校准数据 + - Base 校准数据 + - 现场程序回读 + - 离线/现场差异比对 + +13. 后处理导出 + - 选择品牌 + - 选择 profile + - 生成程序 + - 查看转换报告 + - 导出文件 + +14. 品牌程序导入 + - 选择 ABB/FANUC/KUKA + - 导入文本文件 + - 查看解析结果 + - 查看恢复出的 target/path/program + - 查看不支持语义 + - 转换为 GRL + - 加载到虚拟控制器运行 + +15. 日志和报警 + - 控制器报警 + - 解析错误 + - 运行时错误 + - 后处理警告 + - 品牌导入警告 + +16. Wait 调试面板 + - 当前 wait 指令 + - 等待表达式 + - 子表达式求值 + - 已等待时间 + - 剩余超时时间 + - 关联 IO 点最近变化 + - 手动满足条件按钮，仅调试模式可用 + - 跳过 wait，仅调试模式可用，并必须写入 trace + +### 11.3 控制器面板状态 + +需要显示： + +1. Controller state：Ready、Running、Hold、Fault。 +2. Mode：Manual、Auto。 +3. Motors：On、Off。 +4. Program：当前程序。 +5. Line：当前行。 +6. Cycle time：仿真周期。 +7. Override：速度倍率。 +8. TCP：X、Y、Z、RX、RY、RZ。 +9. Joints：J1 到 J6。 +10. Tool / Frame：当前工具和坐标系。 +11. Path：当前路径。 +12. Path Point：当前路径点。 +13. Operation：当前工艺操作。 +14. Source：当前来源，可能是 GRL、Path、Operation、ABB、FANUC、KUKA。 +15. Wait：当前是否处于等待状态。 +16. Wait Time：当前 wait 已等待时长。 +17. Active IO Script：当前启用的 IO 脚本。 + +### 11.4 编辑器诊断 + +诊断分级： + +| 等级 | 说明 | +| --- | --- | +| Error | 阻止运行或后处理 | +| Warning | 可运行但存在风险 | +| Info | 提示 | +| Hint | 优化建议 | + +示例： + +```text +E1003: target 'pick' is not reachable by robot_1 +W2007: zone z50 may exceed short segment length +W3012: FANUC post does not support this interrupt exactly; generated fallback label logic +W4010: imported KUKA $ADVANCE behavior was approximated by GRL path look-ahead +``` + +### 11.5 IO 面板设计 + +IO 面板应采用表格和过滤器，适合调试时快速定位信号： + +| 列 | 说明 | +| --- | --- | +| Address | `DI[1]`、`DO[2]`、`GI[1]` | +| Alias | `clamp_closed` | +| Value | 当前值 | +| Previous | 上一 tick 值 | +| Source | 最后写入来源：program/user/script/reset | +| Updated | 最后更新时间 | +| Brand | ABB/FANUC/KUKA 映射 | +| Lock | 是否允许手动修改 | + +功能要求： + +1. 按类型过滤：DI、DO、AI、AO、GI、GO。 +2. 按 alias 搜索。 +3. 支持手动切换虚拟输入。 +4. 支持批量 reset。 +5. 支持查看信号最近 N 条事件。 +6. 支持将某个 IO 点加入 watch。 +7. 支持显示哪些 wait 条件依赖该 IO。 + +### 11.6 IO 脚本界面 + +IO 脚本界面用于模拟 PLC 或夹具： + +1. 脚本列表。 +2. 启用/停用。 +3. 单步触发。 +4. 查看已注册 trigger。 +5. 查看计划中的 delayed event。 +6. 查看脚本产生的 IO 写入。 +7. 脚本错误诊断。 + +### 11.7 Wait 调试体验 + +当程序停在 wait 时，界面必须避免只显示“程序卡住”。至少显示： + +```text +Program waiting: + line: 42 + expression: io.alias.clamp_closed == true + DI[1] clamp_closed: false + waited: 1.24 s / timeout: 2.00 s + related output: DO[1] clamp_close_cmd = true +``` + +可选调试动作： + +1. Set DI true：手动满足输入。 +2. Toggle related IO：切换相关信号。 +3. Run IO script：运行关联 IO 脚本。 +4. Skip wait：跳过等待，必须标记 trace 为人工干预。 +5. Abort program：停止程序并生成报警。 + +## 12. 实现路线 + +### 阶段 0：基础工程 + +目标： + +1. 建立 TypeScript 项目结构。 +2. 建立 HTML 工作台页面。 +3. 建立 OPFS workspace。 +4. 建立测试框架。 +5. 建立 KDL WASM 构建原型。 +6. 建立 OLP Object Model 基础类型。 +7. 建立 Station/Resource/Report 基础模型。 + +交付： + +1. 可打开 Web 工作台。 +2. 可新建/保存/导出项目。 +3. 可加载一个机器人模型 JSON。 +4. 可在浏览器调用 KDL WASM 做一次 FK。 +5. 可在对象树中显示 Robot、Tool、Frame、Target、Path、Operation、Program。 +6. 可保存 station.json 和基础资源库。 + +### 阶段 1：GRL 语言最小闭环 + +目标： + +1. 实现 GRL lexer/parser。 +2. 支持 `module`、`proc`、变量、目标点、`path`、`movej`、`movel`、`run_path`、`call`。 +3. 实现 AST、语义检查、诊断。 +4. 实现 OLP Model 到 GRL 的生成器原型。 + +交付： + +1. 编辑器能显示语法错误。 +2. 能将 `main.grl` 编译为 IR。 +3. 能保存 AST/IR 调试输出。 +4. 能从一组规划点生成 path 和 GRL。 + +### 阶段 2：虚拟控制器最小闭环 + +目标： + +1. 实现控制器状态机。 +2. 实现程序加载、运行、暂停、停止、单步。 +3. 实现变量和调用栈。 +4. 实现基础 IO。 + +交付： + +1. 能执行无运动逻辑程序。 +2. 能在 UI 看到当前行、变量、调用栈。 +3. 能模拟 IO wait 和 timeout。 +4. 能执行 `run_path` 展开后的 IR。 + +### 阶段 3：运动执行闭环 + +目标： + +1. 接入 URDF 机器人模型导入和标准模型缓存。 +2. 接入 KDL WASM FK、fkAllLinks、Jacobian、IK、ikBatch。 +3. 实现梯形速度曲线生成和采样。 +4. 实现 `movej` 关节空间轨迹规划。 +5. 实现 `movel` TCP 直线轨迹规划。 +6. 实现基础 `movec` 圆弧轨迹规划。 +7. 实现关节限位、速度限位、加速度限位和 IK 失败报警。 +8. 实现路径点 source map。 +9. 实现可达性报告原型。 + +交付： + +1. 程序能驱动虚拟机器人状态变化。 +2. UI 能看到关节和 TCP 更新。 +3. 能加载 URDF 并显示机器人关节链和 link 位姿。 +4. `MOVEJ/MOVEL/MOVEC` 都能输出 `TrajectoryPoint[]`。 +5. 能导出轨迹 trace。 +6. 能从路径编辑器定位当前运动点。 +7. 能生成 Path 可达性报告。 +8. 能生成基础节拍估算。 + +### 阶段 4：完整基础语言 + +目标： + +1. 支持 `movec`。 +2. 支持 `if/while/for/switch`。 +3. 支持 `Tool`、`Frame`、`Speed`、`Zone`。 +4. 支持中断和报警的基础模型。 +5. 支持 `operation`、path event、start/end action。 + +交付： + +1. 可编写完整搬运类程序。 +2. 可进行基本虚拟调试。 +3. 可查看运动队列和报警。 +4. 可从 Operation 自动生成可执行 GRL。 + +### 阶段 5：后处理 MVP + +目标： + +1. ABB RAPID 后处理。 +2. KUKA KRL 后处理。 +3. FANUC LS 风格后处理。 +4. 后处理报告。 +5. 支持 path 和 operation 展开。 + +交付： + +1. 同一 GRL 程序可导出三种品牌程序。 +2. 每个后处理器有 golden file 测试。 +3. 不支持语义能明确报错。 +4. 同一 Path 可生成 ABB/FANUC/KUKA 运动点和数据文件。 + +### 阶段 6：验证与报告 MVP + +目标： + +1. 可达性报告。 +2. 基础碰撞检测。 +3. 节拍估算。 +4. IO/Wait 报告。 +5. HTML/JSON 报告导出。 + +交付： + +1. 能对单个 Path 生成 reachability report。 +2. 能对机器人和工件/夹具做基础碰撞检测。 +3. 能计算程序总节拍和 wait 耗时。 +4. 能导出验证报告。 + +### 阶段 7：品牌程序导入 + +目标： + +1. ABB RAPID 文本导入。 +2. KUKA KRL `.src/.dat` 导入。 +3. FANUC LS 风格文本导入。 +4. Brand AST 到统一 IR。 +5. 品牌导入转换报告。 + +交付： + +1. 能导入三类品牌程序并显示解析结果。 +2. 能加载导入后的 IR 到虚拟控制器运行。 +3. 能尽量恢复 target/path/program。 +4. 无法等价转换的语义有明确警告。 + +### 阶段 8：虚拟调试增强 + +目标： + +1. 断点。 +2. 单步进入/越过。 +3. 运动断点。 +4. 轨迹回放。 +5. 变量 watch。 +6. IO 脚本。 +7. 品牌源程序行号与 IR 的联动调试。 + +交付： + +1. 可像调试程序一样调试机器人逻辑。 +2. 可复现运行 trace。 +3. 可定位 IK、IO、逻辑错误。 +4. 可在 GRL、Path、Operation、品牌源程序之间定位同一条运动。 + +### 阶段 9：商业级 OLP 扩展 + +目标： + +1. 资源库管理。 +2. CAD/mesh 导入和曲线路径生成。 +3. 工艺模板库。 +4. 校准数据管理。 +5. 客户交付包生成。 + +交付： + +1. 可从几何曲线生成 Path。 +2. 可使用工艺模板生成 Operation。 +3. 可生成客户交付包。 +4. 可保存 TCP/Frame/Base 校准数据。 + +### 阶段 10：工程化与扩展 + +目标： + +1. 多机器人。 +2. 外部轴。 +3. 工艺包。 +4. 碰撞检测。 +5. 真实控制器校验流程集成。 + +交付： + +1. 支持更复杂工作站。 +2. 支持真实项目导入导出流程。 +3. 支持品牌差异配置库。 + +## 13. 测试策略 + +### 13.1 解析器测试 + +1. 合法程序解析快照。 +2. 非法程序错误位置。 +3. 单位解析。 +4. 注释保留。 +5. 品牌扩展属性解析。 +6. `path`、`operation`、`event`、`run_path`、`run_operation` 解析。 +7. 从 OLP Model 生成 GRL 后再解析的一致性测试。 + +### 13.2 语义测试 + +1. 未定义变量。 +2. 类型不匹配。 +3. 工具缺失。 +4. 坐标系缺失。 +5. IO 越界。 +6. 不可达点。 +7. 关节超限。 +8. 空 path。 +9. 重复 path point。 +10. Operation 引用不存在的 path。 +11. Path event 引用不存在的 point。 + +### 13.3 KDL WASM 测试 + +1. URDF 导入测试：能从 URDF 解析 link、joint、origin、axis、limit，并生成稳定 `NormalizedRobotModel`。 +2. URDF 诊断测试：缺少 limit、非法 joint、base/tip 不连通、单位异常时返回明确诊断。 +3. WASM FK 与原生 KDL FK 对比。 +4. `fkAllLinks` 输出 link 位姿数量和 joint 顺序正确。 +5. Jacobian 维度、数值和奇异点指标正确。 +6. IK 求解后再 FK，位置和姿态误差小于容差。 +7. IK seed、多 seed、关节限位和失败原因测试。 +8. 边界关节值。 +9. 奇异点附近诊断。 +10. 梯形速度曲线测试：长距离为梯形，短距离自动退化为三角形。 +11. 梯形采样测试：起点终点速度为 0，`s` 单调递增，末点精确到 1。 +12. `movej` 测试：所有关节同起同停，速度和加速度不超限。 +13. `movel` 测试：TCP 直线误差小于容差，逐点 IK 连续。 +14. `movec` 测试：圆弧半径、圆心、圆弧长度和采样误差小于容差。 +15. `movec` 非法输入测试：三点重合、近似共线、半径过小时返回诊断。 +16. 从 path 批量采样后逐点 IK。 +17. 大型路径批量可达性性能测试。 +18. 轨迹 source map 测试：采样点可定位回 segment、target 和程序行。 +19. 轨迹结果序列化测试：`TrajectoryResult` 可写入 OPFS 后重新加载回放。 +20. 大批量目标点性能测试。 + +### 13.4 虚拟控制器测试 + +1. 状态机转换。 +2. 程序启动/暂停/恢复/停止。 +3. 单步执行。 +4. 调用栈。 +5. IO wait timeout。 +6. 报警复位。 +7. 中断触发。 +8. `run_path` 展开执行。 +9. `run_operation` start/end action 执行。 +10. Source map 能定位到 path point 和品牌源程序行。 +11. wait 条件立即满足。 +12. wait 条件由用户手动 IO 满足。 +13. wait 条件由 IO 脚本延迟满足。 +14. wait timeout 后报警。 +15. wait timeout 后跳转 `on_timeout`。 +16. hold 时 wait timeout 暂停。 +17. stop 时 ActiveWait 取消。 +18. pulse 输出按虚拟时间自动复位。 +19. rising/falling/changed 边沿检测。 +20. IO trace 顺序稳定。 + +### 13.4.1 商业验证测试 + +1. 可达性报告内容完整。 +2. 接近关节限位能产生 warning。 +3. IK 不可达能定位到 path point。 +4. 基础碰撞检测能定位对象和时间点。 +5. 节拍报告能统计 motion time、wait time、IO script delay。 +6. 报告 JSON schema 稳定。 +7. HTML 报告可打开且包含关键摘要。 + +### 13.5 后处理测试 + +1. GRL 到 ABB 输出。 +2. GRL 到 FANUC 输出。 +3. GRL 到 KUKA 输出。 +4. 不支持语义报错。 +5. 速度、过渡、工具、坐标系映射。 +6. 目标点数值格式稳定。 +7. Path 展开后输出稳定。 +8. Operation 工艺参数映射。 + +### 13.6 品牌导入测试 + +1. ABB RAPID 导入到 IR。 +2. KUKA KRL 导入到 IR。 +3. FANUC LS 导入到 IR。 +4. 品牌导入后再导出 GRL。 +5. 品牌导入转换报告。 +6. 不支持品牌指令的诊断。 +7. 导入程序在虚拟控制器中可执行。 + +### 13.7 商业 OLP 工作流测试 + +1. 新建 station。 +2. 从机器人库添加机器人。 +3. 从工具库添加工具。 +4. 导入 mesh。 +5. 从规划点生成 Path。 +6. 从 Path 生成 GRL。 +7. 仿真运行。 +8. 生成报告。 +9. 后处理导出。 +10. 导出客户交付包。 + +## 14. 风险与边界 + +| 风险 | 说明 | 对策 | +| --- | --- | --- | +| 品牌语义不完全一致 | 三家控制器的运动规划、过渡、异常、中断语义不同 | GRL 定义通用语义，后处理报告列出差异 | +| FANUC TP 二进制限制 | Web 端难以直接生成真实 `.TP` 二进制 | 初期生成 LS 风格文本或中间格式，配合 FANUC 工具链 | +| KDL 不负责碰撞检测 | KDL 不是完整仿真引擎 | 运动学先闭环，碰撞检测作为独立模块 | +| 浏览器存储不可见 | OPFS 文件不直接暴露给用户 | 必须提供 zip 导入导出和备份 | +| WASM 初始化成本 | 大型 WASM 初次加载慢 | Worker 懒加载、缓存、进度提示 | +| 数值差异 | WebAssembly、C++、真实控制器结果可能存在差异 | 设置容差，建立真实机器人标定与验证流程 | +| 后处理责任边界 | 导出程序不等于现场可直接高速运行 | 必须生成校验报告，并要求现场低速验证 | + +## 15. 首版 MVP 范围 + +首版建议只做这些能力： + +1. 单机器人 6 轴串联模型，机器人结构使用 URDF 定义。 +2. GRL 程序编辑、解析、诊断。 +3. OLP 对象树：Robot、Tool、Frame、Target、Path、Operation、Program。 +4. 从规划点生成 Path 和 GRL。 +5. `movej`、`movel`、基础 `movec`。 +6. `Tool`、`Frame`、`Speed`、`Zone`。 +7. 基础变量、条件、循环、子程序。 +8. DI/DO 虚拟 IO。 +9. `wait`、`wait timeout`、`pulse`、手动 IO 切换。 +10. 简单 IO 脚本，例如夹爪 DO 触发 DI 反馈。 +11. KDL WASM FK、fkAllLinks、Jacobian、IK、ikBatch。 +12. KDL WASM 梯形速度曲线和 `MOVEJ/MOVEL/MOVEC` 轨迹采样函数。 +13. 虚拟控制器运行、暂停、停止、单步。 +14. OPFS 项目保存。 +15. ABB、FANUC、KUKA 后处理原型。 +16. 至少一种品牌程序导入原型，建议优先 KUKA KRL 或 ABB RAPID 文本。 +17. 基础可达性报告。 +18. 基础节拍报告。 +19. 客户交付包导出原型。 + +不建议首版包含： + +1. 完整碰撞检测。 +2. 多机器人协调。 +3. 外部轴同步。 +4. 完整焊接/喷涂工艺包。 +5. 完整真实控制器通信。 +6. 与真实控制器完全一致的 look-ahead 和伺服行为。 +7. FANUC 二进制 TP 直接生成或直接解析。 +8. 完整 CAD kernel。 +9. 完整 PLC/现场总线实时联调。 +10. 高精度真实控制器轨迹复现。 + +## 16. 验收标准 + +MVP 可按以下标准验收： + +1. 用户能在浏览器中新建项目。 +2. 用户能导入 URDF 机器人模型，并定义工具、工件坐标和目标点。 +3. 用户能从规划点创建 Path。 +4. 用户能从 Path 和 Operation 生成 GRL 程序。 +5. 用户能手工编辑 GRL 程序。 +6. 系统能实时显示语法和语义错误。 +7. 系统能运行程序，显示当前行、变量、IO、报警、TCP、关节。 +8. KDL WASM 能从 URDF 创建运动链，并提供 FK、fkAllLinks、Jacobian、IK、ikBatch。 +9. KDL WASM 能生成梯形速度曲线采样。 +10. `movej`、`movel`、`movec` 可生成轨迹采样点。 +11. MOVEJ 轨迹按关节角度差分运行并满足关节同起同停，MOVEL 轨迹满足 TCP 直线误差容差，MOVEC 轨迹满足 TCP 圆弧误差容差。 +12. 不可达点和超限点能明确报警。 +13. 程序执行到 wait 时，能显示等待表达式、关联 IO、已等待时间和剩余超时时间。 +14. 用户能通过 IO 面板手动满足 wait。 +15. IO 脚本能模拟夹具反馈并自动满足 wait。 +16. wait timeout 能产生报警或执行 on_timeout。 +17. 项目能保存在 OPFS，并能导出 zip。 +18. 同一个 Path/Program 能导出 ABB、FANUC、KUKA 三种目标文本。 +19. 后处理输出有转换报告。 +20. 至少一种品牌程序能导入、转换为 IR 并在虚拟控制器中运行。 +21. 自动测试覆盖解析器、KDL WASM、虚拟控制器、IO/Wait、后处理和品牌导入。 +22. 能生成可达性报告和节拍报告。 +23. 能导出包含源程序、品牌程序、IO map、报告的客户交付包。 + +商业级验收可按以下标准扩展： + +1. 能从资源库创建完整工作站。 +2. 能导入几何模型并从点/曲线生成 Path。 +3. 能对 Path 做批量可达性检查。 +4. 能执行基础碰撞检测并定位碰撞对象。 +5. 能统计程序节拍并分解 motion/wait/IO 时间。 +6. 能保存和应用 TCP、Frame、Base 校准数据。 +7. 能将导入品牌程序恢复为统一 IR 并参与报告。 +8. 能生成客户可交付项目包。 + +## 17. 推荐目录结构 + +未来代码工程可采用如下结构： + +```text +src/ + app/ + main.ts + ui/ + station/ + station-model.ts + cell-layout.ts + resources.ts + devices.ts + resources/ + robot-library.ts + tool-library.ts + fixture-library.ts + process-template-library.ts + geometry/ + mesh-loader.ts + curve-sampling.ts + collision-geometry.ts + core/ + ast/ + parser/ + semantic/ + ir/ + controller/ + runtime/ + motion/ + io/ + io-service.ts + wait-registry.ts + io-script.ts + io-trace.ts + alarm/ + debug/ + kdl-wasm/ + bindings/ + loader.ts + types.ts + workspace/ + opfs.ts + project.ts + import-export.ts + olp/ + model.ts + path.ts + operation.ts + grl-generator.ts + importers/ + abb/ + fanuc/ + kuka/ + post/ + abb/ + fanuc/ + kuka/ + robot/ + model.ts + frames.ts + targets.ts + validation/ + reachability.ts + collision.ts + cycle-time.ts + validation-report.ts + calibration/ + tcp-calibration.ts + frame-calibration.ts + base-calibration.ts + program-diff.ts + reports/ + report-model.ts + html-report.ts + json-report.ts + tests/ +wasm/ + kdl/ +docs/ +``` + +## 18. 近期开发任务清单 + +建议下一步按以下顺序推进： + +1. 固化 GRL 语法草案。 +2. 建立 TypeScript monorepo 或单包工程。 +3. 实现 OPFS 项目读写。 +4. 建立 URDF 导入、诊断和 `NormalizedRobotModel` 缓存。 +5. 编译 KDL WASM 并提供 FK、fkAllLinks、Jacobian、IK、ikBatch API。 +6. 实现 KDL WASM 梯形速度曲线 `makeTrapProfile` 和 `sampleTrapProfile`。 +7. 实现 KDL WASM `moveJ` 轨迹采样。 +8. 实现 KDL WASM `moveL` 轨迹采样。 +9. 实现 KDL WASM `moveC` 轨迹采样。 +10. 实现 `validatePath` 批量可达性和轨迹诊断。 +11. 实现 GRL parser。 +12. 实现语义检查和 IR。 +13. 实现虚拟控制器状态机。 +14. 将 `movej/movel/movec` 执行接入 Motion Queue。 +15. 实现简单 HTML 工作台。 +16. 实现 Path 编辑和 Path 到 GRL 生成。 +17. 实现 ABB/KUKA/FANUC 后处理 MVP。 +18. 实现一个品牌导入 MVP。 +19. 实现虚拟 IO Service、wait、pulse、IO 脚本和 IO 调试面板。 +20. 实现 station/resource 基础模型。 +21. 实现可达性和节拍报告原型。 +22. 实现客户交付包导出原型。 + +## 19. 参考资料 + +1. ABB RAPID Technical Reference Manual，RAPID Instructions, Functions and Data Types： + https://library.e.abb.com/public/b227fcd260204c4dbeb8a58f8002fe64/Rapid_instructions.pdf + +2. ABB RAPID Overview： + https://search.abb.com/library/Download.aspx?Action=Launch&DocumentID=3HAC050947-001&DocumentPartId=&LanguageCode=en + +3. FANUC America Tech Transfer： + https://techtransfer.fanucamerica.com/ + +4. FANUC CRX / Tablet Teach Pendant 公开资料： + https://crx.fanucamerica.com/training/programming-part-1-initial-settings + https://www.fanucamerica.com/products/teach-pendant/tablet-teach-pendant + +5. KUKA KSS 8.7 产品资料与操作编程文档入口： + https://my.kuka.com/s/product/kss-87/01t1i000001PTSOAA4?language=en_US + +6. Orocos KDL 官方文档： + https://docs.orocos.org/kdl/overview.html + https://www.orocos.org/kdl.html + +7. Emscripten Embind 文档： + https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html + +8. MDN OPFS 文档： + https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system + +9. RoboDK Basic Guide，说明离线编程是在离线环境创建、仿真并生成特定机器人和控制器程序： + https://robodk.com/doc/en/Basic-Guide.html + +10. RoboDK Post Processors，说明后处理器负责按具体机器人控制器规则生成程序： + https://robodk.com/doc/en/Post-Processors.html + +11. RoboDK Offline Programming，说明仿真达到预期后通过 post processors 生成机器人程序，并覆盖多品牌机器人： + https://robodk.com/offline-programming + +12. ABB Downloads / RobotStudio SDK，说明 RobotStudio 支持在 PC 上进行机器人仿真和离线编程，而不停止生产： + https://www.abb.com/global/en/areas/robotics/downloads + +13. Siemens Process Simulate，说明在 3D 虚拟环境中维护和优化机器人过程，支持离线编程： + https://www.siemens.com/en-us/products/tecnomatix/process-simulate-software/ + +14. Siemens Robotics Virtual Commissioning，说明虚拟调试用于验证 OLP 创建的机器人程序是否可行、高效，并验证 reach 和 cycle time： + https://www.siemens.com/en-us/technology/robotics-virtual-commissioning/ + +15. Siemens Robotics Programming and Simulation，说明在虚拟调试环境中结合真实控制器代码、机器人程序和硬件验证完整系统功能： + https://www.siemens.com/en-us/products/tecnomatix/offerings/robotics-programming-simulation/ + +16. Visual Components Robot Offline Programming，说明 OLP 软件面向多工业机器人品牌、工艺和复杂度： + https://www.visualcomponents.com/products/robot-offline-programming/ + +17. Visual Components Robot Programming，用于对标机器人工作站规划、调试和离线编程流程： + https://www.visualcomponents.com/use-cases/robot-programming/ + +## 20. 本次修订摘要 + +本次修订重点围绕“对标商业离线编程和虚拟调试软件的做法”完善设计： + +1. 新增商业 OLP 对标定位，明确系统应采用“OLP 对象模型 + 可执行 GRL 程序 + 统一 IR”的双层结构。 +2. 新增商业 OLP 典型工作流，覆盖工作站创建、目标点创建、路径创建、操作创建、GRL 生成、虚拟调试、后处理导出、品牌程序导入。 +3. 扩展 GRL 语法，新增 `path`、`operation`、`run_path`、`run_operation`、path event、工艺参数等设计。 +4. 明确规划点和规划路径生成 GRL 的规则：优先生成 Path 对象，再由 Path 生成程序，而不是直接散落成运动语句。 +5. 新增 OLP Object Model、GRL AST、Brand AST、Executable IR 三层/多树结构，避免路径编辑、仿真执行、品牌导入导出互相耦合。 +6. 新增 ABB RAPID、KUKA KRL、FANUC LS 等品牌程序导入解析路线，使虚拟控制器可以解析多品牌机器人程序并统一执行。 +7. 扩展虚拟控制器设计，要求 IR 保留 GRL、Path、Operation、品牌源程序的 source map，支持跨视图调试。 +8. 扩展界面设计，新增 OLP 对象树、路径编辑器、Operation 编辑器、品牌程序导入向导。 +9. 更新实现路线，将品牌程序导入作为独立阶段，并把 Path/Operation 纳入 MVP 和测试策略。 +10. 补充虚拟 IO 与 wait 实施方案，覆盖 IO 点模型、IO map、wait 条件、超时、边沿检测、pulse、IO 脚本、IO trace、Wait 调试面板和测试验收。 +11. 补充商业级 OLP 能力，覆盖工作站/资源库、CAD 与路径生成、碰撞/可达性/节拍验证、虚拟调试联调、校准与 Sim-to-Real、商业报告和客户交付包。 +12. 补充 KDL WASM 可实施计算函数方案，明确 URDF 作为机器人结构源定义，要求提供 FK、IK、Jacobian、MOVEJ、MOVEL、MOVEC、梯形速度曲线、轨迹采样点、批量路径验证和诊断接口。 diff --git a/work/doc/通用机器人编程语法规范.md b/work/doc/通用机器人编程语法规范.md new file mode 100644 index 0000000..08d1d42 --- /dev/null +++ b/work/doc/通用机器人编程语法规范.md @@ -0,0 +1,1541 @@ +# 通用机器人编程语法规范 + +版本：0.1 +适用范围：离线编程、虚拟控制器、虚拟调试、多品牌后处理 +目标品牌：ABB RAPID、FANUC TP/LS/KAREL 语义、KUKA KRL + +## 1. 设计目标 + +本规范定义一种用于离线编程和虚拟调试的通用机器人程序语言，暂定名为 GRL，Generic Robot Language。GRL 不是复制某一家机器人厂商语言，而是抽象 ABB、FANUC、KUKA 等主流工业机器人共同具备的程序语义，形成稳定、可解析、可仿真、可自动生成、可后处理的中性机器人程序。 + +核心目标： + +1. 支持离线编程的完整流程：目标点、路径、工艺、IO、等待、流程控制、报警、仿真执行、报告和后处理。 +2. 方便由规划点、CAD 曲线、工艺模板、AI 规划器自动生成程序。 +3. 方便转换为 ABB RAPID、FANUC LS/TP 风格文本、KUKA KRL。 +4. 方便反向导入品牌程序，恢复为统一 IR、GRL 和 OLP 对象模型。 +5. 程序文本稳定、可读、可 diff，便于版本管理。 +6. 语义确定，编译后能生成统一可执行 IR，虚拟控制器不依赖品牌控制器细节。 + +非目标： + +1. 不追求完全复刻某一品牌控制器所有系统变量和内部调度细节。 +2. 不直接作为真实机器人安全运行的唯一依据，后处理输出必须经过品牌控制器验证和现场低速试运行。 +3. 不把 CAD、碰撞检测、机器人运动学全部写入语言本身；这些由 OLP 模型和仿真内核承担。 + +## 2. 对标原则 + +### 2.1 品牌能力映射 + +| 能力 | ABB RAPID | FANUC TP/LS | KUKA KRL | GRL | +| --- | --- | --- | --- | --- | +| 程序模块 | `MODULE` | TP 程序、KAREL 程序 | `.src/.dat`、`DEF` | `module` | +| 子程序 | `PROC` | `CALL` | `DEF` 子程序 | `proc` | +| 函数 | `FUNC` | KAREL function | `DEFFCT` | `func` | +| 中断/陷阱 | `TRAP`、interrupt | 条件监控、后台逻辑 | `INTERRUPT` | `trap`、`interrupt` | +| 关节运动 | `MoveJ` | `J P[...]` | `PTP` | `movej` | +| 直线运动 | `MoveL` | `L P[...]` | `LIN` | `movel` | +| 圆弧运动 | `MoveC` | `C P[...]` | `CIRC` | `movec` | +| 笛卡尔目标点 | `robtarget` | `P[]`、`PR[]` | `E6POS` | `pose_target` | +| 关节目标点 | `jointtarget` | joint position data | `E6AXIS` | `joint_target` | +| 工具 | `tooldata` | UTOOL | `$TOOL` | `tool` | +| 工件/基坐标 | `wobjdata` | UFRAME | `$BASE` | `frame` | +| 速度 | `speeddata` | `%`、`mm/sec` | `$VEL`、`$ACC` | `speed` | +| 过渡 | `zonedata`、`fine` | `FINE`、`CNT` | `C_DIS`、`C_PTP`、`APO` | `zone` | +| IO | `SetDO`、`WaitDI` | `DO[]`、`DI[]`、`WAIT` | `$OUT[]`、`$IN[]`、`WAIT FOR` | `io.*`、`wait` | +| 标签跳转 | `GOTO` | `LBL`、`JMP` | `GOTO` | `label`、`jump` | + +### 2.2 中性语法风格 + +GRL 采用“声明式数据 + 结构化程序 + Path/Operation 对象”的风格： + +1. 目标点、工具、坐标系、速度、过渡作为数据声明。 +2. 程序流程使用 `proc`、`if`、`while`、`for`、`switch` 等结构化控制。 +3. 短程序和调试程序可直接写 `movej/movel/movec`。 +4. 自动离线编程优先生成 `path` 和 `operation`，程序中通过 `run_path`、`run_operation` 调用。 +5. 所有运动语句显式绑定目标点、速度、过渡、工具、坐标系，允许默认值，但编译到 IR 前必须解析为确定值。 +6. 品牌特性通过 `post_hint` 和 `@brand.*` 元数据保留，不污染通用语义。 + +## 3. 文件与工程结构 + +推荐一个 OLP 项目使用以下结构： + +```text +project.json +robots/ + robot_1.urdf + robot_1.meta.json +programs/ + main.grl + weld.grl +targets/ + main.targets.json +paths/ + weld_path.path.json +operations/ + weld_op.operation.json +io/ + io_map.json +post/ + abb.profile.json + fanuc.profile.json + kuka.profile.json +generated/ + abb/ + fanuc/ + kuka/ +reports/ + reachability.json + cycle_time.json +``` + +GRL 文件扩展名建议使用 `.grl`。 + +## 4. 词法规则 + +### 4.1 编码和大小写 + +1. 文件编码使用 UTF-8。 +2. 关键字建议小写。 +3. 标识符大小写敏感，推荐使用 `snake_case`。 +4. 后处理器输出到品牌程序时按品牌习惯调整大小写。 + +### 4.2 注释 + +```text +// 单行注释 + +/* + 多行注释 +*/ +``` + +自动生成程序应在关键对象上保留来源注释，但不要为每个采样点生成大量冗余注释。 + +### 4.3 标识符 + +```text +identifier = letter { letter | digit | "_" } +``` + +示例： + +```text +pick_path +weld_op_01 +T_curve_032_000 +``` + +不建议使用中文标识符。UI 可显示中文别名，但程序内部名称应保持 ASCII，便于后处理和版本管理。 + +### 4.4 字面量和单位 + +支持带单位数值： + +```text +100 mm +0.25 m +180 deg +3.14159 rad +300 mm/s +50 % +2 s +200 ms +2.5 kg +``` + +编译器内部统一规范化： + +| 物理量 | 内部单位 | +| --- | --- | +| 长度 | meter | +| 角度 | radian | +| 时间 | second | +| 质量 | kilogram | +| 线速度 | meter/second | +| 角速度 | radian/second | +| 加速度 | meter/second^2 或 radian/second^2 | + +### 4.5 保留关键字 + +```text +language module import end +persistent const var +robot tool frame load target speed zone path operation process +proc func return call +if elseif else switch case default while for to step break continue +label jump +movej movel movec run_path run_operation +set_tool set_frame set_speed set_zone +wait pulse timer +io true false all any rising falling changed +trap interrupt enable disable raise alarm try catch finally +task sync +post_hint source defaults point event before after at +joint_target pose_target pose poseq joints robot_config ext_axis +fine continuous cnt z +``` + +## 5. 顶层结构 + +### 5.1 最小文件 + +```text +language grl 0.1 + +module Main + proc main() + // program entry + end +end +``` + +`language grl 0.1` 用于版本控制。后续语言升级时，编译器可按版本选择兼容规则。 + +### 5.2 顶层声明 + +```text +module ModuleName + import CommonTools + + persistent tool gripper = ... + persistent frame fixture = ... + const speed v_pick = linear(300 mm/s) + const zone z_pick = z10 + + target home = ... + path pick_path { ... } + operation pick_op { ... } + + proc main() + ... + end +end +``` + +顶层可包含： + +1. `import` +2. `persistent` +3. `const` +4. `target` +5. `path` +6. `operation` +7. `proc` +8. `func` +9. `trap` +10. `task` +11. `post_hint` + +## 6. 类型系统 + +### 6.1 基础类型 + +| 类型 | 说明 | +| --- | --- | +| `bool` | 布尔值 | +| `int` | 整数 | +| `real` | 浮点数 | +| `string` | 字符串 | +| `time` | 时间 | +| `length` | 长度 | +| `angle` | 角度 | +| `percent` | 百分比 | + +### 6.2 机器人类型 + +| 类型 | 说明 | +| --- | --- | +| `pose` | 笛卡尔位姿 | +| `joint_array` | 关节数组 | +| `pose_target` | 笛卡尔目标点 | +| `joint_target` | 关节目标点 | +| `tool` | 工具 TCP、负载、惯量 | +| `frame` | 工件坐标或基坐标 | +| `speed` | 运动速度参数 | +| `zone` | 到点/过渡参数 | +| `load` | 负载 | +| `robot_config` | 肩、肘、腕等机器人配置 | +| `ext_axis` | 外部轴 | +| `path` | 路径对象 | +| `operation` | 工艺操作对象 | + +### 6.3 变量声明 + +```text +const int max_retry = 3 +var int retry = 0 +var bool part_ok = false +var pose_target p_tmp = pick offset z 100 mm +persistent real counter = 0 +``` + +规则： + +1. `const` 编译后不可修改。 +2. `persistent` 在项目或控制器状态中持久化。 +3. `var` 默认为局部变量。 +4. 类型可以显式写出，自动生成程序建议显式写出。 + +## 7. 坐标、工具和目标点 + +### 7.1 工具 + +```text +persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 180 mm, 0 deg, 0 deg, 0 deg), + mass: 2.5 kg, + cog: [0 mm, 0 mm, 80 mm] +} +``` + +### 7.2 工件坐标 + +```text +persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 200 mm, 0 deg, 0 deg, 0 deg) +} +``` + +### 7.3 关节目标点 + +```text +target home = joint_target { + joints: [0 deg, -30 deg, 60 deg, 0 deg, 60 deg, 0 deg] +} +``` + +`joint_target` 主要用于 `movej`，后处理可映射到 ABB `jointtarget`、KUKA `E6AXIS` 或 FANUC 关节位置数据。 + +### 7.4 笛卡尔目标点 + +```text +target pick = pose_target { + pose: pose(500 mm, 120 mm, 300 mm, 180 deg, 0 deg, 90 deg), + config: robot_config(0, 0, 1), + tool: gripper, + frame: fixture +} +``` + +`pose()` 参数顺序为： + +```text +pose(x, y, z, rx, ry, rz) +``` + +首版 `rx/ry/rz` 使用固定约定的欧拉角，建议内部立即转换为四元数。为了避免姿态歧义，也允许使用四元数： + +```text +poseq(500 mm, 120 mm, 300 mm, 0, 0, 0.7071068, 0.7071068) +``` + +### 7.5 偏移目标点 + +```text +var pose_target approach = pick offset z 100 mm +var pose_target p2 = pick offset x 20 mm y -10 mm z 50 mm +``` + +偏移默认在目标点所属 `frame` 下解释。需要明确坐标系时： + +```text +var pose_target p3 = pick offset_in tool z -50 mm +var pose_target p4 = pick offset_in frame fixture x 100 mm +``` + +## 8. 速度和过渡 + +### 8.1 速度 + +```text +const speed v_joint_fast = joint(80 %) +const speed v_joint_abs = joint(90 deg/s) +const speed v_pick = linear(300 mm/s) +const speed v_weld = linear(120 mm/s) +const speed v_orient = angular(90 deg/s) +``` + +运动语义： + +1. `joint(...)` 用于关节运动速度。 +2. `linear(...)` 用于 TCP 线速度。 +3. `angular(...)` 可作为姿态插补角速度限制。 +4. 加速度可作为可选参数： + +```text +const speed v_slow = linear(100 mm/s, acc 500 mm/s2) +``` + +### 8.2 过渡 + +```text +const zone z_fine = fine +const zone z10 = z(10 mm) +const zone z50 = z(50 mm) +const zone z_cnt = cnt(30) +const zone z_cont = continuous +``` + +语义： + +1. `fine`：精确到点，不做过渡。 +2. `z(distance)`：以距离近似表示过渡半径，便于映射 ABB `zonedata` 和 KUKA `APO`。 +3. `cnt(percent)`：以百分比表示连续过渡，便于映射 FANUC `CNT`。 +4. `continuous`：允许连续通过，实际过渡由后处理器或虚拟控制器策略决定。 + +## 9. 运动指令 + +### 9.1 基本语法 + +```text +movej TargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +movel TargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +movec via ViaTargetExpr target EndTargetExpr [speed Speed] [zone Zone] [tool Tool] [frame Frame] +``` + +示例： + +```text +movej home speed joint(60 %) zone fine tool gripper frame fixture +movel pick speed linear(300 mm/s) zone z10 +movec via arc_mid target arc_end speed linear(150 mm/s) zone fine +``` + +### 9.2 MOVEJ 语义 + +`movej` 表示关节空间运动。机器人按各轴关节角度差分运行，关节同起同停，TCP 轨迹不要求是直线。 + +编译规则： + +1. 目标为 `joint_target` 时直接使用关节数组。 +2. 目标为 `pose_target` 时先用 IK 求终点关节。 +3. 轨迹按关节空间插补。 +4. 后处理映射： + - ABB：`MoveJ` + - FANUC：`J P[...]` + - KUKA：`PTP` + +### 9.3 MOVEL 语义 + +`movel` 表示 TCP 直线运动。TCP 沿起点到终点的空间直线运行，关节角由每个 TCP 采样点 IK 求解。 + +编译规则： + +1. 目标必须能解析为笛卡尔位姿。 +2. 当前点作为直线起点。 +3. 姿态按默认策略插补，首版推荐固定姿态或 slerp。 +4. 后处理映射： + - ABB：`MoveL` + - FANUC：`L P[...]` + - KUKA：`LIN` + +### 9.4 MOVEC 语义 + +`movec` 表示 TCP 圆弧运动。TCP 从当前点出发，经过 via 点，到达 target 点，沿圆弧运行，关节角由每个圆弧采样点 IK 求解。 + +编译规则： + +1. 起点为当前 TCP。 +2. `via` 和 `target` 必须能解析为笛卡尔位姿。 +3. 三点不能重合或近似共线。 +4. 首版使用 via 点位置约束圆弧，姿态按起点到终点插补。 +5. 后处理映射： + - ABB：`MoveC` + - FANUC：`C P[...]` + - KUKA：`CIRC` + +### 9.5 当前工具和当前坐标 + +```text +set_tool gripper +set_frame fixture +set_speed linear(300 mm/s) +set_zone z10 +``` + +参数优先级： + +1. 运动语句显式参数最高。 +2. `path defaults` 次之。 +3. 目标点自带 `tool/frame` 次之。 +4. 当前控制器状态最低。 + +编译到 IR 时，所有运动必须有确定的 `tool`、`frame`、`speed`、`zone`。 + +## 10. Path 语法 + +Path 是自动离线编程的核心对象。CAD 曲线、规划点、示教点、工艺模板应优先生成 Path，而不是直接生成散乱运动语句。 + +### 10.1 基本语法 + +```text +path pick_path { + defaults { + tool: gripper, + frame: fixture, + speed: linear(300 mm/s), + zone: z10 + } + + point approach movej home zone fine + point p1 movel pick offset z 100 mm + point p2 movel pick zone fine +} +``` + +### 10.2 圆弧点 + +```text +path arc_path { + defaults { + tool: torch, + frame: part_frame, + speed: linear(120 mm/s), + zone: fine + } + + point p0 movej start + point p1 movec via mid target end +} +``` + +### 10.3 来源元数据 + +```text +path curve_032_generated { + source { + type: cad_curve + id: "edge_032" + sample_distance: 5 mm + normal_strategy: surface_normal + } + + defaults { + tool: spray_gun, + frame: part_frame, + speed: linear(500 mm/s), + zone: z20, + posture: follow_normal + } + + point p000 movel T_curve_032_000 zone fine + point p001 movel T_curve_032_001 + point p002 movel T_curve_032_002 +} +``` + +来源元数据用于： + +1. 路径重采样。 +2. 目标点重命名。 +3. 重新生成程序。 +4. 报告中定位到 CAD 曲线或工艺对象。 + +### 10.4 Path event + +```text +event before p001 io.do[10] = true +event after p010 io.do[10] = false +event at p005 distance -20 mm pulse io.do[20] duration 100 ms +``` + +语义： + +1. `before`：到达路径点之前执行。 +2. `after`：完成路径点之后执行。 +3. `at ... distance`：相对路径点提前或滞后触发，首版可编译为最近采样点事件。 +4. 后处理到品牌程序时，若品牌不支持精确路径触发，应生成转换报告。 + +### 10.5 `run_path` + +```text +proc main() + run_path pick_path +end +``` + +编译语义： + +1. 展开 Path 的 defaults、points、events。 +2. 每个 point 变为 Motion IR。 +3. event 变为 IO/Wait/Process IR。 +4. 保留 source map，调试时可从程序行定位到路径点。 + +## 11. Operation 语法 + +Operation 表达工艺语义，比 Path 更高一层。 + +```text +operation weld_op_01 { + kind: arc_welding + path: weld_seam_01 + + process { + weld_id: "WELD_1" + voltage: 24.0 + current: 180.0 + weave: none + } + + start_action: + io.do[20] = true + + end_action: + io.do[20] = false +} +``` + +首版建议支持的 `kind`： + +| kind | 用途 | +| --- | --- | +| `handling` | 搬运、上下料 | +| `arc_welding` | 弧焊 | +| `spot_welding` | 点焊 | +| `dispensing` | 涂胶 | +| `spraying` | 喷涂 | +| `grinding` | 打磨 | +| `cutting` | 切割 | +| `generic_path` | 通用路径 | + +`run_operation`： + +```text +proc main() + run_operation weld_op_01 +end +``` + +编译语义： + +1. 执行 `start_action`。 +2. 执行 operation 引用的 path。 +3. 执行 `end_action`。 +4. 保留工艺参数，供仿真 UI、报告和后处理使用。 + +## 12. IO 与等待 + +### 12.1 IO 地址 + +```text +io.di[1] +io.do[1] +io.ai[1] +io.ao[1] +io.gi[1] +io.go[1] +io.ri[1] +io.ro[1] +``` + +推荐通过 `io_map.json` 提供别名： + +```text +io.alias.clamp_open +io.alias.clamp_closed +io.alias.gripper_close_cmd +``` + +### 12.2 IO 写入 + +```text +io.do[1] = true +io.go[1] = 16 +io.ao[1] = 3.5 +``` + +### 12.3 wait + +```text +wait io.di[1] == true +wait io.alias.clamp_closed == true timeout 2 s +wait io.ai[2] > 3.5 timeout 1.5 s +wait all(io.di[1] == true, io.di[2] == false) +wait any(io.di[10] == true, timer.done("T_PICK")) +wait rising(io.di[4]) timeout 5 s +wait falling(io.di[5]) timeout 5 s +``` + +超时处理： + +```text +wait io.di[1] == true timeout 2 s on_timeout alarm "Clamp close timeout" +wait io.di[1] == true timeout 2 s on_timeout call recover_clamp() +``` + +### 12.4 pulse + +```text +pulse io.do[3] duration 200 ms +``` + +虚拟控制器语义： + +1. 立即置位输出。 +2. 虚拟时间到达 duration 后自动复位。 +3. trace 中必须记录置位和复位事件。 + +## 13. 流程控制 + +流程控制用于表达工艺分支、重试、配方选择、批量工位循环和异常恢复。GRL 新程序应优先使用结构化控制流；`label/jump` 主要用于兼容 FANUC TP/LS 等已有程序导入。 + +### 13.1 条件 `if / elseif / else` + +```text +if part_ok + run_path good_path +elseif retry < 3 + call retry_pick() +else + alarm "Pick failed" +end +``` + +语义规则： + +1. `if` 条件表达式必须能转换为 `bool`。 +2. `elseif` 可以出现零次或多次。 +3. `else` 最多出现一次，且必须位于所有 `elseif` 之后。 +4. 条件按顺序求值，命中第一条为 true 的分支后，不再执行后续分支。 +5. 每个 `if` 必须以 `end` 结束。 +6. 条件表达式允许访问变量、IO、函数返回值和比较表达式。 +7. 运动指令允许出现在任意分支内，但编译器必须保证每条分支中的工具、坐标系、速度和 zone 可解析。 + +常用条件表达式： + +```text +if io.di[1] == true +if count >= 3 and not part_ok +if is_part_ready() +if recipe_id == 2 or recipe_id == 3 +``` + +### 13.2 `while` 循环 + +```text +while retry < 3 + call try_pick() + if part_ok + break + end + retry = retry + 1 +end +``` + +语义规则： + +1. `while` 条件必须为 `bool`。 +2. 每次进入循环前求值。 +3. `break` 立即退出当前循环。 +4. `continue` 跳过本轮剩余语句，进入下一轮条件判断。 +5. 编译器建议对可能无限循环的 `while true` 给出 warning，除非循环体内包含明确的 `break`、`return`、`raise` 或 `wait`。 + +### 13.3 `for` 循环 + +```text +for i = 0 to 9 step 1 + call process_slot(i) +end +``` + +也允许省略 `step`，默认步长为 `1`： + +```text +for layer = 1 to layer_count + call weld_layer(layer) +end +``` + +反向循环： + +```text +for i = 10 to 0 step -1 + call clear_slot(i) +end +``` + +语义规则： + +1. 循环变量默认是当前 `for` 块局部变量。 +2. 起点、终点、步长必须是整数或可安全转换为整数。 +3. `step` 不能为 `0`。 +4. `break` 和 `continue` 只影响当前最近一层循环。 +5. 后处理到不支持结构化 `for` 的品牌时，可展开为标签和跳转，但必须保持 source map。 + +### 13.4 `switch / case / default` + +```text +switch recipe_id + case 1 + run_operation op_a + case 2 + run_operation op_b + default + alarm "Unknown recipe" +end +``` + +语义规则： + +1. `switch` 表达式可以是 `int`、`bool`、`string` 或枚举型。 +2. `case` 值必须是常量表达式。 +3. 每个 `case` 默认不向下贯穿，不需要写 `break`。 +4. `default` 最多出现一次。 +5. 若需要多个值进入同一分支，可以使用逗号： + +```text +switch recipe_id + case 1, 2, 3 + run_operation common_recipe + case 10 + run_operation special_recipe + default + alarm "Unknown recipe" +end +``` + +6. 导出到 FANUC TP/LS 时，`switch` 可转换为 `SELECT`、条件跳转或 `LBL/JMP` 组合。 +7. 导出到 ABB/KUKA 时，优先转换为品牌结构化分支。 + +### 13.5 `break` 和 `continue` + +```text +while true + call check_part() + if part_ok + break + end + retry = retry + 1 + if retry < max_retry + continue + end + alarm "Retry failed" + break +end +``` + +规则： + +1. `break` 只能出现在 `while`、`for` 或 `switch` 中。 +2. `continue` 只能出现在 `while` 或 `for` 中。 +3. 在 `switch` 中不需要 `break` 防止贯穿，因为 GRL 默认不贯穿。 + +### 13.6 label 和 jump + +```text +label retry +call try_pick() +if not part_ok + jump retry +end +``` + +新程序不建议优先使用 `label/jump`，但必须支持它，因为 FANUC TP/LS 程序常用 `LBL/JMP`，导入时需要映射。 + +`label/jump` 规则： + +1. `label` 名称在当前 `proc` 内唯一。 +2. `jump` 只能跳转到当前 `proc` 内的 label。 +3. 禁止 `jump` 进入另一个 `if/while/for/switch/try` 块内部。 +4. 允许 `jump` 跳出块结构，但编译器应生成 warning。 +5. 自动生成的新程序不应使用 `label/jump`，除非目标后处理配置要求 FANUC 风格输出。 + +## 14. 子程序和函数 + +### 14.1 `proc` 子程序 + +`proc` 是无返回值子程序，用于组织工艺步骤、运动流程、IO 流程和恢复逻辑。 + +```text +proc pick_part(int slot) + movej home speed joint(60 %) zone fine + run_path pick_path +end +``` + +调用： + +```text +call pick_part(1) +call pick_part(slot_id) +``` + +语义规则： + +1. `proc` 可以执行运动、IO、wait、run_path、run_operation。 +2. `proc` 可以调用其他 `proc`。 +3. 默认不允许无限递归。编译器应检测直接递归和明显的间接递归，并给出 warning 或 error。 +4. `return` 可以提前退出 `proc`，但不能携带返回值。 +5. `proc main()` 是默认入口。一个模块中最多一个默认入口。 + +### 14.2 参数方向 + +参数支持 `in`、`out`、`inout` 三种方向。未写方向时默认为 `in`。 + +```text +proc pick_part(in int slot) + call move_to_slot(slot) +end + +proc read_part(out bool ok) + ok = io.di[1] +end + +proc increment_retry(inout int retry) + retry = retry + 1 +end +``` + +规则： + +1. `in` 参数按值传入，子程序内修改不影响调用者。 +2. `out` 参数调用前不要求有有效值，子程序必须在所有正常返回路径上赋值。 +3. `inout` 参数按引用语义传入，子程序内修改会回写调用者。 +4. `out` 和 `inout` 实参必须是可赋值左值，不能是字面量或表达式。 +5. 后处理到不支持显式参数方向的品牌时，可生成临时变量、寄存器或转换报告。 + +调用示例： + +```text +var bool ok = false +var int retry = 0 + +call read_part(ok) +call increment_retry(retry) +``` + +### 14.3 `func` 函数 + +`func` 有返回值，适合计算条件、选择目标点、计算偏移、读取配方参数。函数应尽量无副作用。 + +```text +func bool is_part_ready() + return io.di[1] == true and io.di[2] == false +end +``` + +带参数函数： + +```text +func pose_target slot_pose(int slot) + return base_pick offset x (slot * 50 mm) +end + +func bool can_retry(int retry, int max_retry) + return retry < max_retry +end +``` + +调用方式： + +```text +if can_retry(retry, max_retry) + call retry_pick() +end + +movel slot_pose(slot_id) speed linear(200 mm/s) zone z10 +``` + +规则： + +1. `func` 必须声明返回类型。 +2. 所有正常返回路径必须返回兼容类型的值。 +3. `func` 允许调用其他 `func`。 +4. `func` 默认不允许执行运动指令、`wait`、`pulse`、`run_path`、`run_operation`。编译器应把这类用法作为 error 或强 warning。 +5. 如果确实需要带副作用的逻辑，应使用 `proc`。 + +### 14.4 作用域和名称解析 + +名称解析顺序： + +1. 当前块局部变量。 +2. 当前 `proc/func` 参数。 +3. 当前模块中的 `const/var/persistent/target/path/operation/proc/func`。 +4. `import` 模块导出的符号。 +5. 内置函数和内置类型。 + +规则： + +1. 内层局部变量允许遮蔽外层变量，但编译器应对同名遮蔽给出 warning。 +2. 不允许局部变量与同一作用域内的 `proc/func/target/path/operation` 重名。 +3. `for` 循环变量只在循环体内有效。 +4. `label` 只在当前 `proc` 内有效。 + +### 14.5 子程序调用和后处理 + +后处理映射： + +| GRL | ABB RAPID | FANUC LS/TP | KUKA KRL | +| --- | --- | --- | --- | +| `proc name()` | `PROC name()` | `/PROG NAME` 或子程序 | `DEF name()` | +| `call sub()` | `sub;` 或 `sub()` | `CALL SUB` | `sub()` | +| `return` | `RETURN` | `END`/跳转近似 | `RETURN` | +| `out/inout` 参数 | `VAR` 参数或数据变量 | 寄存器/PR/临时变量近似 | 参数或全局变量近似 | + +如果目标品牌或输出格式不支持某种参数模式，后处理器必须生成转换报告，不能静默丢失语义。 + +## 15. 异常、报警和中断 + +### 15.1 alarm 和 raise + +```text +alarm "Part not detected" +raise E_PICK_FAILED +``` + +### 15.2 try/catch + +```text +try + run_operation pick_op +catch E_PICK_FAILED + call recover_pick() +finally + io.do[1] = false +end +``` + +首版可先实现 `alarm`、`raise` 和简单 `catch`，复杂品牌错误恢复分阶段支持。 + +### 15.3 trap 和 interrupt + +```text +trap emergency_stop() + stop_motion + io.do[100] = false + alarm "Emergency stop input" +end + +interrupt e_stop when io.di[100] == true call emergency_stop() +enable interrupt e_stop +disable interrupt e_stop +``` + +后处理映射： + +1. ABB 可映射到 `TRAP` 和 interrupt 机制。 +2. KUKA 可映射到 `INTERRUPT DECL`、`INTERRUPT ON/OFF` 等近似结构。 +3. FANUC 首版可生成后台逻辑、条件监控或转换报告。 + +## 16. 多任务 + +首版只定义语法，不要求完整实现多任务实时调度： + +```text +task background monitor_io cycle 20 ms + if io.di[99] == true + alarm "Safety signal lost" + end +end +``` + +虚拟控制器可先按周期任务模拟；后处理时根据品牌能力生成后台任务或转换报告。 + +## 17. 品牌扩展和后处理提示 + +### 17.1 post_hint + +```text +post_hint abb { + module_name: "MainModule" + use_wobj: true +} + +post_hint fanuc { + program_name: "MAIN" + default_uframe: 1 + default_utool: 1 +} + +post_hint kuka { + src_name: "MAIN" + dat_name: "MAIN" + advance: 3 +} +``` + +### 17.2 brand metadata + +```text +@brand.abb { + conf_l: true +} + +@brand.fanuc { + group: 1 + cnt: 50 +} + +@brand.kuka { + c_dis: true +} +``` + +规则： + +1. `@brand.*` 只影响指定品牌后处理。 +2. 通用虚拟控制器不应依赖品牌 metadata 才能执行。 +3. 无法支持的品牌扩展必须进入转换报告。 + +## 18. 自动编程生成规则 + +自动生成 GRL 时，应遵循以下规则： + +1. 优先生成 `target`、`path`、`operation`，不要直接把大量运动语句塞进 `proc main()`。 +2. 目标点命名稳定，推荐 `T_{path}_{index}` 或语义名称，例如 `T_PICK_APPROACH`。 +3. 路径点命名稳定，推荐 `p000`、`p001`、`p002`。 +4. 路径整体参数放入 `defaults`，单点差异写在 point 上。 +5. 接近点、工艺开始点、工艺结束点、离开点必须显式标注。 +6. IO、夹具、焊接开关、喷涂开关应生成 path event 或 operation action。 +7. CAD 来源、曲线 ID、采样距离、法向策略必须写入 `source`。 +8. 自动生成文本必须格式化稳定，同一输入重复生成结果一致。 +9. 编译器应能把 GRL 再解析回等价 OLP 对象模型。 +10. 后处理器应能选择 `compact` 或 `expanded` 输出风格。 + +生成风格： + +```text +// compact +proc main() + run_operation weld_op_01 +end + +// expanded +proc main() + movel T001 speed linear(120 mm/s) zone z5 tool torch frame part_frame + movel T002 speed linear(120 mm/s) zone z5 tool torch frame part_frame +end +``` + +## 19. 后处理映射规则 + +### 19.1 ABB RAPID + +| GRL | ABB RAPID | +| --- | --- | +| `module` | `MODULE` | +| `proc` | `PROC` | +| `movej` | `MoveJ` | +| `movel` | `MoveL` | +| `movec` | `MoveC` | +| `pose_target` | `robtarget` | +| `joint_target` | `jointtarget` | +| `tool` | `tooldata` | +| `frame` | `wobjdata` | +| `linear(300 mm/s)` | `v300` 或自定义 `speeddata` | +| `fine`、`z(10 mm)` | `fine`、`z10` 或自定义 `zonedata` | +| `io.do[1] = true` | `SetDO do1, 1` | +| `wait io.di[1] == true` | `WaitDI di1, 1` | + +示例： + +```text +movel pick speed linear(300 mm/s) zone z10 tool gripper frame fixture +``` + +可后处理为： + +```text +MoveL pick, v300, z10, gripper\WObj:=fixture; +``` + +### 19.2 FANUC LS/TP 风格 + +| GRL | FANUC | +| --- | --- | +| `proc main()` | `/PROG MAIN` | +| `movej` | `J P[...]` | +| `movel` | `L P[...]` | +| `movec` | `C P[...]` | +| `pose_target` | `P[...]` 或 `PR[...]` | +| `tool` | UTOOL | +| `frame` | UFRAME | +| `joint(50 %)` | `50%` | +| `linear(300 mm/s)` | `300mm/sec` | +| `fine` | `FINE` | +| `cnt(50)` | `CNT50` | +| `io.do[1] = true` | `DO[1]=ON` | +| `wait io.di[1] == true` | `WAIT DI[1]=ON` | + +示例： + +```text +movel P10 speed linear(300 mm/s) zone cnt(10) +``` + +可后处理为： + +```text +L P[10] 300mm/sec CNT10 ; +``` + +### 19.3 KUKA KRL + +| GRL | KUKA KRL | +| --- | --- | +| `proc main()` | `DEF MAIN()` | +| `movej` | `PTP` | +| `movel` | `LIN` | +| `movec` | `CIRC` | +| `pose_target` | `E6POS` | +| `joint_target` | `E6AXIS` | +| `tool` | `$TOOL` | +| `frame` | `$BASE` | +| `linear(300 mm/s)` | `$VEL.CP = 0.3` | +| `fine` | no approximation | +| `continuous`、`z(...)` | `C_DIS` 或 `$APO` | +| `io.do[1] = true` | `$OUT[1] = TRUE` | +| `wait io.di[1] == true` | `WAIT FOR $IN[1] == TRUE` | + +示例： + +```text +movel XPICK speed linear(300 mm/s) zone continuous +``` + +可后处理为： + +```text +$VEL.CP = 0.3 +LIN XPICK C_DIS +``` + +## 20. 编译语义和 IR + +编译管线： + +```text +GRL Source + -> Lexer + -> Parser + -> AST + -> Symbol Table + -> Semantic Analyzer + -> Executable IR + -> Virtual Controller + -> Post Processor +``` + +运动 IR 示例： + +```ts +interface MotionInstruction { + kind: "motion"; + motionType: "joint" | "linear" | "circular"; + target: TargetRef | ResolvedTarget; + via?: TargetRef | ResolvedTarget; + speed: SpeedSpec; + zone: ZoneSpec; + tool: ToolRef; + frame: FrameRef; + sourceRange: SourceRange; + sourceObject?: { + pathId?: string; + pointId?: string; + operationId?: string; + }; + brandMeta?: Record; +} +``` + +## 21. 语义检查 + +编译器必须检查： + +1. 标识符是否重复或未声明。 +2. 类型是否匹配。 +3. 目标点类型是否适合运动指令。 +4. `movec` 是否缺少 via 点。 +5. 圆弧三点是否重合或共线。 +6. 工具、坐标系、速度、过渡是否可解析。 +7. 单位是否正确。 +8. IO 地址是否存在于 IO map 或允许范围。 +9. 子程序参数数量和类型是否匹配。 +10. `out` 参数是否在所有正常返回路径上赋值。 +11. `inout` 和 `out` 实参是否为可赋值左值。 +12. `func` 是否在所有正常返回路径上返回正确类型。 +13. `break`、`continue` 是否出现在合法结构内。 +14. `switch case` 是否为常量表达式，是否存在重复 case。 +15. `jump` 是否跳入非法块结构。 +16. `wait` 是否有可执行条件。 +17. Path 是否为空。 +18. Path point 名称是否重复。 +19. Operation 是否引用不存在的 Path。 +20. 目标点是否可达。 +21. 关节是否超限。 +22. 后处理目标品牌是否支持所用语义。 + +诊断格式建议： + +```text +E1001: target 'pick' is not defined +E2003: movec points are collinear: start=p0, via=p1, target=p2 +W3002: zone z50 is larger than segment length +W4001: KUKA post approximates GRL cnt(30) by C_DIS +``` + +## 22. EBNF 语法草案 + +以下是首版解析器可采用的简化 EBNF： + +```text +program = [ language_decl ] module_decl ; +language_decl = "language" "grl" version ; +module_decl = "module" identifier { top_decl } "end" ; + +top_decl = import_decl + | data_decl + | target_decl + | path_decl + | operation_decl + | proc_decl + | func_decl + | trap_decl + | task_decl + | post_hint_decl ; + +import_decl = "import" identifier ; +data_decl = ( "persistent" | "const" | "var" ) type identifier "=" expr ; +target_decl = "target" identifier "=" ( joint_target | pose_target ) ; + +joint_target = "joint_target" "{" "joints" ":" array [ "," ext_axis ] "}" ; +pose_target = "pose_target" "{" "pose" ":" pose_expr + [ "," "config" ":" config_expr ] + [ "," "tool" ":" identifier ] + [ "," "frame" ":" identifier ] "}" ; + +path_decl = "path" identifier "{" { path_item } "}" ; +path_item = defaults_block | source_block | path_point | path_event ; +defaults_block = "defaults" "{" { property } "}" ; +source_block = "source" "{" { property } "}" ; +path_point = "point" identifier motion_stmt ; +path_event = "event" ( "before" | "after" ) identifier statement ; + +operation_decl = "operation" identifier "{" + "kind" ":" identifier + "path" ":" identifier + [ process_block ] + [ action_block ] + "}" ; + +proc_decl = "proc" identifier "(" [ param_list ] ")" { statement } "end" ; +func_decl = "func" type identifier "(" [ param_list ] ")" { statement } "end" ; +trap_decl = "trap" identifier "(" ")" { statement } "end" ; + +statement = motion_stmt + | run_stmt + | assign_stmt + | wait_stmt + | pulse_stmt + | if_stmt + | while_stmt + | for_stmt + | switch_stmt + | call_stmt + | return_stmt + | break_stmt + | continue_stmt + | label_stmt + | jump_stmt + | alarm_stmt + | try_stmt ; + +motion_stmt = movej_stmt | movel_stmt | movec_stmt ; +target_expr = target_ref [ offset_clause ] | pose_expr ; +offset_clause = "offset" { axis length } + | "offset_in" ( "tool" | "frame" identifier ) { axis length } ; +movej_stmt = "movej" target_expr motion_params ; +movel_stmt = "movel" target_expr motion_params ; +movec_stmt = "movec" "via" target_expr "target" target_expr motion_params ; + +motion_params = [ "speed" speed_expr ] [ "zone" zone_expr ] + [ "tool" identifier ] [ "frame" identifier ] ; + +run_stmt = "run_path" identifier | "run_operation" identifier ; +wait_stmt = "wait" expr [ "timeout" duration ] [ "on_timeout" timeout_action ] ; +pulse_stmt = "pulse" io_ref "duration" duration ; +assign_stmt = lvalue "=" expr ; +call_stmt = "call" identifier "(" [ arg_list ] ")" ; +return_stmt = "return" [ expr ] ; +break_stmt = "break" ; +continue_stmt = "continue" ; + +if_stmt = "if" expr { statement } + { "elseif" expr { statement } } + [ "else" { statement } ] + "end" ; + +while_stmt = "while" expr { statement } "end" ; +for_stmt = "for" identifier "=" expr "to" expr [ "step" expr ] { statement } "end" ; + +switch_stmt = "switch" expr { case_clause } [ default_clause ] "end" ; +case_clause = "case" const_expr { "," const_expr } { statement } ; +default_clause = "default" { statement } ; + +label_stmt = "label" identifier ; +jump_stmt = "jump" identifier ; + +param_list = param { "," param } ; +param = [ "in" | "out" | "inout" ] type identifier ; +arg_list = expr { "," expr } ; + +expr = literal + | identifier + | call_expr + | io_ref + | unary_expr + | binary_expr + | "(" expr ")" ; +call_expr = identifier "(" [ arg_list ] ")" ; +``` + +## 23. 完整示例 + +```text +language grl 0.1 + +module Main + + persistent tool gripper = tool { + tcp: pose(0 mm, 0 mm, 180 mm, 0 deg, 0 deg, 0 deg), + mass: 2.5 kg + } + + persistent frame fixture = frame { + origin: pose(800 mm, 0 mm, 200 mm, 0 deg, 0 deg, 0 deg) + } + + const speed v_fast = joint(70 %) + const speed v_pick = linear(300 mm/s) + const zone z_pick = z(10 mm) + + target home = joint_target { + joints: [0 deg, -30 deg, 60 deg, 0 deg, 60 deg, 0 deg] + } + + target pick = pose_target { + pose: pose(500 mm, 120 mm, 300 mm, 180 deg, 0 deg, 90 deg), + config: robot_config(0, 0, 1), + tool: gripper, + frame: fixture + } + + target place = pose_target { + pose: pose(650 mm, -100 mm, 320 mm, 180 deg, 0 deg, 90 deg), + config: robot_config(0, 0, 1), + tool: gripper, + frame: fixture + } + + path pick_path { + defaults { + tool: gripper, + frame: fixture, + speed: v_pick, + zone: z_pick + } + + point approach movej home speed v_fast zone fine + point above_pick movel pick offset z 100 mm + point at_pick movel pick zone fine + event after at_pick io.do[1] = true + event after at_pick wait io.di[1] == true timeout 2 s on_timeout alarm "Clamp close timeout" + point leave_pick movel pick offset z 100 mm + } + + path place_path { + defaults { + tool: gripper, + frame: fixture, + speed: v_pick, + zone: z_pick + } + + point above_place movel place offset z 100 mm + point at_place movel place zone fine + event after at_place io.do[1] = false + event after at_place wait io.di[2] == true timeout 2 s on_timeout alarm "Clamp open timeout" + point leave_place movel place offset z 100 mm + } + + operation pick_op { + kind: handling + path: pick_path + process { + gripper: "main_clamp" + } + } + + operation place_op { + kind: handling + path: place_path + process { + gripper: "main_clamp" + } + } + + proc main() + set_tool gripper + set_frame fixture + + run_operation pick_op + run_operation place_op + + movej home speed v_fast zone fine + end + +end +``` + +## 24. 实施优先级 + +P0 必须实现： + +1. `language`、`module`、`proc`。 +2. `const`、`var`、`persistent`。 +3. `tool`、`frame`、`speed`、`zone`。 +4. `joint_target`、`pose_target`。 +5. `movej`、`movel`、`movec`。 +6. `path`、`point`、`event`、`run_path`。 +7. `operation`、`run_operation`。 +8. `if`、`elseif`、`else`、`while`、`for`、`switch`。 +9. `call`、`return`、`break`、`continue`。 +10. `proc` 参数方向 `in/out/inout`。 +11. `func`、函数调用表达式和返回值检查。 +12. `io.do/di`、`wait`、`pulse`。 +13. AST、语义检查、IR、source map。 +14. ABB、FANUC、KUKA 后处理原型。 + +P1 扩展： + +1. `label/jump` 和品牌标签程序导入。 +2. `trap`、`interrupt`。 +3. 多任务 `task`。 +4. 更完整的 IO 类型。 +5. 工艺模板库。 +6. 品牌程序导入。 +7. 复杂品牌扩展和转换报告。 + +## 25. 参考资料 + +1. ABB RAPID Technical Reference Manual，RAPID Instructions, Functions and Data Types： + https://library.e.abb.com/public/b227fcd260204c4dbeb8a58f8002fe64/Rapid_instructions.pdf + +2. ABB RAPID Overview： + https://search.abb.com/library/Download.aspx?Action=Launch&DocumentID=3HAC050947-001&DocumentPartId=&LanguageCode=en + +3. KUKA System Software，说明 KSS 支持 InLine forms 和 KRL 专家编程： + https://www.kuka.com/de-de/produkte-leistungen/robotersysteme/software/systemsoftware/kuka_systemsoftware + +4. KUKA Application and Robot Programming，说明 KRL、Sunrise programming、simulation/offline programming 等工作流： + https://www.kuka.com/en-de/services/service_robots-and-machines/installation-start-up-and-programming-of-robots/application-and-robot-programming + +5. FANUC PLC Motion Interface，说明 FANUC 可从上位控制发起 linear、joint、circular robot motion，并管理 speeds 与 termination types： + https://www.fanucamerica.com/products/software/plc-motion-interface + +6. FANUC ROBOGUIDE，说明 FANUC 离线编程可生成机器人程序，并支持 CAD to Path、仿真和路径开发： + https://www.fanucamerica.com/products/software/roboguide + +7. FANUC ASCII Program Loader，说明 FANUC LS 可读程序可编译为 TP 程序： + https://www.fanucamerica.com/products/controller-series/r-50ia diff --git a/work/doc/通用机器人项目主要实施步骤.md b/work/doc/通用机器人项目主要实施步骤.md new file mode 100644 index 0000000..a9d3dd1 --- /dev/null +++ b/work/doc/通用机器人项目主要实施步骤.md @@ -0,0 +1,530 @@ +# 通用机器人项目主要实施步骤 + +版本：0.1 +日期：2026-06-27 +来源：`/home/meswork/kdl_work/work/working1` +用途：作为阅读参考，概览项目从 KDL WASM 计算接口到 GRL 编译与后处理的主要实施步骤。 + +## 1. 实施主线 + +项目实施分两条主线推进： + +1. KDL WASM 计算接口线 + - 任务编号：`KW-001` 到 `KW-013` + - 对标：`KDL_WASM计算接口设计.md` + - 目标：提供稳定的 Worker API、机器人模型、运动学、轨迹规划、Path 验证、诊断和性能能力。 + +2. GRL 编程语法线 + - 任务编号：`KW-100` 到 `KW-112` + - 对标：`通用机器人编程语法规范.md` + - 目标：实现 GRL lexer/parser、AST、语义检查、IR、Path/Operation、IO/wait、后处理和自动生成。 + +两条线的集成点是：GRL 的 `movej/movel/movec/path/operation` 编译为 KDL WASM 的 `MoveJRequest/MoveLRequest/MoveCRequest/PathPlanRequest`，由 KDL WASM 返回轨迹和诊断。 + +## 2. 推荐工程结构 + +```text +/home/meswork/kdl_work/ + orocos_kinematics_dynamics/ + orocos_kdl/ + kdl-wasm/ + CMakeLists.txt + bindings/ + kdl_c_api.cpp + kdl_embind.cpp + web/ + src/ + kdl/ + kdlClient.ts + kdl.worker.ts + rpc.ts + types.ts + robot/ + urdfParser.ts + normalizedRobotModel.ts + grl/ + lexer/ + parser/ + ast/ + semantic/ + ir/ + generator/ + post/ + abb/ + fanuc/ + kuka/ + tests/ + kdl/ + grl/ + integration/ + post/ +``` + +## 3. 阶段 1：基础工程、Worker RPC 和 GRL 词法骨架 + +关联任务：`KW-001`、`KW-100`、`KW-101` + +目标： + +1. 建立 `kdl-wasm` wrapper 工程。 +2. 使用 Emscripten 编译 Orocos KDL，生成 `kdl.js`、`kdl.wasm`、`kdl.d.ts`。 +3. 建立 `KdlRpcRequest/KdlRpcResponse` 和 `KdlWorkerClient`。 +4. KDL WASM 只在 Worker 中运行。 +5. 建立 GRL lexer，支持注释、标识符、字符串、数字、单位和保留关键字。 +6. 建立 GRL parser 和 AST 骨架，支持 `language grl 0.1`、`module`、`import`、顶层声明。 + +输入： + +1. Orocos KDL 源码。 +2. GRL 源文件。 + +输出： + +1. KDL WASM 构建产物。 +2. Worker RPC 基础 API。 +3. GRL Tokens 和 AST。 + +验收重点： + +1. `init()` 返回 `KdlRuntimeInfo`。 +2. Worker 请求有唯一 id。 +3. 错误返回 `{ code, message, diagnostics }`。 +4. GRL 最小文件可解析。 +5. AST 保留 source range、注释位置、单位原文和规范化值。 + +## 4. 阶段 2：机器人模型、GRL 数据声明和共享类型 + +关联任务：`KW-002`、`KW-102` + +目标： + +1. TypeScript 解析 URDF XML。 +2. 检查 link/joint 连通性和单位。 +3. 生成 `NormalizedRobotModel`。 +4. WASM 根据标准模型构造 KDL `Tree/Chain`。 +5. 创建 `RobotHandle` 并缓存求解器。 +6. GRL 支持 `const/var/persistent`、基础类型、机器人类型。 +7. GRL 支持 `tool/frame/load/joint_target/pose_target/pose/poseq/robot_config/ext_axis/speed/zone/offset/offset_in`。 + +输入： + +1. `robot.urdf` +2. GRL 中的 tool/frame/target/speed/zone 声明。 + +输出： + +1. `NormalizedRobotModel` +2. `RobotHandle` +3. `JointTarget` +4. `PoseTarget` +5. `SpeedSpec` +6. `ZoneSpec` +7. `OffsetSpec` + +验收重点： + +1. URDF joint 顺序稳定。 +2. base/tip 不连通返回 `KDL_INVALID_MODEL`。 +3. `getRobotInfo/getJointLimits` 正确。 +4. GRL target 能编译为 KDL 共享数据结构。 +5. speed/zone 能编译为 `SpeedSpec/ZoneSpec`。 + +## 5. 阶段 3：KDL 基础运动学和 GRL 运动指令 + +关联任务：`KW-003` 到 `KW-006`、`KW-103` + +目标： + +1. 实现 KDL `fk`、`fkAllLinks`。 +2. 实现 KDL `ik`、`ikBatch`。 +3. 实现 KDL `jacobian`、`checkSingularity`、`checkJointLimits`、`checkReachability`、`checkReachabilityBatch`、`checkVelocityLimits`。 +4. 实现 KDL `normalizePose`、`composePose`、`inversePose`、`applyToolAndFrame`、`applyOffset`。 +5. GRL 支持 `movej/movel/movec` 和 `set_tool/set_frame/set_speed/set_zone`。 +6. GRL 运动指令编译为 `MotionInstruction`，再映射为 KDL request。 + +输入： + +1. `RobotHandle` +2. `JointTarget` +3. `PoseTarget` +4. `tool/frame/speed/zone` +5. GRL 运动语句。 + +输出： + +1. FK/TCP 位姿。 +2. IK 关节解。 +3. Jacobian 和奇异性诊断。 +4. `MotionInstruction` +5. `MoveJRequest/MoveLRequest/MoveCRequest` + +验收重点： + +1. FK 与 golden 数据或原生 KDL 对比在容差内。 +2. IK 后 FK 回代误差小于容差。 +3. `ikBatch` 返回顺序与输入顺序一致。 +4. 奇异点返回 `KDL_SINGULARITY` warning。 +5. `offset`、`offset_in tool`、`offset_in frame` 结果正确。 +6. GRL 编译到 IR 前能解析确定的 tool、frame、speed、zone。 + +## 6. 阶段 4：梯形速度和三类基础运动轨迹 + +关联任务：`KW-007` 到 `KW-010` + +目标： + +1. 实现 `makeTrapProfile` 和 `sampleTrapProfile`。 +2. 实现 `planMoveJ`。 +3. 实现 `planMoveL`。 +4. 实现 `planMoveC`。 + +MOVEJ 重点： + +1. `joint_target` 直接作为 `qEnd`。 +2. `pose_target` 先 IK 得到 `qEnd`。 +3. 各关节同起同停。 +4. 每个采样点 FK 输出 TCP。 + +MOVEL 重点： + +1. 起点由 `startJoints` FK 得到。 +2. 目标点应用 tool/frame/offset。 +3. 生成 TCP 直线采样。 +4. 逐点 IK，seed 使用上一采样点关节。 + +MOVEC 重点： + +1. 起点由当前关节 FK 得到。 +2. via 和 target 应用 tool/frame/offset。 +3. 检查三点重合或近似共线。 +4. 计算圆心、半径、法向、角度、弧长。 +5. `TrajectoryResult.meta.circle` 包含 `CirclePlanMeta`。 + +输入： + +1. `MoveJRequest` +2. `MoveLRequest` +3. `MoveCRequest` +4. `TrapProfileOptions` + +输出： + +1. `TrapProfileResult` +2. `TrajectoryResult` +3. `MotionDiagnostic` + +验收重点： + +1. 梯形速度曲线长距离为 trapezoid，短距离为 triangle。 +2. 采样首点 `s=0`，末点 `s=1`，`s` 单调递增。 +3. MOVEJ 关节同起同停。 +4. MOVEL TCP 直线误差小于容差。 +5. MOVEC 圆弧元数据正确。 +6. 三点共线返回 `KDL_ARC_DEGENERATE`。 +7. P0 中非 fine zone 返回 `KDL_ZONE_APPROXIMATED`。 + +## 7. 阶段 5：Path、Operation 和批量路径验证 + +关联任务：`KW-011`、`KW-104`、`KW-105` + +目标： + +1. GRL 支持 `path/defaults/source/point/event/run_path`。 +2. GRL 支持 `operation/kind/path/process/start_action/end_action/run_operation`。 +3. Path 编译为 `PathPlanRequest`。 +4. Operation 展开为 start action + path + end action。 +5. KDL 实现 `planPath` 和 `validatePath`。 + +输入： + +1. GRL Path。 +2. GRL Operation。 +3. `MotionSegmentRequest[]` +4. `PathPlanRequest` + +输出： + +1. `PathPlanResult` +2. `PathValidationResult` +3. Path source map。 +4. Operation 展开结果。 + +验收重点： + +1. 空 Path 报错。 +2. 重复 point 名称报错。 +3. `run_path` 可生成 `PathPlanRequest`。 +4. `planPath` 按 segment 顺序规划。 +5. 上一段终点关节作为下一段起点。 +6. 轨迹点合并后重新编号和更新时间。 +7. 保留 `segmentId/targetId/sourceMap`。 +8. `run_operation` 展开后 KDL 只处理 motion segment。 + +## 8. 阶段 6：IO、wait、pulse 和流程控制 + +关联任务：`KW-106`、`KW-107` + +目标： + +1. 支持 `io.di/do/ai/ao/gi/go/ri/ro`。 +2. 支持 `io.alias.*`。 +3. 支持 IO 赋值。 +4. 支持 `wait` 条件、`timeout`、`on_timeout alarm/call`。 +5. 支持 `all/any/rising/falling/changed`。 +6. 支持 `pulse`。 +7. 支持 `if/elseif/else`、`while`、`for`、`switch/case/default`。 +8. 支持 `break/continue/label/jump`。 + +输入： + +1. IO map。 +2. GRL IO/wait/pulse 语句。 +3. GRL 流程控制语句。 + +输出： + +1. `IoInstruction` +2. `WaitInstruction` +3. `BranchInstruction` +4. pulse IR。 + +验收重点： + +1. IO 地址按 io_map 或允许范围校验。 +2. wait 条件可编译。 +3. pulse trace 必须包含置位和复位事件。 +4. 条件表达式必须为 bool。 +5. `break/continue` 位置合法。 +6. `switch case` 为常量表达式且不重复。 +7. `jump` 不能跳入非法块结构。 +8. IO、wait、pulse 和流程控制不直接进入 KDL。 + +## 9. 阶段 7：proc、func、异常、报警、中断和多任务语法 + +关联任务：`KW-108`、`KW-109` + +目标： + +1. 支持 `proc`、`func`、`call`、`return`。 +2. 支持参数方向 `in/out/inout`。 +3. 实现作用域和名称解析。 +4. 对递归给出 warning 或 error。 +5. 支持 `alarm`、`raise`、`try/catch/finally`。 +6. P1 语法保留 `trap/interrupt/enable/disable/task cycle`。 + +输入： + +1. GRL 子程序和函数。 +2. GRL 异常和中断语法。 + +输出： + +1. `CallInstruction` +2. `ReturnInstruction` +3. `AlarmInstruction` +4. 异常处理 IR。 +5. P1 语法 AST。 + +验收重点： + +1. `out` 参数所有正常返回路径赋值。 +2. `inout/out` 实参必须为左值。 +3. `func` 所有正常返回路径返回兼容类型。 +4. `func` 默认不允许执行运动、wait、pulse、run_path、run_operation。 +5. P0 支持 alarm/raise/try/catch 基础语义。 +6. P1 未实现语义必须在后处理或运行时报明确诊断。 + +## 10. 阶段 8：语义检查、IR、source map 和 KDL 集成 + +关联任务：`KW-110`、`KW-012` + +目标： + +1. 实现 Symbol Table。 +2. 实现 Semantic Analyzer。 +3. 生成 Executable IR。 +4. 保留 source map。 +5. 完成 GRL 到 KDL request 的编译桥接。 +6. KDL 实现 `estimateCycleTime` 和 `resampleTrajectory`。 +7. 建立统一诊断分级：error、warning、info。 + +必须检查： + +1. 标识符重复或未声明。 +2. 类型是否匹配。 +3. 目标点类型是否适合运动指令。 +4. `movec` 是否缺少 via 点。 +5. 圆弧三点是否重合或共线。 +6. 工具、坐标系、速度、过渡是否可解析。 +7. 单位是否正确。 +8. IO 地址是否存在。 +9. 子程序参数数量和类型是否匹配。 +10. `out` 参数是否赋值。 +11. `func` 返回路径是否正确。 +12. `break/continue/jump` 是否合法。 +13. Path 是否为空或点名重复。 +14. Operation 是否引用不存在的 Path。 +15. 目标点是否可达。 +16. 关节是否超限。 +17. 后处理目标品牌是否支持所用语义。 + +输入： + +1. AST。 +2. Symbol Table。 +3. `RobotHandle`。 +4. KDL 检查结果。 + +输出： + +1. Executable IR。 +2. KDL request。 +3. `CycleTimeResult`。 +4. `MotionDiagnostic`。 + +验收重点： + +1. 完整 GRL 示例可编译为 IR。 +2. IR 运动指令可映射到 KDL request。 +3. source map 能定位 GRL 行列、path point、operation。 +4. `estimateCycleTime` 只计算运动时间。 +5. `resampleTrajectory` 时间和点序稳定。 +6. 所有错误返回结构化诊断。 + +## 11. 阶段 9：三品牌后处理原型 + +关联任务：`KW-111` + +目标： + +1. ABB RAPID 后处理。 +2. FANUC LS/TP 风格后处理。 +3. KUKA KRL 后处理。 +4. 支持 `post_hint` 和 `@brand.*`。 +5. 生成后处理转换报告。 + +输入： + +1. Executable IR。 +2. target/tool/frame/speed/zone 数据。 +3. post profile。 +4. brand metadata。 + +输出： + +1. ABB RAPID 程序。 +2. FANUC LS/TP 风格文本。 +3. KUKA KRL 程序。 +4. 转换报告。 + +验收重点： + +1. `movej/movel/movec` 三品牌 golden file 通过。 +2. target/tool/frame/speed/zone 映射正确。 +3. IO/wait 基础映射正确。 +4. `post_hint` 和 `@brand.*` 只影响指定品牌。 +5. 不支持语义进入转换报告，不能静默丢失。 + +## 12. 阶段 10：自动生成、往返和性能优化 + +关联任务：`KW-112`、`KW-013` + +目标： + +1. 自动生成 GRL 时优先生成 target/path/operation。 +2. 点名稳定。 +3. path defaults 和单点 override 稳定。 +4. source metadata 稳定。 +5. 支持 compact/expanded 输出风格。 +6. 生成 GRL 可再解析回等价对象。 +7. KDL 底层导出稳定 C ABI。 +8. 高频 FK/IK 增加 TypedArray 版本。 +9. RobotHandle 缓存 FK、IK、Jacobian solver。 +10. 长路径分块计算或提供进度。 + +输入： + +1. 自动编程对象。 +2. Path/Operation 数据。 +3. KDL 批量计算输入。 + +输出： + +1. 稳定 GRL 文本。 +2. 可回读 AST/IR。 +3. C ABI / Embind API。 +4. TypedArray 批量接口。 +5. 性能报告。 + +验收重点： + +1. 同一输入重复生成结果一致。 +2. 生成文本可 diff。 +3. 生成文本可解析、语义检查并后处理。 +4. 单机器人 6 轴初始化小于 1 秒。 +5. 单次 FK 小于 1 ms。 +6. 单次 IK 平均小于 10 ms。 +7. 1000 个目标点批量可达性检查在可接受交互时间内完成。 +8. 10 秒轨迹按 4 ms 采样约 2500 点可稳定生成和回放。 + +## 13. 推荐集成顺序 + +```text +1. KW-001 + KW-100 + KW-101 + 基础工程、Worker RPC、Lexer/Parser 骨架。 + +2. KW-002 + KW-102 + URDF/标准模型和 GRL target/tool/frame/speed/zone。 + +3. KW-003 到 KW-006 + KW-103 + 运动指令编译到 KDL FK/IK/变换。 + +4. KW-007 到 KW-010 + 梯形速度、MOVEJ、MOVEL、MOVEC。 + +5. KW-104 + KW-011 + Path 编译为 PathPlanRequest，KDL 生成整条路径。 + +6. KW-105 + KW-011 + Operation 展开后复用 Path 规划。 + +7. KW-106 到 KW-110 + 完成 P0 语义检查和 IR。 + +8. KW-111 + 三品牌后处理原型。 + +9. KW-112 + KW-013 + 自动生成、往返、性能和批量优化。 +``` + +## 14. 常用验证命令 + +实际命令以工程 `package.json` 和 CMake 配置为准。每个阶段至少应提供等效命令： + +```bash +npm run typecheck +npm run test -- grl +npm run test -- kdl +npm run test -- integration +npm run test -- post +npm run build +``` + +KDL WASM 构建： + +```bash +cd /home/meswork/kdl_work +emcmake cmake -S kdl-wasm -B kdl-wasm/build-wasm \ + -DCMAKE_BUILD_TYPE=Release \ + -DKDL_SOURCE_DIR=/home/meswork/kdl_work/orocos_kinematics_dynamics/orocos_kdl +cmake --build kdl-wasm/build-wasm -j16 +``` + +## 15. 阅读建议 + +1. 先读本文，理解项目主要阶段和集成顺序。 +2. 再读 `通用机器人项目功能与数据流程图.md`，理解功能流和数据流。 +3. 需要接口细节时读 `KDL_WASM计算接口设计.md`。 +4. 需要语言语法和后处理细节时读 `通用机器人编程语法规范.md`。 +5. 需要执行级任务和证据时读 `/home/meswork/kdl_work/work/working1` 下的实施文档。 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-01.mmd b/work/doc/通用机器人项目功能与数据流程图-png/flow-01.mmd new file mode 100644 index 0000000..9a1121f --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图-png/flow-01.mmd @@ -0,0 +1,58 @@ +flowchart TD + A[项目资源] --> A1[robots/robot.urdf] + A --> A2[targets/*.json] + A --> A3[paths/*.json] + A --> A4[operations/*.json] + A --> A5[programs/*.grl] + A --> A6[io/io_map.json] + A --> A7[post/*.profile.json] + + A5 --> B[GRL Lexer] + B --> C[GRL Parser] + C --> D[GRL AST] + D --> E[Symbol Table] + E --> F[Semantic Analyzer] + + A1 --> G[URDF Parser] + G --> H[NormalizedRobotModel] + H --> I[KDL createRobotFromModel] + I --> J[RobotHandle] + + F --> K[Executable IR] + K --> L{IR 指令类型} + + L -->|MotionInstruction| M[生成 MotionSegmentRequest] + L -->|run_path| N[展开 Path points/events] + L -->|run_operation| O[展开 start_action + path + end_action] + L -->|IO / wait / pulse| P[虚拟控制器 IO Service] + L -->|if/for/switch/call/return| Q[虚拟控制器流程执行] + L -->|alarm / raise / try/catch| R[虚拟控制器报警与异常处理] + + N --> M + O --> N + + M --> S[KdlWorkerClient] + S --> T[kdl.worker.ts] + T --> U[KDL WASM API] + + U --> U1[planMoveJ] + U --> U2[planMoveL] + U --> U3[planMoveC] + U --> U4[planPath] + U --> U5[validatePath] + + U1 --> V[TrajectoryResult] + U2 --> V + U3 --> V + U4 --> W[PathPlanResult] + U5 --> X[PathValidationResult] + + V --> Y[Motion Queue / 轨迹回放] + W --> Y + X --> Z[可达性与诊断报告] + + K --> AA[Post Processor] + AA --> AA1[ABB RAPID] + AA --> AA2[FANUC LS/TP 风格文本] + AA --> AA3[KUKA KRL] + AA --> AA4[转换报告] diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-01.png b/work/doc/通用机器人项目功能与数据流程图-png/flow-01.png new file mode 100644 index 0000000000000000000000000000000000000000..46e2d82d6bc140523dd061a2f30b090b3d736043 GIT binary patch literal 696876 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

GR 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%0As_ez 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

dWRonG45U&r2xndE}d+^|glmo3Kr`2FU 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%0Dk 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ⅇ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%0D)qKUEBG#8UcKoG_=^d`HwS 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

r+1U57 zVGiD_p6*!A^`gAm&-$d@EvNtq*8fxk*5zs9+&a(@HNciPg|!e^pwn3^5z};}Sz7`$ zlt6DuosKp?q)`G5!_6vT&Y;BJ#01KX*Pl(!fzF-JDc(Il->__tbSDWgdrx)Dr9>_d z8|T5-c_lH3KWB5Em0Vpg|C60l&Ot*afApg%*EQ`D_E&e>J$frl;&@+%GuqiCnSAuA z7bu@NJtt;TD>C8yktojBFFuynR)=Mrj$p#nFh9{v0d$ zrSFtH;+fYHwtlv!sUd7KKTyY_SRS^~u7s-KS= zY4`-?T>|HhQKk&9^%!#Px}G&E2(RJND@aRVru1CzDU?t zngQjTXG?ERGCXel<;BDg5BqWw+MV%dv5f_Z>T&J8SzM#b|IC?fV`nW=yb+4n&~gi5 z0+2~{0>3Qv!ayVG-_dmFx*KN!HZ0BAWw1nwco;ulvhZ0^ST}Y-==VYG%^sh+8E9lc z;vgHx}{$7(Hl8*#0tjY8v6>8F2FaVV$Q2zz!SU26V z#dYP!qnlUf+N{)iXFJUEJlm+u_c{bCoWH$zw5e+3Du3cLfejc|`(r&%5F2w!#bO|d z0j<;{KG|)){!o6JChKN-*%~^OqPie=b^?q#_TflPoQ79hVx|je!|MOW>{`A73}mH?O-=dYjB8;36L@?eYjPXH?jhO?X34{!csqYScp~YeQG{T7~|lJKZE$MS83QWx9Mf37;b!{Y^<0uF4Jv z66A?L8=cv^O(0+>eaAyExyQYy5G-hJ>16JpOlsz@T@kf6e>rK%+PJ~DwSB829D3g2 zLjG3j(;H2Wiz;L_s5B(!4!<34GA(l~Br8Kd$iz(;cj~F~z?FR=$_u2o-*ohGo9S!h!>P zN^V@N2#6q=U2>W|;6S~LMTt_Qq2*^wc6Je?q|pVOm!+GYI&i&D(d0I|m!cS6b)}2o zYHm;O5Dq(Zy=Q-xwr#ho3WFS_`P;jH=oe1y3^MT+_J+IwN#bz2J=2~2&}%5{u_$?@ zZRRrpQJf{DFjPX4j#`dBi!k3FHHhoL!zHz-rPpw?@?u^^q7HSKy{=Bho_1@L6Kh#5h#KyAhHC$_y4rz6yiG zrgk*!jDZTS?lz6}sVU;dFM;CEm(Cc^`~l7Sgt#mW(aD1F2a#VRm}L$#Jh;@z?9&je zk&Jq_13t0I9%+GRh)9Dr(!l~7oSxAgI;caNsw2B^3SMa@S9%643ZDmFutMQZRRV8 z7ltDfy|?H`+Z40T7xB9;zdtdYK}@uSC(FsP$gQA+;%Qx*b9kl2P~*^dOj0~fgO8=1 zAN+utIG4rjev&~-+>yWM5SKt9%K_+b@4{1cW?_RQxgS>j@_3Hqfpw;^YqZijyf|c1 zEVJMWSA??)KJt6mc(bbwnem$9-5sf*!18<-A%4{7^pyWN>)ox1;zjuuQw0%I_yA*3lf~(gcV)BKhH2v^bhR+=#nzgX{2} zkhh9GJm))itnX;*!e*XmEaovs7q0NL@7GdA3J}3jj6lyf77;q-#$eP$cO(EHa`RXU z|6aA&!GbwCG5B1dju8v^(g}y_N`O#a1SPfZUappgUgu1Jv=rP7hjl-qJ6Xr}0S+Pa zf((rm!O3d?C%%;c9~igsCKMcqE5c4lM<^~~9b(kJI3hUH2Td9Nw=9SRiiN|iYvl>g zqi+^}VOuG;Hrh_=Q7`YkdWGHHlS#U|0283hD*}0?UhPEe}`ba z4DXgWC-WwmZ9j(~5$tt%ty-pepkH@FAMbtM(CfozN3bPrqm08*nfF&xCvBTMK?*hx zZgzm68(Gl7aA&NE7}QycAd0m&h`X)D8OnkMBE&$`WM+89sf|bg{Kq5EoiwFWb~JGF zOcOY*=v*imh^!9fxGz!iLP-QI+3d&7azSv03T7tVwS1qn%*S{+(E)DaAgNd$UL}7M z8?lQ!?dJ%n98dU@UK!+DuqK${a`6jIH*Ma^7@GTf+@4MP>JA7!#h?I8k-Q8`?A@A8 zl9Sa$A8gz5ZaICu!cHQ>27)VPZ7U*vBb!{C?rd+sf8)oeIg*^Q?*l?pOG?v*x4Br( z9$Fs4x!4kQyCeJHs48qpyL8vi9w3bm?$2WE-TYuNgt#Sp{E}BXKT;^)uPtGYXd#84 z+kfu|{xL5qCM=G|a_>_nedg}dG z)4_izV!FSt!=8Mv&^3xq>&+rc;kt<(#Q~3g5JL`7VMSxniT*n{a2j+d)2Fc&4E}~! z&~|J+s3E0_4<8WkCE7|T!1+fXQ@OY!ljE^f=dyz=n|nO9_iGU=MpXxH3F@^c<$Y8u zUtc_0LTKwy+EY4)j$lWvcE+vib&)z;4W~IIUd=+myC(8660Y9D10QpR;F%Eaa-FQY zTI45olSG5(^l&u<=0O&05h6tQP6o7t@FVI@U|E^;_^l}x~n~9 zNFAfYEpaAw%)pzsDZ?}nL!sXTvS!|Rt{>#w#DXOvI#s{use^Mu1T*^FG>$|8xQNmn z;19Zl;-D|E=N8N8F=(+u28b}8;F--Y&xIYb1ZV^~<3q}$^()$KaPglfq|afn z8+pK28d+O~1}JCrBge0_CAi#TFC+PH^^= zauK)yw0W`C=Fk=9_xLK4uK{+&Wuup4H4kS6oKm1RZDik}r3;op^ z2>|Cx{~o}8y|HP^RE?;}Dt^phTL1?El)0}LqwfdLP7b;-ayM?JSZfV3`%U1uz*6tP z-vf2nl@$H)2dhU&T$^=;aAYvKnaiZ9$7zw2q~=2Je^_GB*?&ckb&If_GGxuPOx?X+x)S5rJ+?-+Y$A&t? z`6=#)+-ATgWuB1ta`KOS_lg^uqfvlQdM1`sEkc#vx(lTz&8R9mo|scG@;n?yf?pvv zrVys&ZjIuA(I2>Fc6TL!pum=#;VtG2EJ=Ce0;&htD`CEyg8scdy80ckCb*^VuWXr7l`=WQhK&0;#k}|EaBVq z5sJJD4F-ba_&UE{M|>6mytsJUBKD-@q>>@q&f7Eu3m$gKrJ5U(gciQ>F8Vu3Jhq5} zbP`@!f(m-}EpN3~k(zqn@;D_%Ps87Z%o?Lf(1blySB#Pog)u4ZR8SVo@jTUU2X0H_ zLlSFICl4)G(F5^zb7STiEb+L9AAQWm$|0m8VDSc#bl9cgd&wZH4|O*d)69L>M3ty< zOF}hta&=Sz0u?1wcR$TcIRbTRosii^J0*gIy18+KD_zbW`EW3LZM%91F78l0w;L_j zR&}3h+3|nm=uHvHo}ZYBXtyo9iutO;LuwL$kn5<2S zCk3vA{kJ6dfqg=c!f$j82zUYjm2Cn$rwAxa?*2LAQpD*YDG_XhvkFQa;C_YxyJy@G zD&I1?H*O z?46z)LFgF^lmVgL%6Gvt!i2h#U*RqG_FgY$4#Uc^1z9HXwE#(=#`DuSA5L3@vcIU| z1EKTIzD51UlOs z7G+EMb()qHMnz=hEZT+qcxD~4aU*(CPifPrQ&!54_BfYait}?tJr!0mB$sm{A{Pr! zoZIVdQxDxg{oB0%!T0Wbzdk3PCV&G0#g^hzQMGpCx7?~XG^OP zrKW+$gF7IhfwAF+UPEYlI;D+D(~pdrgOh>u z4^PHz&{y$z0M#;(Iz`QA1L{vn|?asT)A_VXVMh-*XNoJ*MDNp5&k3n9f1tAEFJK ze<884$1ak(QKOl^A_CJo&Y(&`awt?D{19qq?K_jVC!dm?1bp^MZAYWHIGDFO)Kl07 z7ML1|ZV%b*V^-pUXXaCRSD5L>-v$wu*gGj9zmqZ!{KwZSw01!nU9%P9vA&F3an`E914}c3(^66HB>hM zEc~=}`oSQNsE9C_>-<$)F}f!mKRNKLk>qwAmlUA8p&+33#(pDD6yWEmbaE=@*M~hy z6q~kgKMqy^1j0x*_oWFkDJokhJLX_Z3wE=5l;JMIXOvxvk<)NP(YR4Ja(i({dr?k12At`2TK57ms!@r^O+Ew3MQGL>cInb~&$5ZZ{;W#Au_+OgaJZ-e8q^L;;-oL!n z0{|{JR7vW=T^|6y#s$Ign!-5Ch}Hw{@b*`N)c7HS$CeTy^_{;yyl8JWzzSCXADmV)XEAHk>!Vf*5L#r z%s!3QQMniOLLoq8VaMC2U502c6ihUT{kKzD3vj`hVqf><&CP}C6iLf^R7JIUJDVWC z%mjoT8wO*=7ojM*iiSfe0@yUhT*rFvS`g3+!zM&QWod^=IJYGlD|naV=vQ??N_dxZVw z*LC5RSM?U%JVPkYHCmS7jiBqbVC4BxM5uuPF%aMusX(?nM%>#$krTa-yvIP->gD^@ zmOv15YdqhCm9e9c+2up@wfMR|hmHb4YA8);VWB7?RJ`vw)Y z_km}06*ww&ECWe*$`^v98`eyZeeVD4xkfA7I!DwNZ37q>>=)}c>j*kjNxwpwAQQ(%9?=J z5~zN=8?g-JccbEqH;&^8`e86zDDV zH*!%OpT^xC++P_OY%SaD(dKX?BBDkYKE^jP&8Bo$Uu ztFwxPi;a!ymW6a3>pMv9Xxz9D+Q^5Gy2JMZEqWAk5#8trUz>&2-McoeUk?wk2|PI2 zTAU5oIF`5p&3c<3PFZ%OM&q8C=n=*~!!1p?kMosP6W#_nsD)(TW-wo>fQvOoCJGeG z?ep>Kyp;%pC!Yg9N3SHc2Cgt^sk@}_W-dt#`Y)8P7;B zfbj;&%F_}mv8jm#uP(~e=!I9;gz^6zhQU?%^lG^2&Yt$s>}X!7X}R|WHT{Ew(M$As zYCGP$kmcxmh^4OYv?4@iGpEBsJXT4YPxJDWnCqmus^f2QIgM;diP^?c>sX1s!6z`D z&aiEg%9~O!+_9qR27c03&E+qLI=Q-*h1YU(o8@psbKvP+GhI8CUN zzIgTRcIC%WdYo{v;~&VP>4r+|SDN6f#JDqQ^r;dvnmWOMt1`7jFSf_jE_$&PuYIE> n5QIXZsJD;%5#LOw0B{;Z?py5l=wgk8e(n0tzg)}z%sb{Emj+2L literal 0 HcmV?d00001 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-02.mmd b/work/doc/通用机器人项目功能与数据流程图-png/flow-02.mmd new file mode 100644 index 0000000..5c9c487 --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图-png/flow-02.mmd @@ -0,0 +1,42 @@ +flowchart TD + A[GRL Source .grl] --> B[Lexer] + B --> C[Tokens] + C --> D[Parser] + D --> E[AST] + E --> F[Symbol Table] + F --> G[Semantic Analyzer] + + G --> G1[名称解析] + G --> G2[类型检查] + G --> G3[单位规范化] + G --> G4[tool/frame/speed/zone 解析] + G --> G5[Path/Operation 引用检查] + G --> G6[IO 地址检查] + G --> G7[运动目标可达性检查] + G --> G8[后处理能力检查] + + G1 --> H[Executable IR] + G2 --> H + G3 --> H + G4 --> H + G5 --> H + G6 --> H + G7 --> H + G8 --> H + + H --> I{IR} + I -->|MotionInstruction| J[Motion Request Builder] + I -->|WaitInstruction| K[Wait Registry] + I -->|IoInstruction| L[IO Image] + I -->|BranchInstruction| M[Program Counter] + I -->|CallInstruction| N[Call Stack] + I -->|AlarmInstruction| O[Alarm Queue] + I -->|ReturnInstruction| P[Scope/Call Stack] + + J --> Q[KDL WASM] + Q --> R[TrajectoryResult / Diagnostics] + R --> S[Motion Queue] + + H --> T[Post Processor] + T --> U[品牌程序] + T --> V[转换报告] diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-02.png b/work/doc/通用机器人项目功能与数据流程图-png/flow-02.png new file mode 100644 index 0000000000000000000000000000000000000000..125261f549690076ec37bb536d52c4ea8b3de315 GIT binary patch literal 455271 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%0A6(u4-X_pLc8_)QefV-+y!MHCQZv0bat?l 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 X9KSm9y;=uxV<+X6jwKw`zy7}fBcbMA literal 0 HcmV?d00001 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-03.mmd b/work/doc/通用机器人项目功能与数据流程图-png/flow-03.mmd new file mode 100644 index 0000000..ddad5ae --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图-png/flow-03.mmd @@ -0,0 +1,48 @@ +flowchart TD + A[NormalizedRobotModel] --> B[createRobotFromModel] + B --> C[RobotHandle] + C --> D[KDL Chain / Solvers Cache] + + E[Motion Request] --> F{motion} + F -->|MOVEJ| G[planMoveJ] + F -->|MOVEL| H[planMoveL] + F -->|MOVEC| I[planMoveC] + F -->|PATH| J[planPath / validatePath] + + G --> G1[校验 startJoints 和限位] + G1 --> G2{target 类型} + G2 -->|joint_target| G3[qEnd = target.joints] + G2 -->|pose_target| G4[IK 求 qEnd] + G3 --> G5[关节差分] + G4 --> G5 + G5 --> G6[梯形速度曲线] + G6 --> G7[采样关节位置/速度/加速度] + G7 --> G8[FK 输出 TCP] + G8 --> R[TrajectoryResult] + + H --> H1[FK 得到起点 TCP] + H1 --> H2[applyToolAndFrame / applyOffset] + H2 --> H3[直线位置和姿态插补] + H3 --> H4[梯形速度曲线] + H4 --> H5[逐点 IK] + H5 --> H6[限位/速度/奇异性检查] + H6 --> R + + I --> I1[FK 得到起点 TCP] + I1 --> I2[via/target 位姿变换] + I2 --> I3[三点退化检查] + I3 --> I4[圆心/半径/法向/弧长] + I4 --> I5[圆弧采样] + I5 --> I6[逐点 IK] + I6 --> I7[圆弧误差和限位检查] + I7 --> R + + J --> J1[按 segment 顺序规划] + J1 --> J2[上一段终点关节作为下一段起点] + J2 --> J3[合并轨迹点和诊断] + J3 --> J4[保留 sourceMap] + J4 --> P[PathPlanResult / PathValidationResult] + + R --> D1[MotionDiagnostic] + P --> D1 + D1 --> D2[error / warning / info] diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-03.png b/work/doc/通用机器人项目功能与数据流程图-png/flow-03.png new file mode 100644 index 0000000000000000000000000000000000000000..84e8f0c3ac601aafb17a3bd353453763c101206e GIT binary patch literal 500667 zcmeFZXINBA*DcD{y|)Moq9TGsNdf{&l&m00l1P#)O3pztG`ay%vLGN?0f~}xR&o)%(kT7x#ex--vm{%O>)eEU8KKDDt z=~ilLY9p5I&STEYtc6eOeR1J-zg{mcvylGr>ka%3wq%z5kGDAA<-O1T$NRg3X}A9K zaw!2~hX42)$0ViZ&;NK&y{P>DKi=Xb#o}H1kM}PMl=QIA{_7R&@PF{l)tCp3vJ@Iv{zBF-Ib zZR6rd`9ux9`*%dHCBC60@!z+x{PV6at7eht(JYwnJdpS`R@lEuLlPCQq|IA)r^%Kq z6Yz2RxdKR6hTh%AzmEO($z)%Wc$jHniv&(mgZ~?R9}fXW>}c~`j288lu4n#KY*8fs zCyu#qvcluk<7wkLui49@X655cgp;P2r+@Zna&w57{%a!G0mb=0+CKm1uFU_fp8SFM z7pl3cy+fj61(AdOxgImRcnV%i*|Dlhjzv6T<~Zw`+0JC+?$mKz1X?;-`_qHM#6W(g zLAr|V(Q92P3T*}3qpsBqat^-zQmxUv+l75`e!L3&vmMjTVSc@z7DWC!vecZjPTM1D zM(r_iCdKB?cPASJ?qfgy^6I|#+5NAhuFIPx?!z`IGg-Hs57CSqi*r52!^$kO5dLk#Uh)BxqNh|FAN`yI{M&; zZ%z7Aa|@6Cd;d510oVDf-!P>pN#JO+1z2{lgQGk8^nYL~J zAA}r^OUt}t!=)<+wePbZebU&R(^Sn+rQIJ&LdqAK^#wdu%C0`F@xTo6mZJKfDOmK( zeK8JjTluO<>3UV)$$%OY&!C^8>=#^T>_B)gNsXqun6Em2sA{m#9tvm|srFi%^=dBzEO;Cn| z#LT$YvrC2Dg>i$F6ogQp^V$5Res)e4y}8ur-4MX*kp0-kPqfPP%ZtNMMupER8S={a z#e4|b6?Kk7FWu(SLHles~{@a^73e1@sv`VnbFi5K9$#kW#2Dc_dgG44Yp zVmGrPTdr4|OysPd^W@OuaQ%6Zh-|if2tQ$-LPAo>-JKZd9E;!dWw$#cgAhEA&KX0j&sj+#J0)~MPvEM(ur|UG1>`as# zc3T%B%DAarwoywsre0*OuDrq5D*AM?!=vg3bHZrlSiq6(z1W9|M*C3hE>`W0DiUqZ zZ8~f;q7V17Iq@C4v&X2bg(b;tMBfR^Mf0#ICCef@vS6HtS9LvNL!NmwIoL0{92A%+ z$qS=9h^`fN2=CqC+%f8iBgO(8^C{)`NlovVLJtp?B|8L`^Kf}=8RMJ`_qHTS`YrZ% za!;Q@Y&TqEXULGNI^4}SibJEw-bt8;ygI+fq@)v~Z5vfESU4{q#YLkLmaO5~(x1|C zCQ>3(!=6DQ?!5`dWD9wkR8b=(=h;lz_RJozQef(PlI-WCogEW`v zfkeXg0P01_!R~xV5Gg0eKhIOutcGd{MGoIE>KyEiEz2$u>U!xL3%B)B59GJ7x$2W~ z8p&g}hO&LvzNcD^5u)0nqfL0tiZqYm99@BVsYmkabVPh>?4GNlPMHhwY81Db8mv-{ zWyGQLle#Eo%_8$q27y@nUT^m5{m!$DF>l@Gkc?EX`(Ff*^O>(s)MFRumt;|IWOBAi zm*L*Bhg5Q<8+vVN#7aZ266XO{f}$HZZ#21Ut}ulvRaWSoXm zyB=L~J*B8a?ksLR3ID4cE*r03pYQ1qA$*PfH4n|F>pbE}spq&e4hv2O)d=02S|ztM zNdF<Oko_>*U z@+X;y!;P+>NQc?)1`fkE5wZexiLToS$L4o$WWsNb+BD9j#H>ZM9)e>zSZhg@EjR6% zgJn!Ym97x418Xu$_@K|4KqXxnA7$M{+2aSxi~?+nbuiNbHy~v5sUfW z%<4wUJ>_&|KIVdW56T_zN-1*D9QJclD_?6sq<3hC34EcCGPvZarRS zCtsaYclM~ojTCY!!krf#d|&vNZ2Jd5!A(tZvjHv@P8pyeWBBY=YgRbZS0Z#BbZH zPSx}8fV}E-Cne(X=`jz?X4BhR#DTqS$^9^9m9xBN5!ze05yts#JS`h&a0fnw7^bdK z`@SpX3wf?jfGEuEmn?|23nJ^=&+N4}aKq z73(7>0OZ8DE*TIC_jBi?AgT;Hj(Pg72JHbnS^X}fP`y1muilF}Z{^s`geov|)JNpD zi2Gg9akp=jE!QZVW3TFG;nHzkL^H-$cnstjL>^pX*uSXu-s`n>1Y0b};=z`{&hES# zqO3y%Qz98OWXn!=_+6%h+-*fqP1jw<7A1ml-qy6Le77endZAP%qWl`~=)g^2Na@rZd-aWLJ^q-Hlw1O%9L4{VeTlh2%d&8YWim{^9~^ zSgUp>GBk@Vm40;g&TNF=RKMua7h+jDonAs=i{m(U@Ho!rJkeHfCSkMkdoPEptc{ee z50r7K+`Bp15JN`sr$^nlds3}y2xU6rvMcx3ILA{Ms)Ye93he$AiFKNYvq^=L(K(F|JDz`^@kMYdDMbUsE ztL9QXlGcmsVN=fKHNt6;-Jc_}iEe1T@};uAJOi1;8ub<~i0S}`qMxDEbT`ijIjv`v zQ@%O9O!Jn6z0qdCz(Zsq=h?bzSGF&$()u?sNAGt}lMk9`G03TfnrZiqPFDuGsNiys zouoc3J56vO5*`KCV`59RoG+ggaFpM^?TUFSt8(*k&W|w+VrsKbSE}9Q{pwr>ChO6s zIdvoLccnJ*Zfm0{@muYJDy6nPKB&xW>ctySL+TU9j?}D zmkY;yvb$}_>9O-sS4zWuQ)O(rB?2|@5pa)Q5(Q#sm6+K)ZkTFK4vV5X`RJlWuW*gF z#)V>$cmJ(0|Nd@+ny*;kQE~lig1DdP1`jg>O^)l=zZfggGah+$v56}A?Zb{^i@d|u z>f~qJJ^~E25%`m>wp#4fIhTc8*U7aI@{mio1~d9Dm;+v`^2Mm(X?jvBkA0m8wg{ua zj|!-E)Qq~$McHVcO)&IU;o>fUo*jIsk_+zbk9012r9N#8^l+I=JChi2zvNBv7{UTD zvBB9U2@J+=+VPKP@$OrlDr&Lu(-+<01|(Y6Yai~3)Y(yFDgh$9RE%mrV6C>K(HgDX zYvUbrGuTQJ|5m*0Lm?0sqgyIPKra&>bNiV_io8ercai5M)8QF4#Y`vC!`DKLd!|g;D>quj zNn)dnL~rou)s)Dv3(zY-?^=fm`og^Bcovk5uNsoeHwR9yT`)S#VyK-^9w^fKNR}1@eb_UHlP;BhT z_d>3!SI^NzUd?{(am2Vlf|yuG=77xlvCNKc%K~(Vv`e;|=3d^-`H1 zsw18X>jslvaLe+z%S2@PUktyYm|%yB7WKcWltYxz3Rd~`-kHLnUU}SwSGVT>`70yQ z1lDDSrsI&yW>F?YV(HL^pliH_Yg1=!!kV_nJnU-Edn^uaz8#h^iGV?{WY;L*5OnX; z=GAwepBnRE*Qqduz!jMX0k@gUv_K5fzE>+h0peDpXVyzJjeYL!zm<%0YGGA7Pr3iB zz_c{v8()mYPc-0%5SuyhYH!DG3PX}mF_*q>)D}g$oCXO|SF(Uwwoan$bUKZ&z_W$| zD#TBcGuOpZ`72rwdlcjr{a08uF58|)dPmoak6M<$+MKgc%hU+yO!NWZdHsF>r-FBD z9o7ZEW4gp%^21j!hzB58`SMc8a6Wp5xVDpw$DC}*>gv_%eGZqU;V~FE#||Ohc*HKc zvn-?Fv&zs2J=b>}1TMUed8`Xf7>IM=< zy8?^i5k&bSnfJA~q@grtNiuhLeO{6g*FffWwdw~_sL-@$z%Y7ozIVj1#!I&*`@v4> z>-gOtp2aonJtK}HSN;||2IQq)Kb+@#EjT=?s4}DOE++V8F|Vj#oxY`!>H~J!3ssN5 zyU{SmN%MQ9Iti*NH?h$75vM);_*D6F{rfcJTLrhx9u&u=TJO6DTSL5O`Tof>XpxJ# zWBKjFa%eqgkdTAbeD4`=bEyp_>*=`wApnW z%)=VHeCE<*gyS+|J($LmBbtV62#_sM4Sv2VxFc5#EvALtT}GTyW0P$~7C}w+Xy>z~F9kvlpi}^fbFJG{tfAH>gJYJ*o%Ga#rsy)*R)JLBsmyON{TlPf7 zn<*q!#x!;pGSeIHO#1hDjyGH@Ct;Y1MN9Kd1=mjgDF!qE@ngNUaUZM3MNfjc3&iqQ z&5>&%$#T)&mlXr&$q`&NeIhzuLP_UECl(?6Bi#$Ey+c(b#>++!d!Bs4YgmN*{VWab z#XL#Hd%~FgN&R*PI`hNB?W|Q(Mbhz`#6qmy8y4ehMbn5O8h%XX5rdK+B`m1BUaH zgoM7gqtVk5?h|5w$>;vT&oUl6d{1uAK{LMrki1dtj#e4ggmP*F+sqF)v-=Fl0Q}3w zyyOQWh49V?3+$rLxy?eFnEGCs<*oI*pxnsoDtmhd+7SAX6OM27c9pS{$u`P0U% zLcRLX0Y+VW$&#jj7c8|dIwj6UzAuXqh1>M^xUevKYChoF^3~o%s8{b{g1?+=SB<06vt{Qyvid_p{dvkWd*C@BRqXB{=~&zTh?6p9xx zA;Ko4memI@?=+K7v|tXm6BSiytlm270eVpgkGP)^eiiRc_++2}_h^3lm$dC&!O8?Y z-Qt}cJ#)s4YFqq{hDi~(`Y0ZYE5xF>^FFuSE1Z9Rl(b(yyuUQ{aQ6Er%vP~LNXri| z62psD(lm_QYb_mh(E((O)_vMRGg+wv&w|3YN48~w(7bYop*HC8_7X3n?#@ar2Kmt1yddaE`_Vgh=XXNjfjeKiX#-5(}Xur0&7gQUTUM|l0F$Ynk{551ail|K_Q^7ZTG zMGh)VdsMSk$1?gf`S{(oNBUONe|DyS77H{jczhMZ7{8B7rG`;76fD%dsu(LU_87># zeSV(}v5F_%u+%0BLtxMWJYxG+;Kg z)g*{A!v}UH*fk*PR79J)D;UDLvCp#4fHN=~u*KZ)0LWtv++I(Xwj-FcWw&voi1ia} zr#@3L%RWkRUKa}W&>YJgl0&+@so8@?ZP*?|X~m#Mf>gpSTg+=&S~bi&MHBwaGWuDN z5PdbSl_i*nCd{m}Fr;K*f1f9#-;S}aAw^RdHBv-3E;1>trQR|bc1i)mbEzlR242t& zN#8f6qex>iWO1!w@%A%``|~5fmr^`UUNuaS=k3na6mcvDeCBhF%u2@=SvZirA1JUC zqBX|nczqnufd7!|Voy3O05p~PbS0EZh-hB{PsgOLZ4HGGi%R> zyYD4VZVi`KqjY#_ee~-UEosE^w@3HtqaiHknh)d|3&rUu(g(#?>L)lZV`81Js`-%H z-dD!Ozj9MbHM78^i)Q=5J?Zf#u|~K zu4K6ph)3)56+Nol`2J*!^bx4`%m-nnHs$iME;K(QJv!2D_WE>FyzZI?8eE#|8DbDj zs7X`LcNnG=a8O=K%v5sU-FP5>*B)GNp-HIY&7F+w-G;>r?v|r&L8;VGdw>acH5x>I zz2GGft)=dYIT$h&>0T;drm%D@8C3iz_kN}2#UBUx&mUJftu733qFN(`p4N5HT!?pL zuINikiHqKYr1mCyHsz1inQ@=^3&eEiI<5UCA0+*8x=QHhhb^={LGfX*7(oZ(%V`2* z5=Idq?(P`2HaSgi+q=7%J?Ycl9t75v<^$Cr7DQ~!R`;gnsw`RRVF*PwS_(8F6GaoZ zTpu1=c{|xQRiKCFTgaJ=^EiAX>xy2(a(4D>|6qVQw%Pk~ddL970K{vRT=bTDvmv&y zMxN`<6m0@Q;S6O7XBPo4{nV!#E5+kHz?pAWz*zP` zqtB#@JD-w+8@qhN6TJy&{J2cMd$k%iCGePbb1@SDfw8;Uhg9eHs<3D>g-l=}n30Un z)_5(gH**M!iHF&-k%J@jqNOF|K>8vYds~g?C@Xg9=UvW+0{MEaxKB7bGDhsyxr$)f zbI3$&czB@#l@mqW$XKBKwnrRY4c9+K#GPF&yeUrNOeTWZY`!Y6kYlHZ#~9M$c|XJV z&pfXw#o;*(l*2{S2PpkG+bax*hq@9)YiedYIBa#}N%aQak6#y^5u+Bx#J%gA}Nl zHX~A@I=283N<3pnW*$@yoG!BG|cI_$M zi&g0~i5EKVKq|PZG(Hre6_R>OsbsOBD@&bO7HSa}i)*uW<77@xKTMX51a_^?t|ow# z^H}SFgM&Uxv<&5)w~;j_bKOX+U1gOog_Uc@=$!pJ2k?fOImSMAMw4@%pEz%^Xh`y} z0k?J535O;R@%kw!#0B+A0ov07R|rmaAfI*`WN9v`dS?}kEys0IZt$6aWxOvH> z_5It(HrHkCNM#j$tltS%f}Tb&De+kPG?|3Q8MGY64|)P;Ch2{ltnK}63joP9-!K5By^Il9 z5)#;)@v)ylImVp{(N;_39qKAsTBX;l7Ic8N-``b;#JT%S1I~%?H_!37$NlnTa%fukfF^% zn)!Gq0t3<3rabr~>OvozV#57>-k<9;ZEfHA_8!od5|{Abzgd0CGa*XEV-!5J5OCYT zF_Lkc_J98*lX$)XXqmnen+&7)x$fCl3ztafCzGtI(D5s;eQ%KF>E=8^tfkcqN3j+? z_914l7^2K=q-1p*b>3cR>BN=+Z8;lFdC<~v&VjU3!CF#`BE-zfQV2=WI|3TIDaD5A zYGbz9l^UD#+XluRF?>1-DLZ1V3!SXCboIRAJlz&XAIg+{v4Q(_W%3rQ;( zuO;V&+lmc)?U|Dd+xR>GX4gVlvqbZbancp>K*2CP4n|*Uw5vw{5wmi?ARk?C;Y6F^ z->e!1!VqHXsnwkUmCo=A3f=cEi~pJmGnY%fZf_l5s3vd zNI{<`-f7}cHFHooTW5s>pLBgDlc4iTURk0(G6b@`z*>(1&x!%RKWwQ=S7ImWNqYO& zrdxD94!i-VJ9Q?AcfLx2vLDi46qad`iJkFQ#QxUMV0&G@)9Rc|?vt-`)idmBSz3B* zPKtfE_*UyUw+Ay+5FJoc{s>i$i8knCkx7>@bJK8XMm`fPNjxJ;V$rqMd?O{i{8!Qi z%=(xiD?5%weeJq3;Y#k_qQ$q7c%jBUw)A|=vcmf-izOo;Yi}!l%>2qO`woMW3q%^L zxG*qFZABI%Fz)gN4k5av@Z2~!O{__$350iYfJo-kAXU-XUu_f$x-;RW?{f#2>ggb> z#)9V0)7k4>V^QjTX~AtgLpOIlwOki1)YtCoA_h>I#X8LewcZd%Yr*o!h?Dx2h>-=# zG^ke@8ij+ck(>#e2~PQuq%>+eU>6YMXtxvSX(b8pgMx|Jl#*Mql;s-IC>zDCiS5nd zU4Wd63Ld*Hja1dV2F*#vJ*H;~g`H3!bzqq?3zczr$D~vgoc&-+D^K4B>yEB$y`LWg zf^DanrDJB4>XaWaF<6<2H(qoEr0DzCvc7|D5@kwWV(_2uoa}YVzvn4|%_3fAA@e)s4G)jP2$;lMxvfBQ3bK%YI(@+P|%{N@UkwGt`>fvR* zmrx^(_(II0>g5Ru8h=Ne_vc$@YZr!jOljkMtlo_aGMQGs`A~bqQ9+ ze!fL|>qog0@v6gOAoKU<=JWip5_tNRn+DAWpQAJi*R<~$Ko*6biSFPe9r}?~Zt1i$ zP9hV=OdX^Pv0=*aWA^x9`@EVHK!5+m;<2v)mUle~M;8Xx3vDJFrqET{m0SB~s4DE| z(omGH3rrqQVlTpEd~r#vq3daW$7Ba6J*%qhnc+HMvsaQCs%H#&@-dwrxC;#|*wrt@ z9HXAEs_;zdW6eyb#80SPLi(+o_Gq(}lYQ7AVg!Oxs6anIV5&`Zy}aYdP+>h@(`r~E zsa^J*MK)8ugarReYe&IQvB>TRPyYMj%HB2#v^7KwuzU`YLaucP;Z_eYv6+hf$7DQOzdu(xul4K(Vn{lF&s zqs|fH;>u|uky%&+#kuhXI91E;)Y;cWVq&g4EAfp%RM!+x-H_4S6oUpsnA!I{XIt^t zWYOM2a?&9f--?azoGGymmRoAXuIbmc%AA(+^=s%wSX4jX*#B{qkI8~;Nvp}iyAcZ9 z9{a09D?1Z@L6hho9HQ;3tBtO12b(FyV~0Op2`XHN9^B1+s2AeU7QH-Bv`AFxS{*%5 zfjRV8C^PfJBUY8ie^<#&eSdZ0n;i}2P+&tr{>{5{m#l6=w0GGa(Vl1nJwt!tJgs`~ zeS(iY#zHPXKV~73_E}|fGdI_1=)KGNu<1g%a@u$G@H0&QQw5L4@x1nQe&lr`e|qHN zE;}uiMvOptE3)mYr-$2eB`+3A++;`IzNUJ$2P+z2mI5c`(OToyU|kx5U&3g2dVY7K zw?WT`A|mb98&&!O5XA-w&qbPebvNBRLve+;K1$_1ohyTfo~>5puvx5;h_WT}G#gYq zSgSdXMm#tkCJE}Fe+s!)_2xc9eS3^We!e^M0^IES!Z(WalF>X<%1vcgE}jRy)^Zoh zvvp>@Lu9nfJ{tIV;T9QRAr-|U^HQgY9P&+K=P2%s_xY|i?lN({ywQ;ES4mBg4B}5nMLWu7Usf-JC&t&9zndYwzd{N&edQH_6PB4+I1>N19`Cy z_JRu=IJ7@@0m=qImFO-bFMhtx{am&8_gPvf14s0HVkg@!th7}zi?>A;hDLkG*fTl% z!AeqUibEr9UV)nn>g}7&41jV{06SI|&=7>7=VFk(%4_|@F)|ig$bf~Dm>?C11aZfe zH5KH`g3aEH?8l|H7}Q7~LYBb;Cq+K?^08E@tP@+<+uTtQS&TK=m|ef8b?#e{MW-rJ z5KlMP*sB;kbwaj^mF5ylBPh}Xmo2sxxd7w(R(6G$A@tFL$+rdc2Z*?aYI*udz_pz~ zSF%@j3pnd0sHo`B{B;F;7xVAR?=Pr)E~$4$*+V%GO4p!oxtgivKs|(44Z?}QA@6h4 zGduHWi2#S!JUpx2cfNvk#kkLXcmh?jP8TB4NFkSDGAkbAZ#TRI@G)ysBQZP{4+jCz1ITT2m~{DZpieWel^0R#bRA|FEZ{TW`JN7 z>LroIc>&0&`g430`s2qj^l~C=QEGSD=DkRVCW3QRhjs<&HFQhXU;eO2ygqoV%k7#I zv%Yo)2*LPJT4Yv%WZe6p>}>g7jg6Im>Q>arU8#L_AWG<@_lpa7S1E=JiLPG+rG)rj zQ1E*iZsf-stuBSF?9aRx5!(4-ha`T6rDw5_zCS7Lmfj~=Bv@ZN*=9LnsR8;$Z#?3> z3Odp$3L%&Kdg-`WwT&f6x`YH10_1EZVy0T}qR~5(+X?pUb^2CSrFMcUD!4X4nq-3G z_7)Lcvs!Hoq}ZI#HX{yidyCVQ#Gm&bfF@*73HBd!DlLLU4mX_EqphlTekR623jK0V z|EC+s5Ebv$aD$=>_%#rj+>90LsP`k0R5$P~e~LU#uV%lTCJYz?s)h6rbW*~RZ6GyU zE}Pd;B%)vc^DCs(EGzV$e;))71JP?T%%+~FpGRq4_nPJ}iq9`tVg#KwFe1l(;WIw) zOqYtq?z?O)sIM|l0EShB0HjD{@!q8BydZHNB{|gdR})sh=648l7(A%*3%v{uSUv9| z2NUEyEu$Fl63wF@H44dWT)+NiP8uB-M9#RQp%V7UGPMq?pp(>FW4bJ z#S$1YkMOFyTQPUwa;LIT`JL?d4`Hu*G@5Xray6y<=>oa1MpW0 z_kVf0SPYL@J^s=HWU)5oy4CD??7kdN>%M`E%wYCmrAvT*6!YHAr@6OqBm&4Nk37d+ zMK0i(1y={4je%;6+NzS-6|b=;VDz@k`UgLU(G4N=n24`fi6aDTWVTUm3bVtg^X79e zNZd3rhnP0om@!23`ee|UggX7aH>gG59$3EW#tLrppWhfYH+0HY5Jvx4ZCu{#tELRZ zqtRL{(axPXQUrftkn=u^Q7U&BQIh9l9CaJ_W(@IoO(hxmtS7^204hMMhPXmTg!qW{ zHWK7?zQFT4JcGDBkjD)lPDgaAyR^rPWP<|6c0sEkb!Yy@?#66S`F8p04Cr%*A$+91 zhQOSMIn0Q7=mA;^ymJH9ps@koW6vao!eObD5t2@aK%*lurjUNqhnrovtm=75Un=Sc zL5S9B5OE+hdhU-^Kvta9?bu4dFoEMOEuR}1`aYFgreWvUP-&o~$P>Jl^~jbuaCken zUxB@G+l94HL1g0_aFn3dAuAp#61uKID@kGhXqZ6VccGAUyqy8n{6HteADih8K@~J0 z;xV!-Bl}Q*xoO-d8{zks)`tK}3tNW}(5mON*hsXW&q*^8H6t3Ep2xbx}Q zqfZa&qX!~xpdnh~$M~}YsDqtHdbNn=?|d?cY}hif9|?QaLSBBEL#6PPr;gid8Zwko z;xE$MPo;)|VfMKx)aSHv8XFVtD8J7cL^5Ld;x;{yA@s<<{t)eEcf?>zfN{)*po{F& zcI@0oJF{C0f?AOVL1ML(E7<~YM*P~xsRTUG73_j0t37`RWLTCJtG>VzF9XCyK3ss3 zZNgJ-keyHpSqAW4<1&7Jh>nmnn=0sP4^ZIt5{8123|L#FE~?61#BKJI5yv9v#du8e zlmZFBmqg0a4I}mnonI-5@l5!#v?Ga%+w5{O1E5e1Njwd9ak_78_Qg*RaB2Z@_?RLZ zvA;?g?{R1oCj``y`)&?1O0eu`Sj~dLQ;;O<38onq}GIejDO}q(TklxXd@LE zC(wk-STcA{ntf2u*PdjTx=Ir%v6I)>l}@bE6i%;utwA5r66llbaRbOzm&iz?qV6%Iwbujq;xuIgUz=KksX&N8$IIWvMfp`e7_`&B-%DL7q zfKi*}0?A`$aTdk#>it-c|3;DpQ&PQ+8FN-HNcI(Ki;(62Y}4?uUy0^gqO}>Q=b1;{ z){tjl$fJxpCgfD0@`>dyS7#ta+Xl@#$~hIpWp1EtN>sU2DUQwnN&4C}OI@^8P3^H%`y~R0iPltXz6gfq@ zY9?i|WFR@&5o`dpc8&%vQro6}?o)UKt7dp51|$fAvq||AZGa%077IxTsD$-Fgd8bE zLx;^8!55*yM_+u}6&VY(;$rvguJI&nuE1)0=|>kpKTmG62vT&xohN@t_40mp^i>T3@GRk}NOR7W<&Rr7QP703znu>xYdVZDSv6bB8R;-Ln!c?68&CXqp>tZQK-M4+Rh^ub=w7 zv{|iBF}Oa`NWPv@Vh5=2PYMAY^(-y4)B32ZRhw01pdVWqzs?Z9+h0)O9JKBWdAVo( zwf12(sCQhq+*n7Q>xdY+EGwP?gZ?)Gpg{xh!eu*^vtxEKOS%LXM3VPx z4bz|qmj;?6FgA!`@>MO6Fke`5lA`w3yahFdQ$~npR!0@tCX4%K%ybt+s)=c&zm=|+ z(wMyctcoW90wcd$sc3kBPOFMmZ<1`!TRbRsQ78RVQmyjJU4pI>f~FXsuCeEYZ_BATK2 zECcHopP|UIuTy4va_Qzh)dQi-A-ba+n`IH?J^A|21?C{UOed^u22)8hPy<*04N6na zTQ|3q>#=Uc(x+9bFN?PVct|AaMvdmi0(v)qSBJ6z2{rM)5BDa)`&NF7(A{!g$fZPz zCR+!;JYBuqJ-ZMrj2}O}zn=X%zL`_|vHw78VvsPOC1$PVC&<<&flT9fjFsNO6Fk@u z;~nYdYro_zW>Grb%U5Pm*fU4k<+6=n^lxqbL@+q(@t`6Q9K+=3iFo5^y}3vaGIOPmqV>86(n6q?^f6Er)Ip%nBg6jWVFNAVAxcD- zT%mhoK3mBWw1PSL^0B*6%^-+gM|JoK=-RbeL|f_PA`TWswK(!qK&~Se59k@Hj01m> zXc1+`f_@iNW(=h$uqxImvkt-hNt2XVP-`-!#Be_U`2z%B5d-H2{<%OMs4CB|QmC3) zW;fG{=W44=Q2^zv#=zKhH^2P$vK#;d6TwT6^kOxASQ<$GrYPAHpfPPaE@%n=c;P_f z5HoPoT5gdWixcuYs&>HH8Ssb+^3w5SRqcik3)T8mE*9-&moH6NJ145F&Yz)LAfp^- z^U1M){n6)}b6^CQNnRHqW>ii; zJn$2J^gw7AA<@a67Wr}T<8sAah`!K66lI?3E+1a z&=%PG54d~j5{@^zIf5Ld<%_)&Fqf`NrH!1?;|@MH#FRAKP*5H6alO1G71-lC*PZ4F zb%(mHnqxOhgRKhM(s&DP8Aoc(K0SZgD#~iPa{GMe@}22b*dydEnM}cP&tq?hLUH`E zE3^Ky%OMXkHH*QC0YCm1W9Y9$MK)sC~a>hF3YjdZU5{WwPFoFoGFi;;ma`dmJgqgbb!CgM&up}DfE3h8|8zE^4dn(XzG*)4IpSNIx8tg`DDj;Fk zal?i3bmMosr%`^(EQ$!l?-YI_xYaPN$LQ?3VO0Kk3YZF5Q9ErR+1@Z51zzCF@39M=M` z)EppVX|ivDPt&ZO|@is6nG!>*bN;Ie&Q-6PJ7r476@K4@muVRKK^g?ft6)@u`B1#E6Z&+BHl zEI%AKN|%YS1ch!WY+j0|Z;=u85m?$Wy4sJ_D>YUetzGlyWWz1yMxVZ#870g*9BAE2 z&KDg#QMNsrV%C>+?bynQu)O1Rv&sZkdFJ0MznY8&o<2{zyin+q|Ad^kc@kUIP83wC z8>53nMrn0k()oZvfqY+gduaIwxd3Q`g~(akTa+P3k99oEciALEruD8}-hB?cXV!*A zYYe`9pb|~zQrEGaiKGy_o()oPq@^=u4gfwNAkCNla;{;d5J4<}5Kunmj<6&pbJCZr z>MFB1lR_x1YQnC9V~xqj8m|~p*%hp?(G9z&&g?3 zxfl{QmGsY9R86wdDho9Mx8vNBmAd$FMNw}p(W~Z0vG#gfV%{CZ zY$H(F4wbE`7j^jz1`p-%NLjKE!L=Ow8$z4i*Ty}4x|;IEq|7L6o5nFajh^GtVW_>M zID7Y{X!!UKPr{Z0vAY6}q+iHxjB@EV2CBhm&X$fPz|N<{>!7D@l1Rr+|K~=K1GqvZ zwz|FkeL8MwHHbC_f!rxIT4)w52SnvCzva}G+*V^4$dM%I-73@c!%J-%Z4MP>tVj&Y zdlsz4WwkTT=+p_TLR7W3g#CvztBvvD2D|m(F+T&83=-ab)MPT#$66sSb;f5MnJW@A z%D{IAjQWL~&Kuy_?_W#NJMdUO*zf+P*J1sBgE3H5Ab5_sV>4W0lPG3f4l-w;DD9wAZMVfAHbBJ&yXmVnvdauW zZgo#BFV}dCBqX*=Ggut~EQT0oNRP4XwULRO17unhJPRqH+lGoI>wTXL0I38$C94FT z4cIt%w6_dL+1GhQQE;z`6{im z8~sVqAYOSTKwOnSWZw0}ll7mdTYAIqZ`0P;<3Hm_x?A%&9n5E#n8W)vsH%ZVmW@B0 zhhEp%koeuh2=x5C$ZfUV#zV2lm3}JG>PZ35g0zthN!%Y10<}28= zFK2w`hpv*uVTmoPw|h{wI`$-hYjG0~)6cRso~yY^ylfC<@&HTDAyoiTOL+zzmo*mMH|E#>3XW=E}NM()qqLarfi^0ez{>T zyIP)LEY_Og{52l#2b>KDg4->9DP9tZBP^6I4GnKupj!8W3ww@&`M2ZaC%!bmDHi4~ zzRG%{QAg)jyaJ0l3kn^&;LI?h(bH<*UdkCi$m?(4^FOf%#F%oocuD@5g#54?iip~=G+uE3saj6;-08SC<|{=*ChIG&sWTB}yCbsC zwmmIXH9BXYu@Rb>hc=hyB9AX}vuqdI9u2K%w-edM z9)^*F5?*^7bU$F^d}Q4uoJEy{?K936_t{@({q@_$?+v5!^71%1IQ|(Su?&lhbRPF6 z`5Sv#PPX)~BLcs~&5u=MV87>u!fUz>bd;o)L!gkvUi5!!j0HBV-+QPTtnbLPyS!t3 zBns?D(fvxEo@Ae+6ojKd^17M2wSa#X~d4ukklU+f1OyEQw&_!guh0> z7#%0)I==3X=+V8>?wy=rxTUJ7*okC}Coc?*xc$cJph;5rd%5HC(PfW3y?&jH$n_Fb zXVh9e$^Oz@Go110r+2qjX7N&On4yInU}S%o&fiFy8Q`o4}uWGgplbFPO4+t3T;>nDdP z%FTqxu$?u<59_|h@y0aTZMQ3)0DBE}{qL4SnV_Yu{%45}Pn+m0eTuihK#$tFO#8c? z*&2NIbEB+kAvZMEOFP`zjxOl_j|lcyNqn5BsyUp=v8E{pq2^}%r2QDcu(9FG3NKU|)Aptt!slQQaLXwiMJEz+Ek z;Xv+W-gkUq(C;bp>x+AQsZr*7wr~}{7G5Ow``~{#jyezj{g76ts1@H zx*C$$z8EpWmZ)vn(21%f;Xp$ty^kzUis|>D>CXj3+}EZ#T8WP$f8Q~HZZ+g}@R0#C z$^0I}FKmIE_#O!ZykDuA}_X6x#yjMYY(Ob4g zE+Omq7JK2p+xjRJ7;%4a+R!Wd-(TYW{-wf#0sPYP`q4IoyUf8S1~k(9yT567Px|Yi zaOtFD3w9?@opUWpQ0F2M2X^kCjD?)E(qNkGBz?aLJNz%)rA}HQ`=oyI)LX>AAFuGr z>xlbaM?>1r_`8!N8aID6{$cvJ4RgF%4T(EF#Oqi=_iz94Lr?Dfch8#$a%YFJ-z^&d zw(N)1AP-j`V7>fnFuy%Lx!VWIy^}}zVDNkOYBOCtx%$+})jvFvluvGN_xtwSNl#8b z&i_3gme4C{jxi*vnLbtT|WBF$;7yx%z9D;&y`F1GADj57>9_H zj$5dc{kF?1CmkRBTmY-l>&T*v1%H2>%oTL|=FsEN(Tst%q}?LBsOc6M?Y%#V@2ckk+8${pGadN4|gl67}>H3gt0zDIV9M+F$zTuw4f+`|*`hmnP`tMCp%w?se1m zIBBT~2@^@7@^}&DDh){=K7de-s-vTW5Zh549OL;qnW*pwN6s}BI-T&(KmT+fw({>y zHovbsEsRDg_(mLGnRI$Jgdrv5$Z12fOzC-fYju|tpmH(E*7E-T>9w^rsL-s+$MPQ^ z0*X^$GC|)adDM{?&y!!B4Nibd+M$s3M9n~UVjmf46vy=MDUjc0-b8S*gdLgYcZd_g zW$mEUka#7rw!SX19@%j`|3@vd-aYc5)E40T(lS1Lpl%M}Qf{DQdt!TtMma7G^Bwp0 z!{SADliSBZV^$hW!~`l+svvs`2|^-~=sHH>ixVs?@x^+ZF5W_;A;S zRN`sb|D4JK=?Qu!@qcHATJKZ=0Vp>mQ0=ja4wu^FX_)nOlIG$6uD_+VDSaW-Lt=creA!8e5D9lMvoBB+r&{F(X9BTgsZ4Pk(j6dDx; z#{s(84Ha4F2?z+lPE*3x=4QMX&mZ-(ZwCiC9GjzYd7aE7-T!4(P5X^wZ!!4K!Uube zQseo5W}{D2w{6_)XSZaJE9A!cE_=s-_^1;{vx%ojA9_cBZQ0{ppYrmZAMdk{9wt-E z@aPiwXD`Z0ngt6HQkdqd*81mo8?(=2zcZfJFgqXG|C7*uew3XZZkT1yQY7b8BzW}0 zBa^b9Q|54<&g~ihzv%k%fE@F$ea4WOL?KFIv>-%_(rOv%(WXL5J&Ckxlj>#R$PMWV+x6dbIAmiMXf-OveS9e^`gsfQ@sM_?mpi`_Tv2Y z69-m)!Y`0QQeB2dy6*pbBXTQ;p48H<3aMJb?IAl|eZmg^`r)&`@zUMSzsX*mzkYbj z|9;qsLi_LXcl7?xU43Wd+578-53cy$vb;R$h%?J~c>I5#@f82mXZaT%t~lh7q6a>n zj?4e_;Q#)q-UFX_>E&zjKm2-^a}W9SKH4Qf8pgTuW)sgTwCQJ;AGdbpaq-FwZ5)|2 zZa!uEmwzYn+{zb-Syt0b5F#PmuWeq+W;b&-nz11HpZ)M>@p_P?edaG-}D<5`E@PSX6%F`tgtGmu9Eq!zpJ(@Le@1uNocSLYa917A&R_PxeT*wmsqY?z_OQ(IcK;8;dOo7i z&i-2J|6$jVQ>`3*XO@@fFzop90lhop>JwkO{85QJR^GE`FZuMt&CBO~=gQ+MImoBa z|2lL33%}>+hZz(-mv{DmSoMckD@WL&?AW}cUqem#zJ z<#AX+zvWNnr}_P6ckghKPe<=tzB=tIJ67RGp^bUE{0`q&fU%SY)>VJ`lmCZO_sF{X zl&$;q!z*FJ-8<~$)Bbyxf0+G$Km3?NYxrpChd(y2?5-3KeweiU!!|2xxyK!E?A*VL z*LNsqDH6R~uyO^ZnD95O%ujRjh^ZY}eu&h{hw7cmaO7WpbiB^WqwB?o87dwwKYI5{ z2&LPWCoT1B8`D>eM95*>Ps8PH?0ep~>W72a!ql0L4(`wi8gUbfUbp?~uyE9#Tx%;B zSD1aU?=dTXgpjTrz4(+r8obZ-Lz`Ul+l$F%yb)gmd*|e|u}f@mPDw#TBKyZTzS51l ze=B@$ccSr$eUZ%(LFeoE)s(Gg34+Bl(lUm`z6qL{eY8_4)FRo)iGedL20}`o!ljuc z`~O|z<}ac-0!5udpb zFzB#2nkR6hU>9X!T4VjhXB2qYFN_Xy#!i2vd3;o9*)q#YXZ(46c>@VhUK|k>rC$-2 zd@s|aQi031M~SJ(x6fDQ{cFe+2-b?cl8oLr{Mfv=y4vcPi_2si+u|J~Bcu3PU)Hlou7KmA!Q75;a1QX#$A zm>Bu@ugAOK@p|8u9xpK->Gp?T@bZOYz<#^=^1V67WH|ZqeaTEEsK0k#HQlxs2lICq zhW2K(CZ92pMRUx&qO=Sk}q;&!*o&W{aB z{CveG)&}j9+rb#d_=Iex*b{-@B+VmU!^#Z8o9*hvv zuUuFLX=Qf+n!HnEwr+Kj0aRc!*RW2p&Dr?+I`OaBWuze7KWI_qW;cKfl=?F?uCNJ( zo8s8e)iI-WxB4ymYPTc@Wk_aZw8qdY#tcDh2q;ERF2J~pHBjeIsPPvIjg4KF&>V5V4)e~D1P$RA-d znG>&|u0CIT!y!=2W~Qeq8in8%Gu>U!pFTZ4W|ON)jU#8-7S$(33mP|9rkd3ZG}-*M z<0z&5^D(OUpXmo0gK@BNa}Ld^B)*v!3j$OP3E0HEnAS_V>R!c$wN3C^{Vz zA!b-_Q)39!e&IsdG5xMCroUK)GhVi!ylMp97bX6JBDSBYYY+$Y*C*M;k?ox6SWehZ z{hXVd3-N`HNgWQ{Jj?O79%)$VipV$iw|%ZUxo~I5WnTN#I7HG&Hj+(gppI6(l8kF@ ztx$MXkndq<`OGH{-90+bkEm~L?yrt{MrCB)y{PbNflcoh@+^;=*LZ<~#x z0{8_gG+)28sr{;>)A=ou`s#5#)$OSLFl0D?K-~g5^`?|$s`#DW%U2Y6=Mb62Ov*vb zO(!?`oDi?Aadi;mLuY!nZ42zvnLBsxG)<3+>iKcsV?EpHJ15Cj9ZqL9OLhQ}QS=(Tbn|A%H(w>_ku%82 zJHBVQ`r+0lF0G9lZO)B~->31>(&n5^D{}74xK}^@7@ZJW`47XX_vt)rDS0`xDKF1R zZelt9x2{>JXVFIbBkIQ%18Gxyb|0blX%nwpir1x-88{8=(9AU5#@2$4bLYHg*m=du z9mj9AzY#YtpKV$EWStB#U5?1OZ&l`V*_s#Nf@tVI7Z<~=@dTL`SQYV<3}g=ZTDQ3? zhfa)iNPE-UPj_@VEY1d(`torXy+FUhz}zU$!Gp}3`A?rK5b-cVyA*UY`cW5pW$*=V zm2J1Q@^0&&3h5cinRS^%GgFW)zN~Xo$jozUYp~6L6HK?R9CVX1x?jT+yNKWEOU^R4 z5fU>gWUa{<%HbP+G0{KTYj-NEacgOby!}Yv(1m~cX9s3)2#Lj8jlLEcNSR2gSx6fF zAu&f?h_fHR>S{cCK#6ni2TjZ4oV`zQDg^WcZhzrAlG@I4YTrd=WmfY_XedniN3fI} zJrUOVYv~wPT=0M7gYzX2w63Qy^=t3~zxb^~YC=2#-B53{4@3j!T;Y~|=QON3 z4!f2=DP(i_nVdaelxA+wCQyD+Pfkuw=-=CY30!N_M@Gmp@_hp`9ZwG!L(=e>f=Gbf zY%W{Sdgjd~=S8P}#N{5SG;H`Fz|R?QT5Ptjl-07aka>n21D{f$WQ=m-G4qx27CEimG79n z5G~kr=d8K;cu8_+dxquBc;v9upp7K}ve(*)=@`VBdxn&`Tz&pbQux>H$V_|7;=;8G z5u2{4;VNYf+u8n>^9($+`q}?*&4nwgo0|%W>;4V(@~)hXr4*c*`(f#pi}MmGb0ekb z7&@pcclPX>HjA@o@5}2>g+WPPmdfZi$87m?x+^&AXQ({?R;I{(e0+SicYV|?PI(Pe z?+z(aC{*#HdH(MMNf{RX&D`l*G6i;1ekc>~CqT_LZdu3_-r;}zlH*_!ckGmH=CD`D zMAMe6VlLU4!O0s?lvC1JoN>Z`{SWmjZ$@+o)n#*XuH{VG%iLUF*9aE50``((_F+g< z<@MuOXFZ|yer-4GSgK07j;i#Bz@Qb?h9ppL`#pc|at2+dwH( z_SCS+^&_MV_J~0C4QvbMHR{a8I{heRzL%1TLvE6KtIo?r?r1=9q#&8Wy8VfSi$~&< z_ori|xAJxiMA%i@byG)ZdEOEk%2gF!%$$Z7D5;~5MPg}rZWb8i^xj7`E~_X-S6f?~ za?G@+lGgN(cFea}{6wEMpA@IA+$G1r$ayvSGH9?iZ?5dXv6`&W>Fy!so7b7yxw#F7 zet0d+(^&Ri7P1_8Yc;A}$h0duD$0Jud+?A(R=b->Fk5-O@4)Fz~l|II9!-w6u(amp8!nHcQKfq=%=n7MvHdx%fF8&1Ox;O z1-+6v4cESU%{mu}wQE_we$jR=)tmY!Z=b`=_jH;~yU^=OBk+B|e4vrT`gl#OI%Das z_Kpse;__0(Xa6idBq+#ZWZdwV23oGD)?N8% z@5!F;H$LaBl%JoQBRvc{jSL42Q{>_;S^fe&gV1nqf+l?-acT*)8WG4v*X5P-$^W>a zTEg`@j2zhBGL5Lh4ZJnS!nqjX34817rP>F*H|jWLEsSqWzE!s?j+X1|!-vgv(eMh; znc3eMZSs0w(2MnKgXT4M<0T@44XJt7fd}3UC8$|-Fy%(J|9rBE`67edoD(Byw9BX1 zUwOO7UtC9^A6Y|JJoG{T;1c=q54%i#2$0jc51^HoX9|ulaui6Hh>k+ecA+9~HH)B8 z%3zjFfrrDP9!RdX;2Q_CCn1wB;qQ7dlfWBJ1H!|-ObjIg3AyA}_ z24}wo1{J1n*O8bV0K#Q9XR~TAbzxheCfuNZM3ZPxb0mtJmHZbR?PQNyi%G5+q+jTI z7|E7dZI2CF>D{_IlCt~W8T8ox5TDD0FeyD!#ngy&`}s8N!RtZ0LFH4UF9eM(8aKsl zsuAIA^vyG9q%z+5dbow>z=0UPKB~*&4)Jk?Zf9_zD7U0yG=$ky;yOB;nQqC@H{*b8 z>0=efH?_3#1f3>FU$He!|9s`(S~E9QXgS}fLq9P0a*neulbS1ewp4rS5#%Y{%fFB_ zX9~h|ubvA`F5oN87!{DCo}Gp|oBq^Ld3pH6&}vSjio{a6R;pcpk^>PKQ@?$BrrgXh zaI!TX&7U**OofvD!0x%h2ffXnHT>U zd$v8Ez4G*Eq}?O>eqK#5tc!e)-}Q|s=lMEX<1aW~(Whe|OFhM!A zFJR;)sXO;b9b8+wW9g)ad3<1nV>-iZI;)&Lqe)T8QjQZ(Zl1Z1i(lBQ9Cu`~Q;^41 zI>lvlAKTmyZ(L=bdo!J++?^H3ryPhaAI8$P_+;JbD9KJHz2=&@_L?^pL5(xxN%#_P z`Gu*oOm>+ijcP*MY?{n{3KBd?-pw<)Z1z^oR_496T)P{Ff*>I z^-kH#VLyCgp=| zVgdFuCx-pbx^;4in;wq0Im|O0vnA^yay`aW)AbsEQL83!nFi+v7q5-2b1meb&Mo~+ zF{a63vK3meX_+<0yYFud&nt2bUYxT*tBQE*gBv-%kMbxa-JfMtNY|cigc~UVlD&WK zXNyDGgDtOKO|<53d@UawU~9W;-A0dEG~+PvpY~?Uq}e@nvvE_)XAB;36CU=u5G+2Q zwK(76{3dX`w+3y-holZxmHa+p$Juyjn|*z(2KOS97ED8TaG~78K6nQYt&`b^48yuvB?I6p;gza=Pr?*}dN6 z`wO$ITHw*dsZQoZWPVck$x%H6f{U4I7%O~q;s@IPjda^_A7WB6kq4^LShQ@7arN1X z^6hDp>3-wI6o6#kO(9iERa#1!X*bHW7Uw?o9DO19s$_C9@1Rg`v&kNq0ryIql z+dT%=Ql^{czk$4&%rbrR_SU(0rW_4svV?m&Dx#DjBUDrN13@L{!CS0WbHmwdWevZ- zen{A|l!jRKbRaJKE=?pYFV5|pEMv+tsVk`qxFwP%p(H;qR`hvf@AkL z>eijUlK0eU+4M47ESM@w7CAZPiTFNIeTjlQ>F0e^Pbp`k8{`rxjbg)j-@X1CD1TK` z_Hr?^qCVy-6-S!EIL0jXc*eOCw`w0a4;;*xV0N$&9qZuHP}dn1KKFRn=u3K57E8;l zkh)m)5<0;~yZmi}_Bd^1lTRFjHZ3$>jSW9O4ccYccYNu9(_BAsu~jF_g`Um4{YfDQ z+hRD6`Zh@oPMIlrtLZNx-QR-5+Mw2taXp3^ooN5~W$-SVKG`m_i{1`G3arPAVq z23J18B7y#Lo9=K2PPv{+|C)#6gA%&g^9Acj;g!F4Yk0=npkgmsQ8L?p9zH*pu1Q$G zG9_;S3F4Nr&nc&Ew7T@3R0cF`(793b_JBt^+w^C>qCyv&ps6Z!6-zv~oeMdYFH)l? z|CG|mEa6jmewn4}21`ZfD`IKUD*1e}Wih0^EiP-O0iOZ0*_>*9n-#N)6uqtz*DIwd z)5ZfRV7*1h&sXvUj}tlpSgP7peMCLYe(1jBI`{8jdmcR^(whG?rJCvVj|dx|A={1T zrvzTvlfIYwtQxR5<-w=kxJ8la{6=UB$plQD^I8p-4BJsWGv2FR8Z-gjMy}?q;<8-< zX4DdY6dBm{RJxi@g8k#GeKs^THqc}_J+fFG`9f$|LXxfN$9QXBU*C<#)4C%fb7d}% z-Qu1pU%p%d)Wx*Hc%Z4Fi(rLP#->aBW~or`;I}OlxMSdRq=_LNo|)#pGspIADyg?s z%7pqGlIcA@0wC~}Gl-AFIovtZ{Ujxa)K#L6hVnD+siT|{)=F=(ly^qT2iu2-&vIlZ zgULN?N@G#o_$#EUt@CfI$y%uNiwG1S_9`O?dM}>T-o|N%FK^i31L@rV8Vob2F*2xG znA`!LE)jJ1RQ1!qhVuam{gshsLZ{w;mBqZa8{V9m+me`$1SA8nnUIrSek#iL<%T?+ zjZg`6Cw56<%VW1<)pTWW8M8tdsg<{A*Jrx?d`c&Ja zo!*D|6)zv(XC!!0IQ22iQ9(aU1{fkeEN{HzyZ7%!Ecy~Pb7vyb3k77rBD~X6I@`#4 z^qR?y511r&(zcfA&WIRPN z#q&eR6Zp1Q8#QfUOm}k1^!iKg(W|%W>B72+jB-K(=U+IY4UcV{Q-)LCUL=;+VXU0X zd9W^Ii{IQ&4*TG06vcfKX|Z_TC-~vx@|9WDLou7HSKd84cyliCq0gV`e%n#_Vskw? z{%G9~6IHwr`}TFTih4%TkKwjC=F-aDeGMa(2E-c^*lE4h&VL=`rhaXSL?)NC3x#f zvYt{tm`*Hp!xRsB{ z_f=2ZzjnUUQ+dLOEBjA1uJ8+S_wLELHX&1ySUb>fmT5gsx@}-4G1qSVt+6qqfWD-t z$h~2h<^3^;I@QFr+(m9;T@uL)LC{$D_qdW5Z-N&j8y9{`mab=hQ{+Lue*1Na+Xr%> z2$%m}sXD&pl)K?2;X>)tq>3#s^NjVS#km;f26vqg)O$i4(8dJ0K;~_?r5dBlqAqd6 ziX%|@w%_Y#ZGzdE$qSN!JhoBF_V)JY&J_S;h8o@Mc)q!ib_Y4XZ` zcDE4KQOSP#E8Dq#6s`VzA3T4%6(HEiZa5$2tL)`IixU!C3`So0T)B<1pBwSq)6=XB z8nxytZt}z7VjQgj8MnUT0I4q}hK7wPdyNFazm+(%m)v2Od)oI_BYXAg@#WlUg*)!w zJJYtAlqP_K5ZAsD1N-B*t}yilf&?4L7%3Li$ebNux!QN8)>YEDwC~;1FDg2AJp?X1 zlMFLD1%VIubPkSOB8ck$a>jLuGY-b38Sh=IF8Y zm5u2&6sp?kw)b=iU>v>arO3HqsciN_+?)HHo0v0LAhF-BG2bIuK9>gwYW-;~m|*RK zE_1Km2V!o~y_u0~f1$+9TX<+KbX3FssW%$$Q+G8POBHE_d3`q_A~xgUoI_Qb6O&O-pIvJuy-*5)WKW&hq&lp;TsN z+}_^K&K8d)xHfq4l40EYPW0KOA?&f(?Hk`PqqSR0zMxE6mdQ zVBE61FR;JC(sUQ{U5~+hpGkHW1cIwZUD|GQhw*5(-L^vz&zz*Q7?y5n=vOb;d;P?T zR8t!i2vGz1x03X=a@cMEZgnJ?o144!liOHLKJIOqDv&*;Bu#GSGT&|ge#4t%gmH&T zvF(McK5gSQi*`ew2Dgpv02LXrC5Xh#==V@yx?I}Uh4b=l`Gc>Hr6=oHSS@q;cgwOD z6&5DU7U^imcGWHnc}&XYQb=y3x}rc(+13u~Wj|T@jwJ}btH0@JoXNEN$~*mXk(NCZ z6}cT(1#4`7Z+KESeB~U`ApX?RfBat1%or=bMk4*U&jvjv->D;^t-p1p8)6-{3 z$;J^p_QNAk5;``c{c327U6)7==*#&cLDVwsF*0sUdHICtZB5Ko#$-NTUawnTS0?tl z=H)cH`b7ELOe(6)h|Xa!L^tR+k9tg+kqS6^fJftmX)BAu?0q)TcTb+3`CHb0EXQJ( zgT72hxXHTxB)ag6LN}Ho*|JW<<_lu;K2ix#Gpfipcb36gh;dP61%g0QT5ieljJMNx@&V&nuv_prXM zuHWlvx9%e>c7yTaWwqBQG9K9!vP$eceoMEG@p>0besE+x~VKlc7=S&rc}ePG*bgWvoF zAf8GxokWL&;s}K}_SaXti&dvvw&V@KYTvV??qfRvwfAzFLu%&iMZG`pm69;`9<|yl`ZcbFZhWWlVyQO*XCf&>_>0t7&M` zU%{8O23)wI|AO5^IsEf4xOzO!AkG3`>p*sS8=q-zHvT^Q>bsY=HYZ1=a69r`e-zlB zX)MWw<|AYLo9dXxiPFVnt%m28_sG+%?@KZgBg{0vD@PF#pwwEVoxc3|bfyi-4gX|g z5_Pw4GfP~}JUQ9DX z9$SCpmGYHZZX-d?=g;Q^UzeME-o&~k zUXu8zzQOH6&XY)b*C(O3EiJwf`DVcs%uADLVG@!+tQZuOd`*5E zQ?}(PvxT`6+{y!&K5LElTry3+nw%35p#F4vH;huq0bs_g2;FOqc1UjBvqSIlDHJA> z8$n+Ac!?I21g5iBdlE@gxDRe_3~*(z?9I5}D+1`JxGEZMvKVg(OC$L1LL{X~NT)9EWh#jhK91_!D5Y3-FMofgnIOvs!PSd#u@OQ@)dAB@HCwSIt@*wUz zP=?^14(_|`NL=DVw|w^W!lbdtWTOYD0AC{ioafK*^$#GABMA{>C0Vmg{(?r0o+;YB z)z3NWaEWH8)SuGdGhg)7tp?z zyBou$lk*1p>c018mLi^#WV5^8X!qk^4e`-$uTHJWamyBL97_7hU_x0f$ic0CV2uXQzBUD?o6!6OR%^b@rCEAv4!Q4zUX9Xfk$0#sppi(itA49D>?d#66B_7J zRawbyfu6d#@4?OLIyc#EV+j&Ag(YjdGyqoz_ska-!Fs~$#S%wRxwJ^Bs;1rC`1y2rBXefg6) zgB$hQWjc-!_vih)ccB(Sk`u+o=(m zpAR!KCQK)7TGGQ`4)Uk9dvUkPN4un3HyA2QfHK7()h+bv+1e8IyixGPBRWy5(e@0t zs54%3pJi4ut4Q-k?|&|tLUYOk_gzJ$?i*~!+1^|o_Kf3p9nUoW3jR(RLRFO?CBR>A z61D99@zKa{x7CAazgUH-Aab78eiPI;DS&|CC4MHGI0Xd-Yn8CWsQx!I70E~*QrjA| zy9OawOBIUCMl7>!MlttCv8D1C-}F&ui5EdFE|o<#gWwsY zxa(FMmLwDgVKgF7CQf+7RruMg*#TO_UR#}Oj-ZDCGi}edPQ}@F^yGPcvFYo3FCloN z;3+gc#d@5T4;!aY13fNSc2^{!Gzr17vq6vAUSj?P7Q9!arHaGHwrw<6f;(!*W-`Nk zKF1?#qYN!QP3E%#CJWQBBjBvS|~*+=2No$|V>YP5;~{4%vDZoX*g3 z8aCU1Y@IAY43=k|wI6nqpx<#+NZ-ZA2J`cpZAZ76zV3i9D8qu*&6`d)ayn3N)$>$` zmgg&y0_upcY5i0u2b_YZzxmiBwff3v>Z1d)$4K)Pi+KEHIa__zVW`;HUhnI3%dE)# zqIb}l5=fP&ZZMcKal08O zOA%wTN~_M#Gsw6K4QB9E+PKK3!>5kZJLGH}P_V2B6NFmhy@;kHgJb}Jg{ZBw7ru+n zZ54!x8+sNG`khj2S{S&i&*`<8HL4TDhg~zvTJa|_Cqh;+s!U&x#vtjj<6e<6*(V@{F%H3t( z5ciEtp(-uUAe8)@eU#Zg?cMyeh($N>3>K?Ln)Zg z<&iyJZ7}|L*RktkO_qz-QAv>Z%wN!W1ATo-O$xp6&-nC#85PQwjOO(E5B-^cAEoC1 zB%-S+JvyEc7x|l%T|Ify;9)Q&dD61K{;=*z#sTtFj?iRdDNW3IM)A4I$#RdNEy->O zYj>UCtQEm^79aKH;duVR!;$OxyLUTHGs5g<=U9yAjHX!HX4qc_y6ro=a*1ay6osh> z^pE}1rgPByYe@-)Z(l7H?p4y1#aaJ98&DOq}();;1M|faZNS> zimfF)n^3rj@fe*%nX&L4idVYu=(o{AcafjK*eF=E4)ni$`}Sk;nLN~r-ccyOt1Aok zbRe~B!PsHe-}IQbiTupifiK@|dCpWJCV}1WYME_5jB-->jAWCB#>TV*KIN|_7qb^_ z#xMw$2*QQi_EEQp<67^wY9DslHS!XfZ<=CG+t;xu8bdjcRz~MQx-n*FWOsIT4T`3O zg^j(Du=^3bXxoa3@w6TebEeZ*C_g6}j2j`DItl{6dI-;Lr8I8xkRMCj&O~q1myqr3 z^QL!+(VEfVdM``MIu^=!n`EDOo7hITfX!;}YCT_+pSME()?9 z1sO+~U(tGyr-EjxlZ{YfMnB)i=8#Dlz9*dQ95=CMlMuV8APNF@WsJ@YGPhh*NezEF zD--yOann1?;jLZe_?3m72Bnxe zDy~@Hi{DGuCR;7}<5e#o1@bs1ZSa`CU6*lS(02X81CPmW!M92F-yObURK&D2&;0w) z>t||9z8Yv;2WFK)~~$N(xmJ^$erw1+Wqn0e6Y#uEi}CQno(AZ`IW*ba~^VPdan~)Q8C|B`9w;k zc&snXl~dFj^`Iz=iB(Izg=F2-m?BDCYd6M>J$f>8`AF?Z-{5mc_t2O9@|j^8@Mh3s zNUx5q-Hl!+3nTmIo+L9}uWnbd7m+eY0(ygw-8e6_Hyzce$PX;lsyFOC<7|#geNAvV z%0VRuI{Uen`+|r*m_E9t2FANrw3mJy5qor1l5#pf)-lMdM-Tk^a?X z>zDV>6~D3kM>RP%vp#U)=3d5Hv{?}U%zULOC(*iTwtc& zIfkX?#)y?3*OM%0JV<9>3O>s=ue4cwKwFR3`j$=0zfQN($Dpg^C=)_P9gwZaKQI_{ ze=q&T3ogG~X3@K*^@lm}ulhGv7D(p^KA;eNjwe}vmHn?;Wq4sy{DezT)e-Klz}s}E zIm1%XHBDtj?=$34kQzGM~AGqC(OL&hT`BUMsNG`DiPqE6^mm!^T>VO#AU!#BIf`eXbJ9A%`I z0V+Cwe)nmWZMcQ@%YsKc6<%nS1e`$0rnGn#hS=t!p!wMKe@sn>_tI>g@0WCQl93Wz zUX%2dMyfp>ILpYT^2Ew3UcP*pOb)X34h;>}q_v(L2&D9OYi#G;oB3cV*zG&Avch)8 zRZ*8*t-LVRRr%5-j-A2Y-Y63Dtf;7fWWlp)edJuchL^U|Qyi%3RP_W^(zw4YiIe!s zJu8i1cb|WNQ-mhRei??t0C>T+-k^y8$tQ(gEDAYwAOGTB(_XF9eo~KoE*iB=RbEY= z>zsC?&T`nc5h=K_pXJnda!;0eaaVep?rsNQ@Dh?|P{k+*gr{D{71<7pc~T_A`S&w9 zwNCph3zB)KpC|cmckTx;?oL_&LUeA*$;nATzI`Vjry3@o93)I9zS%9?ByS9^<(&i-KG;a6k}jlI36G3;c@tI zxfZDl%(ZTRp^7J<+I*=w+4DKC#dM}nWOstb5r4s(O0`0*ZFVzsy_<2&YQC(!8Z_VJ z6|cabI3MXVwp2g3N>LsK&~H`Vqn_L0?4|R>fX=V78#Zi!9~QXtvkXgrw$3YLZ4CLt z;SIij4%%*(kj8t3$Yr#T@i3VWdNZ~#XK{07a@!_fzH~|8j>OrsXHDzbZH-ZVxQ_VV zZbEcK%6$2>pWHx9XSo>8u8JW?Leo>gatrgbT+jC(ICSW*i358X>%H2Cy@U~x3WJdo zGI@tSXXkSkc#X;k1%)44*qpU%*DjSfG!QLRVZzI&=UOn)*4n445EKUbDm3)(X->3P zb08z2|Lpm5bjk9oF^28H&pQK4$&ovEYRGQqsjF+vcWX-|O%252epp^XN(5Req4h`% ze!RPS`5}Zz!0(5IbR5>mvc-l$!sNX^hNvUH-!HFt;lfedsiAlUH8oMJSBSu7-j_+y zj65g$rRS};cC53}M~yTtPN0x!Yr87sKy-Drfb%i_lr>xy{x!R?QEV}sSg8Z2|GQFV z4OwBnVPP&Mqo^^} zjD`6*Sc4#%f(&j^i6sLN;|W{j*|Tgb?{X@W$-B34xsI@7q;EuIB#Bp?i|b8FicpF7 z)925z)URJ3aFWq=_Y*&`4<$EqbtJA4V$g2n(+I`eA;Y#x42M24Byf3BwF69qI|4iZBum5%kH? zV?^hE=-|PJ-#NiA=#7>OVEseP38StUxNNyS)leLb#`#uJk}i~JK=@;_sjd&-zj+s>=Q&#_uph`F}^Yo;b3ag2eXLzWJ}mt4x5T z?M^=JJS(qMvo52SEU}`gZ{NQCyN0H~%Ikurrsl~tFv~X&?8Y(0kRVQ(7e^zjk&971Wn%KMs=2#*4bi)GcROLVe=oh1nScP|xG$v76WOA> zoUNyc|BF9mp%}-?3+-T`CGVu7;%n=Th?4#J{%*Jne91|^UWKPN^*%GGt%~uFE+pt` z#tB!V=&Pf%b3lW;hp=99{*GKlD7U1vKU9SPy~hU(7;Xn;^6DE2_j_q$GDDn+n^(D{ zmU6e+2va)nL5XlB?QLdeW^Qh7ZBisXJw4=OKZ=KX(av5L&Xe|ve)~2+)av%rfRI5f)*4r(phFgOFKWv^!>JQyVnaY5*pU+_PApj=qOth*(tONHg4}za zXi<*SMl_IlJu3b31@(&8b{(MgadL86ZFmoFeg@JPXr8i%X<+1%!@7@DMk?X4y{s^! z>Z+>DRmW+8%J&fmr{cwb7AAxPCmD7m-^z=C<5>Afr8h5=LK!&V!~5$=tcfb8Ir#-4 zY@w{K&KmTsZG;m_&xX2MapcUES14MTBMMuzAyd0rTF015Usq!ni- z2ZOJKhFK0aukQZmvt#Eza>XBTLwpIVR3T{=2C+;<%N`@Fy7*OEXH;-H+o z`d`DKdm1kcU*xurgL)fyVJU@qhD0L4!`y1`>|7TnxR=rIK85skxC#ZL0Ci||natK1|%39nYI-&6D+}RGg}-`1282uu~6lX&5-d!^4TfqmV6*GP(z$IH3!Y0~poqt3RO3>t;=46R2!Y2)E+I zfZq+dL^zM%rkx$8>e!8fM?&(vQ1!s#!A9zo2Dx&aU$<%3iziREeB8Z-S91{J9UCwx zA?TvPNP7`A*dOQ5+65tuxl9b<{&t<<<>KPPJFilu|IevAc_^UiDuy%$aM7Y_6hH(^ z&4L@F7ODkrNuU>gn8yic3d!K2ipq(bU!KBm1621A2aa{2+;t5XYC#FbkGqwe|5@aU zI^1uGI`jK;%{i4!Gc-Fz%}k%YAlidbWe7 z$jHaE-Un(7_Z~ic7!hC8uDX1?$>e4@idQ(#V?G3)RQ&J$>E;rtw5o?A>_AM2J4jiG zg#%rxAD(}TKU(mjo_}EfGC;g29qFmjc|ajuRZ>#o!=_+OaBEqZPe4o#vx+43yb(Tv zY#|Qc$E^QCje0LAsKaNPq*8`k+llM4?ynu2@ky0}ZRx+c02Z*48}?kH^)1^0W9Y}) z;4y!(X3JnNYgsiezqp*gOrUTQB7+~|)}0tMY~oR?bP2_=-_Rpuy#5!;WQPZQ z-R=*(w>RM*QVMFEX+y?0^X^Rryu37Ct@FAuOLO)f`qQEbX_%As5wWqG7C8(4^~Sqa ziyYdw?^ReBdz2x=!Gi}0$+)|ngfPeN>!kVw9q6UV-@JW$t3FZB4E#Zg3H69zH~RT5 z1{0?Um}PiarT*?Ex8#M6*^SZBynpOvTu{EA!TveI9+f&@YvetQFp{`3Cb_w1*NY&+ zSeUlv?KkALn;FA-uM&BSVxAk#0=L_xXo(P7_x682bI(mfgjxvt-s_*`I1l|gPg`#Y z*LZn(rTjy9E0i9u(LICYA+&sg#b$gQ?CvbG+-I$WM#kXzM?PA~UxhkC?O8tXAbVs0 zh{i^=7|ypcWmB51x^5yY2#X%t#f$rgP5$z1+0u#uLgV!SbP+NU3twyS-#0RU>f0p+3#7LF9eKY0mDxKuVD@lX2aY-0?lf$P9?@n+0mr7=w&o83EB^ zh>;1zB%R$?H78-y2$0hui>*`|jK_9haDg$bGz<})4;p8ej?t33!fz{gSR1iAk}|>S zsEk*E;Wzl1UU37C?~DPqbsZgZyUlmfnQhy)p%L&qlDbUhK;{y&b*0b-2&Qk@#J&BZ z_?$NfUh|d@n&D(+i;+WeL6$fUt%9nIK?)c&)A?kd^g9Ohetk(gztsrajs&<5(32A@(Ig; zJne~&BPZ!!s>HmqLS&vYTkL1^fr~3t_O)>&U{%#Ijg^s8=0O_lJu;{h96oAZNb8*> z3=hgw7^;r@!lT1I_p)9_oTgtHL0InCs+afa1Bg9cBvd4RFPLn2Xy|p=R$yiR6~6$V zjsG2`$O|R{sC8AuCG?rQY0R~vnEsNQ@Q;XBkJG5mEZFa!M_YMG^64x*u0+yhc40C* z8(S990PgRqQR>ab`APZ^(;SImg&*u{&!0UL;C~wyMnng=2(&);*U=F>xTl}M*uOyV zT`@*EMu?@~}|dOPwlfu?qg2_H0mhc!On z514k+nvf0oy*TcPz}YJAwLuZ&+(cN4TQMSwQ0oPpJpQPQuvxjNgA*0 zHt0k`550I%G6OG(&1NT$D>?_fsnQ0hTT@7mj~~LDq1pBRn%aFh5U_KB7Y%TR+_oPE zZiGjh@;C($?2|4^2$h}mCv<0i+eqejfOaahm`C{3c7z-D)M0S}{u}%f>#Fn{IP8Lr zCb>(8IyborH9K`^6&MBHa<5bS%+8ATlXvg<rqX6tqMrTUfV+_9G zPQTO5@UdA1MdNv{jITZx!Q3-%c)fl5b|UDNi9v*l+C0J+m7V+VhDj}lj12oYhLh_B z!!V%bOv|>j=Wm;tt+^&Ii!mjzPO4e9R!ip@J-x>ukkFJ$zt{VCEclcg8b4Xc&GZxX zD3U@8wjdJJl1yn4}o2gnRWyf>LOndyT1NHPZc(X>$7+zABDpG5dxzzYdaXL0rK0Kl-} z_$JsU9v1WwFa&$LQn?sOh3U@RtBGhlz29wzgz4nE;`|VTp-}cC(zb`}sC+ zY{^>spTqj~swt#C406vJNb7AqEesw#WvoIPyEnGVuNZS0 zIbn$~IL{Sm9>aqHYsNQyg&No*%T7TfwWlY#o6;?bWr}hC574ZS0+{pxmghK+QhId- zg(tS&NX>1sLBquvn!k2<0u!z(?nW7R7aA!xJA|esCXS(n5e&kH3DxVL!|YB~yGUHB zOz`(48C3DYT7pwU_qsRDZpxm8kGasXGfM4vjv({TvTwk&xr$)<0ed$DV4&t} z+*bmzhY`Atzt3BuB2}~!AEnK)f61!?6T3SRcsclJ zw-|f&869P(RUwBP-X-Yk)paiO!h7;BUc5-S^$A=O?cxnSpegD=1TNXy9UP>;mx9ab z%_qX1KjT(LlSmbw^)L;=5t7vT7>mWs&$rjRdjBzUMNXA;5BR<5c{FUGfcqAzJj(q} z-Cx&)wM6)|I_&PyGh%1)ir8d~sExat9NVmkd^c4>>V`hVB4de&6K|aO7H_Xixr2aOLL0olAw~X+o`C}PfAC>RBe35c0l&_xK<2KO5DTXqxAb=k!Fhm*!lA3LV+Ic>c#xCLoSH-_U2mrGHZwCtn+J+zi z!@}V2SC@T3J(lAr58-!V?p_JNb4)?9r4i`sTFVw*(#=RVfPn>!V28RW;Mpr9O--sh zmJ`l}rtCb>J|>qPJMWL1uy3v_rdbmrth@QNWu6|d!-pbSPS9($N(`JQ4G4ywc$-25 zDo2T=fg(YjIE%m8QS|jI_kjbh`v|gt>bFYw39*bCtSg*cKko^+)l^E0w16|+*9fR{1meOBvCk5lA(*!T~`Sbd_$9u4j88~_v z7q-=0`uutPzp+E^Y+;YKZ9E8C*(<95G-qUJRlf9fRIyaZ3N|Go6%x?^e@kFIyyV7^ zD%JRFpYkk=gC(+GYNGJP?F;cXgk!)RCSHggDU!tB>Tz_DpcN4rfurHmkxSt$ngX0f zP@VV03vg!Z)~$b@WL_`734po=ExaC-VvGWwgcQmN(Zhcp(5`FzlHJ0k<;9?CoWZWB zpfH??o^%)%n~Y9~q^D2R8*JRTagA;VdRQd%D#8fw`{Jl3qE{?jwB;3?HzMKjOc3|= zQT-jfTP2j*bY+)w605GmA;=$6c()Y66W9y+iN84zd~=j`WTU|kc=EV z_`ccM=E*D~pbxuOy_?516Nm$|vel<(_=mLsV3LiL^V5-SI; zXonN&Z-T73%fDTYZgCTQ66VV9iVDj2prQPO^blZv=RCNH4GY7{u>aT?N!8ng8^kVyCz z@@zA2opSvZI5Aum!ij-nR}e&7DrEIB)b2g#lRtD{ftG;p-x@B92m$o6%3%CZKM_2^ zk0JMibQ%GD!w8kT-^aZ^%H#|2Tkjd(s-^NS<*MW!J>9x(+qBxD3vuYg9tO;ai->rT z1`?k*W5`|HyL|R@SVvM7g`@>wy5#UN1Xk$diR*a}5SqtSWeQxQhlCGutTwQ$3O~YL zI*8;h9tLe*Sj8-2@m7(rl-+QgzYo&g<2T^t6imJL%QJjnnc?h~LRg8MUaM%)FPwBY zEQj$cBFXuoT>3%-LNSs1MK!zp`F5abO|Qz7eV^_?w#yS!lYxc@*A0s z$cW2+$0d#cYjo)FVOCK}ynOl}>EUnR_Ca-K1_O{ojR2aUzVqS!CgJ_M#YBZPSb|8V z$zDDo9^Ld-mCsU0zQZ8!gECoFQ3_U&AXVWP&(+3QUcpLYisQB=&nSbu!qU4CI=sK^ zz)1rLrHR2pB9<$L`;NNw4lLqtnwiaKKk*HqsQ~XZ;-yR5VotPs zo*`f?LXtmYf>G}wos6wRPUHXQuw(W0^>Y?)fL0d*A~#9Bp8wF=<^OSYCSWD)OrI58JEh5pP3^UeHDHO_5o>G>Sc4di{u}sQRQKPbyYD5vK z?{`1uoyphn9mo5=K6?Jo{lD+)IA7c97k*|HAf+SGNk zcg_!7=*p0C6rfL(H8nQ}HjY-$e{gYGDsxMmDY#o0Sol=KjP1<|+S&B(5elScB&rdr zb;I0=a3CyMNG-&GIUAh+E*a!3OcT^ySDwcrNtTun>bk#I{3n!40(0?#Z~9vM*x|{g z!R0-B^(rEAih4f3-(bI&hj5WS*~>M>DYcInx1eOT@$;K=o|U%CY~k1>$+ncLT+?|V zM|s82d#m$&f`exWyyz&-S#olWrVxf>rZmfQZ&itCLV)fDQ2d5#);$PWQLTU}1ChC< z*P1I7v^3f$d48=}R-!>)^)Qh^$R6vfW@VhU*>gnERg~!ouTD;i%)=~1Gjcui);fBf zU?pht{&v=wbJl~(2@R=9m8UyJ-77!z1DYLr^ZDq*6lokUUK)wsZ~rI+B{tCEVcfx? zrmk*(Gq}8sk^Ytgi48T`2)sW#CvC38102U>i1{^tPZR*=>DplL$L=4_ z4E%a~;69>tZM;#K7+^Q7NodgAn*6xD|NW*a#EUSb;Uzk7RJyS4KLC9vf5 zDr5^vUFa_x8!>hIX4xfN({+`7C2u>VetA~SXou=M&t}uv5XSAgc(@J?*g3!MvmE}Q(8_&U-7I(J5!92@!0ZMKmsPdvuB^S?k85Ic zHAiY{y4~9S6ZAD)Q?+34i9;PAasIcFmmd^L7fIRB!xs>szBK+4HGk$O5aIg%?!;laB+Ui0gO@3cUuR(aT=D0|P$3SiThnYKk2jjsO5ABLo32B< z4*L2C&u&(Je7~V z-M9OeLbq;DcP_CmiZe2a$@6$<6_KwZRgF?x_h-Jj<))-WN9UwXp>_Eqx@rF~^HA4r z+I1dZPuxH5P?VYwtuZ)5@!*$%8#P}|TRWsr>9qG#-n*y%c+5CpL-MT~MibYMeCO+V z$lt&Axm$IVWzu5JZUCiz{r<3RQ`{37zMtmi`LPrC?B1P`nK{Dw7*cb?v{KqRA#l!Zi&b^b<`u6Cdbnx(%=b-0@4;NJ!4RMHys$Zfe>F!80)$voF zGk5O!@RXFV912>4CbpQR>~A>IswPd;8i!;II@G6=gk@ z%Inbn%c@-`v5lJU-nnz<*|TSV{DDbNryf%&3y@M+xKzWA9ygR3%cV46| z<&O#q3UYFcBwF5Gd-j}wsLZ>Ph-5In{&|7qf73&jvEKC;4?r2ldiClhY8}aF zKu+3W!RO0==9_NbyxG|JaL*AwE4Q9KUi;|LBmRl`S?vP}%V&6*uLdVNq|`2UbxjOx z^TQ7#&0}QX`j-APGqeX=Ijz;6JNNzxO;f$!-qe0ZqV^szEpUx;+Or`G&!|X;IFJVZ z-9_Osdy=u&|0X`v%X~kFeUY$n$$v%<-m{0coO``*-MV!+Rn_pK)wHM?dvX!u_-P@D zT?jhGf`(=IT-cNoRm?&hNO=TY*D6atalf&)B)fHe?8H^Gl1mq;j2zj(DP$hNY&D&N z({uI}7cZYNV@8YO3t5cs-0)&&`{O%z?XvB2&$?g#{;gWIGRePHR1~~Z%q#NB7mUb% zPbIrrdf+CCjfrQs9wT(-%^SWpWx+WlqGOLvYdgtbSw&`1un^O|y-gPN>UD(k!C6^c z-1FASyXGI?_~-W-%Nm(7v{h-+BzD-*3RjbOk->!+u-SqwDuJ!Tr>)xYB=p0=lWRSnV$vszFTU+8q zUhu6ucg}I}YPkNOcRfu070CaF26vhZ&u~Tid%kjOd$Y=p#~KzU-^zNs{YX&PQ3-yJ zE?9nnoMBdWM0ik80jy-pmMwqqlDXk_;0_ZQ(zAC z_+Yp_Vo|{?<@6UyT~hLIg|>U=tEo19`ZipjB!8ntCl(BAT6VDS!~@6G4D3R~!Ukyk z*rCI|{rhvRgVV=TZFzjDQ*nIp*I$FhQ-y?mzrU+`C+u*nuPK8~7}rKfklVhx)_2*k zapU{i+PuWW@rjA;C0ea_{`MO-VYM-14E2fT0Mq^p7cSf$vDj^vGQr6oq^QO`f@#w% z_4{f_$5RymTG~tUECAHxl$#xI+`JhZpq)Nx^5o2>KZVD%=vs=q>MDDC`So3Cs~|g? zC6c&>95K#Z`NGqOYul-$Bjs{_oktkPUA=m>rNp2QELJcK6f@Tx?20ynRYZV_9@5b< zDfjn7ERXaxhOq0`uYdVi{rJHCev_Rj`zB17(9&zf@R1`AJNOvqmx>@T!#O;=)U%un zBYUpQSc;cBJF`M*rQfGDli|~*O&dGbXpU}aB}5DgU6xt(>({a)BTNtcj|=!sr_>Gv zo-k#Uq;T)fojXS?3e(osmWkX;pka#DP{*LWx8l*t*Yo%2DO{kdyEkycx(9WPo5wdP?IdyKXLpx&>r}u z=r}R=EX&f(&(GIaP(~2E>*nI1nXt8HRp2p+#xIysAb5<6g&Xh9n>V5Aexust!$ajL z*F+s7yo%@XN)l}Le^GHX?#NA$F&P>2{8g}$Sl6%iB(gSdcnOUi3EQm#Z zwDpL!&d0pHIgxf8rN`h~FE5Fno}N5qxrp1e{zHq>ab`KG?)A|D!+f$nFY!J7@C`1| zup5fL7cV*>pSG41+XFf=_5THZnwMKx*Z`sEPE|MWvq{^q0Yqr)a>(L+!T;_`^JsaWO=Yr@80WdZB@nM6xU(z`Y)MkMPYJw z{Od;Ryio1ddfd8|W#&Lx#n1bR4h{}P=@ydsg41Wt2qFUT7S>5&{F0b;hUD1R5uF}( zVsXO9;4bM`d9wAhGh)v33T16^9KQINg0o?F1i(&m;}K3uDHO^Q*4Tk8`-# zav0)-{3azwx9|2&$eQfz?0tLp8g2Cz_J(P06EH9zuLVDu@9Q>s-ScE#G4I%T7@u#E zyk*1Y%~zQr`RB^(zqYQct81CJf5h+e_m?Owp0K7%G8;OEGe;COw%x4QiTgF7e9rM? zZm3|wM2fo!H>t?5?z@(hkF9^SaE?BuA4gc8a4Jj#qEl8E!@0+TnsT5OmW5420E9PzkGRh(;Fj^ z7|QP&i^L$kiZ34zQWLdiz7N3Pg_?2vxE9i=Uw>^`-}sIgJoiAqb{#tSRjcY*E`}}I z+y(*lV@-{3_3&?zuiJN%Tcu+FikRn>o*LChJcCU%9|Ape-ZKKmYhatF@A{^6xu$%IcKy&Wv(Kf}f+Mr3IGY zxD4d6)UG|H=39bj(xqWtUVm6ay<80mr*~+8wWo6~vJNsIMtnoYd zJHzB(!33KwvbC)s@^>CMeQDYU6Ry>G*X>6(LA+T_?B2bB^Pm(nn0%CQn*#Nk8=qSm zm6DPozPy3zcbKGjb9P3?gBnHlKri*B!})0%Ob{Ste0cYcQoXjW&K~q`b+H#X`7gk@ zz`cZ)MJ_HM#Vgpd<;UEg^Jo`J{vpu!?))koEnoz(0IdcPB=u$efAwVp9-HC0jq<6r#P}CNi?;SHjv*pczX1bI9y?}M zKDJAjE^2l|iaHCbMWUhb-6pW7U_VYS*-`QMVpGX%=5&|8pGZ8Qm7#@1_6&!LU@c*N zO!T87Bg439&-&Jn+Z9ym)<3EaUaCHR{DdUG!QD%??1??`bVteVBgIXb85v8sWrK5j zp?^YC;}`5!)@#=elN1XC1@7$6ED27C$iEkCXeA>#3U?e8+l8y*0dwblw>@N$pv9v{ zd-oVI+3rwapn2o$53U|Kf!y~$$%n9c|^chiXNo}xQLG7jS%Yn<5 zCio5Zvwr8h>-NMbi>7>AfBA1S?u8Q-q^XF~b z?jS2AB_(}ZG12YyUjlA41V)H>bCOL?j?vUiYS^{J!otnX%~nm9jjJ~D(0#^1Clmpw$4jT?+4R7P@On)Dki zFlU8DiP$w@veQ{DJEyfGm>ZZO33TY(dBObo#t(7*W!M-P90G9m=-z!J^7GI(moHxq zy|BT_N$N1jv%^+b*YZtM+5?kxzpn&>guFSqa3f@{|f`BZF4y?tW2EhOm+uVdE~~Yl zo3V3Cy9jMQ($Vqns%J^DL%GJ|6LukS_9cbeYT^vmt&`~nt@~Oe5}v7zAGcBhx$48L z#2Jze_zv4k&we{YYDPms&z(Ec)Rpxnt*b4}iC(QYeRNxi%!zg8@O0?X#q=SFS=}sJ z`=rYc%MD@&bHSU;9GSxm+$NPq1fm+MEx9yk&>$^IT7Si&XS)>oaiGybLoa;GymoA( za=Tgi0tUq=eg7Q4^Bk{Vzh302>G63JJWPF;%dxS9+B%KD-@Rja&u?;oR(y3bUNKr2 z_{oa_TO$En6=8h8v58n0`(3EnKeTOIU6i^^-+9V2=J1W%{B}u)4vo$&;yX|aUb>Ev zOz-Oh1^GKEzVO{P8EqKd)2`o$J^S}J+?ltBk6^c|E0N{$-fU_q@zR`Sufu4ixxf9^ z^l^hHq!r>!83IHPEgSo3;_$}hF|kXWUa5Y|X;Y^XnYA>PB`!xALN|SK08fliwG-16 zgc#bo^;S1GzX{^hRCW9g4=x(K?>-nyWuX&b3$V&)Isc|ZoWgZmyKODFv|@G(R`-aH z58VhID}9^D9QaK;b?o@F)>C^W@f0p;O!?r`wo>J3cMge~o!DtPg3Q&*`~HMX7nIPMGYd~l>0$HtL7#4{ILhVuM#b_+oK8_6;&mTE zQH^g*KX}WFJqQ~|gMvDQSgZ6MJEG^Pty@k9t)#U(K85!58jPdzIz2SBjKjjb@C}eD zl8`_h9>}S5w{8$vE-bf8!sIDfRG(b-o5|M}z|_lvs}TRo$&Rhdi!c0-3+UD3=bw*j zx-2NuA^SPQ`&NFw6B><6wWcN~@o)@CDJx5t2mMN~3}NaMP-u~WDWVLdcyB2?yLZ=o z7R#Pq)&{t6B%7i2=NI<3fiZ`qq8wI~gd`FJALb}W_cJVS`&@zA;IuMyEDjPLgLk*+ zyK_{9dpDU5nkc{HcJ)*MbFG@;)L&Fztm6reY*JZj7 zpBU7 z+|mBIwA}_+1+Et{SY&GY*rmv0q6n!b!$2*G3optpw?CF~#F8xCiS{kTPAO8Dd44jp z>R=5vJ34liEDvO}$xvWVoq}>v>h+|cplzQ`Z=d`rsBwNi^=aJhE zzP`fJ($YKWaPGxrJhZ_THn%-tD1Y*000%}Dd$#!x26@&C)?E1Vw&}O|k(GDn_+;Gs zlzLTpLfy-u!{YNckhG%d!O%vl;*MW`ox-JH<>e|ol2`tB{7=YPIC{|l_}OCCtXcIH za6ax$FRQB|3@Mjot%+V3Qom~0K9Yr#$_RlpLXYq&_#@s=>}^jN%PyTe(+Bc<-~^kT zQhYb|c@h4Ub&4pKQ>RWHKYqNTqIORcP7cpQIX!m=i*(@*Im0V|NAp@yE0Ie-0)~;d zM$RyT_ThZR&f60l94uF0LIQLaETHCc1r~@LO^X>E?QDt5&hk~(cD8kY+j5s@$Y%kx zpoS1pko5mpPxCw$sy{1gTS}zIffi(ui08_1C+f8ig_1(iLchz~2d8%YQ$GVx&j>C#AAaP>W06B9I;cxRUizkfnAM3jM}#(Y+8&vhVZE>1E{DC`bGK>~HSw@ld%9VQR4=QRY;!kue_4;L@`0PI4 zeYSp&fdfUz!@rVcw%*?UIYGE&-X8cP{%(`%j2WI!qgR99&IB@KRSiiAC@N@gfk-b~ z&k;NnVfGzXYRWFLNC*uLhwBDXh*`CMa9 z^vmPNm)^5Zv8txBdiCm+ZE;D-$`vaHlX0JxCOG5d{OPBkq~%prjVQLjtacK_q}#VS zr+{ZeE?GZL&;onv?Bk ztZ4LtI8{+`-bm^B^XJ;6Ls>jN@RZNx=kv=#DKs=4o=@%Dw=aC48Nwi=DN`}#FPdyH zmyyHQIr0`}W_)lI!$3Osf!|jI29*8^65af{?=$ha%eysSaj$j>M4c=@SpofmPCd`h z+f!6jdUPHzXCnQY(*RWWGc$cw@=J~^+qRWm&T98KFmOgA_<-8)-$JpzagIc*k`AD* zEKav>PDHG~|NfhP8DCp5&;z1@nI3IgwBRt_wL!_PvjWE=12G)J2sh(iNYKn?miUM`h@PJ#pfQjlX!LI zLr7SJC-@+}ZBy@4#gSF6&1aDPB81j&yGat!>AMpc1$GUjLBgr0#gZjp5hFRLxaTl& zUGy!Ai3~2)RvOSrp4<$DMd}Ah@q{OMUXThouz4|@V4-)S#%*zqkSJ|S{-CSBulO3_8!1N?6_9G?WrSg0VgQW`O0MA^uzv_Htv{QLLsKYUO$ zYAH#x>(;9m!!+Y5;Wa9ALbD-CY*((NZ948QMs*n@F%h(fqxMCF(E>^rr&>Jr6rM57`o=5QRzkO!d^t;*=dn>RLc zNh-}wjBmk?rY0n1Yj8yX1@;u)&YSK&79Ii);i(`Nw4TCSo8&5vA8+i| z-!>8v_(Z2E&gB@+6?p(J&EJ}z!a{qZ4qGTfZ%?xSL*9kCxzwkdr)Lupuj_~wlH$%n zafB4KA_aA{xsP&M`}Qemx+>(-rAxeT+s7ri#01Y|5i5nPYho;h!J`mr8J-k`rS$mI zr%z0;59d%JxA|S%B2cTNW^*hiCz3Y3xYaI7Z%^GRnbDhC*B&F@ef)SN?&QgnLL!y8 z%*J&9BYQ|&4vxR_?)laX?)d#iV$yIZ4ZueI!t#sHdL3fADq?I!B zel5)rKeTDHnVAYh`TJ-sb@v4E9GXCo(}w~d~5bU z8y2R%}TRH{gz&0Z=#~KF|=XANit zGhM%Z!8ycT6GOkWG%e{;9wWY8^B^5!Ol099>E_s3Zqlu9UyFOz36Js4TyP%YBd1v; zqg%tWe?bY)og2`c(;ReR%h=$t#+hiXS)-g2lag#Lbn3}G}rjtL$15L!h5IIC73%Sy?3F>hk(rsfz636ZHX$E z_k`O(E}&lb;6b#WHh&p1(RzE226zsLzsjDyd$Zt)*QRij(W6l9=lOCjad|W$5x$Z< zFj#|L=dVD9x0RKxsc6N}9Y;sUUw-*LFze$w_(xxdry`W@-m_=&mcK*X%lauO1fD!; zZ7cZx73vC_^V9*#)KdUO|*ZD!zb}@hQ)Lz z;*U3gW(I-t_3L#SDZCw^)VE-!`~ota6bG$qx~Om8Aoi*U>(El-Sbz$e5s}}b)#O7D ztvg^N##Z<^Jp_k@0NdXgVM5kWVrkk8ic1+fbf{j+z0+ZAJ##3{DO0A1jaiam+M3}d z3w3mSR-RZekwzdcw&T0Z*QX(axt^ezl~MhL>wVAE2vJX+LccKPEgZ{BUDBua`G>^XR_2&RJ}IRHl8l;nLJ3-D%XhiWP`IkW(b zj%|J@j!sE%@BkF~c_z8mlDq-Yu|1V2v|hB_%imQIOb=GOy=lA0>3CO9>ni5*w{Q{7<^Si z*3s5p7w(IZ+Nr1JlqsLT-YqIh#oEMU=Gxc9-U1Gnb!ewi$p~Ovhjwx)Nh6!oO^Z{f z`bNWM-Yw$ydEmgu>LSnLwC%8>{>e-BV++0jeO-UDC3fr5dZ?Ez}G((OZ zTT@yjXy$t_P|m-6`NCa6y3ew_(Lp2zfxtrKob%a=6}6vRcj(C_;aZ4eiQlsKFnp52 zN`%J`Yl#RKhc4z2p0HPf@KqDiZr(g|ekOX{YpoxFvN_G;QoO2&ODCtD*HD=ZlMezk z+lQs0q3ID%%>Qv1y*#7Y|8&T3?P%uZGiOR*+^7`6P_eV6(sB}dX@ZuJjg=Q1|MdFI zL4rr^P}?0UQmASlAfNR|b8J@fDq?pB-s{mJ&2wedQ8CM8>ejIs@q}tO1<^dxA7c)p zg83O=j5nwtURmN!wJX-??PE7Q1wCR6_*O%xy?=jy#wb*Bw=beymHh~{#skDEdafKe z*-1N8A2+dq({{$h?hV8wpML%NO!i^g&&@>y$1jQqm}q9dDAi0*Q;UjZHd_F7M1-CW z=Zz{^ZnKccrY4w)VIBmvh;VoBclh3NT6L00qo9;2A@1C|B@5rTPasT&zF|F(Jx36z z_q z?qTgiI&+P$4en1Tj#!j*{dPaUMdC>G$&d#}joCN;BOlYEP%saY;4O8}^2MBb3iO=Epyq~8 zkxZ45nS-q$B)9@LK9D=cMgM`jYi~)2KKwDK1 zx0QNjMDP^dx^_)-69+;1Yx9Gk>ywuXP>(XqB>GY*XPGaJv$yo;!l93tOJd<^d3W*C zUc7j*>cor*6Bg?W90t(~r{<$-dSO16GRQZ%C1>Q42c*CjlF>5}nTr^Th^vJr`9SoT zw^nW2?xL(eAJcB@ES@3hyX@#mNe7KJ2Eh;C4qCUFs-2x3{wa7MlS^m6g{I;<6oe0S zy!jqKKJpF}9+~0ebGM7U&z<~DG$cm|vwRzB>Jq);K75xbR>y}Bi*@T>GnCC_ykQLkSr~1|$PMbNTST(#i9bRL!A8%^ ze4dR40%vCAtzZ85BG^viIJfz^7$lfyJWl%#FO7FRbzEf`@|E#P#X*D8aADuL!P-d* zl~QSO6UYrwy0#n`J6E1#ygZ#y+b}(kqks`HddH3(bjT4LHDtE2*RitTH3Py z_9=oYEjQ;b6KvBen~WY@{L+_dY*lRB3oYz2*8(bCk2;H#{xyoQlqf)-#I-~unZ z@r3mEoz7AI2fWFo&EAJs{!rp7GzCvGWQc$a<~D2BLUQ!#+O@d4x`?Y-rib(J5kcrn zgdn;Ztn|et_wMyhPM0KJL5>KTfY4>oD*7Jo?sO{U%QY6+2CiyDDv!)jhOy#ooL={l zc=6%&;C-isX`b!$ohM!@2CN7t*f1a6XX8!&xO*36Y{WjKM6H0;0vjMBJ9dc{Mw%1~-=`ZyEDKNKTnRS=-gTZwSHE)YNZGfvk@DpXe)|u2(;#h$(NA2SQrUT@D`1V$Q1%s3B*HI^6@hDsy5*w3q^w_ajN}r_d zadB~cv{qSj;4t5km;#Gxe6|!vE8daSQJWkc9}H1)vWTJ3;91ko;^0bUKm%mr;)fU# z7@R}@o57q?P2u0LO5JAp{hR0y^<%tJ_?Xl-$~HJVSBhaf3?6Z*S}&&yBnD%e?FfmV zUvTh1K4GwxL!RKi1VP_UX2@qN+-r=bgV8V-2-)Y_Aze4=-DFnL3ErX+-Sg z4CSYKrUvH2m$z-p>$V_~`|)OkM>j?X&hN6@>SwX=BDC+lex8yfT=^_OLi4PxJecUW z@362e(S;W2&mL~!`5xZ$(k0<)466nT00=>&zxD$X-lzP8Yerrym|Zm#`S4DDUWE{| zz!Vh6?10s9=B!*S1V3Hdq~qw)wL>Wh3ZD%^U66aBBq2XE%iCJDmLIcd}DLxI#CqVGr! z^bL|S&8t|Nj|$pz=J+ptfSa1i4nVo-SR2~znknpsbHK^wXBEjh9`@13xZeoT>qu3} zweR1rH048byYcA9rZ`KtZM)VlDLy{ZJT^-Z;}XYnbfI!}?2(!ujF&7Kes0PMduU-c zYCtQ}Syu#cQO41ig^CFke%UQ5DheXx39pBqxAE(r81SNVb(?KUFU=9dhP{HVyVD8o zy{u~Gx6DP_iclOq`ax!y6?r4b!4HQhkt_l< z_lW>D%l*?|ySV%`RH1E~HrFU>$$vakQbb6Imc2TDL390DS20?L>!QZAkZAP*X>9J( zZ<=dNY3#05Gvg7#Q##JeZAA`g-cjLLv1;a9lmqj#rGTK-{uwyP5RlB9qQ0R8NfW}v z9O9@+2{Bd8Ec%wbE;pD)z;$4hwP0WJp%77Qvv1%2h3|EhcmQG&1bxj^-++L{Z>
    MR*qj4&+*o>G`Ias50V+NZqZbR`$iBm$K7Zysh%=Lu;c=Vs)qLY> zDX*~_boRccoy6eTQl|c(y`i@YZvGm6OUio0{~05O51+(t!~22NggcY2`E~%xb7;8~ z_8@$ySpA{RS6@YjB;8Q|{?5UHrq{n6Mm$HKsACwKJZMk|CG|fBv?gu)vG?$tpnXfH zEKl=7ur83ZyWb>i^O$*hbIdI)2wL>UZsYy5=Td~}OvwQ8lGK7|zmh{Zo=t?$f5;Pw zA7j4%mC%RJg%jVhWefGM-1*J4Pcv0gxba!-=dN3~zB7c>^U{R?bZ4NEys`zMpTs0B zG#QEUO03ZBaa3n#FM3E5k}E#3moH!PC|Sc*RHkfe_{3*(6NEG7Nb8T~wKQ-Rd<5O{ zxbiqg1a98jvV4BPRq*CH1^;=NE>=gy#Km8{8b7D_URGKkE9I&ET+arNYu`ya8 z#=+0O0Rk4i?kGE9q9H7LRlCahEhM{({^bHB6GbB{AcptZxkCr+^TRh^gm~b*xYd@I zRaf5+!tk(MrFq^!n^B>wZ|IOAr7@BI0|pFGSqKy_e)A@?%>a^SRQCP*!H|kzqr4B? z+7(P5;Ey+*4Gm>Vl!kzEM2}Qq^TY9FDD*V<;Ut>vs8I%Rgj(@isb;%(W!m= z9Kn=HLKK?SH(vQ8h_ek2!X|2a46`LRQM6SXWB#I}CjJG6GYm$L{IAUR3Ky=0PbCLa z8*21~(S%LoCLFM!k&!GMa3!e|r*!W#)qPJy!i1P&Q-Ij{8(Ou^3!7MN2vGLJ-ov!F zO_i5BAo{qLEWx@B zg+{W9tq=NE-lW+vgiR^C2JkPPLXm;bn`}CNDdaD^K~$zaiMJ9o~fYfwpPj{dHWea6B-PtWZjiGQ}L-B+k8O}SC`8@t04Z@Rm#&Jz89?df@^REnxn4cSBKt zvuZOxc0(-e3MSQeX5Zy~pHH-Xg! zuoWakZhHD^T$b=P1W3)-uvZc1Gx6{s!g*JZoj9=?2sfjZ+|esB$ZHmkLO#RbPVY+)f5#`aRkEu;xnT-^F+3I32 zLi@Cjg^*G4B{>ft^4^nR>FEu}($=Ra^x>OTnJI*2{s08LofVZ0X$F}bU4S|OYR z*+0BNa&f5o6?8->2Oy5F|0FpfEjhZIx?T*FxR}~#w1|r(yz*^WSK#A=>Dga$7cFG; z-Ao~*N~(S*Q3B@0Rp;byIgkYnRurW+L08KqP$F$Jk-|%J)R-~vXy{nc2K88tI4*D5 zek9YbT7!s2T#_uJ+?YYDG+F2T8@3f@;Sqcle>B2n%-Ui~zJ>@x=y#w*UbM?W_s2aI z6cUNVd@n^Mr5;I-Ma!GUyP6tt9ws)24pkDfQQ|yEjfXf~MB#d*n_!lQ7nXi$GNY5t zc<}(3S4MMa#f=*45Vy+Oz2mJ)Ra6H%-OPvNC4R>VibKR6_hUJskz~IpIW1Dr(1^`l4d>>hsXIqk5hpX>*-PQnrAv;WBTw$C3Pi1Y z!=-@)oLtwMpX=F$Um4|P_z;E?Q7-54V-ch5@ZPPTxSN7(vnhlJZE_D&Jw45G9t&rs zq&T=4T+!;0m62g!sjHaKbT}x;qFjtjRx|pqWkcFCVdW&OKKL@jM~M4h_CAf@uo49Z z7(aTc*GhUNnX|#;7?0zfnON#0?JRqH0Sct{8~vY1>lk)A zA0C-wAY6}U1vrn5k|!Wmm6uhR_Q4MK_!*6f@as zu2O%;!}e>x zgxSozhl|slgmsKb7BLX=0IK#EtWqLQD+_PqW>e;=FxGiA;MB`Y!mgF7Hp{o8#pLV( z1GYhfL)0T@y(%p|oG7$>0=$@I40s3>ZXrbDW5sDc;u zXLZedga|+9@czs;OsW(l zzjDro6bp%RDaq_Jb3;mtnW=Q7P$CG-SSv^xtx5x$@UMp2wyF>QOkmyBN!Y$DSK8S< zlXq}|>t0G9if<7Q0LQxYusr1~S_3r)!Z`c=(=tXaLTC89&O;Apk1HS)0Y;(G+U5R8 zukyFI70Q?6#4?i;nI!RvC8jcVFqaR6xVw;0v^ve|BA$uupY(=2&fc5KG$$Y^JnYhP z1z-(l)n5fZ9^Zp_xmrp{c&VIP6)Ph!*~01d7~~}q6JQlRP)NX0&;S$*BSzqh*`v@| zl9rp0l$5&Mk?k%_5l^ETh@)D5;l~|pd1vm^VeU2id*h}}Anddc|9g4y58=#td9!BE zzIpSe(0k+$!&Vj!4~L@X_-n;u$DyQs2|Z$!xaHmHeg*mY+n~C>feGXOT%LfMLg(GA z9jJ}0&4X=>ffyGvzBgN+t|h8!&UwUzWd_E^KT9t$-;n6oSz)}4ibgbhbL2*HxaB`C zv)tX23#})+f4Y?Hy>FkYvo~`AIL*+7!W4o9S@^zLMvDLvH+T(-Dhsr-49eR*R;;wi z6|$R?6BkHRX;W1Cwt@{b`P)A}Gg2}y`DD#Lr5ktc4g!4iGoIT^Wui;f()!cJ-t?OFmOCrb zDp%OsUzjCsFA<$f;o;b(mS**r7~EvXIFCLGVKr}F21~*hI(G7;dPlYKalJFfEeA<4 zji(>o&W||~%ZL2$vR^0Y&2I=FXTYQiM^7 z;MXb(M5Haq#A?Q%8fGm|oM^g$K5NFce4ECgalqi8*X zJKJAO=I+>stpWVgik*8yd<2Ppai*QG!47HyP_lolh_@I?%cHGmf)UpyrrC*^<+LRk zd-K4b8P!6Xas2XTQzDy!QaAkI6Dmc<_2K%@C;`(3W-xK&;7l$dKyJdkBy1mu3R_J{ zjh-E8xuOzqqVX#sK3*g&%YS!mA5b#cZm?+elm?wuG!i%{-U47!TS#)(v-M_oBy=&eG-k!kHVL~LB;=k0je`T z6}L)o5Dx(XasSaHxNa}$w~3=H&787Vuh7{UB+!puH&CvVd3m%r-+geLox*s;CILT# zq{gne@k6a|9@HG}Bst|FDKw*iVL<@0PRAjWeSKeGK0e4dl}S>4;| z>6s<$r}A=3EGksO_Zf1>)BYj2_lPe4J3VDS7X5`!65h42auUFVkQJUy#mvLupapXY zG?4bpFEH?Pmg+@Wmn(^hiQAy=z8%BDPMibek&{PO`!l3{)a1!ei7kiPNkZxz@fkiH zG;-v6#0V-ce+Tp5PMJ0+Q+&K)J2GF-{{4*h;tP5RZ-y-)=MKfK?N}y9G`Mn z7*V)UiE?ks)~O(T%^jSlqP4|xqj#F+KjT;&-S8ft3k}UI0Ox=o@s-b$JTu=jv$skfT|NYylT(xIw^A9zAZH#WnZIX6snvRvaCq8#GKdsM@O2 zkBf3%ZC<6OdN++jNn_`>ncJh46csaGsSF)@^Z9eD>6SITnyNNiKUb_AHRCy)&lLkUxI>2hP9fioJJFee=b_H;0!!c>LG}ErKl6aOYy(BMS$c{))7HLaJ@q z&;iErGMn6PihbcE$a{_H`~gQq+vN45r~*WkzYk{ftyRyzTK$YJrJKm)9SYaf1j`B& zCoyK6yorjVYq`?iUJREq63p+l^b}8Cba7oh?ikL{+1oXiDJ$;(MVPuOjYI9id@-|+YD7*GMuXCm``HQ1{-u}4J?(It*X$k4r zcfx%8yCQU*`+F<@0XS%fjX$r4)cdzxyC}VWF@8=pe6ZhSYxi4s??(N4(0lLR&y>!V zZ~sa^+dIQQ+Nh9_$}JV}7-x@vy$2A$1UuKe>|lMy(1Su@D2!w*ijLk-0$wvZ;&#!J z%yaKvt_%0C$-G-kCXKFAd!=4@nyr>_(fvU&8bXbyfqd47rid)p<#7lSqd*je(mWN7 zMy~U9-Z!uttDgfGwlA+EZclsl6+=3vXIdMIzB=R5?I28H2c!--3iJIakdj%o4O`MG z!D%)1J^!t$qQc_QXO<~*7ZRAcK75-iq3_wIo6jN6A^7KN}J?~1XEWm7E)%jIuqrmSb$CR`~u;&#b!jU_B>fOcsbdnhP~dH@s0`KeJECCpz= z?VaHfM=h}ITBb97Xl$nmu$p4YH6C%M9rywjS5McJ4tRBEpl76|YTU1oF@MvwmpM1( z-R-`sE1zfjzQZ*a`-aNpq-W#S4U4E39SYCR+Ey0ye9Uhn_F^ETfWh5ac6EbUi<7*H zf84e;kAU&wlaz;y9qWYILRtvM1fc4O%qf-}13tP_H-E*2kCZfRu*t%sVz}As)O1Tp zFJLK3r}5E-K+TQ=D5=mR{A1TMiP!u_DbEwVPTAJ_MOcPY%!axWb!E%dcehg5)>O-0 zbjiGT@45A8ZUJI{{3uDY%(=asA`d{}S)RuL7qxAGt~KNu$mI|1{)c4ZtI?wI=2eS9b?f<$%)L#s?wp*o!5ShX)JiWDAw}4|-Qxr8fxcngm2uEK zxQ)ISJrWJIewt~r&1M}}kF5hYvpu)6Tdzb%@9lrYITcAWu}$=R58yIF=kDFRt;?Q@ z*DKnVFFO7pk#(y%zUAQd2JaNy>zEiaz2~i1XOLQ?b#h``%!XL1boTA|JPUPvhFq9>C#wM!+!H;kxz9vQ|j zuhu{C_3Kypg~VxRxmI*47WvMlss&VM8gj|mt008kB^{J)fR)LAtLzD~)ne^VKmPdO zfNi?~astuXx{GLx#R{}~&iTkKdtOvkO-E$JC@EUPG`D~(g;y%KmS;+xaPR(oko^_e z)RMV0KG2`JtZ)ORj0Zf^{)1$uQmFU-6V@*=d)G~TH)`x4I=bFnhkd?1X>=<|d`0Qv zdleT`)jzf^yZD&`AuuTDdr=ag>C`UJ&+p3e z>n%(A?Y3UCX2Pb|26hnCu5d1fI=2&kPPi{kKG@-*Qq%Q;Q@0p2o|oS}lkjRl!a&+? zCOEfK)hB}e-eur51{YNp#EH~}x=1O2T}Du|UT^%WH=#|tX>6;EeT$2FYzc~8TRRfc*!=jFWvkg}vjpHwqWKjMy=VJcyu2_mx{ zEq|L=QH4=>sW`9ZXifNvt6f_O?`~yb!lED~mXKBB0yK+h0i$K~ahT}#r%X`&^n{c& zif;TMY5{f5Dj~8@id7MKfb{K97;kv8CoPG&?+D3AVfx3$mO2@BIDuhz%5pF}?SUUTSeCGc$ZuMk#{uSo?m{0GwF?IDDWO>zI^xZ#c+JvK-!`Nq>T?@#{{DckSmB`I0Eq^BR1Fh@Vn zw{RbGdvlrpUjyxw{qcsA#iITTb#*@zz;HcqEzgpK*}8hH>Ax#$L-8SIhxScJA_pkXXlmHFW=+@x|FV1(<=t7F|5qUH2>r5;>ytAhGORZc zm15pNG^u>rIKpY4VP7^^w$l}_aG$<;6yBb=HOka$XLp$6&_DYV38tA{(U^YP#LJuOF3(V(<>$s9Hvj2% zl%aW?y~jqS7ZyS^vm2S6TBG4Bn`&ly_@IALlOIeJzhIr`V~JO}&bf!qZ=Y;HtcP(5 zNUg^Q5R(LzR0Odq_V==D4QwlsON5n0zF+ruA4Gs~8W+v+kp}wu8eO-Is$|~7mrK_Q zr=HJn_SpYXp-lO8)c7`IuH{~6m{2-#k<(p@-Ixuu5c50dq-O-DZ>fkudU85vkfyzq zxy>+D5tf-8D^FI9q|$fPp{BZ0~c_Y=uuKqn#?9AWQ{VCw`4nW7}&szOs&-{-I_#7}YMPb+c(%^UyOJwB8%I7$4 zp5QAfJWQ?AcUj@wo)2{8^UTUL>{M*8^l-S(tp2Sf&u`pTD%4b-I<)~SOTKaANU$)N zcG-1dVr4C-!aBMr4I|=;+gY}jho398%ArR=`M!33QVA*{w-C*sL`&l}m7QDzy~OwE zL8F}bK2n9)X*75(ten^SV(8jram`=Tlfl~d`S3>T7MTU-1sW9XBtHQ*);%PW_%D43 z`-c2s^KfrI0u8ZU%)~d~qEw}WxM%b0ow+Btl?_f+ z8ku!9-Sy~jpqzPzuo&iVfcmts$%sTxEL$8zCEcg(tntySR7@i-M~*g4{_q*#ziuTS zxRS&V{fDaV%3sp>bC+o!4#k@RzL1Ihlw7*Kf?y<%0;aaOx=Qbq6})0ay1?eqpZVvX zf3p7$3nwx^x#Oj7V}}oyK`E4HP}K^{si!e)6RK+7l4*}Vy>JgT8n`B>@Wt~}g<2?o zNfSDC>ZH%?wuC?8^|RQ2gyz92S^>VXmoYq(Gh0W5QW;SXN2oL%9kUYUHb{8-M>%fX z=vL}8myWB;{BI6TDf8F;G(YFRoXB$+=rIwl5<~l<5=@iKqZMfQOL&eg4$|16J#?&l z_Zs%4w!-wDZjZ4(aq$27*Lmb;*0Wy{!uu@5`f2FoedP+j`9y5^2K%%9Fzw6HAXwAQ zp=^lu#7YqkpFDi{{-pv$rnDo=e1}3s+{?n8WJ&^(Lg0-$k*d5uNO z;{m+_b?j$%9x!!@H^Z?SH=NrDe9e#l^~fz;;j#%A$nCHh=~3_M>K@&O>P$b~dT+xi z+*!HtLuMSoTjN=p@sr&Yw1VwYWhT$j-U-dpfAsP+MpHoaEkC}8tjrkp0`C3U)>!|F zK~&DPK2Y(;r`tL60CXV7JFWoAN=FtAd6s38h$}|_HEF%hEDt!!sW^OP$@8R*uNG)* z-njAM=itM09yw#}N8SnVZ^K~8cnz4>+vx>#FBu)_(`x|&to3oH5&Ih6c^7mp^3ORR zso2+L^%(WBtt8R}x)Zs7Q?F|Kg5c@T;zRdL^~}5*2GUM_e@~NP$57_Qp3i<$ZOel} z)$C^hx>#81<8>QBzRy@Z7YKYAZMeMltX+c4D`-t)%e0_WdcUXGcQh%?{M`<6%%4n4((MA0(m#i8RlEx74 z!j@*PDa?FPIFhevUQTHX;$^ME!U%K?cc$Cit~4vX*?0W9K~?dnPFcEVCPew_YM`$8 zxa}L-iJe#baN&$hkJ-*r`j-ZFDjhMu>NMr&`=0l&a;AEJqx?c{!`k>1wlqEx=vT1b z$>7m}kYqh|gOv$=BOaT+es=m@dOd~iPql~0Cv=bRf5wmkoVRgq&o&5cm8U9Xy zF0osXu*c$EH$1+-U!q{wlu*q&8?GvtSD^6=sVmn5qrpStrgxK}xdDBrR z@q9``&SG}6P>P}XkRvy=C;yTuO>3)5@-kr=+LxG=ByWLfc**zZH+9Qs zD*2!+H6z0nu-`Ajde0bVQ0f<+@87$6iY;7kA|x3_6lyCyc5?bE^eKfn1WE1|NC@0P z1jNElLMg?#ktkh=c1!U$($RmZ^1*@AT#dak>>FKQ7%82$@MppXBOrT>9g%u$<7CDz z$6jtQqKpmQ7S0*)L_V!K=vRVINI)SbL$h44)zT6u@a(LUvZIQv47Y~fw%n^UpR*3$ z9v*~^LTb}(zyQ(xY0o>Uz2SSVR*VJ%SoEPj6m#VddUJ1@?7DqpO&hUNUga10N))Bi zWRi)IUl({R4$I<|3tJhEk)AOe@ycj(k70U=w;vLTqZcbw+cp9;k;PU=!NXmd!2K%y z?Z#9oCiJ>Sz$ATToOmNH3&JCt{z9|{a<$A`a4bVwnXeg1vh0d5O4*1Y?$7W}nQ&wP z{CNJfXDi)92dK3)-~Z0vgZqGntNh||&*Y5m#hQ@FUwiiGu_wsrZTp!JTcPUbiIGt8 zvEh;Vd!kb_S)fHhSuKmBVwNQIAX?vEM6_T#w8owLOVx@@zh_)3Vw}3o!`a|u@dQ{} zY3}fZ%R(pbWjnGBeU|v$#9~OtBDYm8npC`S08A=Rg` z1ndnDOks%Ib+xrZGLU2`6@AJueT;VQR46k%ga1l|AX9SiJlj^$s6Iwl2IiMJaKO3j zrkCNE^zzf_z|uj>x*X1{s~_0od{IF6n_Ltkn?QLs%gp1X0Or|VQif_+g+Kq(K=D-RH+Ga0#**?C|_H2)d1%L3*S)Xoly{N zOslf2+0@dI#}$C0qe?5pda zp00dL28ct;KRxyu)HU#^o$((qO)kBKM;VX7lN5Dzb)mZPha_F@I)PUZ-E)*7V#eof z+Qa?~G~vmT<}4n?;29*<(n;UkM@aCat>{$QU^Zq^39O%Sa{8{wB!z_=H*Q384h{$i zyX|BUIap^-@5c^^&avy~>mVPau8Lu;Dz@37R)cQGyKDl=?oFSXH7wX0ptD=W=(;;Q?|sT!B#i%~ z>bv8y-v9USI-RtTN()I@B_py&(vXooiik3bD1?mSgoZMrNC{!D%FsU_>zSPxUJ#(5U^mQc6wEP!AB#6 z6(&$a_N7|(&UX)@ix^(gfA8vw@TvmwD9Pfuv0nD|>gy1`R;%nlmbYrvs*CEKeD|#3 zd_cvDNmPm!xVh=-0Q#3OZEhOWNy*WYy`-RJWE5c+h$?GK<`_yf!k54P!U|z9kHQ}Y zC&dz8K3T)52*q}oBQRiG`#)sZ7n8clJ5vNWOEm*@%p$hX`JOQ2()z?Jn!qp6PpgD7 z850CKeb1fKI03N|p@m}iQm`|^1rY3#}H(q@6K^S6JgQ4TmCJ zQB-6C;tb~DxM;`g)Pu-{gJ?SkP8X~rnP(=oI5*bSWd!3y4dyplBC}j{V3%143ATY1 zWVOWz!Jyf|0fR*Jp3v#e1R3d8u1PCMg<#0t%IPbEkRvC0efRaG5auKJ zI}Jr0$Y?U6Y**gUjDw`Xko2PoEX+)#czooe>DCF;?YntBF1tk3r43arXlsi!H9X1xd~IXKZ~&M3R# zBE}}R^wjlTd&%F`a7bWwv0WSF(Q_@gP*VfEa;X-K){8Muk}%)Ayt-P|tDEM{NG=go z8<`ZqRru%GW8h*4pGi`)o$nhuf6jmrftppSQ@7b=P5&yY0y=C;O0*<5yGSrcWkmMXd%YP-k6a2j(Zod*y%psB!xEmn+Z;3XhFS z!knR}Iw~qE4-?WLWL{5u>Y$R(BV%~?rYR&9McUiM@U70Df4LLNG??Zn*Y zbVKL>J8?A%S6}<9^It5WsHp4%fI4ty>W`f1&Azuk z)XMe{m`wrS>P~wo*4es1KTKUs?E!;U;BhU>)I=X2<>O+spwyn7&14;7@P**n8!zxE zFF-+en2f{Pq3kk0u5FbJ>DYxD1>VxES60urQYeN$M#cez&m(7pZ9Uk=A_+zukPhT* z(`Z39XZi#-*`+@LxYm!aiQ#sM&CtCv{Q9KM@ivSVk)_iJ87ce@4J!=D;IfoQ=^g4Q zF{F1CO|2>qsdk>*OZrQ!e``J}cZor;WkT;c*_ zehG)dcQVNn2n)(Qm(Eh7Ne|;XKOqR81*{B`jd_x*WlJ%M-=ygsv0Zi18bI`V(4T-; zQjMIgnCqpQMBEOdBB1I3ix>+;oCgCJkb5sGlrG&Ao?a|Al|kM3<+EzOXpH}R7JYbl}kx*lT35pr;-v8 zl+aI}ylb~3?OAirmfP<4M(C$ZA2e~OBT zymA|Tl!Le$Q%1=!TNaihpfdfLVJU54$hh~R_;ZMlncn09G$@KBeOSq%0&e9B>jCu;*;{UIXkNjVFSR}4i`Q*M zNgCYBoSh_7)3Z_9&c7WbpAM5&7-HDW`Y7uGOEg6nQOlK0;%?-Qf6*PUvIfCcy=u z{H6-=d^sJC%tK2{-pj}NeAp>i>Xa-?RMZo1Gr(Gh@*8_W(71^=Gb~ zQc{v4U8H53EI}weZp#npfX>^^NZ2ruUbss@{b4a`;0HxSPIEPvaoC|YjmXY35h53W zf`N$jA}CEqrLsRvLJ;GwE#ZJhA1u3e*FH3ylEaXC*RCQP88g7gn8cBZ-Ugzoy*`&Eu36I*>J}g?sa=4CysIlkl^UVp zQHF937Z_3W=oWqfSCY9Xka8I*3OXWQsU-#EK)Y=^y4+>$XenxRHn{s)3emMF)(j&V zYfm!1-}34v(8J|kC-i6EmF|fb>5}XIgnIxeiT7KyVFm}p}TXL2(KHKxX#kX zB{^vzGm(2{J(q-g~8L8-A%0w_;*Abdn%5GB2ww56UvVhm!P+k*!ihVHg>X5Tv| zdk~ys=#`+5^hJ#eP9KOsK2o%Iwgc=6uYlzBf5REqqh znACuX6OA_3q!c(b#Vy45@bDuLCNj>D@Gkcs(i)4;gh5uXMI@Dj9B=Q52fkH#$ay7r ze6|-Wbn*0{Dqzf}qw)9jC-C`7Oix%w;b-f+bi@FY+eO61k?|sk(nNy+JC^$T$O7kmpNCWKtWfzZzHi=oJK>5d|*sq-%U);GVP+M+*syUy6PNDXqX&mAe^b@-<-8$hAB|n00O7ONGb_mJKY_nJ+jk|9L&e%+xcN%NxJK@Yg}C!OGm|gU;|mS?{^62?}Y7m+E8d5jlfe(Y37G zO3|Pt3M3~_ZoDl_hXW0A^!sBaV$Gn5L`uo*2e*X`-qG;r4RKNm7=@-w#N(}z0;}mA zuB)hg#vF7*OsBAvN0>*3e!kAS*pl4M&bs5SZdg|8BQs2-YHMpla3`2sr*!sg3+?Kc zXOZaRAm%=1rlwH5S~wp?|HNs&0jLYfdR2M(=Gy`p61=3+gj)Y^5LK4@xnA8YIYO+7 z^bkLyV++(X9z>^?Ak_loh7$*pv8+DV6?zQ-CO_$b+>kefL^@n}6LgG|3n+jDv1jPOxgXol+iHQ!`vz$#cBPYZ+ z@!v_5V3wKtPu75{h$t2Xpy1aZs~(g!^??iySEm;vi%j{PmO0$^)mji9V9L8RJ;C+e z6MN7FEj>&Kv9t@B_i&Zw-=QVcIKo(n)q<@@P486Z!AX#Mzcx0;xDm}mC~1N#m5;sWw+06NV>th8o3~odvLLV(&pbC`Nn2S;? zqJsyBGE3e+I4AdG`9QNnF05o;wWmDu@wzK5^n@!2pHt++oQG!uTof>NP4MDpX)VEz+BDI?;yC)6Rd@vq4JbzK?Ck7iOW7hG73O;$fhXa0)%SmN!0bS!=$yY+x%U73 zzr70$xD~88MrJvfFR7ZtwjFdaA{O4#?60Zepj$o=0jmbG`CU&>`BSGJzk33!81SsX zdNTd>_^4cM-?hlL$DyHlz)SIU%XLM0CV(PxPs&2b1f~kqZ)VPrJ#StbSbpa$?WQ^PwdT=42vwzj0gk@pP4pfjRnv7Bo^+!3YDa14ihX$_k2) zukjB&D6oYk7sJkmoFs2?K4GVF5Wk1AFW&!|$%PC4=DUm0Pk@*)vhW}vvw*Uo66#zy zr%RqH_*3t)XsPhi-|V<5A=f2i_dSs0y#X(hwxMg!yRfe!*L7tj=OyV3U*L%xy0 zQ+RQ7Omk9!%#Zd;6uT(t@2jhUJ|=$NjYbpHf3O-F7clatTT$b%KOSxU(MmEe8c^{L zlPM4*uWLt~Y;RmFTnTp_fvsHhk?pS7fr$(-4McjGEpWE@*s1B(4Q1R*Uy9{=6(`}Z}>@j){*Qi!v${8;aDOuj%FGiJRKf);!i03 zUQZn_Jbp~rp17m-4&53|7k;^Aczk@6^ka1T zCl$Raf|^3V2aXaSH>y75viw2cAio>y1`yr>b{`K9&L%zFj^-cA@OwSq(9i@y?uQqK zG7eBT5H+G4M{N0Ww*^J|)D|YD9H6{{WP}yIK?XJQP))ByL_=D8$&;Rf_XKV=17J`T4tv6QqP6d+oVsW zT6fEj+Zn*;qa6?@?wio(zH10=%}ARED4zJYrPj8#&rw`*S)6T$3yj%|%_i3gdQPx` zry(U6b7Z@Jl37`Gx4RMVP#HL*aA3cr<<(;e7u3>6TT54+K@@I*Ipm~;h7jj5cZ?UDW z%~b&0w{mocq3I4v(|F~n%&;g8NR)umU;qin-=fpfJ==p&8@#a)W4wy3vgq(3!l9sY!-F9x@V0F6muH)P;|U z@kT!;;oXxfiOylX6aBw;L01hP#NKH0=FMP^cb{fDgpqdX>GoLF1PCIFI@ZGv8f2Va*$!|O9+=pqGd5Q@WM{qO$OEZ;s)V+ErdY4Bih z!O&nQoKlK`5uznTd;X*o3P+8oG%vML!CBH6X<{wZ$vQ%P$OL6d+y!+!tk@of%_N40 z?*c1j56a?1HkSPCKQf#hd->kT@dcDDf;XVelk65{j(584J5U(aP85nfRm5<)@56T0 zzn|(Cg}aL~YsnbF7;tz*Bu%m2AXlOncoa*F#$JLh{o#tau2XIFgXh?8s(^RaOgkp{ zgaEXzend-iq~o~ZlyooZSFCt#co)jdO}L#Z&FI4ZMx=T`QvdX6;pc^XcqVkO#JpBT znvBb_5U5YSBSmrRw%i;67$?9UHkhWPvN`oj z!dnLKb$63D=QAWE)O2+;J_GZa3|*Y#5ERrD-@b7pAA0<8uF%+yc3uu-O90Ow{)NHG zC)G$~Rhbg=`)c{nvi_t;^UyeNqvqQUTA!$j#xr|2}AA;mvjW92W*B~fO zay=p{X0r5rlt(5w4FDFV(6yI(9Wy-IQNQPndsCo5K3n5630_ts%eS+&#kQd8iD*A! zHK2~8V8!Ew)Z0qY{!U>yCbdYc>gcA=8vsPZH^C&?jkvTve}c$Dl1}50hGM`A3Nd1s z(U1xTDN;B4fiKWUz*Q~by=E>v0Z{@Bb1 zIMO;d4us=hFLwrqHBF%_DRMPlsHm#ihQ*v%i&(cg42aN6NSxh{uYq1Zs+KkYT+wO& zZ}|3Yu@Sf;oCa~kI2$Eo01M!%n}D?lt$#@jgnS_2qv_i+UZD;>q=Qc7Igy3I(XhUX z6@!PthO2O4p8GZ+v$#CfJYL8^N6>*q1aI(pWN;+;=F%AcUS8G*PzQDJE+~@2;gh+S zBpO?eicsjE1%?L^mo5ybC$%{2cbFKQqZ4p|`YFIms8NP(9h;a~fXoBRu8~o=CBQA5 z$LqE0d-hSnw4h6}v`qEja%rPrhpG+}AY3L0hs>ZBfN(|+l-#8+B+SOk`}6SPw9ii1 z*)j4_GY;SWp@K>1lGY+~>N)VGhmh7}V8`EOX2$d(w-kgZFkHxbinPTaC#T{BqMV}E zaac8|obX1Y$&<7{`aD!IZK7*3rSgoG7czBS17ox44-i11`XB#3iNL ze=AFjxIc}Gj#fr78nqMa-8ig&jFz;;qrkv)ut3pQjeeuJz3{=)`OXJB1wHL|;CY%H2NR3yz9G^9J&!Ei7bGXR>NW6h!w^gNz6^^78DN6_!mY1- zl)UtHQ!BB<#36u*idNpz7=Qm-$YUd?{%cwP8JWugq=@_X%hO=BNYIZDkL6-!4h6ZV z1cN#u$m|5m<9Y;FgET4PMplC$rv%>p0%~l8k)LaVtG3f?`Q(RfMHl&!EDmya%!7~H zi#!H6`w)0!cpqHqhgf?}YV>aZk+Y0FIPH0y8YMjvA}xTeyYO*6Z%J!CxC5{DwgXbR z;3J8tF8koqw=G+JX$!Q<&Z3$|L|(Dn7|eJD5~6b`hKVf;h#)M-aUvYU3xv%HLKNsd zW<)#=R{$$x5P?{lAf~Y15m68z2CPSlzpE%=xA*)xcl4%g)jC>SoU+WW<%w6qW?B$HbR{b0lE6>qWcXgH6K zh*$##+@D}TB_A_mPJvtk-a7C(Ys~KwM8g|G!4!nL%OBVTYZ1Gezo|k)&cw+Oo@`1zxzwJ&d@LM{rb$4A~ z);RrKKPP*8LxXX-o`GTctkmq3v*~aqn6YvbgZ4e*RFrjY`0hm?K!4gxaeWOU_%w{4 zJ(j4W2f{$gBH!KdJjW&Ykj#)f17@!#2>%iH@ zwy@x~Y)8w^DvECowr>G#WALy??xG+&iB`+A*Q$>Ly7Z=SZqguuwaOuKqN0PX%RnVL zdN#?ZH117SKL-7JYuDn`l+Xgvbb(RroPtqA;480(w}1updo4#W zAI8qCas8<5LA=88&j79*G06fk41dAn{hE%jQ8G#b*xwRmI6*=mPqCu^1tOv>h2kNr zW;lu)jrz9KN=k|96Zae-wr?PSb=@luHKq`oN>TLQo?Ru)5>2uY*OxtjIJ3F~bU_#1 zNR-=&SA;<$3G!$o6rwj#$uik$+}p&qhvND%9OM!-1j(*}1}5;lA-#4%ZOT9Y)v6NY5M6(>p(OwX>Aj)Wu%kM{!?pbSbMy}jX{8`w3tyB;GVSFk}TgH-x6&`r=4l~^}S=wwH z^az&?+JHRR&#(Uk95^!y2X`k7F&Bixd~kE(;a>{=!R{F7KH9I@|J3|VW?$5^j=~ku zr=HoB?TaQUHy!2gkfr@wmuMQ|V1iv|;lzaPa|@$^`!!?n9Vy~pAiU8L1{Z_Ry-(g2 z0)~${RrjodW}+vIO9h=Q<4Ahmd_2r93&G#dm_8qeU>g?t^74ATMu*!h6|*y+x6Ay% zISkn$+?KE3iM9w8f$H$4$>{z99gS}lz*#7B-dsg_Yk^BXiJ-LsirWRyuFdN5Q)qJ> zh+pHnQgP{`c&I@F7VEHWfuRGeO!BvQY>Hh5Hp3Zg8mkr*P;oqbiBu;e5%OC}`D%g& zhgtA?Au#N}k$6~q^C8%+T`N>nVo2;2rs9YyC%bY8qs3W`pJ~mOTz?KlKEc}%OIH`M ziN+zZSwY!ijUx43H&mOjP|ZhivKObTT;OKKEEmQTTykJ2Iv%W}{Oz^8!lC$H5;&4p z&V7-A?CK$8ale9())9s<7&q;E;GiKt)D+fG48&tFUv#gJgmnqaoq`Gy>SOo7t-DL% zG*~vHQ`x^huD41{gaSEwC@zyzD*%3jGwQrn&S+jdf#Ve_iNoux2B81laMnPCzmn%O znEQAAv2k01C|eFKZ;lc1!7wrfBd~2iOeuq`#84tqUxWIGF2V{d;V*^#iWr}@YX#-9 zHkAlp2dU4950aCkQS`F`Nz<%s-1vn}3o>8-k8 z7JS^0^WvT#|H$)hP%Ty?W+S@(xG-J@7nJG_ligSD^p;KAf(VR>Q2WK6&8{nDmJdxS zcvnEu=!y{%-Xq7w4+jF{*N?Njf<`^SBlzS!FYt9rh1h}R;)IXNo;6ZS>QYwbCyt3k z?&$s7L$MR0XUD(a!j8xu1EsCjAloH#G>~~1a7^P-I>J!I!@km~VLY|S>9+<);3KaP zLwI=ZJFVQqQry=(j7nYO`dt3ccSGn$M@7Dv@F`@$U-uzur>8=4k8k1Wiz`z60UrY2 zGFOMAP2L4oZ`}yIHE-6BmoU*MD1#Eq%cdBm7_^BBr)l{aVfb!fEvzsqC=mO(CI%*# z@p|rN%GVW+z%J2$TXdW}$UDTJ0QK;6oBlkVoClf*PVFIk*adc%PvCD$RItGKz}MKr z8pD@(XD#LJ1xB1ym#KVa`A3{|9i+1e?uBG~tKL_J!GFMp8liF1YU#hf-Xn%r={VG&!d)t<5f(e@i0mgGtU(`B>wg2?<|KOvxa^$QFEF&uJ!>-<3t#tA>J zfa*%;?g%678Iv)J#t7AKG7=?tGL&J}dzxjpEpq{XW<_L_miFchE(DhBs0xA)lpx4~ zR8TWKk2;|Nl{f+^xUU}~3&n>QMi3<*qYR#2UeQC4zuQVxx(bQTdv6%AS0Wctg7jEN zkA-;2w&VNqbHG5qLAq|`j3uQ(z_!wWYT4tyc&PE@x;yZqulN4<{k@5G=Gd?LvH<6` z2Iz2xLq4^zGq_`P6midGv*86qyqK7A{N)TH{*K)aU!al3sS2+!coqjB3+@H~qJ1NR ziWxrzo-=4t!n40vT6Y=TiM=%P0ly~?z(m-f1%D8b(1s&u;+(+E!dWN*bz6}Uv|qU7 zuRCNqx_Mou6<{ZhN&wX+1@V$q2F1UQ(crA(Ct?5*mZuwfx^&0I@&Bczh^fMjWd8X^ z2ywwP%dCAXcQ2MYk`xQS&MNX|VxR(<4o4Uvj4&ZycY2F=V4FYqNKTwyB`u{++#C7n zli#lhyB$h$ch|XVpN~-KA$qi$gNe2P)sv1g9aDhYyT^59INXt_{hGxD&6mgSaSD^P zZWTqEWy@-J!|cGBbh8#k8k3zHqjI0locK!y31cWZpQsVhegL$lk9ERxZz+X9DRo%O>I~Ka-AX(=7Wu9!+01|HAu-2 zJ4L?p0oW+3lnMsF;2RT-h!{O;fkHs)tovddD_gN?u+<4%cVAlK3XbOonTB8>NniZ4 zr^@_^y}>q0@aun}wYQT5_np{_n=rg|l;&saHisEBTBNt)k2iJSh<_AegXR`;sMo-B z#2~WZ2)-)A*lRnIeO)aX0SL~pGx2#j7@?yG9cjQicW_0*RN^3ViGYO8qF#vIik)bG z;iw>iv3rg1#{|g?^#_EHS2DieUgJ7+%44m{w_w{ZXQ~&i)f_hEbrZ!J93(@#k83#| zaq9{t{Podj({CWnyxMQhE`1&$T_B*WE-LiH4lpAKFd;x>idBfDa_Lvr%}z)@0uS_M z?xh&WuDAJM-{xQnzjagsWqcAouQYf!8n{d48{{Qp@x`oydvx~6r6X}0#El}Wc?O4w z7@&)tbtW_Sdkg);@WTCVZMaTfhnMb>5bUL=D~bSsmN?2fmmU*AFQN}bXLh$GC%$&V zJKyaj@hM;ttga7McefZUTX^>63x2O-H~n;3iHEdDgoy@K_W6a<-@Rm~;6`!vb~7tt zd;-nV1|F5j4_T;l_PgiR`x{m|05|syoEpn%gaynCzwTfSWwC}E$tVdpd#m69oqeT_ z`;ngs#8DyFgNg5T->h`E^V-&``=-(u0U(HUgM5e!QRlJ3w1s4xzhBMR`kBd}%*B1C z=K(30{ROia{SMJ8S>s#ir&ud%KQ@IZ|9hw8Rg{poNf=`m!RS$ZRsS3H!wC3+ z-yEY{rrodTx-u526iMqk8NbM{bf`+T@@0{Hx%Fl-w+dMSy)BE5xU9ohs=Lp}>1 zLYcmR)kd7^DP$RX`h|=Kp6lc*M4sRXhPUu1mex5V3-4G!(ASFkMhoD?jh{j!XEDvj zY1R7)ct*~QO3(*5hb$C%;LUOHUv?uG*Tgtqo1uWgi`t3j3zt?75HA~z9hMBAux4#( z{crJ5wC%yMd*hzF@*T)TZr3@5XznSRG*-PAf_>d`7SE}W##U+_|ETL5f;JcA#c-fo zxWVs}`tH8jdU&(X+S)$k&~Ld3c}C0`%57vmd?ud48bVhX*v#*p^ zy-yp_W>yIU8&V%|s&}Vi)fUUIoWr%?`H>ZS1(nZYCi}A~Rtx;^3ddr#;%CawE%3ug zmng%SQ#{`yYX^^v*E{*y(*)2evZX~R(*LO8JR`U{?2TA(cq#n6{1=|+h&`b%G+w^2 zi8=e*t@V2lg}pg9->;41;gz<1bCjil8ki*HX$}Kg5~aZ$UpiO>(dg%PI*&T*<^Zyo z<0yw2hykOnQuxTX#m89K-O67$$_Uez*CI;adJH)0F?z_{kYaD zyIY8zY!Da$B=Vg*1dn`uz8ue}`AUTaD`!pcNf4Gq+W0p&<1Te+Qe1CEX~d|J$v=z) z6#}}af6FBEUn~Ft*%!nkTUIVv@j_gpF&upu4$l5ckE^lF$<4+{EXk7*#qUi5L05?F7X7^Ik0`lfvWymB*63Ggg zB%HURF(-;$02=Wao>|B&83CAD1!rB?C+1G1<1Sgl(0OEVR-ciW;b7m5#pcYNHQ^Uz zW=4Oz707akvu+K&yw8JwuCWFo{0O>naAWDQQQxlu;5e>(`GPg_adNI{0koXQ&FNfW zsAla<3?1(|IAdTa=m@w=8eosXKQ#at-(?Z}RQVV~?|_BDO3D^zbg0}bH+Dk-`p`;) zxT!H(PDU)ZEx9iHj@_gZUXo*@?BuuI}PJPPoXQ9L~Zm|}lRBwE5%s@8#yhBM${fJhHD z0Ut!yj+4`(owD5bD4uuvZOek4k7B3OzJTLOFwc#TxU>n?I03x6>M5Y1+g*BJ2SBKJ;(CUq-ly-{UfY2b7^_xeyj{lH$= z^D);NH))zT<}z}={_ zbZ`O)V~S8f*?tQ?dpM<5DGpa^m2{KFledjLr}keHO}hz`&Da09Q9V~@=ZY-~^=5%X zH%vO$gk7Ckh>K*-W#Zsx;{4zbu%CSl4gd_;nvNVNX=W=xZ?f9 zTU?l*FlE5&$B|U(qaTpOX)AYIu;HeVpWO^g*#~7^ARsATnh=Z%g+(|)i9qbK{1--C zF?^WbX^1C-C9_A0O^g@|pw4OpSi4sEF6XKEt#3R^6~+Gm6~NEB`^03{PooNIzT5#|OXbS^ko?v`Bs z=6D8k2%p{MQj`b8ooZH(yN)pWB|-)(KBNK5k8|X|Pq%>TwUr7S>C)eQ3`ZP_^kLlx ztPe?tSNN`8%1rSlzNs*$g-fXs-Y^;l!-@~s^BUJfBo`w;uCFo1;4qCDNG#+9l~*KY zq9KAzONeXB|Nf4Ro>*FVP?$mu8Tn{}Y@@rc5K$EK3SWl*ePqPP2*jTV)ex+m0!O9O z09r$IluVM2E&ZH97neR`9p*@p7sB3R&6ODmB!cjtjv~604U#`RlZ?z6TlNBPm--it z$Zmpt-2_~?hhiN;ayRmm6rk}0Ks$~T-fE+K+QA*r170QVy@a&jHR&%%CSjXl^I-L4 zuvffiMx$k;NKprQqb$W}85qZJjVusrTM@IhyaB{jB6Ga52E{2U_@_0lgG&Gy{?zp~ zw|=$=&3^4Sj7!TVg6VARG*GpJA&~rUDLhDGdISlme88dj)%a&Br&E!ukjSx1aX%wo zz)#X!4B`}dr4}i_bUt6CqHCz|1Jds$lp$#;NnQFoUyUakZ_bJ?J?Q6keb0fRdhFi2 z_W~eEI!fab7C`>)%-iKvdsq#xBeGq>$7gJUB&^ld#mtkM8nY zs2Cyca7I*tH(h=!{LX0k^hrOghQ&t9)*S;Z6_)VEDrv3%y*E}G{*i=wK>lFz@4KOB zyl3TZuK&*YdSKG`{&FI94$77lI6_`-OO+g>$ZLQ0^RgkF(!Y0W4FM1saRy7gm+vI5 z%6ep}K5j_MmUq+|;Fmp;E16%wDA~>LQ+$`9B7A_6A$+Hm%5ngL+lSU_6D!bXh)?|A zZ8F5E`}gxMUW6lMRK#$fl?LkxmPURI)-Qj3&nFQdjS%3`{ku~5-I+gYRzSXE&=MSh zS4(a!{g>;WC|GJM42q~*7*M3sLpADiQfSU3_{+yYmJ zqm-Gl44LCycdth*{ebKlevY3=@+yU+-AlQt^q*k}c=(Wzb%-wjRDt{O>J_?Y7!gE^ zul&|4zqB#HW~z`9F2UY7$1fvbGOXT0eQk|v=zlmv5H5S9!ZVe>@FtvML-R5MN0Th60YFjmW%1pUjcEOAB2T>{XKf1;@pf)Yb%?oO zcaf#PpokI*7~-bz^HIPS3G$I*Me7gyb-Yj!S7^V+tBp(lSQJ&#yW|L6mizC)Um)UF zwQ9{L=rdVQX;lp%lOouhw|J7}_b2}=ov4C1cIoxVe;59j4Y9p$e~N{aE%YdQ?gLJ| z2A$!VOGa?ZzfVEl!nNZizKqpdOuk*?y5-+9viuw5H0!M1A_Ky2{{1(*bpZ$8CBNsC z!Tnf*AS3>}tU-iNyR=oDFnhjC|KFFjQpM3FU)J~DzbA{lPgn-7rL^6D*Dj4fic40= zot2)QEoGAybZFxDdEpR)h^-N?J)d7P(5$!_i5OwX=T2gTI6fpd!| zpUN^?IYWPWkLMj&v7D)nTDh@|P9^1{4~d}lPSz^R7LLI6*C({|?t$SQ6<-QQ4Bj~{ zOmkrS>55yIAh)G>_SHK2{RPXwtlBHSe_om(aH^6>&iojmn=Z9q(bET?5P5Tkd}7o( z|0}sWCVQSOdUYP9>Fd6vLE(&;Q=-D9s=-{<080%lGU^`Maa!C>yOy84@O{a{e0Ig{ z48`w$ww?7@>mYcgEg0Dzpgdqgv8m=i)iSLguc2_h@>{nV2gm5;$5qz+CZ9M^+ji-j z$Ni#E>JH{>$&fNi>;1}v6|^szcmkTvE~7#`?1{ElM6~iUq`-i`XHqr*v1pg zTuim=>rh~x#J-gj1Jm+DHS6ID9LFl`kLwQ14DgnfoPKr)3>v4Q)btZ`Rj8)S)oX`# zfBxR{?57Z>;z-XBLKL$0s9n>Ayf>>+O1&7jfl=ftBEcA0C9%E;WSG1a>G*1cpww(X zd~=R;BEZ6#IHJOvgv*AK>`macG@wy*W&Shx3B!oI#fMKmrLx#!L4xyZAKllM7Lo#H zsRE%^A@_MXgwMZ%Q*GV<@T%@ja9BAiz-vfDTOb`prOsm7JwJCg?Qr)aoA7x4OEvC` zvw2QxKA8SHj>q>tnFxg>Y`uL;1}_96;?O-?^4ko!F))kTx8ISQP4w49nnwM-XNBu? z6l%!{l~w|*H`N^&dR#Y7#=}!~m&2S@@pG*hweGtTm^gDXXIj#caaXtA$&OD!$(KAW zfj*H;i^A{q`}~C>=ccGr?>K+nrgiB>6e}-T^GenK?iMg6^eSB%+?7#kbWJ%GDm4$h zRbEmJSatjxzG)~rOTxF+?L{eAzSoOH3}Ev>7}NtN!lc0zEoTBkGY|z}MuhA}BlZJ8 z8&=fVZXVA;-!@ty++I)tN8u4_9w*F4kZ>Tpj~=8$zV-1;Kg7>S6VXMduhu7-y(4a( zfIh|pitBlUat=mzB}SJPt7zPCp0an~>xkAi?i70DI3EOMQlgD=7=v#8^zI;e#+Md! z_S!Z70j$M7-=mK69oskr&C_I8QMOQEeeSs}M|_++R!p0KEsdJ>)EU$HQGk8kCl6Y- zJc&z?5_a}*SHQhK9IrbkpQ5>%_9kj~6uVe>(@&_0mc3iMncZkVuiT<|2vA7U1xC}& z7KB4!f`*4cJ-bF^W)F{&9EWWL{owh+o@rme=TEwa48Q+v$vaE(%&HyKJEI1K*LukMLU_tI43Z(!!t8*z^1BW3E)74I*UT$rnX(eXpqcFRf%x_ z7YjfDbwalrCql6UpkX*1R^#}F1|p?%(fl!wMJ_F+Z@Vp4Ui+|=O_JTy&Qjf3F|}Rcuf5)+@rx*kJHce zb9e4?5e8k5Z62JHv23E)CxrMbJceS23~(r0r0f z#jW5kUqB6hf`~wYwTW6zn;Z?fX=ErEr0Gf2r8tjbVKYRZx^$gEd?a*)B;7ZFXvwtj z2nXDw-p`rf%V_J_YLaqxl46cG(`@0Vpjw+7bu9iYM}>xx>Dsop<#tcskN1&sT#S0g zqadl4Y%+wyn=I>d6ZDnJQEp(L(9aIU|354`Iya^ap1=?c);%mKN8_K6V4wVn_jZ~v zeOtLFM2Aw=>t8p#8g=bGh!`6atEWcJA(q^D9JelB&nZx3*P$QvoIa~*T7Cy8Jpv5%>3W;;#=j`2>f??W{Qg1P zk)atkzh}V|6Lam`rkm^b&dXHMETK;2RkTU9s+|b_muEDMlV903xA{V6owQ28D)9jDz#$L zKYFpoC|zWi$gjtoyloD>sjN!zd=DLShSJOfxpki&QWoob4MWUQF}Vx3&Axr!Cn6JJ z1}-ccd15~{VaX#Fw3}TO49bJ`{q^S1Gz>d_|Hj7#E#+g_K9;keS~8R2yEgJ4M)VF|jR_v%%9qPN zzm=2f1BEXXrTmIN`l~NG+|Oz{9>`$kI@#3=0 zRfw%{)oXVMMBSz%?3&K%lM*GD+MItH1soKIPo4XI=Sru@hSeYG*?B#%EN!NGCTnjPi%uy zl7tJ*R$hIux3(F+5^z~);j3$WYj|V(m)kEY!JbHK(2vij_3M5IVuje1wm}gd&Dd*k zS{8VR&hNqP+j}koPHhGy5lj9v-^1hnhP_=^oAYxl8k6dGIi+kkOh_N%n*F}-5V7N= zOp=;5zCSahn_pXZr)&xVe|omd|5WLB#Q7wlZ%EI^@TSrbjw7f^K#q*L`#4e$OVq*$ zwsh9ixeI689N0cm75;Gva5syQ@)wWwRxN@#i2KMGX@Ney@3e^#AfU+tpO;!w8)eue z=6%$fSFm2x5vK!eqMlOUnr9tKJDCh#=L(yTUcueJUz_k+8ujS~v zjuQP8BnUS}a>(V}zC58N5xUV*A!F)SeE#^IIx8sVe~jLI)3eq73f(B-Hk6L)ZRYS+ z4v586ZO0j(gNngZ<7JPZow$eFRl@TwcgUt4Q%TydK9qw{j}jpGBagOyFaFuS_=J@i zqeZrXfAl-dElZa2zS4Kl5JB?p&9qU{3+Pk0gfI`XQ}n_JpF)oIq7allQgk09)sLMt zHEQ4p9x4GTbK9MF#pewb)J%~f zq<>BbL8>0?s7;dSO>Jlk7;w9XY;Ou#%cH?#!To*Fi*1M$5pvB8ISqXL-3!2QwBx?= z9dUoXP!Iq@?c3m79V)+Gx8b{~3z<2fV?H{fr`W<;Bj9 z4^X@9MO0M6-zsGAKGE>oqk&asztvaRoR~7qzYFdUTeY(J_B=Ws_A}h?v7A3T>pATbAJ#i!=#WNY5~ zF%K(7%L@T}--C(bZV9$R1>)Oh`W9y= zn(vAJ?)wryxi31n{Z;jwAa97g4nXKgh7nR0W0}1*P0YNko(b8bukqXk73+C2%*xmK z4+&1rH<|OYTH*Yn!7g33?YVWC0}Hi2620NpSw_c;dEhkQz$^KEl84d=&&u7$hn0sY z&3him>=bGV-f2rzaQGXV2YU9cf4j_eQi~cYHaIgoENd*+~PDm4C~%!2MsKTa}@c8E z%a^{bh_AHHB%==L=*~#Pu96pWEcU&Xt+k;&8Pv!U7PQ6cP`-ZPr|x@a z-=6(r6sbt9L@8)*^i;U-$Rmv39GzKGNiIV+4nll9=vgV6;0#n}jP!6!BVu^YJ?q{= zYRUdRklgmSP_`b&fjt$H?O;Fz`qzN05);!v&vkRgn2Fsv|F=2Wt$~C^j%z2Gw7WEq zgq&4kijGHuR3)i9oKzl_({ut6dS$6zm)XSK%{}hg106 z&5@*zg66}8xYZthq-0bh=!A%&k#&V&Z(%*Jp<@zqIBZqj)sNTz$vL(?NCGkds+M2k zXD?|bC^5mP#|VD5$TfP!ip8HbG}aOaH_*{jG}O~pGOqWX3X}9|EiZr1 z_1IwdG^XM3d|!G@a%wq*_!P+R8cqJ z^wZ+aRvL!}#b>^ki!*=HN?jMem(O|7XgoaraZlP;iu6r|)fYfbD2ceXsw*0SDH|6T z6%;folA6K7zEk&i?9u+N0Nr5%SeS+S8cmOdUcqc^^_xc3FFi72gzd1LzJkL?>C559UrZ!>>d+0eSIhqxG^jL;(M z-|Cw=yTvJ&xgI|wn@nT?pqwv? zkjPwOU0wpY1*LwM;Y~6-JfD4h!s;NlUkHdhLNiIlXU7?eIlglv8$B5%rCQd+U0pO? zh|Mm#Y6zeuYozF~$J&o|A)DDBP$#g52lAP%yKpaJw~)ffagxbw*DrF4FEH;j-ucUD z(`_!pHCu`eZ`*b{*_^w{tH=jwDJD6AmT9hpxz-nVCMxQ<6=@fT?X_7`CCRm!op_$V z;bINTgSd9bfk+XW%j|?a6*bVa2p-oub_IcOH#}-7px)zyjpTBTuS@} zH9gjfd>Zis<33UpgIW2CWRJm)_;mfvqrr$!vcBDl13DGdG}e5D1L|=erIuA7RCMIi z-r>;YicWA<=85)HPsnkiy{pVHpK`B7p_tKML9c*{Ih&zsW$|IXM6EmdPs(*7j^A2;axITsR6MwsHLj^4FqSB3DVcH2Rl%+EJcDVVfOD@iFrGL_n z)`1;13zCoG*pv3N#ojNS)~-FL@XHd#gA?_Eqzkm0OU@y{ayCo8RNI<92v!IO&W2Xa zU~TW+cRv?oqh`D=cFu4KxBMzbpej7>l{w5rH>zUD`ukaX%fo#^n=G6^|MGE}YnGZ# zk@I%XhU{dreOEXAs+jvv-Lu;S8(RGK{k7eFu9{xE<q`?3RB62|=vh2>10@6* zgj9JVBT>&5f-mI?9I6uOd};LI3FkAm(=uOvdTa|h`4o9(!*hG7r0&{)p(fj`#RU$a zTLM-cQx}`(#zJY?>W{JLPTn~zaeX*5(D>;J>cy8bJ?Ksh1ul2i*=TyyIOxm7YKmH< z(&iHk_S@Fx>F2K*a^GB8^4m%10qHS$0UsjgjaH|z($}Ul5SXs5v-hYjIYMRIZoMC> z7(6kxzEGJv^Tf1u^l}V6zd!qp`BDz%+iO404m(MxJIJLZZUGwIes**x`>&6OEFRtF z+uV}=Q`L&`gvwu3xqdc_b%nn`EoYAGU6{S1JTZ@QbCcwxM3%9G+~=(Eo5&`v^_w~1 zz%i?dgAFM(USBt26hLy}OEo?76k74YZ7~Tvr}-9#-?@Yy%GbN`<3%t3bSPTJ3|te8}ae7&7`9#kbziqS<1I7DX(9k|r(6(V)*U1!bU!Ml@z# zY(|+m6DXjZz&@YS2&fXtNkB*ky*?*0*B-vvpQMf|+kNy+_&?1G7BJO%@?(Qd6#QMg z06zTi<5h>CP9m!wP1?;DUuJWa_?Mqq=TL~SfT|Oq|zeV}w^MQat zvf)icX7Mg=faIoW2YAn2$m zi^ZKY5Rja@VJlvFB7jaf}hbm!iw$p;rQu@$$x`=@&Kzh<5Uq#p z_Dm1E_xxJTnI)i7<2wVB%UoY|8e+@}Xq-Jc1n~3+H#5Vjx`g&$K(OVXx>4nYjHMi; z_{O>{UI3gB(5(QwDgnUK&*Vu4W@W!n-4!|fB(d4j$s|)ke-PQauz8w8WZU3s(I9t+ z4E9rY<)e{&2jrM!K0P@oD6eeRdc6M$s{+JbFFn|KLY9g-c=lHD2QV)nDmNCfWA)9L z#}YyAFDgfhLmwW>KV%dY)PQc(1NUs6SHNos`->>PzODOc#%$^gs-bxHvPVERpXGB( zzEgkh&{GI6ajz4wX_QtIP*Nog)ZtN5;q->i*aCPv$>hai9+C(=p}x7fqQ%cwfO=!@tzIE+3u9 zFsaaKw54h6bfX=9c<2tz4e`eN;)tv*2foa*Rh->6xkKoHt!Z|?+F|b@@kyqd@|cE3 zRI*SEn`+EowOd@M=l0wt>m5*gxdDtb`&YkWxi%H-hx6h*i(InPWIlhqte@OT4s_F~ zLfFbDW5=jC;J_-DBbzN=^Ob(DM}Ha8Q=9J}|F#-~X{X(ObpaO7-bh56M1~_$^Sog>Dng(h<5aO{=1N)nmUhu|D zo#K7XXsP(qxy~LmOf=p}+xXqShqeH_3y&8xDtRWiCrJj)P0ddufpAY(2rn{N9#63{ z@A3UMP|wv$U$7!fWc|^o3*Mq^cW4Y1{lsKuzq#4Zj?W%{w9Rl;27>$> z?;e9#fmKz=onDp2;C{G0`Ho+7zX$BERn9{ka_m>WJ)1zd+v=Qv1LNr@u5a2<>s`!GvX2L?hwke81 zDiko5On-bn)jdM!ukh$e1ESY|MWvW-51PcVP5Gly9CKicY_&+P^Ec8q+%$ja_D|Bc zQb5K?*?;(Z8zI%as{}cl3HoU@iY|Zo6Zsq9dETRzFr-qQ4+Qp548j5R7^NpEzlJYG zt?7ErhOuW3I)%hjn{q_hpy6~_q+ayekLGP>ui7S^lVyjEe_9aJe6Q>BuWt?h8Ases zh#t7UWuSSogw;3;Q$8o#7=p7Jek0UT2w1nSwi|6zwsvg7z!GOi%a#32@^0oS-msmm zyuqtGk^KGq(^O%K^a@iz+=IaNC7$qok3;Cz^O?oyAs|$YB75n(sx)OoDe+HN@@RB( zjXyn6R#RB1*1%M%RPumTIoabwg=wf)f8*G%K`~ej*(H!R&DUGB%eSpGEgL~w>%+kG zT8}#AO1UBpfY#LM<_LkT#@_v8?+IpFzc!ag&#|k;Fi@|b%|}lubm2l2>$eQ6XMyhl z%-B~dD{Fyr%Sx4Q%rsCPE}U@SYm7QN6K#T`kbqqd5!CAK@0??8pYKR9c#@s=Ufz{3JTh%3>!SSU$uVF?nYb8IvqVgSPR;qf%sFd zyPu12UCXhij2tzC=7De5k`P=DQD<4nhG(-`Uj=vXPDpgP4yGalH0UjQ4x$60cj)#z zaUuOakYS0VK_e0LaUr3@DHWVYg!-oI4C39WFWCiL$l5_VZ~;B^@}$G`4M4b1f89d3 z>*^!AQ+D#7nFCUNf(LgN#dj8M)m0Jk9yU_|rjJhB@h~6v4KfHxu+h<6v(D9v0 z^0`vu;>we^MbSmszR+K=IwNOJUkPVzF)=2UWI_|fpBKGCv{|^1S>xO`^x)o>i+*`JhBrgblqKzw9 zEDF^U9BMKC6tB!D_S4URG5y3DgA}!@BMMw+YPT`#yVKMNAsTskzBqJp9w*2y%ZQ*w z*scnGcPTax+)2LQeIRT}pP>a+Tg;Sy-kgb#QlRSt)kERYqf$+g5(Qv+p>LIvz%3Ql zC;Z#x(J4nyV0;F+}K+{p%VD!ie zTvwuaQ`LA`eBc(s7ep4pJK|m!z;^9@6Xxm7wYQ`V;nd0V(QuRUX7NmK5)%B?ZrNej zuxuoqciB$~qcupEz+WrXq93s!>fjF_FAP5WRv#aov3;x7z1^zLt;T$-%GDF>3}RPLTql+>T@Q53_`;KqlW?cR*f!7ER^pm{ew;`jRiiLr?jP=9{e@05Zz7xp1A)2n{u^XD=^PsM}2e)p*GKd}IT3j1NRFH*U^eNL%*SLC`*Z@u}m*o!WX z8){!uq6>h?LFNLF9YV}JalQ@aShJ|TQ+kheq3i4M2zM0Wl{Ig_etX*Son!E*J7gU4 za^{NhwRk1goNy?d%pSoog8+pzFD|wG2^cM+q*EKg`MEBOOpqywR)K zPQW(%Q-01~-NO`M2?c1&<6Sl{RNR*b6RKgVu36wzB;%+s=LzsSGIBaf_N0V?n9@tZ z?xSULPFKDEH0%*a&kF>hYr_siM|<) z*w7j=#mnqM5QcRZJDx->*xcai50lJuRm1rIa zmPeZHhVcQ|&ZBERq}PEh7K0|zL3dqvL>7GWxdr&_r?+;Ocm;854-?#wmJ5UDOdBMV;oBU!QzY zyB6qL_A9DOa9QIAjxL!ag{_wRoR>zviaJ_!JmB_;O2Z%)>uhAJ5OWceusog0`8ekx zIQ{i$srg|oH0bri%^~8YXl=_le+ovFh~Y)^+JB(*8WJ_jzX%sHHPQ4ym{VPXh7h!X z!+ZcU5>K$pcy|R6TIl-tUTu-rW_&RGh~GwP+Ja^|cy4peHFb4{gWqk#4}31`Rd=f! zB6tfW^jjSW3@ASv2(39r#h*YXDP@`)xlKO2MM>UVHw!&1W`xqMk^>-X98aXPE z0r;0lLsR*hfs+BlyDqf@C zP)wh+}4dLC$)6@;Ll9|8|eIvAQBmm^$ZxrS*V z@RRlRSR~ociFSP~IqH!S;sB}*(#OI&nX&QCN8TE*QRN<6sf~%zys(;z3VR@zy`Pz^ zFmYR4W25HM+*;B|7zew|mfh{@+9|yX7h4=h9gtr|=lf>!oxv0N32%`}2!$F1PVnd9 z2XIwSP(FUG6dGF|!F$i?<DewCMRw4%1c$6L{Ldcb(G50mL& zh&xAgS~$GiTOhSh#L85De_h~fCqc@CyHw#|z0erW{g|d~=Jc)t{-YtK4s)hH9SyQcIcFGTMnxd_3p~~~g z#D576I>fx}#N)hF!=*!R8CEN&e3LoAQaR851@bGMo>J|fa%%U#Q;RIZQz82}oK%;^ zXH@*Iw`Jy6sSD)I{L%TeG-L;rIdGpk~s{^s*ogW*bn&@_NfkbEWa^8y-}JbFfl zE8KP(&u3X=#wYqCY_CZc>IWNLL(b3*{?>YoHR7YMxA;cEr(szcbMH9@Qk6q>H<6$f z7B-cmkRU_}>S?t8M3UTzK=&er)ZL zOzHbeg9aWIXqy`ACcWFNTc&&!t6CiACsUOv_-C$akHI;z!4<%v;r2_Y24Kf6|__89V8^gs)HYU z-K@Cr>IBD)G`gonu^)QX5UiAO!Uplgmc;G~$XHtq+2Nt6GCKg$kw5J%r|*t@rulPd z$ozV5x;%dpu=ClU(S@7RW08UbSF=IciU=w^HTQ^oFx)c!*3e~s1qYLb*J{=xsXlR5 z^!IdMA$1O8moZzN@Zvk}wc;iXZ-4@~uUE-UpW5tdKY5B{BE{Bxl!9r%Sv<=r2TZ2N z&eeONF0Wbe3lp}Xkaix)xLNmZFW6yhy}4 z?47#yEQ0Xzk1J~jWwdwEAK=-kIPM@Aii5D6(PEPGt&$+FetCFBPKuZlj61fM^r6VD ztOHbDP)*OE!5r5pT&a6-ysXy>^9(-S_%t|?YgwA}ID(Or39xv8w`iV2f8sS>#Zkc? zC7Wi(xl7xLgP&2i8Dc14;tOUp?sbND-J~WZi;GQGEc4<=PR%)ve{n}*M39}ptepLo z0L43`x)j0s9Nv)oes-Bq$6|0o``ky`8CLYia?(`pX7 zOs61mC(C}OzF)D!w%3oZUtQB%FYBA9ui$e`>Ju`5dB9?m<01`J@1;WxG1sD^R0Bc= ze9A3!T7Vm)27TI10i*9_xp-% z(4-rnVc{r^vcNlnT{6$brlaljycaKJf>ONFYn$0EF2_!U;r>Pl_iF3_-9zyF+f37r zEA<8R4}zjJ;hmu9CRG}lZrI3L{@i}X$^Q(7B|2ge2kJ(&=WRW1Ui#_r5>*LuC8@p? zzR@FL-(p|VT6RpFmwbv4#QW<;r+pRJ$BkNRaxuaj*jyW+dq_`3EQq+*z$iuZRzQNN z6_^GAuuqD{n;&FgFAHKs*5)0&%ZAE?ty zs%9lXjmA2qN99gg^!(sIbY?IQbn#+yck-?JbK7|h)AjecN1RmMV9pMbx8sl3 zjj-pZg$YCpM}~Ts<(nn&^#IvY2dsNuxr{L1+wTRy^^#cfmp?%LeQiMflfz>3?n54v zgROZd0fV--!aZ9u7(Co7Q!ii)bbVg|h!zv?9Ki8J(_h;HEVtcWAk!Yd7cMA-4fk>y zWfkyEk zw5C>r*6*-m$KR_qCy9sNDBKHD@gEjGq}_IRdCu^7EB9BwZG}syic~9L%Ae%9*nNN` zq|`weM#sFb)p`6k-`gWBQF*|7rF`=7FzHtg8b7M*X#-Txb|;5-}cK_+->?W z0Ujf53EEe+Jr<>mOvy1Zg0+Odnuc{;!0Fnc51NP~d>uwfmFRMU^gi6~Xz4fxl}#6l z+-8h5O^<6_4qU2AQ@&SPB5sHIe}vj?z*gDRSKmSx@{t8=gr z9)vY&%&K*E&#?}cxVOE4E<9$F9ullgT%tLb6ey?=1(3ysOIKD z1oeva89C`rEkh}q|JQp??5il^!?nZj>3C@%F4__m=M)!cexO^*NN9S8!iG7V8B zju)d5LgeT3k|@%53%+x(9!peCupZoWw`z%&>G4iGp8Jt9TOp~?AOID;Q&L&cW_BQ1 z$=4_$2!FOF>??F4y`kWcffE9H1Ll@Pyxc_pND8QiY%syA1_k;+FE%Fo>U@b9r&hi| zgk6fdyY`v{#BykdpBa^?qPq8YVhSi zaS-&B@T8$!6@m&yCpH+phjQ(?F)W4A#<7E)oQ#z(_45g=Fn1nRHN5O1y!&v~9R+La zxz7fonnCG%h3KL)R(`x)Q2K_q`w4@mbQgr8wiWu{6x@{Rp6q?(qbE4-Fj@A+WFxuha0te0Se$iZOq<8TgOaMjutp6AY+pN*}5-nCh|v$`ChH zVl*JOX2eSkbP%&nAddXfkAs2`u)TeKA zhialFuxWgV*#I(CD_VBF3&)d`;w&1I1Vpw3WGl5pEpZ^9=%Vo{GM`Jen(quL`A$%_ zorNw690q|LaK%934mq@*!@Y!4>;`(F2zKjKuh}W~yDm;l$L=v|DOL|BAH8!)+qc3I z=5pd!+rhZXxC+>RimS0NbC^MW5qs25C-QWMC|nZ=-^O;^;|-{DH*B0tm$-%G^x!N; zRM|?hdmYU)7#hPevL0)PZpfOLsp+^pQA#5iCF}C|&7~act>Omk^N1CMq)XDac;Y3! z>2XHBJo{d|jXu{06*u4{-91nex)f{8kMj+0yedimkQU>>#CT^_;K>n!$B?Y|Oa8de z{otki!T1i?ahxz6WE00p_%yTfcuVLSLxTsZ|W^TYzCruf?0FLMaGFK7{^o^`_ zSchHz45BNi0o+o92(y)xgQMCh?wv@_`R%8d%A~WZD&SgYyRx{;r;m2cw&?5A?$jYd zKOi(ZkF?NWIQt%TRK7it=}r(_sLal{Pxte9WfXl!t-LH^@Hndn@=Hj=KhFYFg!32Q zE-Uxl9n*9-L0iGopf-MlRtRjx%HkvlEh7lGzwt=RIyE}0LkWf?;R|8YVa!>Wj5A(Y zMT4SOe*VoYB;)*=z;FOv_~sH8eQ*;a=(qQf@atyib$!r&q|oR#TyJ<58PwY}isiE2 z({6jEQ^I94na!^P)CfJ;T=oTiVRohTAstJgSMcGCJ>l@!$|~@dY^8HdpHZrBa6Zn? z-8INd$}_UYxE-B4-NX{?R?#9xtPDhL!Cu~u29VQKh_nLFTBl;>Ov92QPZ4o!NepZ& zrKM*u8;CAg7%}B~5du~uK zdLf)Ksz_nK9HdaXh|oM?#w&~W;wm9GUxaKc7g3Q|lP?)|7`&hVnenn|5nVnAr$Q70 zYUk^dtEAd)9v9=}l62e&6Cqlh@nYx}8pCK(2_GVljq;6aEyffOYuN(?sT2gY|TUbKtwewM^twS0>m!9RRWSMe} z^K0}M+FJ*|4W=if_xL!gsZL{z2nCJyAxbMtwELZEbbMZN*OirCM>vl?ZPdiSx~-63 ze{q_&Xky$iH$gR3L}8Bky8`$Zz=ZZCN6Zln9liVa5f-4MW$T}Nd`@ZJ1zMBBOaUbQ z6o`b>wGyHnZw2898>oj^yha_Xe<3R@%vf{r(2(f4eX4*VV*l_YpLw!h0Wt}+=%%T7T*@1RIFbkS9;a$Wp`%M2K zgI8<0{rsQU%QJF3#?{^`gv+Fbt@vyQwjms}Bh%az-S&&a+Qaq09SFJ$clJ@JgxW!7 z=}uLzbEy=JVDck^<73VRTmv+H+VG73&ca2c2aAidBByF)8PHENR7)Bu+>yLMbo})k zkZYoA)pqHi#{N^G_XdsPIf--;Tc}uAjYkpjHqc8g{kUMmC_%}oJ{~K!GK*(}VK^%D?kd2K&A4^ai*&g(vghH^ z@+@`Y>G=LOr=>@gA!CF~@BuVP=xFc#+0&Pr&0O{n*~2_Y2IQ(991f3_>KFsm;jC@* zwUT>^A|M7vBLt@Ec0y|MkZRX>k=JMg$MbKGc@neDi>VG?3FSAbiP}!I^ykT>{K25v zp-(X3WB3Sc5&+Eo?A$-GBX@R_v--VMc@_eW{{8u9-DVpI;@h3A+2e%?)dKxZw#igoPz#RN;N5KQ_ z(kq?NupbzhSb!RXq9&Q1G5G%dkKlre-J3W>qSJ>sPfF|lN&8|CgO*e0E50C9Z7&G+ zdHag{r1flbiR(Z$cd2TwZ6}y{K0nX%+b;ALz`NKUyTzxl8$?p$=|6KtJ%-)Im5bnp zq)oXBS;9Csn$lrTP`| zTBkA#bqIC~yXc`}3;DydEy+b#|5MYoA?cLcFD$}bxVn?wgFEDOvq&h1#}@^5KyNQbODGE|aR<67Vk{CT!MRxScoR>ztRvXC&* z-#%)*?oA}RG;9f*Gt84dCctkVY1Q72Jc!yPlfGiJca1rUUUV#PcNRt%9}LRYuef$S zQ$B5%g{JA9U*ht=CevOEkq+!3`1I2?9icYu6ZAjl`o%hEj9UXD&AVf2W7h(+W8{Vb zQ%VoY)u@c47OqRtJ(N9scvQv$ggJ({#&D5&(PFYxfpq6UtauRzPFgWH;uZ~5>dXr4 z9j#W?*YF++x-bdwLz7_s-svW zkV8r_hs_LWX+`wffvz9+E7hWx4Y$$}Ue5+Q8X?j%EeOj5Ujd2K5<%ZAnrvzrntTX6 z4InQa+oAKKL&K@gVT+I4m5_~gI8Rk(9^ZJVuLh@nyzQwAPq|Z(Hz>uYa_9Y4g|qJN_}jeBO6b5_)_=ebGO!N8=dQ<{#EZ1ng3*!r6W)MtQDK z-S$wxV|lHZNpJ22%t`ms&sx$#j|j!c&+!L+%V)1=)=6__jm9T9!65EzejF-zbo;#Z z(Ar4ve%p3L&v;K^*qve|EYHRnPAqC z!_J%3`~$51n2m!fOEiU8cBv(G?-zYSgyG(fR-4S*sM2`sZX9F#-skRY3o)4QBxWSN zb|I*fNPd11GQk?K7Mj5a4A$sJ6(~IMH9r6esXZsR0}Qj>s+=TMa?gDha4q4QNNZA^m2##j{R4`=1CjUl=MNx>bf}Ti z|F+vjPXU$^AX~HbeCrZcni&j9aPj_@Iu&m{qJd1xS;Ju@v6H!SG_K+0DIv%T!<`mi zJXGY`L~^?nDB22XuJ+ZvObKwVOY1#*?C2YUH<)~Ke7BFWCg13#!5d(*<)6F&>p0pGBkdlT8gg`JB29op-(KTX?z?#leL02O zxWA9-WhvY|wB|ZSJ-S8+fRIs1O{H~?x^1u=d^O&w7yqNGnakO(=C)Vf0TA}dQiu02 zsTb)C!btQth-m)3rQ8FQTSm06x1;@jVr>)LkyZej|D(L_0Z_y%X3>bF^-c~jo=(J` zHA0&YvYQc15y(XdqCx%=@g)pVntT_T{>e;a(cqHHYTVOWB>6~5&JYVO(}~(ao9E|{M}H?vXaBN<><@a6PB5m zmPQ&oA;!o-PF>USO*c93Mq~0?YGqeV>*wSC&XyhY)y_q`oMGekhFA^Ypn+6^@X@&p z@^1_M?g*u`#PNQe(YvjTHT@rEdXHbrKfkQu*|t#qa&HLlNC}K6IMn%_n^U6cCy-+$ zzBDLL+jCD7ln@VUK0vWSfbJ3WbV{RKX)c4~@iw=GGay5!tZSmXV0m?^tUjR;8fy9H zluN^{c`oq(6}epu45grB{zCmb<%B9CrElAJydEi7UsV`Phy7rOh^5Z?0I17FLyy!8N3+uAZxv=gg*0hkb_}V;D1e)zEf=Ij`?& zd$z#tCh?d5-W&df$&&zOId@t>{H~d#zJSNZcQ?(@+EPP1liv~=F6jUwQMHbIeT=C! z!n`|wTlZ(~6b=Zdf&0Rl@!)86)sX=4wU!Siz(&E+*%@)8=<$o9LnmY|n0yQ81(F|l zdSGbWl+MGH`tcE2zQ{3#7i-&&= z#*!1G(|1sw*tQ*=@}g}8pq?E_Qe^(cMlkNvhhvXyE^1~|;iPnCj3yJi7k$|v@dWu< zCx^cs54WEyS&U6e-61u+$Eu?XLeXy>SF0?ES!?S1)gAHD(9-I)Mp%z#xAw$l7F z>r6CGEh|LsPZ1s{YM<^>LmL|d^BwKMllLzz&@HodK%7#>ODFKWvHJNlAKS{@cfaG{ z_z|PKkbVQJHvM)bBJqLiFa$8om4`uwJeDBlecYaZHhJz%pnCgLJbX>F@J*6EL#;N4 zJbCfl=Lr*WvaGOzsef_3f^sb2Uk#+-`Sf3&VR$+ECg$rl@az94{&}7GUru1_U%T4+ zPv5)0U&1o_PxGn2KR;meuZ~i1BFU*CT(}lsd~UIEs}qcF@$q2=FztsrcKp{!3vw>v zYybH8|NMPI|LTiHB7F<{-}`p{{m*L*ApashQdB_5hSKiRx9@1Ptzo8z8*C&f31{SI zLFhTaI|LsGc>Z~NN~PiyqEX!Jqu?R@2Z1^teRvxVOhAi>8-|zO`=_nt`lqC4eE(;? z^Z%c3{D1!Z-^+sd_kYJGUanreM}3V$>)?hDBJb5Q=>K9#f>++o6AuavM+X0P+WV4f zU1=Yu^7`G4RE1lZ5lps;g2{;Y_T;mG(J*ZM&*`e%mY*J=kw+A3GtIBK>(cSKmOzym$C4MZ&x@=$lPJN`ZUMm}qu- zbewtqntQ$<)%yI#-LAhe-bJ{(a0dgdyW`qkzsH{ege?XUzV!JYI8q&)ZA^hrgCpB^ zPNI%n3%?QS(PCgTG=N`(CmS(;0pCCSQCs;Q@v?t>{Et7Pe-BLm*&qMB_5VZr>w&$$QPk2YP1&WfCA-niptcqvP8){|p0V#jguCXye((#O`iEWSzkW6J2-SZ(%m4mfmFG@k zAl<)x=u15Qheh$fe8VM`p=f>a{>#^}8Jl0B>-g^X$R zxy1eW&)r>L75`ZbxDD~!6)|z^Z@+;5ER6MaLHf_aAnwC|qQv@Y_|Ibadoes8hl+1A z>5VwX1Kd+}dVTETlbiCqWPLgJ+paF?pnpT4d%yPQaN_}w1jq#jqfd90?d z|IG$`Qb-d)K|l0HB|@2QBLzKTjyP)0_wWW(zhmMRm{b!2v0|Op30x9ds#F|cZcpF}I>)4QAvpx*?I4 zYtf+ZJ#wA=?A04LXp18;s3#s@E)2$qx%jgxu9*K4MZAvGxdYkJ`2Z9GF|gU+{N!XX zH#CNjn!4dHo^A5QL`l@)@uZWBXP_Nujk!XNtHOw9R$x+?((Y$tc^ba9y1=p9~<8%9ptu&^h4 z8Hk(T%wrH5&Phyt#SBk*e0y6r_y*C#1C6J-ZhG^Z-&((0ygY~L%KKiYc}nsb|MIoV zK~E!)(&gDp`8%+W!1#gn_es}EU$p7$9VL+8(9&iTVuYmx5M|)zfOdGnxe_y`}B+s}|UA2pXxMs*Bh`SuUE#icika=yg@MRK3uUQ!Te+;{=ixOOT?Z}03?M`iPw0)`+1*GO##z;{T6Y7 zQ$xJN$MO|KNL?_yJc_R0P}dj){9TeY`EfzV**SJRHZ0{vs-sP6c=JBfcG}+lH#D0FGwn zUddO0dh{E`fqZ~I*6XC)0&$E}wU#?I6#dPx4SK=>{T*jXh_vi+$RUt}J zd*zUgjm_@eyYXU|aTeTQ$U07!=gWpOuY?g>vEh9Xv2|QNvtE6D7909SiWauB2Nf{_ z508lMei^hGb#A`2J1$cjFk?Imtl;wh-fV`%Tc|&NwLaZgt+(WEuK1w@?1K|G@!dV1 zV23Cy@LGl^(Kfu3f3$hMF5|z5k$Zl$yY}4H2TXqbGm0u#=~eMt)MxJY3=R@&1#kW^ zvAuFYt&5Qj`_=En;NkZ#Pe2Q|8EANDvW=8}EC#i|^4UrJ&;ylR+X=kvknU8PMDbN= zKE4bz99W3A{O;_7zksgK4z=UvBi39bc0H+(s1#kTA%DW|i(DL2XSL5JMr40tFvDZN<5K(n`2aX!00J9^k4*+AZerartVah=A2H`u><=p4sZ&gd zaEbDfL^#`4V9`@5A0@dr(n!hGBWVF^v_4TyW&Qd?Nw`aekMWG+)*{$1*$jMwNC#20 z1lJIH9)2EvUS!&6SghY;l1q`)xa!K9?PUZwXaQ8$Z@dE~1wF%|me=Pts;H=}Ux(RW z9^bd@;U%IcEPVS!%6ynH$1)q2;$kTYrx?i9XJV|(#Gmeq#&cfZzch(pQ9};FS6)1R z*~VrLEgh^?mvK&0^vfoDPL}V@{q}-7AUcY;>d$sB5hIMA;AWM09;sg|`4II3q=J8J zUjAKid&K9R%N>3RuisqKo{KPWdA}-_cQMVREtptAE>7*>0FLtCS53ax zqxZzd+a)PEv2&u=NPDKkAsn6^QDeRM>;Nl*3K{94=C9C`6;6Iv>1FJ!<|@6%lG#X| zKhe8ETRA${fe+y@afyF}D|7R+udE97S1{NriUWTjZHX|!|GQ98H28>)RmA^B$VcV4Y z+i{^So3_UBTs8jtD#s6QSdXOt{hI%S#}N19|4R7iex*(u4ib{o#dAvkeNhmf{byki zcj13*VH{LlKW2!(@sE$QXY(+zXQU;A&EpBi(L-Pn^?P)5wWn-9g*Z~Q%5UE;Z8&@N z*#844J^MKiM;oSw;pb3vlzB5o|L*FV9IR)j5YMz#B<=D2e-BmvLrCuP_r&|*KgpGx z0NR56WRLvUC$EsxMGvDeSdj2KDoGE!TsVEIy!ng{YJ|PFxHEzQY|GJwA2F7_eg~`J&9oAc{ z>#6AHy@yPQgNy&u%+Q)<+MVzNpxsfs?DXky3Q09?+0xyKai~e>A23SyfuuV1`9a&} z9hC5IE+cah!Pvx1hdEE(3d(B{CvQ^@mGBu| zhsCXs0*gXa-H$i>{}EWvzt~MH>OsXb{^#c-1I#m!k91m?R9074SF*KQT@H$sqh%kv z_-ZHBsg~8xMecJP*SRIgOiZ?)cYch4fB`R5*g>k4{Tm$k3uiygw%Z2japXd^}-5({zfK1t&&y=2GlSka1L|Y_*5EWst(CfKS zQOD)pii2#ghexjPfu>u^GTfSlzSMfvgWs>+P!nB%cYT#?-v$_z(4ud3gjrU-I|)=h zOzgR^8GcodgoW?EyZSpeB4)UwK$;A$?!o*M%oLlB3THa^mT%UL-AR>_ot?dYAfEjr zzWxSW_9#Y*PrzmEmqirE4)0Pp@(s!41+gjL*!+1n%wR<<`@Y60mduW>^v_Qeu~T-vAMdk?u;J4>u| zz)7wALgI8J-b(Gy$gTR-t2El99nQY8T-)zrapXI%d6K0`zB+~mwwfEcgy%4=KuSSM zEsX6ByQtn=|G_UFe|IXh&ki@O&dnn6pIcpVu(xc@qzAE7$)(m|`cG$`gN;f1w4lRm zPnKn@Nqer-+G-n!o!9Lo8{P{{^|1cwl&|d^V6<*7aBgf!92#sieRIArMRx~=AQ}5Y z^s~M#5N>(H#GLiUe~;RyO8HphK}-$(4i%VU3&G}J9&T1_@Os5kTkhxl?kuvW)wh?1 z)|WKt+<#qSDF5nC%L3bp)swT#CBkhlBN>6F< z8GTP0J5)_ncu!M#3=*>)>Bf&zYE26g?^#-^JlI2j-gUA!;oZw|@QAQVsC(xp+NAv! z3B&^*bUU-1R(|nySlMIoepLN%(|qV$w|Tc7Ye<-=W3FMN9vS^eO|&H?{S`GpFUQV3 zytw`(#HZly9+k#J#=oo-&;D-Bv9YO-uU4cyWBf~VgNqNW&SPgb#>gHq{ys{{ z?D^@84AM)OZ}W)@INi^9uWC8cnx$Hfp;6zlAP=x9sefTDdkR+u;XKtyamOKM1zY79 zj}io(QA_6(9oF33q{F@KdF~Wkn%6exyt%-9fK{RVmi}|fGtu2zWOh@O7B+Hs%#(Ag z&OIt-Yq1(?Sgwn^UG8MjmwSJqkfkx9@wA0b7c;VMDGUx)2*5L-E-O~c;Jrn z<6kN{&K0^o^$U{?7tX%_!<|$vF`Y>JgJ*^y% z>Dqd}T;HDVm$09{6L%g*hV0=1#<#b=y)=jc!TgW07*{@I3 z-bB-|aL?0I7_Hcc7+oAQ&Fx7ezyaklo9(@U8aWe6p^iKUl?)Tr+q!hqg4IR4BTY^# z;*XVRYs!2i=KhX=n8yOEk5Aw7V9aJ?Bj?K?5&n$A5V(#k{q<7!TTub;y!QJakbhv^ z_q_~$Z?q!zzpKL3@aS-a<}GLnM0A(f$h|st@8{cS1df9u_Ev7=&y$5ou3L&8J8~SM zNT-4Db(eELJ+mI2$e0Tnb&sdu`V~8&UMvh@pO!hT$eycml zbsb7{l9p%Jw0Nr?{V^j}TVEx0WNVaE&Tm?4BC1H7w5dIGxBf0mr!EDZVIyZpnt`7k zrt%~rh`tN;%L=$GxUF#RSU+hG=YmlCXG-vMKL&n3`T5`zoF=lN{KH=!IoQk9#vF;_ zySlmb+w*>u#IO4$y*2xA-0l?F|3lI}^Ofe?-2In~WVp`V`Ea`=reIC;Jxxht=UGvK z+_~0SEtfw(HM+l9T3SlK6m{%_pNvrdMOl&yDUe&curh?tSl|>;w~1UXUO)`hz;i?S z&3#u)I`TzKTKT8Kfl@Hag|{Ym1E>)N`j=rUCYwoxP+IzGqfoG*l=pGiE7gU_MTj2Z zH41Ep9i!%#ht^wPiF?v4{QeS4M$B-A)7HT zZa$Vz-X&n!=Nca0ERI)K1o1e3dsdGJYuJ6^c;DMKvR;v0AIPk6Aclcp{9t2FBF)tA zFOFIGOu^m*g9F)|BWGU8nLTk_622$!l8R|x_tHd(IZnR}i|?uWa=q3wgN$<3iHb2E zzMh}2C1#(ZmzXb7IZ6tx>?~Ts8=SzQOhyr}IxX{OnQ~xlYUZO_Mp6WyX|TM%rqAq1 z0dF~+-N#yNzG78G-5+ZY%Xbu#3FLOy%)ZHVMB~~iUxjG0Kx z2f2|^TXq$TO8kLSduv1-Rv}_dmB$l}bCw{Cwu5`x$wyNp9pdu`K3D* zUhX%>&a5{YeL0Z(>0cz*GaC+>{#L}PmMEM!a_|Z6?XE*V7Mea*r<%bBk>T?IV|ch4 z(6xEU_ST%Ko|bq7(Vx4mc2w=-Ehma;VUdi%lxkAl%F-Mj=PLnAYl_q5z7wV1jPBJd zh(}GC6SqYZHw|vxd1z$HCGh0!gsZHiDYeak)BM-#xHqyI-*9fYx%+MV6lv`*oeFw&)o$cQkam?W5 zp>o*h_cERIMIw5XX^T#E@EHSy!4dl>X|BC^|BE=PzIh&b>D#a;fX}oOIMCtVy0{Td zJEkTYkwsRkW68XZi!yAlp|Ie!o3x=7z5ii_9?KYUEAOjGu}4t&Dc!?vru4q zW4sH7^o-v7>tBAZuo@?wdz8&aX|R1yTzf~}6078m=*veahNJxGckRz>&b5n0E+?hk zUsc)R)KW6rzcANfobGW+GWhgDu3ZI@hd=yDEaBGi%ihO>QfiT7o~V(=;)+DeN$gPm#T1$Z_qn{iL|vEw8`Ci`Kuzo3X$Oa(I~UA`Oxd z8XW=Q60$l6aE^`bN^uh!lQaxJTEdzdJphZkQZi3bIY=~8)jWx|`iIk9D@J-dNh~85yFomGZD{TM$rQ4fX&cIw|W>5<^ z(qW=2!f)<`R$KNNYJthE5%qn0(qNHxJDn#kBjLy8cunl!mr1ITMoSy9>t>c06sN+8 z1E#=PZgT)`$PFzs1{M@V-{)miqZmo)MhgcP{7h!{s3wd%Mb9 zz&O}3Zu7P+C$=P;&V2x+xFhSa#6r;GHR4o?j_y1uCEQ*Tt3IO z9aTu3TdA1dR6L`Q)~j69H0>+*TZ4g3OJ3VJFiY7vB7G`;K2Up z6F8n)J}to?TeT)e`Azlfa~d4i4x*1Vt)g`%bRL16AoWp|r&9kMmuaA>YKz^#1y){Xr zy3D6wsXv0FSOaG-m1u6`!_9`0{NzLPWEp!VkzrC9eSy(o zww3L`%bU${iW182n8UQi?Vsj7-W77^qkh-d&Y^~t#KKQdTCi+-G93v2jbauD+q&tY z4`D)lEh)m1q)-uu!Q=v`+7PFiVXQW~ohPfG`<^zic*+v*MaAU2m9FSw>;+~i@8RNI zT#-iADd^q0-fbwM-gIQUu+x%pgyYg`y+i(TimDIOh!R~X?J@J4tff>kw?i-5NjDHRq!qfg;(BO1Nn^^nyz zp2K9(?%UIPv%^^hE7lhHDL;neGJ)4kET##Y0Eyh8df>s8q|^vp%C&)sGWX7V~Siz@GCOZp7b)N9*P*O!{vSbH1&1$&mU z-pvRP13YpUve}vBR!4y}DR>@j`*i)|sa4T_ALfXZi(OwozV{s5EOVlP_mwCH7;GJ2 zyNFa6rnpJV4H;t@2=L?6t?{B&ij&hr$!c>$d~ao_c2m?;g$a#Ve*AJ(QcGWZM|%>f zCDS~5BF}$Sa)4d=i^=!E2V)%tb2CZ4thKOCyCHDn{dM#8vr!t4%44SwLd0m>5bG|r z7Fw8{+l##9beI(uB%sAj#Rz2LFBbJ0lSb_2DuZX#J`KM8OTzvTdQS zPPb+QNMnV6ru)~3=vvjyIcW8u(f5<(;EC(4{pa&5Lu`ca4K^WFuPgcJ?c7(b_0?Ze zs4(b9gTv_HU@(UoXBM=A+RO9wEg8;&?zCb~rwtqCYWk5#ZKD}8tdzJC!g~ZWr9F>C zT#I&Co}WOI2&k4}??+8dO*C&$m7{kyH$EPS#vWw$Td8TFo<|&m2OF?#2jtZ^FiH4( zsOGWCLg@Ow$PX}5Le&r^Wb**w=#U0$xdUfE{wIrS)R#qG=?|TJRJ62M@?0=Z(UZ6J zN(<738!9UuYohEPZJqm((1FfyuGPRZyU7DeX75&(#IRiD!r7#}b=b}lNu>pB?u}L7 zDBD#FBc{{JRdd*12}h~-VyDjsq72)#d%<{GwL=Z(y!^{m$YO?q$H4mz`}XDe!D=2d zhdKL(g#L=JM!S!;!r}IV{87=|xu%ai%U3Sc552q|^@>IDu~chjMC@@@)N7a?JgpZd z_##T|!h(M3%L!yc`bdb1F;#4%X+SfjXT|WEgAyz&Xq)ULxg}g6`;;2(H>l7%eLr^Rql@Z@iDUP zdGlW`J`6?2m6|fm>!YM1_Am12SBc)O^CDO+=a^Je4(w;H0&4ZtWRfVB4!_%VI8EtI zQBN5|We8^3WPJSe9+R&M1l6Vl(OkcC$2inW-MLa6F5tC z?(^DMuL1%^g8%V_eugq<5;ia3sH%HVUKH~wt)8}1d0~2I zvL_C-kl5klW7Rmspt5!xYd^9u@PxKQL^Z{CvcAHPy`Z4OMyqV#qj~q`1wa2rO2*4d z-OZb`(VmUEfOF9Op)+>V%Tjv&`nlMe__8c}gD4 zeD5h!q%M&bf$d+kMg7Y;^(t2YRnb>M&aEEo=FYk^=q{aiepN7Xc*VDom9{L+PcYay^ilv7Q?gg?)f16wSKqr2?30W;`eh+_&~}kDT;U<=$7VDX zZX=cYmZ;W9E1JvY#}cQ+EOo50>wUiFa{xxR12qD@BJ`oM!QO+}3p`g?KFNxuq(leX zuPiEOjaD$KRatf)ct*vOzWhLxCwUl-i+c<#79E;0Iu_gCfO6LSJE&YAVi)5c(Z+0V$U>&y6^@c~`r3FRR)bl~1}ez0Dl-&fqf zPL}b*i7UHHti>gtcYhD+u2DMq>qJu0$*8zv#*|OL^i^qm?y&nrb9B!0=H(5qg44f# z_1NMW+kefD)@rC&&|qSuZ7FU6j_rF_$Xi%$jvThD!>KtFvz#}n(lXgm<`AuBIe6Ro z>g9qhQRPBr%k!O<{jz1ujK)D|oJgfglEXXlcDhj(;4)n8rXZqWb3~}=Sl-3OC8ew0 z2%6kiVLAH>VF}~scLOMetO%hcFPti z#sa%3Pm3FeLloA0z22L3?nBAA)%@N)W6aLO4B!`6vKl~bh{6a-ry~XC-QpUY;N&c; zWm_49X{Q*}GNF0*SyLy_HP^U>*Mn9}$yBfOrCr@S+TO!)4`IVTA>k1SJ31fOol-jh zz&dpKluT4)Y2b?@#Of8&MV6?8QJQ%%(*EBAUdv=z_z}p`|Dx$D1ENm9aKQ!@Toe>k zP`X1(kPuKhq;p6C2|-DR6bwY9ySuv^RFsBMx{;0{l%WQg;hy>5dq3`n-9`MpC!RV> ze>%e@y>Di{Q<+#FNS{aZ?YzHwyJp`#JJzCutk?+K(Vv_Mt!DvE45c)-w!vYV`RH`d z=I7^Gh;@4&)f4saZ++e>0RyP)V@1W4vqCgXwwknqz-zE4_LKV~yCW@9)!{YHnGIJoU!82-)kw^1|4x6{JRS3hA7A(OP~mh3>Cm zZ0gEfNV$#bR7qjYK3vOX8&I&>XodL|ReB0#aZwp&8TMfplT;D!quy*K-}}FfN$%%A zzO-E0bk1zF_}EbO0*A9!Pvb=M@#6)%rP7P!TWSdc-gss!H%FVKr0u%m|D)X-uRfNm)f)Mt@Qm-#4v%Qo*s zn#OZ~dlpiP-Vs^HojWuTc{y<_Rc6K)=USstxwqWl+TxNfl9dAVQba4>;6)Tfr0Q1N z0^H$9e(TrIsoSwEYEt!&SJ~f>|D9`g6|wGb0-{SpN~Yi?>|n8ZJ;?u$1>kT8soC@^ zqkK-uAew3!A_hcz6HPqOYKMn2rE6+IUM%_QFtkjwqMJUfpi*J+a#(2BZtgxuO$lu59`Z`D?+q9Di^RSybgY9cVJ`s+mrDW1NJ++sO))zS_g}z zyS|BnXixFEsCWT-7(lc#+jajtQ+q4mi3iLSoP5F@ZNyAO96b5YyLNO^SmYOGcIW}N zx6^9P=6u;^P)#$o^VsI@YV|WvG-abp@TAI(%&^pJ=7x+Eo0>F|crnpQwfdw6sPv{Z z|5)K0xP_fPwc z3b>9^hR{1AY5u*{cDf;Sr&U$e0diN@ti1sAg~ks9FyjZH6FXJRmn-B*DfE2sCksYT z1IRX`6+gUBh-Q!%F8|S9OvfPprKLR}`rujQ(;$g`i<%eegQGMC_r!r|Dm|U}T<`2# z_OBDV4Q_W(gYxtF)3@-O|(pzxP&BTiFT;Y=h%Wm7pD-MrgwmdqeAO+-V8ym^u+uJos_Nsm1-xL=)fX z2F+ZFk(IMGfRm;^PzGkbsJHwjVzDzEbh!ny7yzjY@4W)H(g!EH+LeW)cl^EBHM==h z{<<@a#I0|VMJk?viKhDRgs4tL9MGR8tMaJRT^!IZfB4vg4m8%Bx!HRwBChLj%yDnB zW^+#WmVjaus*TR1=`arE3}S{g^_rce9b*_||4r2ob{7!3i;73c+4!3`lT45xdVn8N z(Y(5weF1@6FI?s_bgS`Mgc5iGh7G2m1z3+EWvexsBlZfNMAwn<&!0;c`xDSHFJ4{G zxp`^FX0qn0=l%)5>$(?5{QVG7B+X{=uTJ5x0EF`CgSD2I<%VeJs^4x#UCTug% zzoPiM=F+lV_BZuCW#{R~C7L^>0t&rrOzD0uX^`sjd-R7RKN6>LF{We{wjtQejmA+) z$Io3xX6ohyp<)5Iceocu$q}npiZxbzg!iS!$tGdn)ulr9c&Gu6rg54Ce4=G%lilTZECalKdqD{2vP82zg{!>`1St*)aKB9%)04`dD|nDntO~Z{n5G*c zz`5N0{^j>ize$=h6JlbC`%7)O+S+RvRat?QzeoaxB7eVrBURxIhP<(n1$6!sfYJ3<1|eF!q(mdZov?z&fRwV& ze9R$iKDhNzNgu(6@r);d z5!{Fzpn#tS)AaSAyI~jl;`i^^j3<-XnBmP_n~bW|;TOH)l6YRex=f-}mO?^;mxXr=JCY zi!iBsB`fN^N8i6gi3cuB*wF*ha0gd>7w6~AJtjg~+Q!O9Jc5>r!%~?sVfsiU4A`-Q z%x)WXPBfrQL64QcJ91wD1ps^nQSQAZRd=`^w(bZ!yxH5D9!WB$c;uGU8}HniO2wio zh8+Z0(fRKmT3jWkcq1&(Z0Z?FCTgs{jV=`EN+lYhu88a??n$WA;%{E5^>c{dFl_lK z^Kmyx3~SA?5C`j0^yo;dFN=k0!Z{KO*c0wsc2_~Rd`v1CCJDDA2}ve0=Cdslp=Sxx z#aA))ao`5Bedg^hMjPGSy_U4Q#t*Ux18lBLzziVtLOv~U9IW1cJOl279D6Kg%BA{5 zd6k%DEn?b)a1tEVeTn@6Evq0@A?`2cf%}fhl{;g@NoSIQ#SyT1 z@FQr2S^G@AZbAMs<3*e5E+we{wH32~Hpi-Zq#iF}S9;?!gh5}ojjrPpDby}o9b7TQ z-dXYnGWU}}-$}vx!x*j4S^L?}KbIJ8KYY~-Gi{NiBD*JGyhn8vzrH~-KF29QxEis5 zY!ajg{$J`T?@2LkKXs7Ij)lL~XSVek-x{5k{GX_}Dz@r1x*-d+*3OJPi7*`kZlkY{ zG`|sy0H|s4bb%%4zx1xT*ICHW6Wai#X8Qpv3Mpt@From47isapy5FJdb=D3Nh<`8* z==nxzJp+)(EJ`Vg)ln>TCsbxa5N4)fSXyl$n{axzD>s|X*7&ym_hPDxz!XI5gklF{ zZOa6<269m+z{PJnFI4$x4~#{@H)F^W;;m-xSzU!&%|&a2^CTXByT3Kp#sx#GOoP(cXJ$ zd6#0T`9aPu`{p#-#$NIC$tTnoJL6%g8yq^a=f$!2zF^C;9U*#V8w!(E3k;USgE_&! zz1bmFr{r0B0_xlDz+F)2i#4<1_)L7o8DV0iI{jT?83gG_wnIMLMh}lC9i0<|sy%~s z_hwUs)*_E_2PRPm<}}{NA-t_Z$nncJ@mVHu=lY)ymd-qyOcq0Gk+*e+GnA5^L-u*p zrR?fL%eMi<`1Sllt2>Fi4nEMeoIMm^4X$xKt^Ua_0COgdKwhE`HN;OJZq}yKfF{dc zr^Smh*^HhJ68B?^Q5z-rL^F*NBg>%oR3ya-4083(H^bCM%&iW94TpM@)%3;!j;Z)Y zI%t`6oNuVByTvyMYimzvDBpVK*jN)0X*tcI)LkbR5%l*zD7i23N5W*uzJ}9 z9LmC>>-qKgOd-fH>V3|Dl?aDlhYKSYefG@yW8)DHHl z2?F$h{x7F*%`oli*~;3Q zFeygGTF2BL!Qu+%oFb0e>Rwky9X!lsR*?u*pn33I`rhc)-&mup-nO!=&s&u~tgeZ# z7cMwX)_fa_5;iKSx9I49=JsIpTb3;2s5#bi>Bp^yuf9B;c_3q1VACGCJDjZkmdRhwQWhZy1=&9-aC{Z3DuIGt z!});CI@61I$&lF+D_F+V_CxHo>%H3qYtl$OLn?@Fg{Wpbqu2l_oy}59?efa{(F}B- znEoM8>j|q0g>db;ZdIT~BZ;bKI5pcdRT8(Tx@dtV0gxtRC?;4XUp1Chy?^w`I;_1p zcsb&SlPeXj!LG*4k(bvu&)Ru#h93o_!~{>PvT*4IW^I27 z?~fO4JOa<*vgA;4n(cr1&+_MCuXrEd;J4x=QIZW}mU^JOz-(FH)sI0(8~bc ztSqkw6c6YZ4ya`I$?0?4qgk^D*`(CDnZqj-Pmb9mio`$ zbzJ~bluKqTLej>Wq~D`vXMYCy;{VRcfMDwaIjuFHk+F~=EW8c7E7~(zHx@m+*G8V}B>zF~`61JfH=3KbA_y zYPf^j{W0j8 zzg#O&0}a!FcR8><@nYDULAw;;JSJwCMi*ddnUs9geZo>r>P6+%PIuRWK>ZPQAR^?k z>w>W^cV1ymRh$1CdGYb#a-|NSgJwb9UGN}b&(3!q@YuZ-#hqN-qXSndT2vApJe+|@ zYoX0aow62A>@OOmW*$hk>N#{YJoo0P#I!|+U2c@WPlOUa`iB4oLy#+r@*!9{eKcgk z8vMipQ7hy^pjMx3!eXS`VG@pIZ$Q;V1O@d7&wc?mycp{@Sv!gN9enGbv*6msc;xXu zj)P?~O9A7xeC2t6lJ{5{3YP}PD1yX=JfqqPeV_^tUOgZn=9G{R~>I$3D$J32mq|1e*Ew&Xk@8Bz^pOp)P#JR zU_UO822w|=)97dPL`xMRCQQ<8Lm7UZOXBF@`aXI&Zv6))|Hha|Xomf3#_Tf=kTpsFb}J|6$-w@Kry8dN29l3YJ1R<8cd z|0magv=7#@q2Dv`+WqfnizIb&ITf6|jLu6d& z45xaA(J7vRD`(D`lVtuX%}^gb+=|mhus%!EE7U=NeQmOE^x4`c5I4yMKJFgghX71G z?jRUFvKcu!kZlMl@6nak;3{3Zxi)=U)J3}0hoQlp?%qwiz__2E{@D~Qf1ujy7qDc0s?*# zQ*!u(+z;ftY}|h{ek(Wghv-Na&*EDI&Vj-uZRW3XYn9JOQoYyDD{x! z$CuYhBC0`P=DPZ;Cxhc@qy!6wgAesOBR(KKmVNI7%2=S-tPOQ}LvdF5s|Fiqj*~+C z0~LrtKS`L)mJKd-!GbObUW%q4r0H^J-uqU>sqd8cIE=dl1h0K`(K4Bx{`GRWe#Z`dPF6ai^aPcHjYl`!1i*K;M3lk(| zYhYErx4<+LNmt&4ylmMSCTO~%UFN-XigPclPlh80x;}T;mSfVugy4YzTo-<$N4tUb zk$N*~tt~s?E_gt$Jyp3vXQ>UtB+lddVzH3gK<35gi6SS9#MfHZkQ#k3ulnLos54KX zNP}E#y&kc&qV6-8)llb@UHv=|aEac8JzNYIy2Q8{?9`EWL?o8@dj?AkmU<4~B$uu5 zGiZ z0HN@4B)6f-%}Mo{Q61;yu06D__FIrRJhfJXW7dM8fY%{&fTyh$x5NaQn)I?)0=PW# ztwTo^k7sHfJ)4V6f7!74$b4(v#hE1$X#3F_5XE|UNg!Pg#)qf61n<(@`+FVbv*`0WiwnU(jTBIK(!s~ zbCn_*7fj=AEI85BnWztsG@B<)uUw78Prk8h)W%4lUYBRhhN;Q^8@y4Qv+G`Q0F)y= z9JGBZAAU9WcMA+jFkAxZNO{E_lL*Ex8i5zt!f?;!rQj2u2dcfeUamnmjAJzMW=*uN74XyubY3D=+9;fX@}L1&1Gdg(dNl|nlO zuzOsr8~OLozx#2Z2=35G6y7^pyT3GE$VRMSIb}yX;5-knaNbqJMq} zP~5$T#o*;Q?=wDs=KSaV%|~z^dz(|W6%MAahU;l)M$P=VBeE02sxBcHB35&f3j`$C zQ%Yt8cn0SRq36I}dH@>Y_T~2A!j_|g`U-uJDBa|Yvxoxr)_rf?l7m68uZskfCVaEt z559_A@~CuP@fkTCgSsBWt}S(dcNi;^CSM%p><$c?yG+Sm?zY(x zG6x4?ds;zWl8@T}D#6OwJg`K6ISLFG(uKT&1C zGAG|yr(a3dT_Ea8Q)-OM{rxqn?i-MkoEkcibUMAW6lC3Z)Fe@6l$$llEkCHV_*o2w z7;(d}co7Vo#KJl+E31=f1M3Tt;t8K7Ei0EhaCv6Fg;o=a%z4rq`~{*RipNphN^6Ed zpsH?+y^g0~+P#!d%2tAEo;pWsS`htp{Att&6C$bM02pa89N-l$;QMukAF$AZ~WfF76x`=BZLQC?rmn6Z@&I;$dI?u(4zK zZyuNHxd!_*`xAxI2yOuFz3PRt6}`=HM9%cTrW<3FF3R62c$PjtaGSt+@wD2<2)(?3 zM!~zIK(xG?`$BpLI}6~6HI4{Vr_58z!G5jxdh;U6aRPO%Ix0jg;y_^WXp2ZK(D5uRL%pC{EEU+B$bEe+YoxQ5Xr>|Z#n0hE2=Jt}(> zEG!XSqgm!Z*I{Jz2W{seFg z`CU;yusVqT=K$BwyuBwtc!?Ig27xVXI1Q)3B1B{QjOoHg^0!~(HE|Ykiz)%YR`5eB2+O&EW5vrFZT*o zQNj|z{68%lzwf&Yid(|DuU74^--eh3HU9>U+yY}<&xNZ74GryOPOm^})0@nU7t-_R z-U4wL@wAI5cvw(u*;gt|ghjGH*ezU=45+p1{jUic1iD_t`+=}}Hlr^mdc;qXIzo8y$3~{EZ#(^Fv85^6v#}9WeLiE&KYYcUN(Y6qIq) zjNY!08-t8Z5RB{}i~x{F^U_^u+pk}Ovp$MBOogTTBorLTCs*1G?h}*&_3$l%EC6=< z!h<&^b_qvfJ78QAc9`Pr)>t{2zdU=$?SoNp_n z_kq^~iQKQZ#F=MXuRZyyx4lE+Q)=Sd|Fyg&@6*|*pfU#0C{@d{@9$m30K5FLfM=}PlqmFD=uil^Yzi8U9&u<5G@4AXO?{!tGWjIqTcC!(skJX-t2&? z#)5!+9?@L>iv`wrN=J9&BmGbA`dl0=U4)Fo9Db~oP=TYNED1DoW=6!x{q2LQUj z!O4th_(Fwh0{9y-Lfr&9iI@U;a5#9iM8Ff`@RYCaV+FrK`>kncdq-kO()F{8Hy?po zkkF4?yfss%k_7Ua0 zTN1bJlV2HY9Mu%PM9^?bs{%P2>?#Qlb-~$c2?h~(|Ei8~(ZXe{%vcurE3Mq8dZTxb zl^?A%sULn{hRUKYy)~1U;Be~^aaz!|L2=HMmf`JCpbnTwosQxLD2OS@7re`vN~4o9>y(mmFSW%t=OAahh^K| zwob+2B{;AKdLWUTv#qo927~D`0Z^w8y@m?3Q_*-EM7}SCF48q0*6q;Fap8#D^CTd;BnQ^q@~1(n?2J>bzN1alk}Zv->g5)`w6hjI zgZ@#-9Jq@k95DB;BKU;lU~AfYcl8_K9zc=9(2Rj`y?YaMbKS4O8?m&_x12o>7xPNb zNM&4*y>IsY2PphB$)fozbn2^LPU67G3{f!P_B#Yg9f$;%o&O_w4Q~Vf34V)?46@1! z2?F&$o0rGa`c|STsRnDtt3L+rq)<65_Xf5r?d>$M^Ponz+WrSi!8ppf)r=feiha4U z64@#aT-^4o?~xvpbOL{F>eaOLlI8VI4;3qDZ?#H~BI@$HG*`8VfM zOr#e%O1l!7zdaBc2j+v|cm`k<&1Ry7$^8>4VBc#Ui+t{O4|}{8=ljXaC;Z(Jtb8d& zCZ{%0%KzqB#Xzmy1KIw3{N4mJ z_*7sIDdIj(Fs65yuHb2VLQV_gMlTrVqYiAZOgEAX&_!}1nAbL+(XHGQF$*^{H-28E z#pbIMvZKUn!hxI5^T=uRl%}+eD=k~rqDE(t=E|9m8~RrMaa4;7>RD0TgUMIxZC!o+ zX#OCiH>3vl!7Sjm`s?vJ0B%&Vm8^y}Q-oYEDcOWnxR7^;nt9fpJTyVH?MaKK#vt#< zUpV|Rj|NMv1i~e3AYVc>u}8W8YEY3)@&VKAd0dYL{HKi9h+Q|HgzivLQ!~T&T;`Ld zD%F)DUR%h~ya(2SLwVdt40X=#y#4%K+gH_+=Wljb(_O^Hd`_O3JIH=jDX^9O+qcg` zGEi3=AQya!bIjqxyY?kmLiQO(rK&aw3d;!|9E_7ZV^c4G{MYX{~vH= zMwhG_+GDaY{p%XDwiZ-mZkmhV+F6hnz;UnW#EQrh%2}_$aaM8~fsxTSTC4Dhui)LS z(k_cj7l1Z$ov28EG~;Qm?eIE8hS`_R0`?DqONH7P%aKqBkl38UBEL02ew6_-f|Qbd z^-3fhLVzPh+)vmgK@}c)6Ez|q4&WwRP}FUrOSE9#6<*7DF;=Dx1)AxX@50AeKCVK& zsu#xHQ8wMtg+>0!TUEU84=+`|`6rPZdGshCKJ&2gP7?xHR^V_`pq`|{#7^(W@`+J( z}T_nttvugvWWu>|1&vWV}yq>@X>7`BD~{*1T!V-0MU|9a$T;bn$h zyqBNqZcqpAVb9n);`;oN{xkQ6p$~&1erp^PIs;}Ck$NuUlS(goP(gsWzcpzXAkNSm zY!Oa*=PyeveSx5_9&?B9A$O1E?{@W|3yu!6Z_^iF>BxCLrkXqLVXcO3Z8w-{`Vf5O zI+$H0H0!db#h=ToA=$AiFUBh>ox)t!B)Bx(Px0b5I*s*AfA`7&a6vzjK=+V<#_VCz z)9z-IUTS8IV+~?@sT%mxDxB>92xQPW@6>5pcQ4pe30M5sFGDujC_xu?`52)b>|1cz zO*Oc-u>vSOyx;pd?Zqern&?}{-O9Aed>Ul+x)-ExuH$W)IX{~<>;xUj=w=MZ6(r09 zgAC5i5fhb#zfV8frH0UwHSn^5S^bF#H<)&XExWyLYtp@BR7V5n(Y2)EpDGiedL^Go zcQqID>crqHcu}jJF!il60mfjf(7i-+{{iSr7~fB3cBBCY2hYe~_WOGhuy&*fmu_Pg zOW+qe-KbVc+#Yy67Xrp~QVIx6hxv~;`x_QjiUp5>9WO8#hFOUW+Ko6mp0~wzqH1k( z^2_p>YiEGK)q&CqDH~b8mHq>kZLW<)VfRU>AXpIVemwN|{So-|V_>2oYd3E_xJ$+o zu7m%dW1;=3gzI`7sWBOyo7GPcst`zuYgTb_^>uXwi<|=_T!zn7!zKh#A@-QOZXgqZ zXMD9WM!hTtj_P_Al-S`gsmM5(*D?dv5|7Wk)T*&(0(P~OFeX!7jLTI8yUb@4UotcX zEk6rmkx>@IicYZLghRF?G`x6zsw*%;$0WK~cZcd#+wK9#^7LLLy+4M7M~%DG3xBc( zacmlXrvIqpSro76OL;>cjWB_ z8O~z~V2(tltSer2}Gu;P)qs#6f=!qvGx1(p%_cRga1W%}8 zaCu-W?@1c4ZflNGn-f?2oNomIKC`zi32LNo#T112+RQc6pgAb4ol5<7AnZ3dXgeMEoa zsDaCEh`5;RRr;%MrrPQYqeDfiKwo<(-TL3P7=O_%M7p$K@?NvUv=gKvHXr65#ibxL z$2nOi1VQ(r8cq+zB{qvw&=?+|WsgT3d7bi ze@0naBd+%{nm&5-_YDIT*D2ZUeecJo-= z95(6ttaQAQ?Aj9mo>8)C6u?U^a=1uzi4^Ry-4I9#*^N6ZsO{0}WuVnz{2NK6rKKGy zRU8;JfbdLMJ8rD&*E?B$f{ez;W6~cL{)Ve2tPS2|mj8>~BMSU2znkTGunblTotd+N zAHm+~x_&}*&f!d(d7Qz?p#%GqpP{EBZy3dyz@MvT$QPLJ>dHDki*ttM7eN-z_GYON0!;6&og8o0iomxwd<-EFEQl8%CHUppYp3}n zkYczd_Y@Tl%#n^8J3tvt(wUckL3K>}3Zk4}2Q9Emwo)^<4Cw^Zz5n{=cw}PW&GJ7t z9oS+^9{ZU?AB9Um`NoA4%El`L*_TI35Hn?FXn+&X)inx(WU&G0c^($M1yFowm8nRx(%`%!UmQ>pe zdhc&2w4X}&ocuCtV=gddLF6{v5wsQX4MoM4mZ_7(wyLjB0`FrWV*@TZutR0$T117Y z$z{iWVpNEL>pIh&h;Wlc=?|ZeJ;uTrQb&$s-T_`vOi&7i!#2zn5N~Hh{D}-~nlNB& zNgOC)el&iYXWo36Sxp~a3;$*E#YG-6#&RQ)D>T~wz;L;*HO^GkXohAAn=7s$X7ZR043?Qcn z$Xc@y8O8Tm02@a#2lEQSrVJes(xg@njnX;37U-U?_wXdL>1B^j3tBf^V1pqB#u?T4 z2f;s92{2}lj1L|wxAdF`Km zKnoW6u&*(8eQ*Q3x5tBXKgZq;B1R$Vz_Pzr(VfWjDkRLX$bN|f1&|En!oUY2Vn3Gq z?-ih;bi8RjQEZr(siW*+5?+UCjS5lj0xZ(+FR?#?l+V5!gw9PC%MF&Tttv-C+-@-htugrh}nQ~y~=L1W*ZEM?NgMOzwJlQR@()L zG(Yiyc(=_ki0FZ^8?1d295(J({22JtUfIcQt!qa{XH^8=juo_PG0**|oh<=&&Gxp^ zHrRWhW&XZG?G;)uR61*pJ8A`xC#~t`d?KGk_zlqGV|r}~(Me?4EUyF)T)R-EE;gOp zWxG<4lO*!=vsODEzEA4&pi*9D(Qoznpq^(?o#OQVPrZ()g7~0miFdr6<%qb)?$=T4 zOV_8SC|tItbRC??z&m8RJ>$E-iK*(O0ZTbV!SHZNEB=2hKs-ycNxP7n{o0~Zfu=I8oOsi8L=P zI~g5gxEK=pm;^qm-O*Us+$t0zn&!8Fx6>4_l?$AVA5C+gp#I!f^e z|0I(R(;XcIMf>Vw$(%?6Ru1j-L+3fr5U%{kW87p^@5Cm@%VSEx3(gWk(q9oc85aRF zZve0W9B2GOp#0-|WjYElDQU{ud#LT59Z&37Ae)q)qIEA-Y-JVr~z#5?jSt9Jwv(JLI^d^r3-x;uq z!PhPgodU+<=r&+*=IxlXq`1TT5?n!q`e;eK1OmvYyFITpy>^6o=WYvYD!x4U?y+R+ z3;(SqUaa*ZF&rtM$ZM~wt2=b1BrChu{J(GfT3NW>GQ(LN z-^*7Q&&3#mbpcQnNH1mu9iJ7Z zkb(|NxG1bCe0!;U0KJHrqe=xu%|8;_Gepuli9*vbD&OO~W8sWSNrp;gJ6e)Unj68S z1aIn!$#%rV5Ez4kE3{MS=j)P5x^GpLR`xz@`koe$11j5`KLNa=rWfE@ zI-^I5VMNdSI^N(4ulz2^%^?up=N|ZQA>a8Yu&K3Hrv(JQufw*NrKWDTcJ^gi0AXSV= znk4^NAvbx4mL6K21?8n^j!`&OOkUrsfc)k!;^BL8xCID|rk~sHs??gM*eg@r0J7$6 znWv{?21R?Z;>WpHu8Xw5cHz-#qzE+<^gRIoz&ieNO1s8BJ55RY(q}u%hlSP#bdAiT z4-hTRD=`(p^`xNOdsSL9_X;d}9Iy*b0S4Llyo(1UP9sQW5W&%vU5SKR36{Ypjt2T) ze}q9mIhKBVqFQ_`$H1uW)z-InEkFDT5rE@4;7SC%QP?9t;3_)%rd#AerD3g~WzU7K z=cItfAIaXflfhQ`p0*P9xc>-5XVaN$H=>1-E5^a^0 zIq-69%WnUjo8>rGScwUju7pAXfjq7oW0O-oO`VE!*kg|ta0PWL$Q#+qcS4GivLPK$5VYk=r@uiKjltCc$O z{G7T>X!YLil=<_xjfrXm$`aPb*J}e1*0ocycMOpwDwOOnjTS>#%Z{$g#@MsanaN6P z>z&1`(K!D(j#AzIYXjCBj_3Mj9bYuK#4ipBcBfn4bBrTU`e}fQ_az>@Q!mlkR0`4x zCR!cH_J!yZE;qMriC^Z$ERzb!wlEZA`LiRKL5Rff)=i#(>=O?XREBF7FK>YH+;*lk z*SXRAcwswzsLD0N9;DLwX)AelmT`I3iX6)T{q87C*E{!s41Q1N3zjrnZpF@tYj6o7 zWV&tsY_BmAKXIny2BL+%>6Npy<1F4T-!=3O)@JWEGQf4e0s%W{hGr>rN;{<-P1uX= zQCpXqV6H#vp(72kuF=@Qf}v5}|yc zqv=N4;HCm`DGJA&ssrfh7g4fU^>oIz?wXO?2KyM90X-d z*1Y8JhSin8h8BIwyCw?DA=r`>NGKQwJRyP7I>o(v4nFI>h0ujw&od&S)n}Lb3_GVP zz_>5>b>?&6^#Jq^$X@1ukZkaRk-;SkYxH=;|9w*LS*AA9z??OFF6dq2H6NX^!Yo%; z+eU8;7xqonOLofH_q$glZ=Gn;bwn^fn2i>7^&n91MMx^DRtT(m91HgA$VAdG=&S2H zC5Xvj!0-}x`{CsK@t&UZ!5oM@f?t=XYYt>}DaDrL3Gb~_?~{HkZNe%gu!f&14IUn! z8OZ5N>scOb*M$}4HY^G-dd2ga#XTVc&wN4Je;xF%s(Whw1-}M5`UYe@ zd#1$lI!#+#>+`mc(d|C@ZRbo~eBOdLhMIXj{uJM+(%=J|eB1Qdx{=gTO>fy*)E*b%qp{ZWp=M? zI}oYaG66$m3c$w}Uz37iF&pq|(yGr@Gr8rm#JVT z2^FPPDwKReVnB1eK>poIhD2-EK)TuK*-zyH)LN?+4%M3gt)3i1h}ahu8~>$##N%~VvQ?gW3 z0+PQZz25Lx+}}!D&?UmG5BE^y!2i8iWathlIKi}~t=qYHBc<2bY=$~|7aMzGxFG(j zOCDsKtQ@*{Gu(KV+{@ttNoDd{$G1iC=VbPRL?E%@+)!4V zTJEnOpZ=?akRKm$A;+2T;q+^3#xqVD{lGG@WPNI>}U+x(u*cO@eV!z z92~Y9?tspn@|hGaI+SJ)qbC!nV(41~BMzF{= z$QGvjwDm?vDAUQ3&j-;cmwrW8Tjs|UgW*w5spM?a{vr;;nw`?tk|T8KOJD<@(Xrga z4vv|C`iK1$!1#pE{%Md;$yjIf&+exupp+TV&KLIX58;evb)M*gl--h(Oi82r%?{w^ zgI&n$6Kul~XxOeYmy9Zw?*Ci3c)|(CSH`C5HTQCc!l8?6uSPPfe1sgn&P|kLZHZy+ zb_boW-9(i)tTh`R5r9ww<)P+ig-Ve-&xZ*e*qn?>UWLrEAxq3CL>JwASgenU-8 zZW738*=O5v@2PWd-)vwZ&^Pua%>lF;G9#5N@}a$eNMKV=QjOu*hK22$P)?xYF@+}}+AGz5-P&-QuhdwM(DUF^7ejb`& z`OkRluf`D*-5ZO$$=e0$;R(o26^H9L$-HLL&GjCx*ZNP%h|J&|XSx!kEFbM1t2)B{ z4x$+>cDtKQ_e$YWTu3TXz*;((NEnfYP4xSm~FDTA9F|JNgsmPc9z z8(|F3sR-zKV*qqFOx>M;wxA0znMKNrV*Bw^&MWhv{sj!c!x;qUj1lHbB<|ZYNMK=_ z_475jC@(E*E0WzAT{?#@#x?j*Yu^C_O?E2$9rmiLx)y|f8QRJiAu=Mt+L$2(-6 zi{h~XLBvwzK;j4{)8}}T1;Fmwu=gt3zb<_PeTd$D$r^$b`E>C@JNT&#pX3wE0Q z#<<#qkpp_mM>-PcX-3Rd&a^6Ca z{FdDU5}|z7#CJujKwQAz?FdGlnR1KF8IakQklHNQ_KbFs@fbavtarAk$185`uB7H- z6OY+1Le8PGW4Er}xCMlhiSp&!k1J|Ws;5WnIw;~)9DwT4^7~b0#(_{sl<-cXrMdN_ zS5gtMvdTJL9xGOpYZwD(!bYmV-aEoFhdpr{)T*G35VWXQ&GxA_-llZLY@njdJY0JKx5~B`z z{6qIGtyBEncU$M*Um#%lV+_RWuNOYDdd7|VSHk!3vWUlsGdc-=JVhq!fvo>9E2p{S z(*7vOpefNUoeI0(^2HH?%vHhO4?s7UpH%7r{sc;iep-{RW_kH-(Q_Y)iTNQIhMb3| z6mWmE3dWzYhM&i?!uxnXSM6o;%l!B=ntR6b)YG769<9CJ2XSU!8hZqx7(pgif46&e_r&BdA#W8orKu`G+ z=3B}rdQeLU*pN1_>2~yjGzO19J^(2g1;88;Og(7aa$u4SzqlzM$UIueE?#+?Ab86E z-4$L@3%+5m1o5b7B_1|rkd`C7kE-~YZTP`I$&B2IqLLE=u@8B7)PcUVpHH8#GkjuQ zk&-L!fP9acKfU1@&9-nK;UNo;(6{gUt>a0)@jP|AWPkeK^w|Hxc*9IC0`O$4>Y3@a zw+^1Qiu|_`CTFMP*>llQu8L5k48NP3Jta}E7-e7mmi}-qZe}~Gb z^l)dS_%<+w{MN+Sq%yfJ$VQ;@0Mx)0MzIGgk8CJ11xjVLv*g(*qomhC@}cwN3$-2O z*+etI5dsUa&UtOcwg}hDPCh7&OEH3*ND+v}{Zw(!E=b4+LlN_ySx`J7N%_`?_axr> zZCMa*2(mJWt7tGe{T;!C36>6~+0*{>@Wg-`qLR3K3|BDJ(lX-w4pXN^Z!G%be}BHo zV=ZAyK;wBHLk7xp3l5XVwsv1BSu`1yyYn~Cre8PQE*_a7$dBcLEQbPgFmV5H+j~sV z_6+JIzWaE)k_tpqR^ENl1|50ovwEdRFpY5L-=tmwW%p#_+xxiccA3R;M8mGGAG0}SO$Ur_0baKZT9zkv3&1A=u4#=Rw_Cov) z1J_NH##>o;@Bhc;Y}z*?;?5bvbb?WvWidm-vJTA^qBRt=hwi*37595>le&JG{-pPd z|NBqg2>C%O!kR6ckutdoKnKN}p+Gu{o6!M=$f6&G!PzQT2h4GE0en8ya$g1)K!)D^ z=pIjSY?Vz{!Udvp=|V3XdVcCULJXAZnMW;d&F520G>Jz_rpsP02+8V~lu;~d&BY=g zFd#9({#xWM*qq7~q2DHiU|kd?oPZA05?FNY2ypRv@RWG$MxWbadc)_o(aWlyp@$rTEoK>&I_KOf@FhFg z8xpU?4=Uq#6XX*m0T=JKf`UKa^f(md;V|U z@;b9}QPZ(d7Wpy+K7ninR<2T*#u8Eqid}I}G94*3QCDC{2H*675CxpI8K8!0FPiLb zWNNkSnSfIs4?Xu6zJ7Dt^k}GO`bGB-QuQHOaGw7Wy%vP^WJr8CK~#^pLEIfM=B>M0 zYvL5ek=)?n>0t0#l+>z_*RDJ46Yr74n88i0t=6EHc05tFrGVzzIl%v8>HRkTmoCH4$LI( zTmJ1$j|SZFt*3ngx{o5-X&`@xDa8mbz?8Eg9zy!* zU9gEcuLP8WZ!(ra&KN@;Ra$~LuF5f)|Dh0_3|b89=TADT^?b6m(?s?SV4aLu=#cEI ztN^?<{{*B_qCQ^2`E9M92mNpQua#PN3mT+oS}XP@Khi#$%aXnY%nAJbT?nVSNSaY# z>ResbXZFeNu8$TBKf@Dj(}2gy?8l+vVFrip_bg~w9e-N#LgPAm_EdAE`M|}l*mI8t zf={@UjqX3n{(jH#1M-PMqnk-%LqkDW4D0WeO05D26DPMHE>Jq!jgLNvw>NrOs9op| zQNathkcL^GIasXYAJ9^19(3&)tg|Evc^fC!KMm^dR@Eql7+MSv73915aMprxLVf*}8 znrPend=Df7%;F-;6IKOUHhtLjny_{yP};!U_R?PQ4kyHBPzVfW3IS8VK`b0ttT0Rv z3*wHvYkhE}2x?%IEddS^$%>|VL!nz0C;P1lU(@Vgh0v_ACy+KboM3!unsM|dz7DY{ zg4vt-lj%FZ#I+zUtPf8vgYqJ>M?aJotsUs-$qs3vXP*SEK zG7T&E4)Or_W{MhTvd+2#sXLIFdq;)a&4&px$OpDS8%YtRIrD$md#|V{m!NGFMMXtH zK}B+qC`m;?GD-#s0+NFYNCwFaSw(V=0+J+yfD$FEC^<=x42tB;kmH=1VQ+Dt|KeQz z>wFjAyVl<7Oi#ZZs;jH2yPoH6+k=!-YfGs3vkwSt;dm=sc?9Bf^vCMJpktKy=(62K zLJygI`I@CGvpt-jMX$noXxV2% z1DqfP=~M`T92Hk-G5&jK<@0pkz022>kZ)@Yu=EP@HZLG#EbDv)U0xCK$;3mTB?h{CU zDTWJ{L(l}sQ#oZ#?L+k>!Hv)TfTqa`j+cHfCK!G75mda`%}1B6C%R}x{X7+}3N>mj z%vHfa5!03UKi2V5A>TY^)g!p62W)H@6d<9ee4^z?!(rT zH|6xYimnul@@YAs$m~IwOiwM@q)7_7vl|q6dZlLf_i^09ZLb25^F^<3V!`wrs zO-ybWv6|k<`m{w2PTQm!mcXSVcnc>=G20J7=Pq@oC7vxx+HC?a44_rR4=QLc@jVgM z?T=wmm);&}Oy6do9dz)tT|?hTHhe8 zI9+}0HO~Rnobr}_<@&2$047T@OCs95kw5u31*54y?S|CV*wyaUl5QHw;6LlRQ z^emaT?{!)+x*v3BC6;fFzas_Iik&+yt=b36aCuduvZ|>yjyztgyqHO zd}ZEY4?jpLYI}nK@*`nMU^Ua2`!Sqaf&hXPLDvE1C22djZ2%bF=yG}SVX4`i9a(O^(BzBcl_x^ z+6av|A_TU9+v?r*GZ%#>%_JYbw;aX0E}VMBuITx_lWlt)9^Sf;41xc>GaB&=xB%hwd+CpPcG0n6Q1B;BPJcN!709eQd zFiTL3=8rBLb<%J7?fx4Jcuvb|IKzJC6K%)mcECA{vlIuD{1MPqtb5WONGA%~0MNDB zyn@x~?FPuazwP3<1Q8+<=YVfF$DazmQ%uvS>qBEoU1n5J4(1JWi-xRT#-;Dh*Ohsl z);!o`5)-X6;ff91^{a44$?XgmhOX81zqexZhQ!IR@pA!JSa-mOU!#~w*&p+tE#X(8c}Z{&0x7R4oQwcIN>_D0Qc31Z zJTTZQKUXQUW<|tzu9%H5g=&>)SIsuBSa-VZuZI8`1(U?-^88BC#LfABvMg`Z+T4&cuzOn89Pz4Hrh`S(U8hM zw?w;-cM)yFJZtZ=nFG|J^&6LFxMzo*(KpNMhSp{|*8qbaA|Bja69pp~^1A>dEzJ;8 z(-o#p9X${C`G_arYD?d0M{wDNI!N^50x(fw9v|%d$TaDPTL4%%ZFWNUm6uccS~3`& zEl&bMUnysG%EgsDS{%yavscrUz5~#jt~)NKTIRVS9B?Z~4US-M1k0C0Fb`p^`_knK zpe39AVDT7E#AC?Mc#y&c=hr1}Kyg*uQ!hC^?{Nf*IhO;2HKvpUfbp+ zEt7W(9dQu2W__W|c4qJW<0@dO8e3fe(udy(fEWNM^N>?7FB8oImndl30Pf}Nv!x2# zSs(|i&GVjzd$s^FCh#0J(ZoKuP?aMirM1gM%}&A#lTzzhl3|rt_grb zhFvzE!_cp-)e-bX=w6c4*L=G<3r-W4G{H7&Z7axaEdTu*4LnTC4jBN7)YpOhsne+Q zvj`&oIb{X0?E=Zn*ayiOcDNs1Gx?-6<^c1i5~R2PmMOXhQgiI56(GsYxuDGGdnL>mkG<8S zGpAv9konR}U>5BTo^{?5Sb1eb@Ax4qQLq16(yWzHzbQiYpf$cixWZllGOUaQ#dpLZ z5ccgD zff-zQleuPT*c1_5)tT%vG4=iyI?A3@;

    $=?Ix6iCpFymlYrg;X^3|aO#O)IAI4y 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

    {zxz*jMTk=K2w;j!6WI}?S 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%0D=Luqt}a*ZUE;zCBY+ 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 literal 0 HcmV?d00001 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-04.mmd b/work/doc/通用机器人项目功能与数据流程图-png/flow-04.mmd new file mode 100644 index 0000000..a3ca60b --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图-png/flow-04.mmd @@ -0,0 +1,92 @@ +flowchart LR + subgraph Project[项目输入数据] + A1[robot.urdf] + A2[main.grl] + A3[targets / paths / operations] + A4[io_map.json] + A5[post profile] + end + + subgraph Compile[TypeScript 编译层] + B1[URDF Parser] + B2[GRL Lexer/Parser] + B3[AST] + B4[Symbol Table] + B5[Semantic Analyzer] + B6[Executable IR] + B7[Motion Request Builder] + end + + subgraph KDL[KDL Worker / WASM] + C1[KdlRpcRequest] + C2[RobotHandle] + C3[KDL Solvers] + C4[FK / IK / Jacobian] + C5[Trap Profile] + C6[Motion Planner] + C7[KdlRpcResponse] + end + + subgraph Runtime[虚拟控制器运行层] + D1[Program Counter] + D2[Call Stack] + D3[Scope Stack] + D4[Motion Queue] + D5[IO Image] + D6[Wait Registry] + D7[Alarm Queue] + D8[Trace Buffer] + end + + subgraph Output[输出数据] + E1[TrajectoryResult] + E2[PathPlanResult] + E3[PathValidationResult] + E4[MotionDiagnostic] + E5[CycleTimeResult] + E6[ABB/FANUC/KUKA 程序] + E7[转换报告] + end + + A1 --> B1 + B1 -->|NormalizedRobotModel| C1 + C1 --> C2 + C2 --> C3 + + A2 --> B2 + A3 --> B5 + A4 --> B5 + B2 --> B3 + B3 --> B4 + B4 --> B5 + B5 --> B6 + + B6 -->|MotionInstruction| B7 + B7 -->|MoveJRequest / MoveLRequest / MoveCRequest / PathPlanRequest| C1 + C1 --> C4 + C1 --> C5 + C4 --> C6 + C5 --> C6 + C6 --> C7 + + C7 --> E1 + C7 --> E2 + C7 --> E3 + C7 --> E4 + C7 --> E5 + + B6 --> D1 + B6 --> D2 + B6 --> D3 + E1 --> D4 + E2 --> D4 + B6 -->|IO / wait / pulse| D5 + B6 -->|wait| D6 + E4 --> D7 + D4 --> D8 + D5 --> D8 + D6 --> D8 + + B6 -->|IR + post profile| A5 + A5 --> E6 + A5 --> E7 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-04.png b/work/doc/通用机器人项目功能与数据流程图-png/flow-04.png new file mode 100644 index 0000000000000000000000000000000000000000..4a000c2016d9096eea835a22224d09ebfacb6469 GIT binary patch literal 651380 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�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 kO9lOC?_a$>m7d(hN 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%0A12OSC=`V*Rl#U@C|pLJ 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

    wV{PcNayNCYFnOLbo>m&)!e9i1#d9F?? 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π#T75Q;l$tF%JQ}91Mg0^? zGfekzf9((EX&F~tBjC&Nx_e};9kI>H&BeS)n+1T|{cl_Vax#??K1A5X`R20&gg{wH z)ESAm8*9XO`79&mG+6VA!G@FSZ^5(kk`qd54dNU;7&Yy2XSJUrP-# ztS?M-l?%?AML*Ml=1J0W)X2HaH&rll8Lq$RP;FmT-$v9Aqd5SU#|M1pxm5*N`}la` z0U;-uu6a6jO}?!EnDfj8l7!)%5_ zU6X*GPTRg|A)Unfsv#nsN&V1bKkSnFZn%5U5z$Rx8mBip!eu21_dfrcVO`I>Bw(7e z;P{{O{@gZqyZTQdvn8c}-M_YAf0Ss{=Y4M!^&%A`OAozyS*HIcPCf0K=z;}17cBH! zaU*2*lAFtan0D!l%DKv9cHpl+-0B_M(mJM6=UfIOCD98($_1eD3p`!G882tLf!nA* zns4m}%|)PI86c<1cxwp{i0I!NzN5G$Pp>pSXI|pAmstkG;!hYoDK|~cfixj~katQW9Z_e;$ENb&pTL(XJ z0_0AYy)Zi!q+o3|DvL}tfy=2<2*&^Tns42mWL=&z(!H$J&}50hA=!jPCEM2#+7s3i z4X`F#I=Ljvkvq9T*}ht#09$egTv|tEfri@*wl!9#IQQV3yVTQHd4@YyV3poRbBCaE zWdX*!eXWSGW=(tCdh*>rg$l6$2~2|7${BPFx3@pUNlQV%IgxpJIvNr+%7XJHQ&p|1 zji{&qS`mb$X*zfLe%0UDW_w^3w`nPu%fS%P=iEmrq{z>z-=gB$GWbcYp+if+p%W4` z*47{4o#71^=Z9eLQBVJ=Ie~lEb&q-NXf5dC^m?x03`Rs67#RJ>{sm6Fx(iJbpqMYL zb7}CP`z#$AylXA4at9q9lZVRZzs}3??C%YMf~*sPNRithtN_k$%HubV`d~MzUYFqh zOb}YS zt=D>s7v(F^U{D%8)K(N>oRrdZKQXa_+;{hLov`n;{&XZ>3eoHL+`Cb{LPVgsc9HAA zLV>toeC+J0lv%*+G|cRZSU6wxIA1`+_-#FvCc9tj9`A?-B@gH9K5WNIMh&J4{DQNq z6~rd!4Qd{1IVQSObka0m=`H~;u?zKXYMw!ULABD1fmn= zb*i>nae*qzFlERzH8@s{M(g|>??6t-aP@{Ef995+2G5?K15Act-Ofs|34d#^!eE^3 zn&{CznDX{l6PfXC4Tj9|p?C$=uTO&knA5#>#I`84&Q|J9xDEQ2h?p)C@6kTF6m->W zs%Sm6o~n4XeXHo4fi7e=n0TWc`cFw?Xu6>&35RbFlTwHS8{R%eKccE z(J}BGpFDfUUeS;`@|PR+QP&1$zZTUa;V)RpqC0?izAY2WZ1+{n)+Fe z4nV!_@5&A3R|l8VeP?k|a~_H{=Yc~nAi*<(p@hC7w15a~>GmYX0eVOsEY?Ec_Xr0`)4|1IsUddp^t8 zYP3kBq>+K#$q-gBev-CY7-l07f(B>?LK5IR)#H~HaT4-Cp z9c@7iSX4V8dTwBGfYn<7S2aRgM?VzXir1XqsO~%XwxgTcm42!-#bV*JV^1F{by%h2 z!X-t2CqtYcK$mIF7GM}O6Jt5tawJnclH%(PK+hDHL4qI3zB-EwbcjmaJl-I&K^mkY z2p-HtX|&tIxEL@rcQs+hW_yd0;|ra)e-gT)b%S3PsyLKG`2D0S`tXu1qkee6nTgnM zqrJ13?DbrY_y_V`fr@sW2{b9XefPy{CcQWi>OO_~E1Y_rt*{6dXCwEHUEVTUuR2^A z+2mklgrr1uvi;+2o$-B$7^$zGIu5A75#jBILiTx=fnqI>Q#C-n#w8Lvie-*p zUe%c|dO>5pv&jzZk7s&&7Zi_Jiq;gV39C4;KwC3*x%cp4b!2&HQ4oDBcOcbvAU*v} z16^2t)0=$Ai4Jo)7nv!+pq%dX8m@{qVl6FNUgJ7)Z1w7>jCdbR-pat}q-YtVCp#6w zYl3XDW)$U-8?a6NEcC0TQAWywNQM0|+LYqiB5tk)HF1SNT7hlxZb`F~Cr_R@f!ZvE zdK6O1aESe$WnwBpJUWFN^l>at5V2ic47L`T z7KE90@MVI;(j31S5(dR|cY@7Du<6GF?#ej-N1#6Gi`;D8y0~?MGsT!1UU6@xHRqM+ zs=md*o8I$3RJp4Rn~O_(boGTSlH)WE6b@{iSc|6V+pemf`Q=5HR{`kau{3??Tuk{`)}Z+tAF+`t+rrO`%rIx9*TN`( z7fbAdAhNh*Wc+7!ClI1{PN47Rg;O4?sh9gAV|RJm3s)U!NFPIV^U<{!WGUOV5oFf- zMU30zxH&vg1c9jEy?giO!-va8#e2Ms9t_mxd^z;<$=Z8Vrf+|_oED6_!eJ*!)=9q0 z9Bo)jYA-Z>WwQ^$5@K6VEnTQ{uBiNi>q|=|1p}42>s3PnnWw-0YvO2di zb_t~i@nn6CE}ph+2^44rVChczqzL3d+VK(3O~eBQ$L0Q$cyQDZh|^#9A66#0S;*lr z`0F>tF;Nn`%#58>pEqwFI#NhGgk9Nv*|;|CDRBtn7);yRLyIfKg`e-ftrFJmK0WSj z3qgM{L%nD)BNBzziU;Ywrz+N)DvVR9ynlbD$7@K1z0A?WEEIkL zQNf$RL3`?qzE)p;#CV^R;2RqV$%R#0%s+elH-PtP74AGBo5*_`m{YmMwYr zi7P&a6HMPRh7l~^GNz|kU=Z`j3c_j!N?orEpY=!5+!ep69>|{yY@6ZmZOPY;rsdp; zOu-NNh3#`JjqAmtDF0b>Id&oI^y)GX@fIXZ_& zG0Hp=58+b3q%7O3R&+0Q;d^(2`9&Wu38vgcp%L{I!zkImDSkYt(!703y~NXcA(dF? zx>RE#D7E&L;9BwDkxsp1rUxAfj?SJz8d*95e)pl27v4JhtKiIKXSYfDQ=Y3RW@|-B zIx8K980v~MwMbbM4R~XGQr0UWmBCMFfk|N*VjR`CFX_~Vj6%G${Q{Uv7k-y(U0?Hb z8e;?AcghY*N|{)s!e1rq6Y+VKB|aQWOL((8wy6(*ehn-#Qh)LK<9`BHOBXUkK*gp~ zH^nroZ+al=ef8dT#Tf;jd8s5PNORqHw&wiEQ~=ur9)@y0?j)KjOQ(Fw1^fcxSC|zF zB2p+Db`l&^-eG`fs5>F;htL5E!g4_zURyx9NY`0^wm!{#t+cdLU#7_S&(y_r+)kzc z!^N=P;VKEZTk~y#{D|uW>lCPxjnJo2h8ga!2M{U^G$RQBs9f^KK z+sn5e4*3UuzuYDX?qUz1y~0qS`U!*Bemx7WncyeM{QI8U9_xkg>hGb`^%uaP8%9sr zh+MpXX2g&bwRMy|Pzd+Guy4y~{a@e@p_Y>((-r*;d3A|kEA-Md*j_C_+vF|jP4yG9 zAPy;?bWAGd1vct+_bx(z1ztFR>yP$k9Mn}A+QEA}Rt1R(wuI95jl?eXJ8@J~Lx!xD zxDh59#7X1PV`}cS`?dN&ls({{g~ORwvJ*`7&}vM&`AW*u!6%=JA8UQTO%_4)1z_BH zR|9OI9;(v$x1IHjdeiqFbWBF&H6lW0Q^QwKn^a=$=*bef-EyoO@+tkC5$+YL&#En0 zDsO?I8m*q^PW0BlvmyWUzupa$5;3LzMpU!-$nc(sOh{1VU1lc{x3H8Nsd;m4^LcVf zznjGLaj7s45_0R#tptACg1*-a;WSmWC^0isqrNB`6^#f)K z2B}P--F#&Si1fi*U3Vm+2b5-hIN@vqmiG70@;AxgYI?A1<*tUmX9fjsTBE?f$Q9%w ze+DoGIqCx3V*Gg9ed5N*JHa9odgb6KOMcnU`v2@nJrgmNs+S0vxvHCHTO z4wn!)1kN&)+^8Ou%U{ay;q;IQow{t7(|1pLtC2k?&A z_~g+ea-O*NcLj6Vtq62se?a~K*Nsd4&%txOu0lV5zBiB;=t=y)zrC_hzAV|;c0&rFI0qv__(-|(L+Vl!dZY0f zr+9ta4#LwHl#O0spbf|nQUrR+}2O(BKw@c0*_jAusCB47$i#}?; z2BK$|zOwz|kC_cL?zkcE70GvZO<*#yp=!F<)2}a4^4-#?6~lS6L`9yY+2#ELM>L2VoEl$OE0B{8V^)BFb3LHi_BgjzmaV0wMR9Iv6z8HCVdS=W_dp!0pm-0Z!yRAOD@KcK3Z^)<4=gde>u>L%uH`Kcjo{OZ1W z(*%r~V(v$#=G4t457PKL*#fZ%z1Hwc+@sk~{Zzoun|SRuALpNaEo&Ax!|VygQs|< zih%0A3Gt!Z&sY8^5SP`j4o_p;&@|Z(&d&ro&EX8;lf{=NVn7@YTx3$}NN_gz9fR|s z&7XWv>*l<4k69APxTIn&tL#7ASRQ(GDg0A6E?T%S1&*@cKcZ)_*ntJ-34IvmO(3B1 zvx2w{BrDLv?WD{pr@Fp+i-?h-C#kZiC84Q_iGeC4s%%rTg$V=RVCAY+CK!|s7xJGM zmVnM(^`fF&L>A(yJ-jO?-`zEz^M-_B>SQsJE{L#w@JM;Tz)&H((=(@_z-MYeBvvDp zkKp9%f`yAzHkG~e)o39P9dSacj@Dn4f*l5?9F~RtCW-@xOgtkQ_rGtuZDr{b?MTxM z9dBSyd5Ik_`GyB+!=xq>)5JlBFTX^@KEyL}1|*MG|*|8#{@2!;d7vlORoqnEH5w%7BkgWua;E z=>7Du#|AQs!oI8sYi6EvY-GkqFN*gAPCoySR_L(U|lN^|Z-fkoldi8v8AS(;;GOcrFU}7V6 zJx%Ox=8t^YH*G4j0~Ex!IUx6FTQeR-J_Hb3R}QC|6eUcD%1`kMG{R zc@E+|jpdT9G4Pq*$osj)Op*}TKqo>2pMswdEP-|osXLmGOLF3g2OgQm%U7yONuYh8 ziV0#H1u-Fl2=bn;4O1`$WG3Q)8dHXrx@GD;ajB1Cm+T3z#StkOW9K$yGbvd*dT(U1 zwEaWqA{6=N#R5kHNPnJG?PQi+vk|YxeZMnUm#l#1bP_mWrTA@Eo?Ak8CGm+~vSHPC zZ)pZoI5mt$TIzu)=TMt0$6H<7?w{Mf4{wPCXZdpe91*{(NK}y?Fni_5Tp|NLE~uo3 z89(`(%6Bebx2_MUzV4rY{&YtRV;|s&{(mw%<8$YR@OWUQ^c<;o%4nled6W^g7jTti z_=Y|DHJI&<9u?4G>T||beEE1g{1wtjFtUZ4StxRe2hFzx`dmG%S-_O{rbZwES`Kz}72qp+ZLA`AO`~qFD882&oZ439+`SZ^!=~K1^yjSg<_M_02(YA1B4b#t0 z%V9j%#ecV5PM8MAug*rdfB^P!lYDkR9ud^zkmVJPDB{dr|ejr18 z|H4h^!CABb>TfR0MP+%fO1`Jb)&msL(YE}>kuih80X)*>&t+$b|I_=?L*xlfvw`Qs07|D!boW}al9h33Q;?hY-dU3sS|C8Y{&S1c1d%l9O7nJn23pa-r8 z`3v{JFTQ9^zc$MagFjL0#xrGWJ2n4Lx0Ske?#8_RGI%N-a9qXk#fqF z@kfK{ORF4nu((Rzs+t0kF}68~#Gy-AAmcZZaK`f9K%CJ3;c$olz(A|T>T zlj=)flYa=w*UvNlO@!nt%RDChIQ1 zh~rc^jq=`+`kr*}%a^Z6i;33)CS;>U6o>hT{CMO=;!zSTp09n&_TutMvXIJA*?o@K zuTqb8s@!B8Q-QT1aa-AeJBlZt@zN5mST>76W&igr-Hml2`Q?me!{a4-|A7Rnwojr1 z1O8N{hdIaL*rZ*uq^uU(Y)3^-1R^pu5s(D2rt@+x}!Vm=|F&Oz=ih} zQznvl8W_cao6l2u&^9Ic){A$%&Vh&$7qBuon#!V+p6AMOOOqYFp6nSjZ+wqJ`SR~R z{6kTd%uuK*=S4{vG~E1!e0+CHJz$MUMku?A(BJN<(%sm@A=n7G=^Ah0x(3_%B_4q3 zqfur3oj)6^8?@D;0C_Cn;`(j!)3I$cPKMtKD6EAz!CqG zYKFE9%n7-K67SGmjps_ezFxsb^9Q|=qRH?sr(^LJ)4TTntg({Bd=?RN%9)yqv zpu&0T*9AuJqWM*2Kun%?NgR?~HLgqTQn$B246r~c_&#jQeEW(iEa33-tz@(W=$Qxj zm?C2m$Ez!vp4Zal-1=sTRE}=VUS_*z8Fml_qVwM9NI7;{fBm~qAXIvKaH(!3Gh2B7 z=Hk`8QXnoGrwe~dtw2>hm>;r0ywZuiz4R3V$?V~m*HyIr`^zBeU+4kS+(V2e{JWpk#t^a`;`@BCvcAY4Ei*FR!E%SPHZuyxeBq4QBh21121!ixj_I zq-rV5KCz$|dJuDW!QW872u&TM&KMM33sS%WVn0u_D^mYk!T{YdIB-e}f_aaDZ~T5H z_40Gmu^r_Szuc0-r#gJ0!2|9Ne7Bwe68Mw}n2-f3&bL7as-g$B?2o;3Dd>bB z?5ofS{@B})p@7Vz8N!XvC{7tOew@8{t~YKyN^UCJ@GdHC70gx}mz;d~3kGJ6x82f` zUHz>dC%5<|!rixMdyyD6A48H2O4dku-a72nykPyFrkQI0wo)-RKG4 z4OOiEVihMl-WyWiIdH!%RP9cHzn^3O7cIGzy{)`jZ7$i^lRG7}3W0jyvhmyQmNB5- z1J6JagC<1iKUZdPrc!?GeU22v?? zjB$|#ccNyR(J=%Pd^r8Z%Jvr2`|-YUB$qEYg^hqJcdRgc3x?Z5MR*o07v3Ufd62xp z892&SejUSFL`J-1@U|-)OtM#c@Y0p8lh~ACGxbz-?mPx_l1o3&{|+(gr6autYqyX9Q_#p)oCG(> zkbj{oc^67nFlsdFvD8N#!f;N6X#O1@z4!an#!*ffYYCVoC>VAY4rL(2bpIXv$f2k9 z|I;h$l|g&IMP0;rfxPk2bvejCc*kYhOVZJ)(t@Yq)X-0X`Us+mS|)w8frh}1&`afw zIh8PahFxx{6mrf6$U%hJdyx#0=?n|d@`!aA>*w7%>bpxWl7A;KoISKv!#T}z^f5Gm zd8_P*2$hi?<*>&9p76_WivViJVApT9Ynv@;9ItTn-aTE|h`;U!YDfZrt} zm1*JOE{NXB-`$+LW=M8HQSgLPDINIzVc<@rw}7f@n%+7fk;9WCk|)jb52vzo7p}SM zsrMQQ;l@+1H8w(T{8HUZMQsdt(rZ{uD5CEy>lYYbC$8!|{DLv()~)A3cE!;od14bxKx!t zdX*SqdtTc|4c_$R*FAdn=mB~PONe_Q?Se|B$l-Pl#?DT{Y^)o*8mTHT2=Xr2T>>_O z&MI)=gdv@&iAgP}Ko0`~oJ+J7_Q3{MU?HT)@D`k(ecf^RqHt{u4)l?zve#ysz-@Rwg7RbbOl)Ko(42Ha?bTr9q zwv)`}#PQB~5}H(Sv|o?h-nz-Gzy>4BCHs7dp{?pg((KL7pK8{L`P#ojZX!*nO}}41ncm>&!~d zZ+N7Wt*XHZ_5T24kC4fn0}1?A~f8VP06q;2AtLed=m z0UX>(CHNj|*a4(Jj7}Go;rZRfg*0S%!U11n3`5!Xz(~#SS)0mJEFO#}IEu`lI=uL| zs9pmTEzEEjBFtlt8e+KYK^XFnw@1L=u44D@mm{;9i{SR+0L8|g+84MZOHLlX@a5)3 z@Z3^gwcJ=90rPjv{#0(77W3h$zAmzxs$w?}8AubfX>%c>z#wxTj845cMYPJWqYMB;wLO zN(QrARk?}CJb;8q8GqewI+U?_=6@Gyz32@YH6vQxDvKPf5TmYr;{e0b>rl`-D zB zzeeu`t@g4|ic7_7HV#@}tCuFmn8i$2X}Ufu-F~iE6$HP@=0*R2B8%(O*?p?!(MNI9 zfQ1WQ)Opf>;Gid_2KuK zDV%XSQr}6b!iP$e8s&9a)4hVKF-NB$n0wGp2f~#%RaQgLnG}brMIcHuGBAftBRZCM z*Ks4aRS@LoTThd{0-PLKsIYdBirC{8CWd^gi1Pskk}A~vdOx62yz~;*Rur&E4*q~L z6%~gG(w1*u7KzwNHF$VI`r)_{mCRJd!G>dEK#~K&62UYl}CnLC+!{p0kH0!6OQOX;~n}_j!nL#;}>_$Mgxx zUnK{Z6P<1ZGS*gjGjBcqfi66eJRmE!vF%c^dgOlBO%SNqfDSTq^Z81!B|Ju|Z3l2g zF=OI{7=Q5O94KZ#jkYvq(yE<%J~-3`#*X3neD=0?`>Fa!COWNXWg(8b{v#AFi6Y0^s^ino9>#)-8z${fp5co z#w#G8^?Ue`?X8Z!<|t~|u(NHU8Z`TgE4?b+i6_6XUKOf`g6+=f^DR&JMZ0oT)cSgr zO946t^E_+pBS$)8qIsu?I-Zc(i>FV`!9FFxh9&j5+-~i@oyvJ`bM)v@Ok&vKaf{#} zQ$k|PVdRx03k#)lIe=5=STxQJ8=ArbbWyO}Q?hMAyIU1j(1?YS-&O#8|2lD)e#L}3 z6gOMJ@WLaQgj>W`lv;?~UkHtkW%brhX{*poiRvy)YuK~D;`i zuW!$=7)9{>uW`{yvUiSn68AB8Vmv1@I(dDIA@l7YXs^v2);r{RHz>8d#gdL15iUb! zb{2JsrO*YbYtb$=1Yn6MZu~zsgD{SBovmB$Mjpm3+<0vt&{tLh{S6>2phS@TTbefIV|E>=Kf7qJ&RGYNcJJu zH9#Yx`&D+gm&smO+NprTD@X31UKuJmy)1-o!1U?m!7Cn92~EA^5>+>sjYOu3x+`?Y z)!OCP$#683=;YtsEjIua1?fap5dAQ~_hOS;{l;W!stv9XGq}hsmG4irBWKKxA7@X3 zAXpEE7bePq6oU(KAkh=9r-1nv9htZy_rp@h$)VM_nr`$IZ5pp?ys=2ss7Kf_KXeK$ z7#iyY!f-WG+j;T}8QMYY6TafEsn+?Oow`~b72`w7CkE7kQ)!&4qFwyaJ1j8PswNIn zo`F_6VgdL521(@y@Xze2aq1{#PSkt=WrbmeF{6)SyX4T@+YkevYq5Zh6~9ZimYBQ6 zW?U%3`H2z4yc)i;cbhSW86vUauzmxO((gCcF71 zxck*-GjM{uc@2-Tnzv$pH;YWi`sLuzs~LMJ`8GsLSJ7&+84!QRs^fA#v^;h~0)Aa* zM@QKbWN`U855@|V=L44s8zZ7L&bSsV4m$de_ z*0s@?u|0f z|5zGbhoKx1;mJTXfDgM#~nAQsyf=QDGz)=VD%;$Wq!Yi9Oe@Fia;0R=aL|md8I>HNmj# z9V`~CIv8!@xy!)rNWeml7)HqVkmsPc8=NC41FH7&^TTL~Nb*wwixe1q5xrMxXxM!! zg|$klVGa>^ZLbq_dwF^HY1{>447ivQ)|K-6sirhg`|qE!F6LGZ`(q=FFuAVbyJ+#2 zDd2kHGRFY}sNmQ_sg%BoduDPLmUV6YyA1U1d^eo=;r!KO&V7YD>!+ZNo}J>w8k z{_){1k=E4)wbC_Qg`K)t-~!HV4N?*IiIX-S{BoO4P`CiuI;V~(VT;;f5sB9OCrv)1 zl5?@GPS7`6}aur zEqTHexMoHMVVJE|p6C!302H6vXG5jj3=hDHD1njCcnF#`!_Lf~KB+x8)xDWRco@#z zW8)4jfZ0+SudSJ;tO+q%qt-Pr_<8U$^Y`#e<5`UB=H+wVhOt!ayk#L8Qmldi8ZxmKv?8FpMN(>4%f zxRBUcy~q#m6a*_+cSlBZ;(ua5orQVawej&70{a!}N}NsIsm>*BvZ?I#s_c6JAUEI+ zE253RvS>|%vf-IJH=^` zFkQWwoUF}NZbwKF%xpy7h|VCrwWY|o?rcVluF9rv8h0suut=4Hl>OcSlrfV=hu?xf z%Py@f7le374KN%ww_8m50SW^}oH7*jZE+EDA18oj`Uybz;ma4F=5q_QRdAj)#2pFC z6`rlo6Yyyg)RS?04j3C#@S2hOaIsw`0VXxKwie#s&`JpKtwGM{>~F;@0Ij#IwVF{S zYvtqxKQ1H`8bC`kRh&AVaZH+>uoq0amp_Yp=#Azqv*U1qeL}LA0I_BflhIbxgs#qk zeND7$YPVN8V*@<4<3I>|rzJyJqSw{I2DePzfOQno!mUEsoi#{?Bo07IVVK{vL>oqLUzVyrI)ZbHbn;uby88T7 z2Q0dloW~C%bb~8j*3{M|Rw9E%uIh~19Jp+-tNh8~&KD5MCj(e29s|B|BKPjZ40?;jG7Ay67H`DGeu}{2-*pgn>Y$UWjT?_Kx!T! zu=3kCs--w^(4`jl0Q}EDTJpD82NU5l`3jAx8ayz6=;Ec z;o%Gz1U0mx&27LI_7G>_#sJJm6(*>+OB0XcRYJmr;zuKOZW9+}jW-kCvt?!Hj_BC7 zSN<(XiA8b>Fg(+_&NbdcJMgRooxL3uw^i!KanayE8k!YHIuy(Y)KTIdd;q!KvYbB; z-x4`hIjA9BCodNdpPky(9(2{SH^8X6E}?aMReq{)xCAPSq zz>~mKcbGxVOSOK3!Dh=Jq~9gOY&=9vaJ3gxQ_QP`Etr#U@3df%wlOlsF>j4EQc9ut zj6fh5A#2Ud%rg0aESm^Zpvj2?uH<=b6=}j@uEms!*zFbo(V8ii(5CXk^H~j~iSz1M zHsQwpPwE%)VlTLyquN=%5~}F*l1ASKVtn1Qs-Yt&;tBj=b-_2@z55hVH)=yaFtEp|i>*RJkU1I;kPzRUG4Dp!N>iOE1)IJa*gVwh^2c25B zf*=>1-N1kT*=Jf}aQ6K#(-mm376;vyVKkcwYGS=zcjdU&zV$d{NSKa48=2|F{7E^Z zJ4sk|E1vuYCr9)8H>^#P2-lplEhaH9p7PcwM@t1pE#mru&NW|$T&`luaW@4p%*Rcud z9IQAFxB`hzBN9Iq(8fs5WkAHTA7nuKu}K7&%7D*kSgc#OZtvNZE5VM?BD}zarJJ7o z2>;Vzxo)->_&H6sb(LD9Egli8WC{qEdZ=uL*n3ezc&N5CZl{e*=J7kX$jKmD{& zk0SQ+X;Hz)5r9b>2lf(yFdtgL+Kmnu3D!{v5C4P39dS1Q6!Pw4z|Jv9XYQfk#_bOd z2uQN1cy0aSV8U)UH@Bx-=E-||DQI{8YSTqyy%@7LoU8H`u*zB*XDE0dFk{q5hLLfl zo6glm(3sm%g~wJAe4s6yzNio;G)@y;eKy4VqmK1FHdAKxvpiX0asSJl|A3w;bms%e zAn9cjf8YM}s>zL*5Fl4Y$W+MUqA1LK?JCYz)dl;Z_k6lU3PMOX@>iH zvMSdb=;_UMowv+ms*`tQ4bc+HvI(&Zn2?(K?ZC-8Yk>&Wz+f3x5S z?VF~v37sw!QVSO?g01kH$%&Egvuq)KpjA2nmo!gjT>b~XSv%oM;nv=s8krmg`be+u zOZ01QF?PGyMyC{ypI1G5P=}?CX)W&_d(c7qPOmsAT=gJI4eLw^n)qdphNZDYthnw4UPC)LI^z*=>7-eG2I2A97 z?J>`OchT-EYIf2<>eyYkX>oWGZY}q-!9BME3;2!{@`1{rtIM;b+kR|9kyAtI0Jv_Oq&NtkkEX8U)m^{G3toOu=dRc__uF$wO4 z(k9=!;#AiFMlSkp)<+xZa_<3Ls1A*_IvT~CzcAjep{v|=FIzmxy7YN;YRcdZH6Lji zYv(3!8&iYuDqKgFZEB2-CG35r@{zDF$@vqxb0cPhhcP0dp=f#R*w-kRZXY+%t*yJc zJx{Ul{%x_8z3Bytj4bbf*^AGz(MC{(7f386@z(URHVG&U2y7w6dPUdX@Li5U+m5E{{Nz1?620n4A5TeGrQ~~(~ zutvk7JvqWu1y}zh-Pr?cVEF6#0}oMZw~i zMgUeJgAfm6tfAfy&19%Hzww*4|1G-sRO1)@F(%q{fA^ab;m6|tQnkSRNUCCm;Lib% zp2Q_!f=!lBO3z7EWit89)ZY$Q^$gV1hrlT(nVg|Qqt~VB9s~4|q*m3o;qBDd5cD_H;DrAK;(PfXN>czZp+MADtbzkqpbQq@>ZtGmXgz zB=9HPyi^U~FLr&hW3cvv!7SoH)nGYN8F_3OXu3!$u_~LuBTDb7vd_BSj*5kn^|`2$ zZr6QuyUg?WRsw1JA%iS{rR*;rTV2O5U0eN~C?TzkoR%0F8;)@#6X-uG=~)p!0qCXX z(75+p_PQieFeCLm&_9gIkL0A6FQm=!6jmL%f3kbAVsAZ&q^2V1%H~A74RsU;0NlqQ zIFlHlC&CuD{1u!Dt|`a)EmaBqAIRng99}NT_Z^mK1#6Q7gz)MPGZ*XpkJ$0LzQh=~!f)dcis@A2@&#$Z@yEC2^kL^cQpaAzeC(4Le-KEO1T%68+ zhhxui<;1IPFpz|o`j!HKbb;&58b_j(P8Ew5?N%K75)RL{SS**zmH@LN+$Mdl4m?z< zAkJP=9n(Q$t=>?$1)fWC;1zU)=Vy#eum_S6$n01yZl{3Er^A|Y%)x5HpIN=o?biGE z+`1KSf&7xPCZr!E;cXRC($YkBx&Wr$lq$tNY7my|Sq*6G3oZPFBio-0T%O_yXNEZ} zB#daO6)RW5n_jzb(+nw9irNIvg`SiV6aJki{|PxZo!p52_R%RoEu$zGcez@_L)D-a}4nKE>fA3L_>wey~bCR&J#0F8>#A3;q< zZlT*hlr=uik(d)z<0|!mzd3pS!I!K=ox_xqFRiT_rciIf=IbZF4X_VpeYp91c{EKG z%IoPuiocQ<;eY8B`0bzci1vDS=%LFwE?nIc`WGfzCIR_^m9Q0j#|@hTz&0XH#BdU3 z(35;-82zrlnI>y=7qX~?vHfW8V~k_OWN#2WP||+)t&TzZf-W>Sf63_d4)_9&43>DJ zQj#$>=&SWs;Gk74gjkCFr2X@=+sO4w%?k;Mr|W`N=HAUem)G(cUq4gJX$Sp9hQqssv1-&f~u$7DoQvkON6 z@iM>M+7K>cIk*L0Kd-b3ou1NAI;-I>|ufMKmy)53I2FM2A8w1Vh0EZe7aUn^E*i z#ah>K{0ww{_EQB2r^xQj0NZ^6xViE9(tSnwQ;#11-Il0-sMG&$S%0G!{r>%m)x9d@ z+)k?Vu09z|--3x!1dMA%kI(JhKaNF%-a`Qj)&Ma?&^Bt-7=e^75J<-tZ-uN$>kJhV z7KN>08PiuZxs}~3(R4ZP#f$s+tMe#39kP~)T#mBoPV@)yu>+l%M+pfDP(Pzf8s1(N z`34?uL#6S!&<%Tc!BFjipWOr;rIKJq*w&KNqjT+vb@ZYXaaou^#aSv}dVLn)IL*y5 zPeVf6s~@2c^<6o15#h6i*E;1`B{p*~b_RKGG?GWO5SD4zIj$(mwf^z}hP&2`u{>mh zkkQ8i^IDgxM7m|MV}iiMU%oy4Wuk}c5G*SHLYUA8mlvrC1w5FR?c*vdh#rmo@!Ew|`5RE*8_LVfVFNTqd9kN@@`3{QZC1r`k9~%q z2BMiCV+h<7+le93!Sq>Nz_hECl!74}v`B?z0@eL;|3MWlq`RIbhqZR&sX^)=6uf0D z|Ne#un4nq>JO08BtF)D`qM*Nr)&zYPc!fXk|U{n-<11Ym0^1Jv7X^aGb9l8Hh z(So=Nc=F8i1U}5FjAJsM^+aj-ZVi1=`r_aj7?_5y?o0<8kdW0L>`;o4nYkasK+L~> z3N>Ik5%~AP+w;nQ_znF1AMnoR3hdsweeWA!41C|MkbX@V>g7X{g(k?`e<}7xO<;wf zQ*>A7U=}|JuT5YPt@P(C+ zGvovdJP7HSlo;otNxSr|-PLrY%;>{^Uym_9!Yv*?K3R$*umXim8}&){?m~B6YC4>9 zi|*aH@d*bw^<#@yxOqsh))31O@KNV1GywRujBg>BCj0FbrIa zqIx-fwh5_0aWfZE*&@YF*aVfw=Nrk-N* z=e~RZ8vui#aDl(`-ktiMCflAXHvm>eB2pK8n*T@Fl?T+AzU>oZr-n+=HW(@-Sz4q* zma()cqCFwBNgLXZK}iTjXeBC=j!KKPXr)vLowP}t_I|Aa)jF}0gBF*MFys5rwkC<& zzP^2^f^224`Bzl;U=i7*&2Q7TwJjnGzCv7_6auJ?eTN@}9CXm2pt!AV%2mK+gvw2Q zaP}8Q(@r%jhtUx=u+lFh@(6nv3#@EA^+S7(XSXM%#pROzJ+zlog-b@(vORZxcSrli zI;{glvts<>(2hJ$^d!VLwCbB-N=wBv-(fow!G+E8w9d z%}kTN3u!RCo6T3G={7*d%9C`##9KhptJUuJ6SHTt;%8KclgK=s&@u)En99*q6^i_h43Jmu zFDBGoL7jL@3Lup3f=5(j^;eVgT}~RB!?zMGJ92#fB?-h{E_$vi0#YR+3p#?BQjW@bpT1487Q1jnfhn9X-(_ zP?yp=0SD0E0Q2&{c5voGaz2K$zXF>VT%JG`mEd%^xt$w{WgK=zHLnfoBOxbWPvMI_ z_F=JlLpKPyoFHJ2DMGRDf_znfoY=jbrc@3ci|=fiJz88DW!mtZQ6U~tp5hD2=2fbj zo<5pW5kS}87icz_HE+`9It>kuMKk!PeptSo_jfI=-yR%0-o)Gx7kENKY`I;yj)sP{ zd1UO1u(+J(s>c>Tkp1J2;P3RU)34JOPoKVqYer_xs8Red566OAfA%@IG_}NhVSPE& z77(j<@L>}Njb(!7H!$H2&j$J_-}E$QQmqD@0&1tfE5ly=6e0NEozOc;=bbzmR$vXy zu7m(eCdNDrJ_lYmi|94tL|=?1p$%vO+t^Rd{6Tp54;0Y6&_lQ!EI0zJ1^W}*X9FI_ zKh>_-*HU*O-8=O_6SGi`%d0u;dY}9t&3*wwJSe8j2BmU~ST(BAfzv5!9Q`Wk1b{or zArThx(kZ!7=rO^h!u4*D8u{NHjD1(@>#~eyUxARUnpju1{dFdl8Cmq608iZEzQz(= z;2!Mf_17KfLIHK+Cfq8QPVb=Ka$kTsf(E>7qW6Z5u!;Vjx`tR7v5Veh;yWzX_+u{x zB16UyD5GKq;6X4qVQZBk&KlHR$Y)TmBGLxbQo&)6r3#(|39-vDv9Y!&VE%Fjb5YTz zH9rKGe;Lt*qb?km(ce*xjeJNJhfTS}S8NzK|G`tyuBXVxPbWDWNS*x9X3iz+w49EB zCp$t}3cV~7C61`SMava;Fq~o}3eg>jxnq5;G=>m_Xs^nmB(lN2nLjrLJ;<^}>|SN{ zDis84z-FX~1UjIT?ZN3kzyt6{c?C%$g|M^#F#D^zFnP|ROJ|M(*&EfcXWdn69WtzdFV|+!36QNe_V!a zC&Y4;nV`3<#ymcJw49UQJw)B2t>EiC#`F~Fmo1LBwPZ9!q02)E4d6eevUBt zfhQowcl6zzxu(Ety}d^qi9Ujs9^z`e?^D0mlCh{r|t%S|3Tv zw3%rIfAO${Aj%B@hpMBd#RE$${*F#zN~nqtb(ZgY)YM2cwP_oKn-ai5&jA?hPKLxU zXOKn_@Ei>BDE@sDv|3NZJNDZjv`a$liTY_}C|D)vh>;S+lyefuAF0G{gYJ=t@>qN2 z@`uO}Nk5Pj;G3>5x>j?v%;D1si()n&&xGDp_T|)5$kTAg@}8=Ab!NQrE(nrBrf^SE z{&fPpLj9d*yu1c9LW+*z#o}#najVR-FK0t$L z!I&nS)VS6JNO!k7xf_ z+);XeY!4AhS-gB^5u?g5+B|#wG5iJL=`MGr;YDtw^%|Ok94y^elk9WF!!p~E53W2I z{pbIdi2dEBM7RaIkT*0~*j|kGO&53n1XzX};65oIK7`R8*V$qZ^qC=;&4%(BG}gcb zBti=$6?G!B#{C~XdIZw-ukPWZ4`7=u6s|`zPem_n=0QZ^B$)T%L$)>M-In`+Q}<^_ zlJcc2cO;l>EP%B8fuuOed?&&lsO5t4{1gSMj#pg;#EhF~eSEYQE?_(#sEmJMHZBiu zMcPt@DCK>#PvIbbhfw!xuFsxeOF1UZy}5--xnxXWLH{-AuL$BT^vlL*#Ds)s+|6BYPq7Rcy)4$+YH6M70MaE{Jggv3?<1 zz^P~_L4z#U~afZVAVb1zWD_OlwQK=9?UjW@Ze~!3kkN`&DFZBxZ8-86&#dtjq zqiG19>+9=tPGUDvCf>-85Vt{)Tu*x0)vtj>mwA^h=}Ny`h2W8FqS=@+2goablDQ^~ zq`ZBzEG+41=cm967B0q>r1wRBWtG1iVcRPd+;9_)xB^mElQ997O;c7|f6oLBaE%+1KGc)sIN~x8cW=P8 zk#<}Yl#9kW#?|Sg;acJ^EX&#AK-6C+tG8yU90INhmV#jccvA;a;q3Ax2d>&Tz&GcO z%Q)AT!=$3rGsq8Fd+>1L(S0$6$qC@p96S2IopLtu{nLm`D?luT1dDXL(2SbMg4Poa z6{fNK#Z!k#6gGYaI$Ocy#K6Q*TS?lDiAm(@k+2fCvS@ zGIk76WT455fdq-&{r~K`H6+Q3Lhmm+z})9J9HJtFGzwxX061rQ`0$0!BUmEqF}1~D zy`%GY>oG(TWC3V#hoCa!;dvaL zSi8gsEurhPwqe$Ibkw;5_y8J$t`Utl(p$vP{ND4trluz~LNGPtS7&yRI5PteM<390 zU`19^m(YFQ(OXO8*lKrwUu^6%X5&ts`0!vGL`fWGgQQ8aPkO*UcmlvkS?!QAozKTN zvD8idAu&G^XD83=>$Lp&@mn!@#iQ%GGG_@i+O`Zp9Q*pXyA%r}yA)AC7U2?uOZ^*j z3PBqo1@awSkzWHZX|hX`AkzZR9u9skM;1pi{Zx_se$jjN@{_8*$pc z5NtykTXhHmj7GkX9zN`DE?MgaP7@;=uDwLV(C+sMCa<>2D zh~>e=!t<2cLA`lOU3N_Gm2W%nl**`81$Cwf@61CfaQ^uE2*TS z2gVVi{<3!IQo;@Asx5#>FE=}E^HGBQ#aZNg8E%$wyH_RtnPy2QLCTWrASa)&g4DOc zPj}9swUd4wB6lENR=9%tXI(&A-6%n3y+;6s%Yqtd zuBhlVW+Zs(KGTFx2V;=cQx?|=|WQj=(#%ebNS{FNy!4w#0IFG{m5UmONsT#x{dL&NK*0hkn9&Ce$~ZlEfF7t<12St%+opNkRm;veXdX9jA0tDkCy zk&)NjxgjL|!-R-$y$*f1&v3-%62XV&~^I1>};IGvWh?{xmjr-Pppx@PJ1wHTDsL^)6|zC0zr=QlKk3 z4TgOR(*(c;5ogH&iwr|xNX+t&S8((D(%;hJOAqu@9o=*ZYN^a&K+hy!fy8*wPb zcOVz%4|Se#@^(Lwnn&m=C5T!VDIL{nfe7qRs2$`|C4Gpft1t@Jvx*cd0ddgV5K;Tz z^nb;Q_l=2(84o{yJ_et;)JhR;BD{Nzn1_fYn6kq@OQlFoo zF^g78h?)~Hq{HmcVgGE%C>_Gei-jRwo;POB?4Vqt2XgRiAl=7EfYhdklZZdC;J+U| zrSY}~ibz|J;ZswW$FMFuT*Qq0lnihbFtOsG_XJ!-epSok_-)@N&xkP^`kaJn6O%qumx6TNX3xYY0x{o~h@sT1d9aJlx zF{<`vljHqu$oq%iN^$X>dItY~;Phl7ydOsdn5{{DOs>R`!gtyYF*6lI)I=`Mkr7iv zeW6wxkieKs*%8g-#~a|=u&H^wAf~h*i4LtY2m-kXsdD}+Z#IewOP)cGM7#Q3WSz4? z!lgi_G*|RI^37WW2C0u3sp5`%&m%=4UW)hNKr)EnMCRNbzxAi|w3f>kplXG(P1ppd zN$!|N>$N0N(i5yT4=-=ldu$QvpUoe{#&!?X2YKB`pfyd%R$VL=d8VeGp5VCbV{S0e zKTeDjaXUS?8tn1u3_e*1G2Qeo9$jejUnozqA6c;F1mzjW=IJU#K%N4;VvAH~)#^Y% zcJV{D#DDNpWWpFQIf@)T0ON|mjfcRWT$%yN?1kj*uT&v6lvu^4Hd3E?>)W^c|{3LSvhe( zG7KDJHjtcquU~lt%|bCaf_D((_JSe$8*>Q2&&4^F&;APv=-n@F9EL!?c6b1@i))La z1MWZl#R+FAo4WVZM=*z`#Njwcmpe zG2f=A9?6@zY!5#_O)NFr%TP&k@2>iMfi+faI^{eA$H;XT9{#?o>5H>T`UROSiKx$> zjxo-<%!l3?aq^Lmyyi3XQS90?T=;P6oL#!{E>`Im`X)C=>col#tQ9?8;J-~W*|v#e z8lutMOJ85CW#gvQ&9cAn?l=Wi)4MWJ>k77CrS=X(!`ix`=53Ree8q!p;TXK==sABx zejPiOT5~@<9Im=QXy>ivw*pmi^6EYlj%}9bComt}- z3t^g=;bqTMFup4ePcFSM!}YGx zXvl=yB;TsvXg)y-mo3h{$A8BsS*BJXxr()cAOnMyR7B3il#V_U)_s{FD(LI)FPNKj zFlK%x25XnuZNXm<9jtaMX9H(za4kv@a_lnDlCRe3BOU-arDmz8x&)k?95r2iyP%^vMw3S5T=!l}ks&5tDXoGa*t*xnhCz|h@m@B> zhG@K{13(-q)ga5r4-{2GiFdbGpK z#DrhIw>rzymx3iGUWS=R;NMxmlPtbI9J>UZAP_SJH<97s&#WPt*}R)Jzpfv{*Lqzr znN1UoIhU)3yBtOA4@A(8?ApJ-m{B#a3{5h>15}x1!XP=wwZf*f7y=GY$rF-k;+x-et`YJ@x5T()~<<$R!+^AEOBI|T6 zdSVaFme7?>>i!rsRm^P7+9EKK1T!F=NI@JESHwt?Kz{j{R*Xv3I(DKEY(Cgs^fwj- zR9hAZuBN4~T1Y8BYja_)nj~mzB^Zv-=Qj(K)gD=ZnkA8?Tp0%6p!R(B+qu!CZ+|yI zPCvfo)@YYfJi7J{e|&h{uhn0wx(n4dHUB%1C&-Kxx)YR|0)e~8ou@kIv$h@Y_kDYLLqa5L~{Nt5Yk*Tjw zW0uvt9fwDQ7t1z1Wfg_BZIY^(4_TaVSFW5-uP}c7_co9BuLjPQx_&~eof&&PW?rIW zpQ@jNyeljHxrx%{MJpnj3{DjdJ5&t(7-h9R;s=kLPckK;@XKvrVpSu3Hr3TJg(>|_ zhOVjBu4KDF%{}gg3AfqDBEJhl>x{RwKJu-YXTM)Z#~Vbx3i2_{g9I#3w?{7I zaVxJMY;rv_*ifEgS5hBT=w%b+`~>lwn0e5B<;v5|&zrCMp%EZYnXCK&j^S0uKu621 zi$OsYuRI&)t@;uU?MSIX5yLoH+hD+kIi(}yQq*!utL$p8dVjn9UML?~SeHOHju&ad zt^Nj!m!m~$UEIiECHPp82Q_731Q?oBp(M?r4w?hb^#MKFMi^=g*3UDJ+@~;}VHD^1YN@4o*3@+dT>ZUWy_njfkTFD(2hGFdnc9o!KIV+Q93-BWOcLEk-Z zpglv^s`}4;5ut9$+3)V!RGSwab(B0g(iJ3$4A#WMiD`US#MR#yGld^`S`HTlS#JDB zcdjmg^8+bD!EK3`d1<&t216czm7BgjYan^r>;#9b%lpuk(fr+W$jN52YQdX^A|=nN z#t2FCFU@HxLHA^>Pb@ZXIlo-2f8$*HN9~fV`+#~+%JbzE4xr3Ttcy`ne&9%!bKl4k zH|M@cS7^CU5vz`letAuJWb>U_sfCVb$#V^U zms>d6{BG@#YZJ6W<%b+nhdzG^O#bmefcv5=c<7(X9Sntf_uJI3g4xZJDU~zcVmZ{S zRAH;u*BUUDb2$HK9*Trfke=6BTxnOlFGskPRp%$N5Nq!**M&eQAqEu>P$iTiMfAA!E8N_ z09|(1fa!GFQ?&9xzweC?>za{^XZsoq7PaWTI@`05+7FBo;Pl0*qu+q4AWzK7TZq(b zmU?zpgbh%2^l0x>E%=LiC%N&TuVw{o_jbcmHesTeFNe4qujR3DQY!v;eBWU9uDCHD zl=ar@zZ6_x|E1QKOHj$>5VIT^{a{k%h;{W{P(Pxpz1n`yNIRGMc)vvuW>-BwRoe)S zM8%=zz@jkM`F%t-!K}FDEFUoOH(vsg7|1n-_e?pB)Nw``1L5^)BIad}0 z<+SG+vL0HL&gaNYIW6@BP6@!{Ef|+;zHK;HRQy1GVf`p(a(ur6lrqZ$=obmV`_-UzEIVC8i3 z?af+`d`ugQ#Ss(;N^X5=h!RP?r0bbwbr?{x6YWh^2>$-sS@PNSz)n?FG?jeCtkhy` z0eLgl@I__!l)G=xNLnacotb+}Q`p(|hg<#wS@d{H9ez_Jg&?ON$ML%^^K|ng-)B(* zPHo9MJ@OGGXXaX=dO*b?*-sDJ$czwwL{EOrd@iDZ{Uimtuyxf%)8E7-VHG;Ni=qI` z&K8g!EVGIE)#^>5wgKEUh*fANdim&qkX% zf5bqV>_B3CvylHf&Y)~aSy_Yeh`#qnY7Kd_5p`jp2bWb#3B1i}#kl@Ya`oMf#clP* zR%@)kf0A`=KfhnsiKv{;5$vx|wBh?xnoH?bPw?guY|5CdEa(t8fA>f_+dI4u<)Sjd zwRPv=1R?zdNr#<5-QA(arl|aX!)2~i!BVv9RaLIK2hV<{YrdtU3TRMRh}j-@(dO9+ zwb9}Htd6d-{u}!v?-5vut{`sk_($bvE7H6i^hG-NmB+i#J8NT$uAxroipqs)uFv1N z@qa@FG^a|kAx1I5$O)&B>?O)i1V0@>K!Oy~HD*X+KCAp>#^elluM*orcM(;^hKIZ3 ztkbV1I}n4Dc*?E}`X|=bGGHbrmdWY7(8GUzUr6lJfv6L|_820y%HvuCrL^sZSzO-%e(m=HB z7r?)|VoMf?F1}*0$!$)PMciqOeD_dK9#q6=atVY-wm$>_Qk5hOxGU-L zrLLGakjd@k;dNCFwDCbV0pTlEkZ~J9%Lf4)(*k7>28DQWUcJA~^Za11g5;(%T2Tf8 zC}EqwyTes|@u|y*%k7)r;{*O35A+8nPMJy@tqcpA|L2y{xCPYVzg(Zm?aGX*EKId4 zL3sNeHG=tZr9rIjPY6~n1Yk~(X=!3-wO27R5c30)3dzuB;3lUup(LTh1*H;9@^tQP zmfWiup=V!Gf;|zW;AmjoQCuopdUI(WG`n&eUJ64VTs z-QmN-B?2J%JQgTr*{cqhef+r4)n?RRZq__W*(D(jMklw>@R+}GXyLIDzRaz z%$#}D{dRmFk`y);(3W{&Mvz<2h*L{k+_zA_Ri$?j(yB2-OD%_N{1JjewNJ@IA?af; zpL2gzjf#woO_;lW+@Y)|d8-8O9BV*zGOrEc#l?%;0B3DVbx{&n{Vk=x*{--;>F7Im zZ9Qwt^Hc3I+@iBpxV)wbyPR&y@4YamZ9@UDIpbnMm(vkRt&OAkBj^bC+B&VK);Fm9 zanW4zaQmgPAv@ehj^ypX(BmuXVwc7-G*v7Wabz_5tU4O^s}_{9V}Xfx-e0kF8m-^U zOR2y!M#b+6^`k`?Q1#MzNF*m`j?Bj2d(Q^BDw0HWcGIj;&N)e#=k-}mZixx#bs-oT zq^Z8zG5tcBxaQ3C0<;7ae9y|0E=Rp|w`n13ar57>tn~phMvb5DN|Ekj5N=EQwZc?) z3|EfMIRRa*cMwt=?C=@_{O!}9liZp6L#1%F#n-3#1#;Mo0yf*X7ctCkdXH$5a!j+Z zm*R$X1_76V%X`UpWSUI!F$0*6fv-|-QYMOeuTCGIcyHu;l#+JQ=yM=wk_X5w2i*;x z)LW9sXrZD4xSHJFK|mj}*oKZfJa{>pa&o8H=-2ZaI&oXB+Zb}MgDzCR%hNcEm#65ZS-+1UfwH>Mu$=h zv!I5RoWW%!WM7yk;5!{56*n`k33LqrA};3wO5z4zS8lJu_`h}$oK-_ z^=?iV7r#Y5J;Myzrk_(s%fXDY1KtFL=iaAJ%W<>P7Hg1)6PJ$cY>b{nJyQ0Uv_3-7 z9qnxh8?ausl&Ik2--F)`40oN;41ISAf=nAO=%W+hLT#RQ7NaetC%ttw5>_?EyZ7E8 zJJ2ePlbCm=ndvoamgkfGDs$u??DXEA=Non9zRSo4D5>UW$5?1=90=a5y-NS(E5lTI zZpVAl<*5i0p??11(p(chNdsw_tPx3Ozvf1*-!S!PAVWkr2xki65XLRD3&#^~ zmEN`!0Nxxt35sY=XNQy$zRR zHlKe9U%^$n=$T=h`8NArUGOCfRb)n_TE$oDks>p_931$Cik4-ABA8k$*Lh{F>TLBJ zhmY8)s2Yq$6u{p68qK(BZQx)Sz~rJlH*UI)sAzn!G`j=lJhJ`>7%90gTvOA)Z*aP*M^m*y&|W=AQPlK^kncU6Bh`UnLBg!!R7LI#HP^Gb z0QVD022H#yTyd;~T{niAwfai07Q(P&lx)96L5{G z=%sLbByIAj@0*4Om5jmk)CZYIk%4f@uk7-3N4Y`NV^Vs*95S9`o?+;sp-6(u;})z{ zOzo?1&18(S=Ad6JZ?e{ElpQ^^pM&Ob8V|>Lh-DtH_w?V3K@T8#PY-GgehEv@{_lW; zBsYjt#)-|-(>U~JFVqOuD7o6t&c7#gAj+VHf1yl;m7{78)1<^$dAA``1t~4D^m}TM zu|C|&JkZ})ZilhNX527(M96qeQphVMQ7wAFX-Q2QjM`nRO_cl=o{bmehZ__<2dB zE?W3hS#=A(JQXiH&|f_6(A@gFShut*_UY;Aq3Z~uOv_m9!h|Q>xWTe42bv!u3WMjL z>Hi8KwmXwz>siX$jVHijj?f`YuqkMG(GUo04;phCe}Ph}LzIDj>Y2ZCuGKr)m?H9q zlazwMl_L_sN<9WQDxkmHr*O8&xSO)haXXxV;VAhMQIr9et%2j927UgrIv9kljPV~u%TooR9 zEu&U(KjZ$vgZf~yX}-(5J(AQO1#3f`I#b-CtfLq;<(&2=!=R$*BQZ4IkI=JCM&4Zf zRQ!r|3+(y?lR&<0cP8-Z*~G-6>OCrvH*bHTh?i-WJz+`;J^j^k#-=JktdjU=XvR8= z_-2;p_cE*0!6YCv24{wTgot}!7Un@eMZ1bKVasNYLhohB({MNe{>vCb6KtSJ*NH?@ zEv2KU1#%R7nE`k29`|ti?vVqI5W1K0m#Hiy>6jF{)+{hZ+t|6Pvd(v=Rbs7Lb&lF_ zot&3^YdEoUR;g13`rrxvWHUw53Osyg;lZ@oQ=n zF~VobzwVco=0G}Snp6VyemC`#UO+NGyoKKRjKTO3;GhV=4@&zIBh?~S%&*Z89@u$+ zh;o7n)>}+QMg8k(Q4xC|b!O)itgrUg2M;IAg#7$ib44@f`DvpHb0H$I8GA(9`H3=G z(~v0>u&FMob+9yptCA;07jrm5jWf>9;#-As(C{K<)-5JlHew*LR;hmH#s}M&9(R$7 zvnExBAl&N4${s_kbcajsVQr{|>j%so8>?G4UjQBf)h5@=_eoMcwP%+4^CL&>FrjZQ z0D8no8@k>J|NBAHQfv^=O~)IGLY?QMCzSH*^iviMA9 zI*>fz=1ct<)agfMLQ=B~Kpdo3W~x6II`voH>08HJ%cjW5S*@VF`^5e5&5;Z(zV0g% zlaL^5p3vbyei-a@FeVg&xihR@Nhv;0G%vY))xyTLNH2CREhCIxVDEuR|Nq2uE$u!7sd6$mO=VAe?n{TOoA{q4M$ z=qXGNgq};4pV>8-1sBXg$6}@41NMtE9s2w#{o@;= z9owAO&4pp=FH&oZ%hK#=u-S_;JyZss1-aZ40UONQY84dS-XW`~v~s@Kp=*g$6C|BT zrMIC|yemJ&w*^bILj3VAxlP`^ueL(e-k*O};={u16*TqNS!QNj3f)@`Do|NfRMWHl zcU(wsyNP1>7Ak8lT1Fi#^;IhmFn)l*dIgp#!CJ(%t0c}s7evkmq^XaQAWN%uvW5~p z-ap9Ne7_meJax#2Qbu}*Jo3@gc6&MsCZ*XL;F_piSX=M|JuN4gM{tnH6w6&TO;Mw@ zUvBF=_e=o_xlf7&fq+(Dwxw_w@4ytB)TTiQ7Km8&e!4Wbdft8KA!%KC$QB6L|2X+0 zTQSR~Fn}Kj{b#8OhheuN$~Jm!YUIKjXgpQL;&C z=I=vx)MI|cVmBZ_F@~u@R9;7xYy8!3i6HS?PaG7Mx z_i`|Ou+9JPt<2`hm4UbaZf?GTLOg(30-URNII#v^`B}M$xdF$+RNj5WN-~X7M;6** zagpV_&k?XgY`*`AmiYL>jQ=;yfrwu%l95p=h_hfVpbz$w=7W62|_A+~= z%&o0+t|>u_I+Vf6F6ohJ9nLch+<9S@{S-VqW^&YF2NXBdYKa&cXN zySOR|Kp>F19l292ifp~!LAF+?Ib;R`YnPiF=lle!FWuM;OoFv+44l4Tfl5ZfV0*?} z55{pbG+KNn>0Ra7W<0u82N-_^5d%x<9}V>+#V{CRbx<{qCZ3qN6)qs#D=6XcThnX$ zKY0P2K%!gA1}=>+)X)D`E&{B`TMkGV0GSBtxi6-ZpZV~)3*SqG>yC+j8R%?ZhqvkodEoJkpgnOXI&E~$X;GwYDGprA0M z>$Om}{c=n}W6&FbR3~@sdK9RTWIl8qh>#&UxHa$=P^`+Rt_~03l&ikNja&#f&rgB= zFipDh%1*`5&KL}J#LV~OAE%bK?kIBudks=q5BVV#0Wg#zQpXhvISkt&pOwdQd|EQMfYPqx5!(S>bs zRhO20eHgmm<356d#)xU6_DBvd>NAdgxald$Do169+YcFRFKPo7fs^5=f7JO&CJofN z&+|iaoAWth7A7Ej$6No^RW~ggGQguxVM>$$$$KbuC-*H|I@mjpY$iMq%Z_&B)xfbc zJe)r66ha`}`Ej?^(h8Q#&}TKw>yfVoRFG4+*8Io8ry3@rsVF8;A`M!9!p-Lv2rtN3 z_bur`J6G_7y!?Q`=@z9&DZ*c_ z=hj>0su)==j>dmyvoAc^=oI<_;P23}@(tC0&r%gZ{&T1Dw8=04IY_cJ5>Ps-Bf>C% z*B(I88x)Hy;<^Atg33~X41}}PqVAm>^45Fu4x105pGZEymDNz{dK%}#S3>tprSs@t z=Fr?<0+R#ZX%iQhq88*`Z31tFIo$H~{sw@QAqFl}>8j*V{WnTN(57?p%*l>_^<1z0 zy0T7%i(@5_D{`Bdyipy9A*dSx1KpPJyC}q0=sz97wPN$rfM)`@J$kg5!QOl|9PiHQT&(iSgWar~*b@FI{? z>WNQP@O>kpBiP-ZkxIxDhq_SCgwhh`YzzA%rNIV)oMjWlhdQ}ce=ronk{h2SrB^&b z<{UKYB<=>l5CfQCZN;Cv?r3Tyi4+Qt)s3Ic=J^H4i&&Rhq|T5>AO2aiUNno0^50`R zb$_^D6jlh=S!q7J+zAr}dgh_yLRo20%&I6o71mv3B)sh+U!e7eZAxFeufIM&%KD_4 zF>e6Vy%PE=%npSktgv#iX_bf{7Ox|`BH$76enXw;(4=T$NX918J>)V{LyV4wXR*7udCPT^|n7qO+ zEQhC%c{m1Vp$Y8VOB{Q%Tr=a{G?7=&bY3`1>)SJpBQf8+-6DPjRLLAjjsmArfYf6T zau^a=svk{8z(8Cm^Q4FQaKDFfPL|hV7h3_{!3Xe(oC|G_FvUB%o@z(+lA`c)Ot26M zbf};MV^xXR-=Hgh7=!5{Ky=CpdT|?`*S}X@TVFt(HK7d3evageW9n% znPp!otnPU>VF}saR+35+?^o<2ZB$ygPqNFlyhX^BtFu)g#nu6s)wQ~yB3Uf~AX-~$s2mm)W!3u7KlmK60xK-5y&jKjLu9a@t zkG)=%BT`Rb9{^e!#>OAANATo6$F~)N_K1eYB{;|)j-6emqrmI~f!71dF|CfiawW8{ zT*jzK2kp>>GLB0-W{Wtj9&i(IIS40il~Pcs=;u3q-;<}VF&*oNN7^L+?DcnbX|sCf zT64pc97Bc&3Vl7$8bh0F#(mx4;|rO45DBAQA8w>R%VPmAdm!W3PS!Yh zF|L(gVrmFx%dm=reZ#4mN4_iwDV~pWZf*#3F#Ei`1(v_iFCNp^LjAFypphSkGABx! z0E4*;1^-tJp9~AXGKIx|ThdU@_J^Mo0+Up;QQ#9Bp;MZvcD$$uMzO-y29-9P%M^Im ztB$J@zIB6eAm1E)O^6G^|D~8&T0xScd>AEokE{?cOGrPwwzm23U@5s<0+q`z2TKOk z#oRXsMr$J=y^E52!`Gg0Z1paH#Jwe9jmQ*D14}|&M`uaPZv=V+?r3PX_i&3<;Zpl+ z{8DkdeR~0DshVfUB)6wG`3W(@HO@2ck61T+td$aUI@zT^a0)BDY0BKF-Lr*sZG(e{`~x; zg^Y$r!=UaV=psLX5ym)}hj1pPXHFkI`c;W#J%plp9;hZR{TUf?A9~|uhK4E)FOi1+ z>cCl&8x`h$H^nr*h1o4e|jD!YMg8ai1ANv!%y&FbY@JLB0%WM(J*fx;NZh#U$> z&ekh}W$Ym^zVxSRiSljW~ZO)uaJA_MmQRImL`y}BEDp{NhP8D&h)d;#exvOyPbP~w)k}`L{Ey0C! zMUD^%)t~9Rj!f>Vm%I#Vm#*)%7is2b({Pc6!9w(N)YMDs*P5}zlE+}{H75*oVqKwA-Go zM$D#@DB6B`KZATnbDo*9qaxm8u^NhqLb2Z>& zIQD&&^RBbus`6gww`hBgFAvyX>IY0aF3|As;yI@E+0{QDwCYKT15 zH)D%Q6dcXxgiL}Cc?&wop#_U(s6X92R}E_5@EDy3xp4Odqy?mz!YCf{!Z%*MS|HU8 z;4I!!X?B|B&3ihv54|^Jw|~)XLj_{lzb}<0461JM-_ZN=LWisll`VzyBL@?9?!L&s za9wyQpq@0>n)9gy2J!pb-L44tBX)v7t!cKz)}9iM`g9S}fO~n1JN>lhj;TrtxK+Vf?Vb z)|Jl1F9kW0%7K}dz?@1QHud_YSBjAX+Hv?L4A2h5bNYzS1)rYW`0gV^9SmdV%HgC5sGa3sHRR+ z^~FSi=fRz*gzsgOg!Vw7xxtI?p}Oeb@>R&+zgd#H&hiV3lmoBD z*tgtMVs*Sdr-G-Y%GUE>Bn=M~j-CadPD;?BOat9ICuqHQNa4o*z)_}pzqXDJF@pbi z8F9Vu`c1uxXa0O%9w%X96sXlz=XlloRUQqeSF6%z75=3XIghy&At{<@5eiV2ew8CI zbi(B3Cq(iux>3{9gm2%n)AL7<*k=Uxzs6BS!i`rIcqPj)Ryu ze-a*_e6vV`S~MRAa5W2%=pB+pQV;Unq)`d7cp;RkRn>LAtBy!u65#mIq}@8|FCt|jbVV!rdJ4^gXwhlEap9MX$H`U}!zCTzPE zot;O^ock(G&?w%Db0jJ{RJ*5N6|CK!<}>CXx*P)m1!hy{~1zfZG>E1`D@^0s|_kL zy6uLJIZg`SboufZXd|pe8xJSdkErgFwcD6fJZ2;K#N;^cNxEymazzl%ZVzpKifpz1 zt*HCOIZAq?tq!By;0GZBB}kz%ng=E>8TEaV7xAxu$~c@wZ5TVZm@-kD2B2P)fgWw) z41~eAAR5HH35FU~6QR7t<}+v35{y6!9jGm=p=lTfxRh2Ifm$5N?HDOnY|Ifm{dzSI zay8QF;Qem)F&!s1Chlhew63IwvbBQ*3{oo%rME)lUf}!-w(C!!je`-2mtFbqQs={!)COT|9 zF$}nCvMwriJW&g#QUDC&{Hash2~%Gx)-u4QNF{Y(p$T`@E$!{UREn5F1VQ8h zd0*`Uil8KFqltNe6Yoi=q_QBSty$B}w8-mj2wJ)Y%r)|J^B}}0lc%xdpdZz!*q&xZ zT5uq6v)k-rsLJ-)2-2zaj=XjJMK8y0-L$P^{IGh?x3nd9vT2|jgc5kLdl;(>D2S>V=M^`$+?rFmP5F~psnW3GV+qkeERv+yE<2S?-aqQy|-WJe5 zXL#C--~Z@-FaI%O(#++Hm+zXJ6j-iVXz(GUf+3@&wbHatwXK<#hgbaa$m2X{VdhgcD$E4mZ54f8jlGp0=)8R3X!~gWoH_3svd%mBH*n#&V zuH^Q5H<@HVbm{rrF6MvwP|osw%YTbI(OI+L!#eTDf4w-tW`0RPQmQ;jiDC5myBH)n z_n~cobCZGHCyi;M%a(0NddCi*$e$a3+21P=r6;GOe^nGa8Xo*JRa#((Vt74YhTGI6 z%zRzSkbrh+`OEdh@Lit;EAdfHNyQ^Qv0k|HdG$GtHyOKb?`eH+JSyhYTOuc94oxWiTMNIiyP3frL29K#__PR#dA^f~V-iGDP>bd7QPC(v>5E2qNnVZmJ6MkZ~5 zh-LcQAB9a{THYUf=`@i0`n>C}L7WXXSTk?-wE!OXkzO+@1u`nUc{{G|t*D{b7HDsQ zw%DH*H{4q~d@O7mxB~Ymd-DX0mP(sKB?zf+ufD@XoE9xIk+V2p;%53vVh zD83V|cP0MXC{$EdliAOWUm}(N;ESF$`XGRO7P`b=yLD}9Z}mwWj9!@wShw%Vz7HQD3Ut>!iKi2&9L5YzEl>(jF1J57WHEOYUb{J$aQ8%xDaNS4ip<|!T zq(tw)Kt)W86a#x{ExC~2TB9@v6ap=ImTRv<y(h64G6P(F2dzjeKC9NI{1Oo8}5_5Tt~*Cw>B>A#%GJg!saVq6s;# zMxOKEy*=CX;T?@pRFJs-{^7(lk#CQ~SjmUqMvK|Dxu{m9U!0sMef;B-Cn*B24Q z1N=c|MH$$Ac1G#zT4yDIR8UAKT`$DHM(??M6NjX!)Zr3n7XNzL?|BWZ$O4<^!@5O_ z?ps$oQxRG7+|WIDJL>#KLLh?R4J3KCxz}575c0uEQoz_n@>k@_TpWXTdWY_)x?{4z z-(IJfRzn1)1LWg9)8F4;f`Z(ypu|w(^%ZHtt5yvIu2j9T_#)Y7rF*079)IK==Hg+L z&o4N**6v+&n#kf6Dd415`^&RNfi+T3TM(Sd0FKEio?G&66CCg+ ztyvsx%k3zF-3$z5!Av!DQaSa6yEU3d&ZIY_U3<|*=z(DY(!}!BY`NupS^Kf}O8Bk| zTk?2WBgW8ijQRBGv4(8hD{e?K@iT?-1R>vJjnIp|t4HheB;6H;n*B7Ow*E21%OD6M z$aIBm=ci)5pP|jRImOu>mz!{T@-2kxX49GzT?UWu+P-}|52lY&8{&^qU4~JIw_1wu zMff6rSJsSkE$fWaCCA{B5*OB)+{k!E;ft^mN^)GpF`~*ycrYVV4 zs8{cgM}Fg2!1%v0Rf!io9I_)U+Zap>>b-A9kucu+98vV(7_#`ldjtX!NCB1C+3xhCBQao8ksleOI+S=sV4W@%2>lG=2&4UwR8EbO~cqtS&k?Si-ih@Q_@n`M6*7{b)kR6Ue zYgzEs)6)XOF%1@w`IRlHF3RJow-YaD&P7bpQ|N_gge==Sc6e#D&O|%|a7)%|i0Q0r zz?eH3hBAguqX~xW2xb%XYkGflv;(Vo;FP^!hlpcy6$jJCuF3w`I{jCtOBlu`)Cu^H zD~W3!eP$3a|01FRc8ZkJmp-cvl46oGfh})`T}tcCd-o2LgAQthYe$iYik@r`WgrQ0 zX{H#2`d$$e$=G35nPTTLFDsM*}7B2WVW#5L;({0R4Xr zg3Lu9EFsP6wPj@R1^KwmSxs&aO1{}>(@{Am21xzQ~!gZj2$x9 z{cO((VsMzAP;RPwJEw7TdI7VRQG0os4G_3A#@le}n zt(kRMoP#O9?nJEGFh_Nc2p1J%PrTf9GY<~B!iTcNE^O|3cw`n-yY(NH_oOX)LGa_d zi2Fd(yT`eJ-}{z<&$(XeL+bCidxkIR_dDWS9&kHuSuVKtcGcN-lNmB{@b{35G6Wwl zP+=(k#OLKd4;|V2QgspU25ctLnvFRX9vj_HC+o=E;A=C5x%R4Xz`~z#)E}<9)YMW3 z>MEeU1Y_A(UaYTD4%c@4EK@yzd_<$DSoUc^`0`QA(Ds8kxSi58$GfQ8jrLcMUQTxx z;e0jR$!0*YZ#k{^j+~TPb|D9?cXi9PSvcCyzDZxe)$205&5)qr(+)< zHUJ$k;DI$i1MSS;>{VgKWIwS(le7v92Mijia<|q%E_u8#(07`V6^iBV_my{`d8;O= zZMz5pN@|~yzlS@Ozx7N#p{NqQQg7;)jU?D+no?-{b$Oj&g!R+S(QzWt!hT78% zYgC&k{vNIKzG>hY8(?W<1gbY&!+hp(?`4sa!@E^i?SFn~7d|~b`EBs#%D%Di0?oAX zyb||#=*b5VA%&^7JRku?gm&13%|_icjX9rKzu<&+Nw{sa*Rv0<--i%U2xd(q_NNXx zg$R=uj(mZNz`Ae}q#9YRu`GM&XW1xp5%+;9bvqJIJ(|oYW~T!{j#(pAD?IxWV_$z> zDQc(p%Wao=sIzuG3R=3&pru^hf_MZI?Y_d&q^ZLEU7_4GNw1Bfq=30WhfW5HPlFfk zs|D#o)}4p8<=B^}F1MERK6oGBcKsihBL7p0G~GxIfalj4+@ah5=dr8+Wjwz)%Xcf9 zw+k>YYL}7r9T4`Am4#p^sBV3kTp zdzJg-|C**?4#8ErLjIc@N;`^R>E@H{2(L|wH*Uv;?(lMlR6GJJ;j=&5pcgi)d4soT zl$C7w!I)jxc6c9ML1+K|F9vDUG)R@7i@1&ClkYl>4?K!~|aa9h&Sr``=f( z1TpVBcB-k3HiU_594m>oCO@PPSKoIx@L%5)FNRt2k5&A>%xcCUFBPv)ko5?H%?R^U zJj}oPTawti<9qu+g_lqd-b7>iqkxN{ReO0LgL3kJS7CoQcC7_UE}bYZr=zoFJNpE9 zutri@cmf*a5R!Dk$X6%D34%+Q?=`-pvBd^M{VnlIo?DRZ4|XTMP`|&0!)VrJ9`Um0 zCZ%GSd=mekM{W{1ay~bfh-N}JV;TE;=MgEQt=g7nm+z{9w8_Pkr`)~GQI-?ABndDX z^$T%p70IIuE`rpsaj3av=`J2Fnl7zLTFqCf9NSA7@QuI18FIu82`<^e5_FfgxJSWHZ%Q$|r+2W) zIRv%Ca!iqxWjG!_dK56OJi!2{=azGKZG9iaNX?)uqLI@2vdc@ZjzME6ASFm>OPLeW z{$a;?YLO=1m^ndb6d)9j^+9)v-V-ek>c?l8KH_UFQXV;K4j3GT`$$1UXJwbeIIRt?88BEqzaW33H zzKv1IL$UR6z@h>#Zu++kEixoH*tSxJkH7=v{3eT`RS|s4>1N~YU;+*PJHLG92TRMV zk~!T;pamVuIq198btYe#iym&%rg(Fem+`Vy^Zz^LVPh7Y;`+ zk5q|*3yb@@TnB~jq7~Z9>7HurMa_Ls?VsU%xFR&7U>>xS4pQ~2w;2d5$5D(gUrv98 z)fXydBFlry;(uldV^qW5W#_eFKBRErU9}GUEWd4@$^&zKG>CeVW8ex}i?Jym-4g^8 zeVlUN&b`Q=w{3%~oiTY}>}p?33%SwX<17Yxz_U&aPPhwVu;$o4e@fyXSCaF`{UpwH z=3hX2^pdq!2uMB@B0t_Tx)IwIh+>IiFzxe4DEL-T2 zZuVk&p~rgG-|LdRfATe^Mi$C)%-e*IqvAM~X*Iz4xyuLmW#_WyHPB9y?Yh-orQ+e_ zkM+XlpPx_rcwr|!8X`un!WK2;{6?XOxV&!XnPV=jxjaZXf8=r^rv1B~YDKAd#=*ODbrR0)6g-?$- z{@Q-e86ck2ndVX*F{4~0Lrxz%vSTfm(~YW#7Lory!1>z?jsng&qG_;}14eNLmEIFl zf$!0%cCxu3hRomm0<^WYwIpW(y{29n<>`OrTQ@wnQM&gQKC=wLD7pQveW083O||!_B<%f1V>h_s%!P zr9nG9ievfihU2ciPg;iRY84n7kRiLGfm=s+$6uRBMqX%dyBqsQpV_q#gCuTwLhR)19%QBR0+H#$UD90E|mENjv{5TL{nEepP88M!;-L zrj{SXUP~%+a@cvR9mOFUZHX&S^)&gPE&^Lf5RDYN@|zt#d2*g3)~V$D3D4?CZ9L<# z&qG{#9=aiWV&m-O^A}nx$f-ttNtqt{CEI~m=h)c9J9cQ&ocpis=bBwAV{rm;PcLOg_(6=L^artLX*xmTUP4Z*}O#Y~*r=8*Yj!8Kb9y+x@7neE?M`@c=nj4Qd5uK@@J zY?R)^^Y@|gChAhj-G`_l8UP&x*kSMhaHS9o5^mNhQka4O!9i8J*RB=Sf(Kp;cI}Nl znC#De(armpx7xvmB;R$rvRMZ8*vUCH%RlcWeHu?<_eJ1sW|uA<>hNC5v0N>Sz@Xqy za6xN^Lv#av=r#>lH&^oN95vFh-k+2vvhG^b<>CxP6ey0FS9}9V@mswYzs5zqFhog^ zJv{mLd7_76@DeRBd1))!B$=B-oXT|VPDj_Zm zS)*S$P1b+CF2{g2$RyD?Le_J!TWs^S{b}THTNLT^Tl?U!PyS2!7iuH4=x}oK%gff8Kc#-z*Sr> z`%$y?RSg4an@pw(kmK>uXT&inzrv;BDbkW z%3#BSxtA3#qYj?r_N9D=P$SIkH=d}~*8NWn?{aoZp%}9BJR2j|kmS6PMP2RTHCz*L z_f&*;LLZ98DEEnnYX5`6x~2WG#CvhTSNOep?E#-PjFx0m@(#V*;JVBNE{@P~rO;jH z&R}wYtX5VD|7iV8C^rI&C3rF6BplWtJpg-$TZDr`Wvul{l1%Aas{4`-W< z+~?4Ld!$YHb_)xNmJ8Ni``aBl?+C^W++41U-0`)XU-^%3jRqpiu$L2GuLeF??U<4M z$|-EU_#^En_Z2Ufze7y#i|42QI(;9)m3;-EBK%i+>SfIs1K0UnP)HAn*Z-v>3i=%xY;Rys z)%JhCq8EmkNv6dwY98!@wxO{SyFR%7A7RWaI2?8J<~#Iiuvp8qtYzNaAn~+9g8nil z{Hda6??+3}6~y$C+#T*kA3X8=x8OHIrkD;Q`fpxo)IIXy!}XO2f$NNPOWJ9adudBD zEDQDbSz}IuPwA~}`RUJ5L~OpkckiAUgYM#jUH!ZLkzY{Xse0ht=2P2zeY(z^Q~Cen zl5x!(B|Bg&#-W1Wuzjm!vJX*c&e11QFU4okSaxX_k?PAVS`p~QXbbXL(MNI6Yf9Y# zv1<2@xWx>^oRAcOm4b?6BYDYz2XL~eGN*hk6z#eh2o@N7b*|Q)_v)uVk1$5E>f?2# zA_ezcXvD&j^_Z7ZC?(fiBQP>7aoIfylS2A%78_oR6mZh7#Nq*m-Rdm+NXb{EQo6ps z7q8%}F2$Denj0F3V-NFLs9ee-ZMt!Ru`wC+c*$-DzvLW%nL}In{8+0o$(4S^)}8A+ zm5y!*$uFCxn6M>!`sB&RbmkHlV;`O#B$cu7(5tbok3H0jL@L$Wf8K}vBOjyKZgUgs zi=&2b@U>s>ePXO5KlN!FOb%J(@1-0xbo_3M$vkV}wJ9@W!4F7?9De*pQpW7#7!(RQ zxMQ-zzxzR~{1wi3_N=+mKtZLw^kpbS0^xL657q(t7T@kTLpaFF%nuj_xQi9qeOki3Pn>{Dc%qEVC%V5N3E&quC-6HcSi=#D z(=fYLavXd<-ld`abjtoLZR(NJP@>+}76{Fho@eMNiS|QdZCF(h=Svw%puTWMk_koEc)!`ap0NT`S63M@(&4 z^DAm5{DnlCi&n`Qrdre#UB{;3VUVTz*U8wOA3li0)In+W@y+j1@0|-4?V=t@v|!dp ziIG^h>+Eh`OUne{;E&>UMMXu{4>wQWM7{lR*SVdpz1t42)I2UIyy|R@o%+<-K$V%3 zNTe^8oIta>QeftEc*UdRNa@`cy;SGffgWt0%=w{kVXsBAqMNqkl5k4+1L)ZELwD{g z=+QpJgimH5IN3YYcyMj~DBB6-%4DOw5el`^Uv{rU|C@dv-&GlY(7<%mXhf|m(=)4_ zpB^tY5m27>y`Bl99>k(p0!vyt_xAab+AaW8mALd=E=OpEH{532cUsNf9su5_LQj!h zvZY#SaZHxc7K-_YK2Qf4kkjCl;G0wkce3GpYRX_Z6-T&zu83N3n_S zrxlLg9R3nleHCUO91zIG8~xZ~A7=HE#`(K=teZIj+bNnV3s%YU7%zP-7pExB_pg=P zL^e0-Z0A~lT>u_H`RiM&oxjQHHJfJ59xKk`-*MleT17k4qGqR?X=#84h_z2vZ20Im zfgQ?=<#G&lL7*&{$RHK}qO=Ll*x+h-PI{=~>t&Y?dPL_ZwE1ziCe<&PxzrL0;qnb<2A z%eFatj;qsBo;i;-nF|lJE%c=LO^vdD-3*E6RDX;VndJ5rVCe8`x;eB<0sXtxtF6Dj z(T3N_m++-d6Jq?kW@#tiTfpS6-v~LeIjs3SgN!R-_Q%rsl5+=>K`GMl9M0%NI@%eW zQ2RZJIXHe@j0rV4dQ$c&SUBAXLbzVOBO+Q(e@he+SzY(}^PU@St|KT>_r@k`!T|v0 z;h(9tg(`OP`B<=q5J>tr;6h;vu!sx^|GuN-pIbjZmDwia*!uj4n)c(}PIx4bbHiG2 zsPQ8EWb~nU@>hb`IjU0oS(C+lU7deBr{z_>`JGuBC@k0~o|J7`E0kS!L^LADVW1Pd z8j)9{A@e&n(b5MBO&dN)eqJ%;SLz9^nKAaTpYfR$CdzEsbJd!r2L)*13TcSunFxmw z2Q$Oj580IQC}0~u&1LCy(1Nx`l|DO@=plP$!4KY3uMYZZ-Qf1x(DUWXco;9154Geb zZWExoTsA8XkXB(0(ek0wc%g;OW1oP^6Fi*_I2GyX7Fp1U{#*qE=~#gbW=XUla&^kI zRb8ZVoy$YmbDLVLgnQ@>g%?UDEL>?G9#_3(kvJUU zR%wipG;L-v-)Jh$(>gk3pa7KVu=^*sTGfS`cuurX>`4W^-xx!jE$lg*W;N*teC%LR zK>)85KLq=zu-!-H$)45ty5-Sf&=B_6t~WeO6JiV`Ni0^x<9Z`6=hN}fEE|s#n1skG z*V(jbwL5%V!o4{>0$x53CzH^bYf25jcArbd_NDjgtb*0AX=V$^H?NIjr(UTm_n%+1 z8~ogJv$EX)b?&x6I!FoXw|JR$q3c-4))rUNdzoIs$IY5=(9~Aw35WW?j4|ocb}b}k zX}V>L$t#!1Ggt+`gwm=t(CXY-MsLaeQZXIw{%AM_`hDaLi4dO%2t_-0dk?XvL za(%K=TiEkDliL-zV}a}Rry1^UB}{sfPR179($@XIgpfvoa1W;}mq|~*qKknA>9Ioz zK@G}_V}eVUP5BkM^ci_JTlRhL6c-Z010RI>xxUxqR>RGXF-a^ATn_N3+IC^ooo@vxNc+36AHamsv>*L*wb^#9F{|zqMzHQq!$wj5v zuT1hF(iPWkzh{)*PjxgAR1%5^2}zF)#tT|~`K#&X@~&uQC;IJ_7Bp3P;g=noP}hb< zgvqwaDdfC+aWUElACsWh4~nQ3E-jhE#hD>eCOdeshv0-ur+IQ)SzgL>@}&$U@d_%c zOdd-HRYOcWOjd->gNLT73c-HL%&AE^rB@CEduyy?eDW5>kQ;5Q>3ll=q=XX1;fJyn zX4R}=3~ zhB5#0c1KL=L6nrkuP=&LJ(+Z?d%6A}xWt?G!G%#@t#EnODv_fhiXAs=?Q=T$O{SRB z4NV5QS=Ty#-mzo-&NHu0;*f{$0eD`!t?Ke!sMDkDw`Z1N4ahd1^5FqBI_V73$5T{1 znT}emGkW>g?P3mBcKSfPut{ccA?09|eAgfE-bom*bVuchJA=sT&qvJF0|o51_DT91 zTlQ6z`n1kcR^dVFo^|buw!;kMr-)yzf3E%v3BrIoPL^eW3BPsQMdtTjJ5RrK z{i0LaZ3YsLUf^a0E364vXTut#b9HJo|H;=EdMv=UDZWy7<>qj(M@0CUMBdh^b3Jza zcmUkqco*7Ap7`^;!>zvjH#L9$8iiU=qAD(mm36>}$EWp!>e(7uI7~%Lv|EV5<~!GWKPd zk#VL~j&(rO?p-3R_DhS?Z--AuANoLtVDz)ZDsi-4ZMmzm94H^|$Kqn_bsm`?{fv*H zLg&F=9bl~A+QKLo*Vc|=X+lrJC;z9BP2plzMW9{Am5j`E*Vh-=?5i=D$S?0+1?BsE zZ7DDk~tSvwO@%^N+7t<$52}OX)eE$PQhyGJ&vRm&7@9E5w z-$!YGi6OErYap&B$LpPcxa**c!Hz{Yl&ah-`$JXW_TJQ=;cM7v5sLOT&$g>K=iE5* zyN(?0*rx?_6A{_A)laj{AKZB0s6qMb!R7Xhoi(EW|HR z19#HO@~p#mWFOcT(El{dIQNNk+~tOS^@%O#Yt8XQR9GYU!62J8@7Gt&R*8gFxsrV* zle6dcfBM~4b*|gq4oXIk6rK&O$2v@^4(3$iHF{cYOJ!=3{LD$|gzEc%*%)BPiqUOTFsMm=+ zCyjI)kMrZ59}M)JLxp>=5Pc-ns^3Hn15eV9RK5rb4W>gCus1QQT6BzAf^H3M?`dCN zZU_4H^XCJ16Nw6^&H1X$03{bDuSzTo`j8A~ zNqzf9KkYf&5r+CDI8Y7Vu@y-x@?dfy=Qi$Ykt(;TtyN`~#@^T05FqEqpk5GD;35CZZ!;zwyRrOTH zBWzpDo|<9wpB_CAkeg*BJ3T> zP0(;^p>6fuY|ET>?wOcI^wxrcId#tL6Eyc2tO!ozAZtKn_Nz46!p}48-(L21H)~7* z9tUwP1{Y)`bH3qRu7j;pmB)I+GRHmbytqhZvVaCQ@F-oHpE3bwGYZAoBZU4s6`g6G zmfaNeC{vOCGsshph*X1H_BF(e=Ump8g&srD4c5YF?oH(7 z&UcnIu>9G1D)j?wj+d@kyTUrH8imWF%BLBv79D`FU;!(Sc6fa9UT7=$R|T#rCdtOdiB_l} z#a(%AZR)N}`gq~YH^Na7bk$&B*CJ3(@Wc6iUY@=R-I=si_HGcfW^b(uyEVKnk@a3c z3VB05Tlp3M2LL;LF!@vsw0`TFXvYFq|C1+o0@Jr+Ez*E}DO)w_sj-!1g)q&8-iA^2 zc)X&7-vlhzw-VMat=Yl0;D%T?dIDd_8OinYT(GuLb}Lyg2QIpM*~Mt1aV$61Sh3tV z+MZ!b?m%H8{XsbJ|C0{JB{@eQUa{}1swykH-Ch$H>1snR+!kj7xr>73908)hS++~A z=4%}DDSkax4lQPPj5>AbbQZq3(3KCv^eu5Zp{Wz-DU`D3&SvbCu$cw9{9L0J(wIPdvjH-mZq+2u^SjEIcXw)I zEdM=cSUdvaqkzYOy_d=Yb&^gzLoCMht22owxysl9$`fz6h22e2`w4p~pZ%uP{I*t7 z_`y_s>r7j9XA&OgwP}4Bh+!8$vkRt5lc;$!RSb9#s`la0$X(f4)&koFZCz*6?@QHG zdLQc|>su)E)w#4s22EeHZDS%mG8;m6tc?kOlsVrMy3p!u5|wCW4L|^u%@0Ffn{?wb z2M80iN5z3UN0H8hgW=3(UZq!)w|}Im2MYBRdeEAZil~@7XCD~#movVbNl?`wQU8t7 z`FhEbO=&2vl-Y~oaMks!6`#a`mGeL}PLtIV4rJZ~^^yZl@Y1&P`vJ+%?-&!B#a!@8De&$9T!|X9lDQ4Cq3cc}1 z1F6N9T(ioVyuL_Lf&v06)=29r4FsQ3`&esdY>qD1E+H1=A8=wJv z2?I6=S$2%mftkSm%=}h<-+1XLnuuEYEQ^|4^JWn>V>-7%^ZXK{0lZ06 z4E~#@4^}*~E{eP`)h`SZRZq&==ol~7oL;XdjWkSd>xDORb&JwGvJiO%z1U>$Do!7D za{bOzRaHRvTj#%)__5jEoh6z#-FslqdXE~;pEKKeRa?Ges*=|r&*^xX4~7ZWSKoBX zhe(92aSBAur=EobdHAZGF81|WsFYhuoxidlb3KO!AQTWgj1MK{NeksLHutFMJlH;6 z@6+b^YVF#!Jp7XB0}}K3pvs>FdjY4oQIcUi8D!2J?J8w65{ijz4exr)mr(jcjhq%0Rv>OTJ!?Dv7fDi_~>c`7q>(_dtO%!O7gJHhvd$pZ)z7VqOh^Do zAAg$O`1$LP+isO0e6G!SwgGUlEduW>Gp@+oT|czAI9UKHW3=d83BRzgb8EbTiOPt{ z${~~UITri`EY;BhtSJ}|_>9lxqo$M!CUB|pc)Ay0%vB+|tM&fPn>XPD=2;W{JzC3q zW~k`KA%_Rcdwp2I;&>^$exJ>#j-S)?aXBNXv#%&GAkKFBRhr~V7wsrjJ~QeP&*HPqBhhU2#8dG{FFX-pUXBIAwZ?W+*FbEZH!pt^F+qqOWI$ zl@60tgWNDFs1p{L2J0n!8+XuTPETR<+grCPWxtWWvUuZ|! zkC&+MgBagKMym5c&#!e9EjeEeE$HM#PX#uazbLe=oY5uz2lC}z07H+ZX;SHSI06pU z-ryaC;%lFTwPOf?%|2*o`SP^xtPuf~T;7W{YU%-#s+3wtQ=%ebR@ualQ7}x1kMHVg zjaDB@QG#vzFC(v42q>jn%N8zk$448AcY5(mO$>LjC)>FNAi-I+r z{FG#>X(CRkoPm0H?w%iDJ6u?9V;VnU$5em2wFjG2rmi=Lt z!=iA?xVxV16@whei{!}D#DgQPt6N%vT^iuf+`z^6{U5Z$XK6&25@vI`JB!B4n-lct z5t*B1Tp3Pla^sf_r$R&{ABr7VNFzMOXjDzf&5*Z zl;%G7S^iX#p#(i0B7sYNiB{J>KJMT=+O2+>3y1O~aqunDBJc4F*}kj6K8yM5;#BQp ziS=vWL-5#{Vs>0VebQ~J-=$IpX9|iA5XyYP_bv=Fcb}~M6APjw2ObbDr(c{+GAyUE z>YT-w!W2!`aj;u#9eG#{a8cl;B@}a*xw;x2Dn~+%o40kVAe6Nl2KFWL8gV@ZjG3nP zOe#h@)sOecR3S8XfqHEUUSsPc4%8f(#WNk@IX`Erv>votmr4Jj^`!xV8-4MNhl=Z| zx}h%Ui5_4r2y9*k zevA&=AK*ZD6@KOQ@sb9cnIuZ##*m1tA%j~6d+?Oi)cRq4M;QKf;+e!M+@Es+Ic!fE z`%#5*B%U4zq1H>fkV8pS`vmn*t3&NYkcKtpI{nyo9X@gY@>Xd8u^sD}FM13zo_W82 z%#P>uz!$=-7u2K05`G#$+Ft=NCqmotyTmM$VWJVRs0uo&aA-lkeP35s5efU{wC;IM zpD_}y{rtJpeeA8TPXv4!*LI!Av^t89owd(uc5Jj0g2I**C3W-jPQDj_4vLC~-kwBn zIF9FEV?nwcw1)Qj73@^lRm(m_{$ajmXqOt(ff?G)&Bt0CE6yV&T=%Mrr2%E6x=^5> z#EB{3iw3zT^~D~LiQ3&Liygj{&Zd|E#om_*HasrXDBi{~{d$*UTmTPowgV*mGd90? zKDf0?lnq#Ua~}*lgn@00QrU`D^0jcn&hOX0&?r)mPMSFQp+~1sDos?4M$KN1(>qICQx9# zILs13r?~zdm0=8na5%N%DV%BzP#k!!YyX!0L(=tGZkT<;cwhn;u-O07uty!@N zor~j#{pVGcfaS>1Pd3T;<1F}CIScR^>tGrWTWJ~=&Rp|V3ZIKMs$hal%WF{5(d4~A zgo3FOJhM87lDXgIU~ThkSY-3ZR@?O7(<-5RWJ}u_r}YPh1O=ru^<>f7Rb1yF9fy08 zTa@FO20W<0BryQK9Z5D;ahuBC9clgfIsC#4Vuy)bx@;98_!VPNL@4$}U?37f(s_nO zO>`YlH{m|f$ZU+ESpuuh!ZeP_pzXczF6H{no27i9G&+@05X8CO7lpMKc0~UXBlLcd z`M$-3Un=|SOS+G4oL2MadZh0_Az;_$$PbX`T1+00Hzs}bwIH^{FwdIF0){bl;6+7O z3;wqQl7|F7u*@34F4*Hb6&NPCK_wRWvTD@=y>?6A!BG*7jWY-0<7=@)M}LC)oE#Ef zw;^PJ%t7kVvuhm(2!krNV(XIgQbhPt1Qz>U+yD;2_nLWP*3W?)YP6hrDT8C%flyZHC4Z*h!PVvrN z5O>7V6W+cHP@R7+f2i8!jkl*MtlC4f>8V4V5H{q)dFDwF_bdGjyAStEYy;XIa00J& zihq4ks0&Rr5xkOsOz1D@)$@BAy&+v*QU`EsgR!T z6B@FERlqGg;4qtp9dNB+C%s^kUHa}3)pO^b*p@Y2c&rOaXgE*VIFlfVw){rfnH|k#Gh3!Lbe+LDq%N;c){jcgy`R&CsIK^^hb7 zq_n6n_{by(XMr+pgRt=SM%q>kThuC==JlC0ASY*_o^ zIFwD*#$*w(v78b-u)!`P$Kf;QJ$Uy=P>#=pc*wC}|W7_|uhL^@nljCNiA z44Zh#5$!2pgAjRT(wh(m@v!YkQ*^Lmwbgq ztg;X5RyBIWEVlrm%~?GwmU5JSO3E`ON}XX^v;`Rm;(2SIfG) zj00@q6_7MxC3`Wq@$eftRDuZb#QvH?!*m191Jow)3ktm0d~zPydoPzCURwT8b9vrx zC;$o=sxHN=LIG}Xs?>UNe^Z;R5-2zqfG3^6EZI8UowM@5!E-%pGI=f=To%p)7l%s6 z$iDIhq3qVPujRI)KnC(q$Cc6mw*2ff-%M1-aE6$voNi!C%yZOH-xeSj*Ieu23@;3m z18fovn;LRQF7YY;3SS!P#|o>+I}zgWurYjov<`Z)vi3`&ejIZwNE7K`-f|y z-vNS}s2g`t&L~zlt_vJ&5NP~`)fC$fn0Eb*1;{1(DmadM4t>ub4k-I6&PxrU0l>G( z+kg4xrkZwD5tY;94`S{57eBhP$$o0b2H2Xldn^<_@Mr*TLzW3>{de&|otsD0Py=Wn zn(nvWp?s_|E{LQZ)$4hLF(4CXPnY`_oiK%3!~*V-T=Wx4!ahw7e^Xx&1Yj;lExx5G z1fJkdWBK#@sd!Ei%*oV2lUoPE)@r9OgzRD2K|^8P6@-!XL&q35%;VDgXFzQr^c5g+ zKS~9%cnYRIKL9p6Cz&rxrg15y5GV%mVVw02R-rTYy5ZlmYv`u24h4LgMkK^o3UYKna7)eSH)6MKlSDWx{r~TvYpt zICB;$AT3U?6Rmd6(`KOPoE~9LNLNp7Ql3o%XCa&+pUTPJL(GWdb1&jB@Fn#$#nS z*As`0U6uau#qlsuD*NS~hh00(N*zYr-3@26?0W73>3fb6ytoRRpI4WEDCS3Xz)0BG z9bcY|)o)a&Ntgvk5KlTC)v-(Yj=t_)dKDW4r^xY{115z5?JEeO8|;Q>yR;EvFVvJ) zlK?_BUzhuvCBx+pTRz6uJv$g@9yR>%(W4DL;KWeeR(1cilr?3KDrVTneI z+j{c<_yl9^sNmoq?UX+(U;7^OR3p?mdW~Al`2qo7oV0uj-M2wIdU+}qMA3`ySMmwG zQ~|qnv9eGpGoC`rg4*P1NXWW~TwC>i9SyDqb6 z{805yS69+?f@gF{GunK%Qtk!}xMyGuN3$49rdGwnkCp5PvnGU>`#WqNz{cL-bA!)@ z(<1g6y7c(hSPxyq;&J%6C+<+zkq6t6`0e=i4;OX64GE{>uVCt3K{hd6Y*Ub+j3ox5 zHo_?Ekg@07jl@{T=Uwz)H0*7DTqQ*xJW&X2X)7aVQTS@$pc0 zNSxV4PzeERQSqzHtmO|LXp&8z?4$rMyx7bJ^d>chFVCfE9X;xksO$>^K8ai(!8L+0 z#k@o7+E934vmihX%`3_Plr79aLEk8FpS#<#*xL#gE~Zvna(%4hjq+@4c-N+A5}jqF zvNR7IzzH;&(sC?HwU4Z3Ig067wvI6qu&{zc&UMVfNS%ZCkMUU(lp6mhaMvvoob5{t zipTswgNdgCz40QS(r|jx)>AxgPcV(Ra}cCFQ1vKI$NV-VVmV=EPSF{mv2V1lW2sDi zN(+;OrC|vMkSLcI+nf)c)GakPGYi1>BoZ3#`awhmdy}cSfnQ`J?s!^Fk;OEG(s=F( zAV&&UAcOlb3DaiHcFBQhOMB6v2kyAx)W4!n6uOt>Ittuu>kXqULlwT8bjn#xdvO0i zbgYWw{a@LFZ}l9a@uu%aHDj+S4r%NXC|SNg2EFovFZ-h&bG+obnxhl zsE%og_iZ=XM^~o~X=`c1XN%IvjbGx1~G?+UmRz&eV#>&Nb$G<*Vs9P;n2~w{#egGYz7l7 z8tctcZOT5g*)d95l!5z{GvHqrDP9BW+2a_7l=^t#c}6^5AW|vrrKsSeyG~_K4koY( zPkp$!ynX4PyRZwL-9zaLLr#P$ol&YWQ=I{zKB3F zej5;&qR%lzBWKNlLLL;tf$K1w;k?Nmr zU-F6?>yOcH{+xo6X7-CNUrF8`{ma}uYzSyb!q1%|l)CV08a0y|1%DafmON&v82;!_ zMdpqbB@|1pSF<2QWK+4vn85WPhnf*x5W!pdaDJmI5HoVka(5@_O82jz^4vLi;J^W{ z#+P5dSOR-I!I_ojmHY?$N*oPSBX}t6q97Dm=3UT8@Gs^xNZ@xS=L;FR@i)}2Z?ro z8H)cZqPry&EWwlc*C%2_XU+ok0m(R~Nhih=Y3s#c7gs2laVF^XuX<$VW9FlHA>9iP!_%+l#2b0lP&M+!w%J+94YEev-X*o(=M5zL7y=QhRZ~ z%KhNraWC-=v$WxL*}*g1;*2@?`@@Wxe%n4$m!kUt z4gRK)gyfEUA-i%4A0^`%!wH%`efot~#O8wcDJ;e6Rn6%Nmui>PSS}Kd6T>O}E#?)g z$*tlno`%XOss(KBbP%s%&8{G2eM%`VwC!e)82;s*h?*ZfE*u{bigjdvqF+I>7Z~DE zWX>L8SEKH=oXf2MB1TAeufoe_v_Ou;zPlyD&K!%90GE+wuy(ir1RlL~>-oB6wzpr@ zcw@tPw@q$vvZ8R;|3?jTdCM)lC~8Fo^8l$Y8A`PNGYR#opk=gWjVkFxN}JcC{MXO8 zBH&ac61u2@Vi~@W>~$)Px+4R&ij)0iBee{J6r7S`L<4D*AJ= zaNGB0^*ga5zvnkpfg&TqebNRFQ!6@GH|&GLJ=1Ht9yxV$)o?26&%AvqQn{o z#b4UzI#1%hov((!#Fk`%ef_@j=~usb=DPX9)Bu@+7sD~CTE~^SQ^pbZnmI26+dQH< zKHu=6tn7MsuwJ|CRi@OF73+`YGujh?05!1F*KCOzgl(pVaD=M!NIv`(F+sYT1TvOa zH10eG9}=|lfOHh>Gc7)%HAuBDYXM_TUu<6O3Hw1r4ED`aU?cYnH}F`k_6<)n$hle@ zTyybqa%xkaT~e6zI|aAt@EdYUs&e9HzIZF&zBotFvx9lQ(-LPQfSfyNG}zc-cxNxY z3p^gy0j+%!@OD6VYI?d+^ZAQ_DAW**o}i_JM?8dGHKlfwtkoudmd~_@Ra$Y?4x?Py z-`Dk48BrtXGZ~GK_Y`-1PE~XqJpETnp5#ob({MBH#Y&~;Xvm!Z#DIIp03h_j>H37| z{OjYiC3VUp?>TQ<-VO#xbkVqcNP5r;?ba~y|m6!AjKN+tYEhwl!#U@h~hULUf~Qb~U}UQ_j< z3c*G&;6GF5VRc7YatAB0Abdcs3RnONz7TdF+%t`Z(2JY0)Wux5jX!vsYL zU;&i3`;9ZfUJw!31&C(6vqT5Gl4brcJmdFa3v#n9{yKhkcfDU+aJC~w)2=hTb2=7&RdS2s<(#6y~bI0dP?n@ zH7qyv5o~Y0hKS29BaGCYbXme|W@bZ#J_$8YcI9b|1DAlL{s*rQ2Q455- zPY7*PxKze(%CwzJ0U7}=Qe=U!Y=U79=r`y|hk z9A*=3r=c5ZMZx()uGApV0KyEuZrb{pU-rvBGpSZ%T(5j6K2Vz=4O6;!o~b-mrx!Jc z5h}{7kdSa6ue1Xr?*sye&&G70GdGgI_+APzs#Do2ZpLnGrZy!$dmM!sT*xS$t>{j} zY;v8$TD_+$1=cdO3C(DYd;-5grKRe1}Z<?!eI$$sg;3zw{a*&Mxl%4e)SU^_tdv5949?Wg zs2jp3W0xKeFc?<~DE0z7>)m_#==WT9w^_Sk58w$AcQl+8ljVKdo>TtHC=%0LjS6nk(G?neyOTd#H^4qi?> zjKCqZYlk-4`5QOTI#p@igZuZRJsyUgMt}_*Lk%z#!Gy(u(0PWP$4k5djn6wAi)l^J ztHzIGehYq{c#lS*E=>*eTxX{{%Rk%#I+U7QCIB(HO(#IfAFAhmFX4b^4K*`rAT@qF zbMTDeJ>x#L8eNxW@hy+_D(venGde9(9hsU_twEa@TYJx(f_eTwfHu~2y zi7fWUz1O~q<|zM+qV0@RJF>Woc|m2&L(t}2h13J0n5aB=lBkmmAmgFJgOkF-R=Ml8 zSJ%;w^}Me;WHdj_WsN?FYojjh)U zN2|DaMBlIr6{2;hwhV0IF1nOvKL z3+mZ@h%R@=k1~!t*bo)~l8)WfH8jrFA#ul^%tEn;Zkt{&r;6T>G;UQ$KhxN3>(ICr zPZCCerKqXtv+h3uF2s=)2^N*Ws)}=kXEAX=A<<{n1uR6N|4&{*LU~0Mn$SbuccYnK zJ2~(+okRPWR+YQE`v5>>!W6FUsmY^&W)Qu)AiQ6}O7Ty#O2i`mRA62E`3xmHORLcm z?v@8zpEssn4kMrrxqlp9r1Ee=@-2;8us!~5FJG1*nMcp<-!QYiEswUziK?RSP#`xU zOHP6-<$GVDW<`aZMkwtuL4JkIY{5*F%`O6$uoYEH>Zgk>d_Is9{P=OUrN7C*Dm%#? z=Ta}t^!!EMD(CA5w!ySs_O)kP5xnrv=S+0m5&~6SrFk(F$)b2&l5D_~;S5pZ=;wj^ zig2{6cIU2U#RHBd&5K`Ur-UdXSR;a-DkA4QvMLhdejO(vX|wB_qeV@~yvEHPLi45^ z49)Cv&On14sGQmoMkxeOX1a2dlGCNhUM0Ib&6uOz4k!baHhQx)EQS-Ue`#KhtfAhk z$twJ^n{NX%XVe=A?>hZ*%8XlMX}bp_Bdgt2#_a=#@fuw7>tYKn$#telqqB+dRWK5q z2C0g6bm1#-Je%x}`?&M((uh6;2!TKBC#nc3HRaih*E%u1rg6i0qbwME4g+hxYl56b z=h3!>hl6!;lNw(`bgS;HVE&VRe2nHMFk~9S z`5D^_7bkSFd?}FT9}dih(nj8S$jL4#OAurCMtDumyUh;7jZ)IyC;xh5d(A<1k5u2S z)*U+0-3on%sRI+w4sySTiN=+>HoAA^Qy@?BUtVTt10!C(fjyplCeh3RCY^*dMR54I zRhwr$_F1=Ny1=-H+|BNdP(Cfs`xV3!IFkx+Wold*grS+D<4e))^UmZPbSfv%2wV_M zi{BptMu^boHX@Jsj>}+!hgbt<(ZF7t{_U^xWN++uTvl3#55LEnvy+|c*)@Y6zNL2q zpd{JBv5Kbd(1PbEsYnCJ`SKnPe)y0KtUEpnLyJzGD3?aLcC!Fg@;02-f_>P-+mm?n zwITxiRXr?me1qQ;1Y39eK==ARPw3`_?x}>g)4K;RdG>xzexMTbU^?j6A zAp@M8G=4fa6ByGh3q};YZ&$Go-;5}OD#df!3jkpt2 zR$U^HP)w6iln^>XXWK>}8Gkf!a65Rgz+mrw#g46;FtEvq){bg8`lxj_^t+n5$p)(N z{9r=$AqB;YFnXN=p=R`+v}Bn}TcCv+tUBh&tS)cU?pJDWXZ+5rREh)Wr{da*B0;V+ z4I&!@nDf{huNvTR&!*g?85fh}HiIRYg1NJ;{{;+a4)yJ?+Ln6Gi|tk&Vb$4c3bDa< zUdJI>{4UT0Asu>S!n%($;&tK|ZNhmZsZ1_SuvUUNLC9xj*nq=z@~%9B!SZnd*;gEI zR8ip2amW-ft2Soez}PSW7SUIG%6pb_wS2}o39AgWTnN8Ou2LL&%=N}t3SzaHWx(#r zBhjHyP*}7Wf?XU9n)WM1t>6^iX|uWyaQNam{)7KnWQ{jUPJ7vE9o=aMV^X-Lhr&tN zr@)x7vHRdICSnyx#F9{`lREoZgpH<;SA=5E%*g~&()K*!#)Z#%xCd3s0f!YiwRolh zAw?Md$RDwc%>NXVNM|*&=lp)!^{7KAoIKsmtirKv36+N7eIhIuKhqjSKxZn71;W$K zY1OH*!3=l-bOX=@%+%AcP+h+MZZJRPf-uHrIF!J1qOn>nFk-KWOtYIp!xfMNKx(lX zGAP8s2M!1kpma7_R7e$k5zSTCcn;_vs~u+A9cb87o%QIbaOJ1J*xO5fP`$$8hev>* z=z`))jhS9}Yy_1yl6Xg;P>D+WAm#LaqgR-!M>!}LH&?ZJ)))h3^-^~O{Im&T%ovpi zPZe!I!&T5bawPuRP$D0cJU1iY6QlzI%-yS7zy@({vDSm3uD%b?5Zejd2kAWR*VZjF zV3KP%TTU^?{)&NEDWk7w{^w#JBBxFFNlcy)^?d8NI9p?je(!YS`oX%Erq2CXIp--U zavNBc$12Nz<9j09q=mTxZHUk2W1c&$z>hHE}{0G*)AUH<075* zT~O3RF@r6!N4=FhVOwnCY=oOSt@bmvypm!*hM4}Tupjm(!RaFlmRSg4M)f0w6O(QY zjBU@=8`+Igyr{n#=MnjI1dHmPIMdE)LH%e*WAM-@-rBdXl%=T&ES~j8=@|ThhhhBU zSp5DU06T3~bT}U_AZw)$dO?Z`fCyLY32Mx#8)DFxbb2pMh` zL&53@@uN{3po2R10<@W?6)0Pf<8oJQom6D&Upi?x45w-gY;OzYUM!6%b{hOL(3o9f z4LSvM1J}uXPSEcCMt)@G%%SVDmzIZ4cw1n8V;)0=6xUMcUSF8QLLxK%0N#2s&c^ly zQSG&%F#nlJO!PnH&$U3%;E?{7-UC1vp>Jner5@`#d?7_0AsySBLRN*+tTX@W3O2#F zXWXa2aw8qMg%iOLz|}b}*OoU>hCy+je#TSM-NS2tUmk{3{f2jK!rH7rIy7-=nr=Bw z&2l6dd&rJ>SZ1scIJy>QEO)WDi8N;seap;aZ1gKy;=yT$7IQAUbdM`PC2ef9dM`#v zH5Gve(ls#z;J6gA#M~}+(E8Zr#|+lPT<)A4|1P7#{pWpGZcJrGorIHN+~0oq=hwn- zvFp>HzYYUfJnk9sw2oc(k*nL>zj>W}XZjyYCcH5VUJz!_j!G$1D~;Ynl&{Ky=nz-; z;Vc_p_>hbe3(Kem8LNKZPA<0>s2krWdZq!}#m<)d@N_ggDG405y3OFNZa7{Mf&tMt zOLwwZ&YQzY2Z_UX;==7t;Y3=>Hm5fR+x~v;If!n>Gk*1ObNX4>bJmP8BK>2;FMneJ zS>1LeVAg{o1c}4ZBk^Z5uK0t4A81yrC1$Lg1O5*5m6)nrc(7f9OdelQpKkoOO7)5y z^9Au0kv3ao46a66+8z!FP@}J{GJV4E7$Mz`T;pJ^;C3bF^e!3(NCESUa8{iMCy<+W z@ep4 zBx@uqlPq5uWc}J0d-TyRM;Le*!ukfjDKSlNZ>ZrB>4iEZy(Y!NJkq{Oq~_V&R4oJY zS$?%B|6fEz1l`9vU~K?iLqdwC`a(CVx7_(bD&Pc(rxBoES4WbNfvzYomaXy@SK(nQ z`&UyXG{1$8Lrc9-F^ZAVDe7}EJxP&nl^e^Z1B;h%r;}7(F0VfeUIUpld938zPJ&*L zHNAv$KAgA5n7`y1Y_`e2X6nM>7EWOf{hxw$B%uifzXp6%Yn(>|@YRKAgGQ{m5bEK* zC@C%ucNwqhq^XKX#GhXgzbYas3d@;9^lS=#%$<5k;g9>xmB_1ezFfYHbx^ov=_Xjj4i7G zq&;}UJ&p3*1cUrPEc)Q95e<(60Im;r=q8~W#%7t*RK>fw9F2qud-1(jX}g!#Z;c9! z*2zPSbx_bwq1C3?W2(ta3tN=U3Kqg6uOCkCyf2PkpJC{cn&lA?MDA4zgJqX(_MrPP z_oL-+M#hJ}oW8hBawYvHp^+7X>_eJs5^`hPi9!`8xroU6)V3`wXZ zgAb((qXnG?!55Za-kCEcL6@x9@M;A;9FDE`UI3+V7UAfS&uebi3K#lTM0ppS{t$9N zM3;wqi^+}?Df_+ET8Q=ONUkwTqPxVL)|FBC+QD*_2$xb4d>MRK39MxrF$WVmIN3O5 z2}CH=<0WC7e_itiH1Qx-B{mCuY5o&xWVp)wr-lNdECPyQ5z){el;Y5I+CIiXu~|!b z{9{TTx5s#iXqLk$K*sgt(qz)w4bW_aBEAWx7Rz6iC|g1`hW26rS`H_n)Rm`2Z}nx#Sfs{|GI@!n;pWk=>s43%ppLyQrxu1KvuIskyv{VN-eJXwX4aiiuW0$*#8Ha?H&h67dCqo!r=d#|(WYQc+wr~vYDY3Rs< z{7?5!55hA$h+Gr4Qzi2IJYH0wL5zz;;9bA<-XC`A!%~h3dx8@5w-?3SG4i*2&1eqQ zgM@=1kNJTL#!n;W16S>jRuGoNK0^oeWt$;~W!qEBUtdPZGQQ7IM(n6h(pLw4DGgXH zcl22TM=cnR;v6R(15^RbV{25nzxm0Mi$ow#2q|GS#5CVwf@f%9Vez*i5N|1#1U*^; zFqtjS&In*UB!Q7OL z@1;+MrBIC^+DnLvZZ_UXWgPz`DG|d=ss?ZjnD8MOA`>qo73(MpuCOfCxp%Mj z&R!=6q4hyUl*r>nMWwhv-N&D&7Lu%lk{itMoJG%lqa-y5BLkAL9IJ45-XHsYfxYK4WF6QlVaU|!1@ zORzRVgR=EUE4H7bd7(ll6#K}gl~3+JlSFs9lp#nuU=M9Gb>n?ZEd~gpkqn(jQN|r- z{@^6R7_i*CbLX3iEHAe+x^r(>^I5il_&|zsu8)K))QL|K_92A~7P9o%dHSyE6|1<# zOtpu*$;mHI?L65_8dpKROL=#s$;Gx?_t$0NR!PV{&w24ZM|hMQ3T4oPLlGu=uo`J| zF^KIGCD>EZ;%%=3zJkm?GZw}>mK7$)Nb|pZxvz%?P;zyFp5+WWw3F|b>}=%HDg<|2 zJi*)oh`EwlUoC9Tuc6K}w6~`M4`x$#HW4T4QW7Qk*fGhVS9fpergMvJ>4ZZ1B9ikl zq?kswT50rgIV6{VH2;Y~@i+_=;K4v#|Jtl^2&P~!a;}DiOml&lNF)T3wh}e~v+~Vn z)KXVhm$@#;zpdDoU{=$NTu*>Dk_kx;X2ykqx}@4Y=!&B-pwbIDqT|Qqv87nNkr@ay zft+r-kB^VZP)Ufouv#CNi6Z2DXWg4^De+Kl54P_jmL!XS?~iwf?ysF%6W^Zjvo7Y| zM070^L^P>|a+k`T6(SqNcGE@-yFUJW8~8`(M$*C~+S-+9(MvQC1gOdS^IsWo%YG%f zM0a#_L>gwnL<3BFvA|!hq61#uxzL90Cx&-7>Ln4f-+zCJ|B5C8f`aJTd_-AUnW8;X zD#Q43N9DJt-e@lIU@1C16S`G`>F2&Z8FrB!(1|gYd&t3|Sbeo<{l<;H^GFL%dGPrH zYuzdM+o~P)&o1S$l3a-N%N-tx?OV4Zi=FiK%NL3*xb#7&rIlK_Au5_>p`EV#z<>U$ z{yO_Xxe9o#AV?N5h7oZ^^qetdm@7Y;;@>YKzUJiE(ME?+EWH8@gh39wD-yMfLD*&? zagxv#83dHNbXU=Z?0jIDHfLsJ%y-(q&(ySwI(kXoBTp-$);ma1rRtm+6xXDT3*Mj2 zx$#T#yT6gEiJS6BQWxyp^JfH*Ht6FcSNHI^9K=&3kyze@ zC+l7<)loU(D=F}`x3||z+oI{L*Pun-qCI~;cuy*TU2OZ+nVhnB)7bO=9AN==ei_?_FOhiKRkrF+x68qgi-vy!Ext$`Cx2rTF-GIE zgBZ-di)~-d6FTANa#t~PFuvXr{p}iPzod+hz1a42``ICMc%gO1DhBZI^OLJ>Hmd6s z2O~W<$LTKtk;sPLEdKG&3ojthZ_IRGxnA*N+FZ6(Wo2an@@8G5+#;vH0ld=J{Ik9u z!m5`?>e?T8a_u~SIXzo|PFT#pzc`6L3Tz1(ZeE04W0AIHw8@18%nrlMCNB=p2TS2q z5!f|B9!xX+%Q|89729@;g`Nx<10Ad4_0cNQo;i;n6t-SxFT^1zJEH$%rIF7H5=#t< z_W81YP*2nY=x1cGonFxoW;}T3KZSJ4ty&A;X~%6x0Ga~S7Q=?jjB1Yo1o&!G?79;@ zPQTQOz02I=UZF6C;H^3l(8lko*D2|ATeUAHWrIYD7270ZExQ&7=E zwoNNI%W^6gfCE5P9|jbgoL|O%z{t+3sqT>juo zoBnk~(*wqjtb_yvpzdzw|NZrSqK%l-{u;!8U5UeQqN9=84?9&1o!9b%?rjT5YzxfI z&4c|MQ{9Bwpf%Z4pONFU_E%29r%yH49lWzrav&-^>Dj8rFl&hPH>7h^Jh!*7lP1p^ ziU{$1BJjcYgm!#j;8kY1GJc0qUMftc;11K!DojwV>SHgj;U@1iS~p#{0+rSscRW0j zYyT<&r``ug3`WC;hYJyyIY(FQIG?^ueSi%nXuzTAqj}K+cD~WxEW?uUntQVR4ryi6 z&qz6+|DVH2f!jQXM}OWz$E7B2%avNn2R|}C5TS?^pqn$kHnE`Dj_Q#UTZSt50qAiw z)(BA>#IuY!x~{mJw9pU6YzL%-Y&FeNoa&NCb0siIb81PNXj}&^H=uyf1FN{CAA+aF z{ftca%m^Yb5t9)J=NU`A6C&5z19;9D2U{xl2WbwU1pAF zVokGr?fZnkK2(@46i<$*;{mMiybC?GDp66p^n5#`i|#U9G?MHFwUJUL=`dxDQRNmL_k1br)6NOtbQ^8Ts+vmkO@G&y`i$Q zk~)f9{z1A>P~g?KL|@i_zR=|Y>-1i=U3b8FZy)VyImS8V#Q(_CQ`D?F_UL)$0Z{up zU}|lCYtDJ7a62gx`0S5}BxapOq@jDnY@BQQHhQJmk;6GEPjaJ>kPu_M9fcib ztnloyXO0p~%#@e)0Uk-$YX59@99bhxn15*fw4GERR5-F_B}x1QRymOA!f+pCsXhII z3!NNl+rzm)tr1AO83gd)cJg-gjoa^{Ruyl3CkC}E;*tOTMJ0gRY)^L8@GNHqNP&5J zkBAU!bUrLFiR5w<9p9;)X8D0Z?jA@VgB-)BIk6(cI?@YANN`4 zPJSRGwSwU+dFD$n4zWtxB+aM=xb^PQ2EB(HJ!kNc%pp*S&Vg)quu9o^$22)5ubw{{ zbeI{{jEIODIr5s!SXJ>SXuVUH!L=}HtgROQW<;Y=BHG7S>Lx1Rb#r6II)>*~_~DXE zsV+BESAQT`35}gKqz>PNgaqNFCnG}@^uvnWe%{{RviynHzkg^qhjRgUa<)4?@|0L9 z+ZOybA}%E*KxivnWQ>-wn3$9p_f^G&VdaU&wyCl2zm7bvu(X5HjyrB{QWFCl?~=x# z!Tt3Y5}S^+Ef2l?(tiJKmus_tgh1@3pkGwHcon5dk*`gJgv_$Fyl; z7cTsy^?Il`=S^%7gZfk(f}QVi{UURm_5~Q_3!%Ao{e$&2Dn8-?XLAms{|u71jxY^1 zHqB|H{mHq000j0uHL{ZUd50tC(dOA6J|&AVtfcTnu|LWoyni`!r2x}4sM=oF-rlwb~?w%M~*nu8Z zNsg#8-CV4g^X1E(-1Ll$iFz*R5n1*LI~HvEI(tGUQs-YM4aK6>1lsUygfqb7_wd9f z#(Z?#M9&?Utsj1$GO)h^V%-OR9mC1SS<_t>mGek_2uYD6q!&GKnT^MXwiXp;vU5L% zLb?~HuB$6GZ0;qD~b`JD>R zGnoBw<`GR89f7R4ju4I0Sy8B!AYB1gkRN^FN`GIU|M!pPRrvRwKhd>hFq3<~-Zg_1 zkRDHq4z}?+W-LpD2*Cy=@7XjPE%A)QC9a@z(yT$;VL6^$jV+*IThg*#{8u?iqcKP@bzJr#6LMsyKbRt5*E_NIY5uK|lC`bPl zL7vQ5sXmeQysHEfr_bfoNI>Pj9+lrY`yA#Zto@K5Oyqk&D+IN#)m>mro_;KXhF#^4 zH>%`?K2Wd`sVKG+VHQ;y(Jb`$QhDbW;I|A)8;yORzkX264- z@Cj^;3q?(~1?(&yh(i=&3m5`8~BMCj2faIV?~*b0dx{v8?B%4GVB z&)4P888xS$L)>}w^ZZ~4%q(Jf20ezrc#dFbtDJxQSi(You}vfT{DpzVXnC=2yJ*yD zQ8?eN1p)mK-(BS(z+9v=!xHR)q3d8r{ zxqeiRVErtI14ekkly2<1fjSqzVN^k`G*PM92;a1?7OX^8niqI|cxbDnZ40rz58mam zBfit+^VvB$+!B2uvnyCSlsQckdLLj!d;a9)=Rdq5V?Ign9#FB|CfqyU5+@o(55h*HZ6Vid;E@8- zl76nfz8*=iPShsU5^X=A#k4QtJzqrAz_TeUa-;0j2GOnswW|S;9YYpv2!;#NXT07U zPwgOLKVTX&@$_a#^*rA=Y38*$j-wI~Z1C9U!X`i+%^!Bz|6^>hT_|bfjs}36IVw_} zK6~o6;aM4^6{a?Y_aI})?9xfHJ6-i@P|@q%t$h%r!$C4$h_D35(3;1<=U)QaGBqW? zfe;PdZDY>~@q&tsAhzMb%^f}q+Xx+Ls-~sux&sC<(l6(R}EJU8%Mh%#;d#O#>{B&A&suKg_#LV zS<{v+FwVB3$CkED+ToMM`PqYih)0j^h(fnXs_S$yv ztKwsOKSrXIClD-)k$iHJl>JBx!Vn6G7un6vD<(ptlsBQV-ptq-?`l((!wEjrY-O!&U6ay}8X*t!->*_zeL9 zo%W``$-z_BW}rX`eMJYR{NcZS7q+7;bnzZ#DWxT=TwX!x2M{95qaRyeDeAZq7MnD3 z;gxa~a*zxMV9!ettBz(*0S^yk@Jt1N0r++WD;$%~>WNU&cy)w<-(v2^5NmU6&o=Zh zsm2;WTdoDzx`Z)Bgnf*fFwvU-c490 zKsWIe;}Opc)oK4TM1c-#x0+N&7+f&O$*2Vhgy|LxRYF}9^?(C_2;dBK+Gp7G?aj+= zkcLv&aw0@cG)2Y}?ml9iHTz}I)K3JmOJDqCQ5*o583));D5Y_c^po3hvW)Z=1$fPY zb7|c{*+81Ff<1?ogzTMfcaj#LHz1uONJ3rvJYV|l2?e&9(J|g}&V{$&=!op%r_Pux zqLGv<>QqcGm-+|XQa9%fO32>e*(1MV(|^u6^-R$#9}Pjx?II~M=%VNb_f5oDqa3Wn zd$O7c?MmPA!p}@n3u~K0V)NlpF&>XimWI}=FJmil?f^4+6_P#hUW^L-gCd{8;0<(D zeNgdxr=S3o=RaT0H&c^S&!gK)l#z;FWc@hU3@5{Nqip(1aORbr%k`J5`Sx5I;?8Fg z3!)*WF8FR7OC6~pz)To@eb^hKHW6_yw+)#xfSTW&%RN;b!mpNO@7&X$otJl)uQ9%R zISM6`lC(M({-Xhzbrs}aWplqilKu8XWVFJJ>wt>PSPG_oh2sOX0{P~>>(bB6#qzwC z#)-D_3s^jHnrfNaAdA2FDD?dmfq!4Y7{22J_$UV}aH`#0+z#tSTZhq9ek>^P9w(}5 z6)}bu7LB|@IbXltu8yaVwWC1&4sPY)!8VuT@R}9@AN>g9GHX#IWjLb%T4f*!uN!N6 z9bS#}C%XY208+glp7;b|{emm6RSnd;*X2J)S9a3=&;0?-`@qRR==U1%KLi;G(D2Fi zjuisHz-iteV|F_nsRKyN6?6jioa3i*`0(z!8;0?g?G!XPZ3zw|AqRH)bT%@Qi&yqx zkKTpCsY7ewrt}wkzU1ceqDoR`RFg+P_kN%Ad%#o2U^SOc7&E`~%ySbw!%5@)ih5#E zNa>D zi}$9RO4)^C#Tle6KyM({8gla0@kFF1;JD;?fCSFgZ8zH3yhU4FmW5Z+r>9xACVBAP z=5Q*ygJ1Fgy=vkwR-t?Z)qM5H%POhpeHeTX$dj%`_D%uchf9a{U2T{%Pgf7B0VSR& zp(G3xUV{000zcs4L#xPa%+Bx)4&_`uH2-wL5g2BWGvCW)@%Scararebr2-IZXcvFA z)$ymh^?VjWmc$wvdV_vH$M}a2^B6{;HuxFCEm808S-SrALXuNz8)R!0l^mp4wrcTB z3@6KucE+-HCG_7!!X|TQ!ylZ|gFlL5b^VaH1YUPBA2qK&qvn83yAD>&?jZ`B!ahzfT^ zE?`7$KK6YVHf~IW(T*IX#x+}k5Y?!aKhRMovi$I)!?wd!OALmogW<6#w;E6^l)vN% z2X`53(iXAbN5Wy^*19&6vC6*6ED_CcI3`+yf1*GM$-9Smm`(ZedLS5nXekLZ3|2Pb zj3%jmN49Gfl5BYNI18nkeU8t&yhl#<5UpJ=038TBarkAO18(LD%oz@pwhy+`3vczg z;=*sS{7?9iEAjI7ChV+J)vKOv)yGdXHpv>DG1iXIuLjQ$!Sz>@#}4#~LU<@8fZ;%4 z3LEIB3i*>QMCvO-HRG*vq1lEC<%9mb@xdW>^rc=>b*b%#s{zWbKDHGmrReV0`!1f3 zMYeVSt>hm)cMNf?`|U zX9$3Tw{Ej2S2QE7LWjUR7Vo4?yyA z&d}2qR?G5e!1I0vRD63%@Aoc5IoGr%snI;^!`&E$mFGMp&tDaKEQkf%-6Kl8@R!(L zv~cI3o+aD=tpXkZhxf+g8(PseeY{aP{>|7-O(f>A7uS1HMr$I>gKKK?e$D%9<@)-c z?Q8|iqz4Rku$@r(s*to?wM8%KYQq>L~HS8jFVZSb`o8}1m*3A6iU9S*8b6GQEo+KWHL6ZX4syj7RQkT>Oc36DdV zd?CA|z&b<2Xf*3m38=&-Fo)I;0FWHeDz@;w_)^k*RX#W9NH!wp77y3cJt=Z4x zR@lnz4OOCfEyqLDd?Q?F)aIHD8TR{ufrTK*Lp$jxPKNO0=ibl8hOo*(j}9k~6*-Ky zBR>B$SOr!5`+m?@{OmL*Jj((?@=;MyF`D0An!wK@kEG3ui;E*#c1d6LRJ3EP8oQrJ z6%$qRmlul0=8#_ezFDmUd?!d=UFxcQdh~AfV{qJcZO6Wbc{dP^80q7R0lUTw(^}le zn{u^E-xR$#^7MUwQ||39^tZndse>uL{N|VfOu|?m-_^96gMiY<7l#y~K3Md=u>iS9 z&4g>ND@8YWtn@^X<8ZVB=_rU=WE>#&f`{wI9#OpAftkYct^UosdVz#$#k zB5{YG-uV7(ja>Y4VcO6uZ^!<0j_^kQx^JTSsNYoGS$W)lXXMlBMB&?aBL)Qw=#+^o zYaB-mMysspYfvx{yCYMFgATfi1_L5cZ~GY%eo)C*GSaL@DptmIeT_sjb<^g}qAcNw zL)rssc9crXsyW#J815Q-Ra4M8Xu=oI$0z zsy!JQ8G|ha;NVyL$~aX2HQ$ZMsyR(`d8#CVupEn2zx8K(q_jqxhsB30yIft@&#c-M z@(+{cdPx?#sE{fCwfPNxl47blqOO6X=QtKrJg|@mxMa!iFO@zAxqcjuwwz7&138GJ z2jTD=xFb47ZQ7NbpZxt~={qAdXA-fhivjf*-7D3)tGP@Z8eBP&5%L&svF@_}3Nv%o z+vRSFp1GVKrFfv)CYa8*jD~#Y_yqu%fUZbFqt9M^3fY!tk=a(Al5!Q+H4Y#2l3h-V z!tGAywH{b(w>Eij8zl1j9EPRu>#d|DIW(h;K?kM-ZJgvmeV#XJUDmYr>LRVg-*;Z? zkut~;=mfb$NGnDgMcdsrCB^FW^_w?KeI<|PbYp>TVXVjwXZS{$`+jBuFSTdQV|tRk zmDLb*QTUxfTtoHcVW;;HQkKrtm}E2nop^T1)cr%FoMW%s&wx&-77>Or#VjmK6)dXWu6SZdKrPDhb&)tm{xvR z_X;KSlRO@&{Z4x{zRUI_y1!}(Qvmh&=|MLc=~-i-*j$q%Jd6iYlVO#i+;*)!%&U); zJ~j{sfW1hEbv#)pU8;M)1FhdOGIT79-BD4=E3rf7aP<3rYsA9}aM)tV4`m#L?m9!f zN(9BPkLGTy!U=0r@&Jc4?rSLX6v)3FLjV9A8q+y9t3{*S#w!_(x|3z`+edRrJSUW8 zCvM<4*u{cGZuW=L=lo6+Ek!C>=;)?}nt;b*luX74TCHfK8~@=mr_e7}iV5BL$e8Fo zbsYTSfsMmM8PBLOrsJ$yx7%%pcJCs8geC~cL7)@!_jND3GE~OZ)J!!^wqJM9{+=IL zi#H>D0cr5X$Agc!{31 z5B<91nhWsQo-AE|xY8m=udT!+0G;#BY|fA@gvr7^x<*kidUV& z#}GIWOJ<*Q1Iqa%S%rZNQPduA!qS1W6K{N&gXh);ouA0q>M{M2&~QT&a&~qjIMwM` z;H^IqHFiYG0-^qVcGHD!6rrU*f3Io^xxRS*A z?;Psd1zHueO3x%M#a}tuVC=PqhZ--H^|hQ=Cvq*<@+6YW9hGp1AoGTJManp?yh_Xt zNx}iOu)8{FSU|CO8WXWD_ZjaaKcjC?Dq~EtBARWL51xsi$^{H3q4U^-iu|mstX-E% z+J1Vt9JB#UMpILB)T?;>C@_2ghPyW6_`G9U5x!A3VFX(F7N8>DsDcEOO>0o8Y0;A} zYr2cokMrBM)Tp~BAT+ldlw8l;{vYs+QLaen_>J^CqQaA~FGFD#B7h?vva+(;;^%1V z=gS*-GQ`l+b91;xufs#x(K8gA<_TM)&GFWqiEgBgkI&z7n<8CFgXulQh) zHdZA}g{z}RTlV>`Y*KsPV_=YXC-+@0_0KcYLV?Pu8YwpN2?bW>X55SRDm zYA#x5z4k5hp9iz{fum||m8TG>75g0Ypd$lDocdA)`7*fp)wj6}?A(-a9WXvjWiLfeWvi zl+`APheqw26XSMeO`q%#fb?Avw?tl@&NvMEicU;N{GOM?DDXh0wm~+w8##*j^@>UP zxw%z!^_ZCSRWyIC0neiV_{}5n6fWgZz#1AwU-39|!-J3onA;PDU6BbNN5r%; zni9e2P-(Uu+^0*c)~KjaK_Wa?r(-MXO(P1Ym0U!E4zKS#-B{;Rx+osNb~IDwDO;tNpB9y+-h2M&Ly_n$;2Ax{{m=PI7Ia2zt$23wtvLHar+osz_=4NQH{l^+ ztZ^#;xz1b+4A3=99Yg{iQX;UDTf!-@=}&#MnfS<=nPWPGoLf&_-BrTLDoY5%!&62Z zZ|m5kn^pPk0If(Z1ao$@;T9k72%qcT^X_HQFzjVr38jcWrJv`6pP({pE zJS5NONgEh|pAk)vFA0bots}}j(qP}dROFy8w+0zO16E{at{Cr9OplLbRim+C5WIsf zlq+JMZ_(TyiSP^%ro)Ff@m7H@H31S-LsQeuxf>87$jay2aBa4Z>IuKryYx?bF`8^$ z5`BDgKNMn>@+I2?CvnYz#N|`+&ET*W#MtyNz>I};gzhqJuTDx&KW5++V;YPHL8*HN zi+588lmfJj{7^^Em;Mso(9)o~0F>fDNz;ypjT$A?&5 zqQP*2*o&gF5K@{=Ca9p}W}(Wy&)QCs^j-YBp8=RW*e#1LV^0zAg%Cg|$G0%Mvc2i; z`&}HDZ@#2*=+G^iBMLrcNn8x<^UUnj3Vc7Fp_`qZJ({Cunr${Ng&0>^HqqKwa`9KM z@QB>6f6mhrc5)^o?Ua*`x}(zJO^H#DBHae|##x*tZro;RfrLNPXeEI_HHHNy&kP@( zs=zmvkVVGSw$v?FHzI1mXM`ZmzBzcw-hW|S)~6-wjx$*v?V$&H4Ey{J!j`7)eSP9h zAkr)vHFX}()glpW|G8f=^0XXE?8~YEBs+ZgaODGz0PQ6Erwt8#TB~SZ@w_7sxPr}3 z;XrrT({$Q({~p@7pSI0eKT<~=>b?j=OT5k4a{OAW6N}6ouP9HU5N76qM4+B1o6)!R zxx|%=ThNSl^sdxc*X1%)=m6{4|2b;#>^MkDI%sa@8+K=Cf#U-l+nLL>xY%GCAIVUA zE*3z{dlR#2!%q|$x1byjWJ3h^+Y_VRQZ$4ihhi(Sfcvfhm2CZS14=8DIEXfGI&mm3 zAI`D6^PM~Hz@ZY5toYs?Rzo~PA3{UFMOgcLOpJGX-K-MS#Fy68mjV{;fM=eO%iN7? zULJ}(UEp+tYrKDMxN^w#@=CSw9x?0=+?A z)#S!UKY&U*Es8+m(@=ST`&7I&Gb1U$qi5+p-PvAaLPnkjnl1f#kGJYll?3m_B(+qx z6^B?wT2v=!{^=KpWPIbMxJp8fk(9y*iB8ik(dW(2fOopCMe+RaG2& z_A@#E_t&RBjIotMc0c5LsAfM};eZ9xNbuzwo1qqljQtg^h1uj=LC8 zx^zg{v99LX&iGB#ijU@oa9{P&BbCqmv>!Z@S~4og&m^wU04L3K_bz#*R7C2yi7eT! z8fq-`Q=INzr{G(O=_C#*-);n`>1;xPdSCKvhr8 z@wqH{NJ#DOO3&qtPwOY+D=Jf{Ypsd{1CL?HR~?V*OU@YrPba$l5uD#|`H-`yu6tG% z6->}_jN~E7b;|Lb>KdEz=7`(?<8IUnj4MB`c?^ZF6^?4Iu5_B11*~hl29hAL2Hg$h z4mU1xlv~y_Ny~kh#aPSk>W!exuv}l@{%eW{Q5Z+g^SN}m!$=($q6X|L+lKpEa3aGI zD*W>`5+_JCB+OdozTW!vRxxM-ZAgij^Ky@5-VAqN z4&aXS713`tFPTT`_!Ak=tW@iotx%l~K5N(78j^WO!L1Sfi#Du(R9*HSF`co|!fe^B z7vK~it&-^`u{h8%wMHZv7P4p8;u({{F(hL5*}95v|P zaiMVgazGrd%&Rlx`4__r?ubE|4B3=TEQEgnnD!h>oGW&>b+r;wNF#+ooBa*kSDl1T zQ#lsqi~TMovubH1M;T&2qkglT6?5t7>zg?77ZRsLdKKyJQBj0{zmAupRZEr!eY;gf zL>-wA;@nFiQox;qwu1zfb;z2I0|WJJCa%e8;&f|aV{7ZB)TY#AWXGJUNlZI+H(JdnO( z%isU2cfK#>NzI=q+K(d0Hci|mlXS?DI8xa>BH*O0gHSj&Q5dHf4oAb-geFnau=5ksP&MNoC`4Y|k)Vzcz4EwV2 zc%}<)*lI>^_9=q+G5R8|@sWI}U&1LqfX z-j#4eJ%En1BP447`Eqhd5sr>hNB5vNWO{HZk_?SRoe4D)^DN6Zx{2q&K|;wgVYG=A zrys6Yh%ClvYcM}?Mp2Hv9PUXQjy5CPH-0?{4^vnCJ7TOK2+<1yWZnBv57M>kbav;C zeXY7C4m-2pxUYC`$axyYPzqf*SModT5N8Z0MF!opnhrm~nR|1w2Ur&!uFs|Od1dU; zZKdYM)?g6;dETIeO4zjMjYg=h!o>MVTAnsOi}77HjWC?b1wenn_ld^E_INWL+uWNIVRa!+8XyFhjXRrX|w5-8-Q0eHxs!%SXA(y&miCg z7W*P{Gij!Wl;7E7t6+)kG?q~L2}Nv~W*co}!RJ7zVrkJt!$09_Z6Q ze7Lz(kAFKNo+*g&8gv>+8mUjg7nNm+d0eR83OvDBX)-MU`E&uF?>nv5#6dQ7UH~erzNi9zRwY%M%hzDG+R>cPA9Y*y z3m5p!5@Ye0$kd+>m~cEtydt_YSm>+7cCTIYc^psMj$qK5)fhpZ(Hft*bF;v1Ldrfq z84@PMuK~hYc1}i0YBM^gnvbA92nl?t=6pYnsu|PnD;D+jwoDH4|A+~3nggi}}sZ@JtzxK2nVynTsEtBfDe+`d(R8&HutWLmH=5|Xz=7cvgi%3*ot+3r2bxvN# zs?2g?Y+{`AK9N&HR{RiFQR43f~7hH$ia`D*`S9GLC`&23(Ma5=TgO z&4HfB&^XQ+o5xht@7}%dZ;BKE*{U~iDQ44pCuyC%UY+aPB@QIG^sK8)O7-Ya>lu|h zb_`9SVJhKO4tD9kEJhTk}W9${$2q{n(;foQfdboV@MmqK=fV@8cwi1 zNI1sUfJGcvq|!YBknRT)yUHOu(d}ZUi2w$xIMlnUqZ|~S`yP{tezp%>_{NNorb$!w zu_~7cPmC|jIyBmIQuQYptd|lQe8k1{(l}aS-lg6JPIdWvn$+nti zL*ogB1)ylJ5(_;JNTy%{hy-(3VsRJ)O6+3SWwX6xNIkZz&SSSlPLWCtv*Fd>mbuf! z1|eZ#;SMD0lTp~b2wqf| zfAD3qhK7bMaIUYq@omO=hVE}bK^)(f|J%l27s$lur#Ah#PofTeL!Gn2cp8of~_4N zV65p44-(eO-HtZ4xq6k=?w$Q83w}Tp5RjVK@X6U>3#ch-VUh(VrNOY35#xw3rD-FZ zQK)?LX5BK{Q3{9wkm9Ye?ayT=I57sUOEb^}En07)Z9tHbtDO0E0G-y)<21$Mf!^t^ zt(`w{w$^04$J75~xs}F3rh$}o!$=QS91EJF>H%97iZTRX26s|{!UElF4vPz*(22d7 z--}d|n~K#JW|h+bt1?Y-$|CoBUx}WW<$7Lz@y9QMm1v{@IX2r(kC79$VdUugGq~0@ ze|x$zhga%3llG!t^F++#N}XQL$TR?82JK>OQ8Zq* zIf;Ll=~Y@itI&uN3O9`JOzM~iq=GAKBttTiL_(ZX*WgL+?TY8W%O`ySS{1Mazh3^L zne4bf*%3lbO$(71E!c*F2hxhWyA!&gi7*@Ds=5uJPY`-mV(Ss@&rhdixFx%rR)nIl zM#p+DZH_QTuu6(BJMwh96i~{LB_zI)aS5=dAe?PuxxUaNp~e6C9JVzC%wfTAEuY(nzKZ)epC^Co0ezZgb^Gq z@)I)qkLUlFd>ubktLW9%fC@P8g+=P`bbXVM_XnH+tf%!;bh4BrNbrY7jE+?idlM%p z8G`GsXd6+E5_Pb$Z&CD{Qg(@!FpbEzIv2gM+UwDjZ4z-*Xed`C+6e?Rz~;p7O}o&@OME0=J^3;fUa%p1i=`- ze}Cm-j-^ZUq=XwwlVw7tScy}&z~3wpBg}uL{3&+!Ylp`9l5g|liEZaZe~Xrl1@gPx ziOq_2F^5eV^w8Gg_AwaubtOaAmF8hki>|x$PD15hMX~vMlOB2P9`D^Y*oZ*0eX?X{ z1}s{w1wThX9sLAY`;v7@ZG}NPPS?MpNJ8)Pax5sl4DBR?lkkY%8{WOZ_qVYUZ);aC znJmDGe}`iObm`PC>q#bL4Uj4KhwkXwl+S1n+)h*gAg3x*GUW9{qwiC@kbQfY%ZGoN zmCFjusU-2J!YTpu!u_}D4Y}5PTIW+VFW9NCk8)t4GKeYjtI)iUe!Lb`Snw z!yy^Y0E7N>#I^cR%xC;pEeTVh1~mfk^3|Ev+!(p)e()3gxt5|6>j1Ui?iaz7q|tNP zXspXE>u77Nfdvf3oU=u*bV;*Vr?vX%fjx6!t1Z#SW!o74HVy{B9$Q-@$-dEPP8y86 zzDebi0^oc>?bv|~>?+7q=$gxQU&)i$DI@c*6!_kp@LZ+^;n7F893d)Ee0y`um6?H) zCu-v7ArDdy8W)>t4*?d2a2HVAf+a(x*yMBO@pTskdrux%Gqb^FHK{h_H1Fcqhe+z8 z=E}UJfbBpF71{^#Yj#?u-O}0S6y}Ms?7j<$E+ha-{itVE#eztPIZQKW#!rSr97xIgrks zV?v&}CgUB?;iaez5wC^H9c#ZZXhUfEZir(OTsl!{hg|Tq+X+37g^>LUAUp(6H`8w- zOMbp4O9Su4|SfBH&-+mccH|2s+j79Y7_{93-Rma+AW%W6Da4} z;WW-Hr=bu}#rXihoBH|jS#wZ(?;)cP2PiU^H>f=4H9;-%cR-{Wm$edtF<&IWBL!eE z2CNrvm1wbZD477cp+M%$wE#jP@@Y7u!xP>Q14Y`le)j3dX5jdSxe05Xa8RUCM{5qg zoO*J#SxAiBje&IlH+hvl9SWrzjr;(G_jB9~3(@w5cfoJhLRI`s|CKxwk6u6NRIuI4 z_B6`c=eAs)X{PzFbVTMts1GV2ZWN&6pM>KCyNI_?9#H z{$fc%&PiGl9`f%bg#&v}+?g}YS5PUd2H7f`#4JLe2I-<(z>qcIPN&0UC&5k7NhpGwMb0tDX_B#^E{s!Q; zAcyj2%|zE<46euINGJai44vM6sSVjt0VYsZ1hS2}4z0AXxg;$wiefd~Uk7yA^m5QA z;Lu`ldL*Kd@)40Z$DCWtfHRXDsw^Ne3&R`DY*k;wc zP$_^q1!LIaB#2@td6%F%#$5Dv??7He`^~$lNFO}#^5W9pg}gcX4POk`MM}@z<0j@N zZenP&pIujVOU}lbFVB1@1^18fPM?gLAK0Vqg43rR^#rKp{+(D=xZYtWeo^bL)c*YB z(U&f|mC(^x1tLHrmybgJL#N~B9fu@C5mVo!i+pjZlL4acRC(!9yRvL z*HG~$NqODBKMI`@U%M`)C?nxpH$PlFNpF_z#;8L8mY*#PL{#9J3k;XWfw3ITd70+Q z@hylJR*VF^!$1a+fVVm`(4vrNt5XVgBdikk!^BW5!xo`t$y`6vLuQ~Ar!V|$$L4ZA z^8>ll)<_pg8%`65!^>hNkm!(F9sn_-1rmu!7t8H1uA#lgN!n2FW(V%-?5IwEcx0;s z<4#T!n@}8rLd4PYW$z6b|3#7Fm5M=$P#fxb@K^{2a|$7-L`9hxX?2H(o}M}MI(9DW z)3c1@n5-e>zEXF)vJ_c=UxwKkggAn_ZXASYh&1m%UPQHT@`350A@REMm?=MvdIWwCkBQfo zQJEo@h9Pv=lKM2C?I>t2AG?!`z!y{j3WrTg_bM*yu=S60FEE7CP+uOEdZD$92WvF zG3y>ZqTmlR{x5)7BWhLLe17&5`2 z(*jx=V@5U&tq@MG6NXd&@Zk#a69>qzVCKRRVgy6};FW1eQ zpAHUCw-~P>PvG~_VqpghG1ZL!>iA${ORJBel+~j^{R^7~%FuLbbG&fEw$+3uUh?{A zW1bYbeW%f^i&BE8j@AwV!^|VD^SSgG{?X8}&^9w`TUsAl3dmgE=Dp1z6Mk|pp~<9; z^8k(KJKyKn!d!2ebwScNbYU3(=QME!Te~0zRTOvbQl?0W>`8Aiqh|Gq&b%?odw3J` z79xl!0naT55jvzucDzP|T6MI5-2AW0KA*WPb)=QRYOLc}njp_O3aD2xOzoHs7menc zu3KtY6A&0><+*{P=utRy=q=JF=p}fR`gQX-wa=@n{^w8T2{Ln&2)&O_m|rD@MmSYA z{Ymbr(`(5ZIeeBL`83XnDDi|=we-MbKqY=Hjm&`K;-}d!wUs5M*}1oRCwZsc40@J z20Bi3QLDOXs6zRmLL1@Plzd)&2NLmUr&_k>^W#U4z;e@?7-vUTUzZ_Cc<3|upg)l1zSvuzYZNC>)_|u!(P>5oMb35B z?Gcwd$M%@z-tK6bbdH7+7jc|xXl#^wc`_suAcf|r^Ce^WElyKlJfO(KP3v)42!2zR zu1lpsq#kZLcYZPa2J~ohhJZlkO&If!<6R-s>JT$`bej8O+j82YcfYHL9?&HXxs9wf zXE@3)zN4^hOR;#=iI8#u$th7S`kG+C+j(pj>lGz}=aNRsaF&5{^b@hWq7v`@*o+}x zGOEnKaUMd(%YLNJ3tr)k+(Gw6NM4o@!XXn+nJL4Wd%w^ZyrVv+#bN*CnxS}LO)fX_ z-th+ci|t5Ie>mk{FGRg^AHUMWkCZnU3KbTOhlde-uQII}g(~0Zo;m$h);Zmu+FhaE zk$Dqt7%CTNx0f(O(3-p<%Y#&nDZ?%c_=-8CAda3derwM7ImPH*d>6F5l#n#|LrBQf zI}h;8O$%7=5GmWf!xxb;1aV1@5j@5g9kz|6sz3O;Ded;u07C)QGrCl?Wv$ylQKs9hJW1ePiYMTbra-RQM;|s9WYm=<6<7C-#VxxvcRWsf9}(y;}X^h11&8T#6m1cWjE3a~C;~ zvE0yo{Saj*t$4*Hcq6v_gf+&=$j37#VWM*kA7`N(RDO8(Yh(O z(x%&nZQMt=<8{)?Pgjd?&-TZx1m{kk)-exHhFD~I_^rB~IBd#2`&%$3A|h(c4Z-C5CVseuOYZ{UF}ne{p5KPy)KNoKy&I?OXt`f`6ea@Ys{ z^P|R>ewlm@#!KL)0UU5nTe+cjDi9%eDaZE*B$dehO>HlIO(^R z=($)nepLXn|JHvFh_YbOWRyo)Tc45)iH<+kkGjo{QW(FQB9{I0EOT&QYpA1cXcxhC z8|~HC%|3(~pVqJVV=~BlLB)sE%?skL#Ls?sj88h5c&1G5lD=K`BOfD_72Z_8EzbKN z-)_Uyw`(+`L=+fQLALCFT=wzQWi7-EQlY)-qk6TgQs}=&>%D$zv_6aZ(M#`>l?nfU zKZx9^2cepmG;-QlW0$FRvTmZ}{}}C->CpnuYKb}r$L&1dihrHRjEOMLnOYnVg8>yo zqtOJ_j;MUT|8eQ<)0alwGAmQAId5twFs?T9M~unT555*5Yq+Rg%;Z^c;E(^YARbRG z2*F*7Ugu!tr8&WG`5zz7ocZv6m%De}9EO+uj~$iEG5G^kQ>dnd5Dz&ii*M_?nPL9z zU5xqkh~*s}Y3Orv(_hhR2+cMA|Kp%+vLC1)dz7<|q<`f{-kndp>LO!}_QO>V@$k>@ zuhp9!A~SB85~EVfk9R3*1|<#DMmOS@L%-g2)P%C*No}6XdxHPR`toC}FQ>3W#cj(j z1)jW1a&nJ8on8JRu024HNY5^6*ReJ^6>oL%|F~^n-MgKic(jD)lEezLgma&YZWI`k z3p@1)`pxO8fPTyT_mYiYJ+)+ce&ZH9H!(K&l46!D{Xb@ub$UiW-&+%qik5P1$k_4y z_ZrukvWpRMef|AtiIbz+5pU)K==c9vxm;5#*Z7@TvhRB!mQ}B|$Eg4J7a!Wkm~YH@ z)7U`KQS$<*gZ%dtcREjP;oO~PzIYiV0y!5LRDAnyOJ(LQMfcY!Q?>=wOnzC%i-ORQ zTJhgsk$3te(1bAQ60WLGoy-2uPs&VOJ)sdCR9x;btn;sVc071VU7poQKBZ*K`kl#Y z2c3!Uq(5y~^ou|VMxv$n<^3R4}DbMWt zx+QEb^$}ml$;4-B#+4rW`O&il0`^7LphMO>ZHd{du$Jq=W6dDlsEbP?cD~VgvyYQ$ z3u0`hR+?CWx}JOf*HcSw&tq%hoIL`@;3KN0AA>9NF~qY@KEzpHj>0x&YA6Q)b+yre z7_;QoFtz_)Vpj4~OYGH??PoJ9<5>5br_8aFpLJ2@KaD-6C;0Z>>o>D9UbLF=okJ3yv2IGw-aBy!xH!=@sSWlFP+j{EcTdBf4OLA$!rmt{3o?OiDrA`Wi<2Tow>79 z-`eRrL!q6^pej&d0(NW_d%`J zs#%jI2RRe;R!rZQsPn0VpXqtdjF+VEIlbb=vEn`4uCsSBr_wO8q1?@&bFsGHTr8>;TfLq!X3E$RpAn_#b(*n4!a_jg{L57S?Y9lkzB=IG zL{DHx8hZ`wI9^sOV1p)_yhWfefPNz;z_Dq?R3^fNo~?19QR4s&eJ{G+O$51Xy_3XYZ7mSmXWu4lN~3<7IDNJs;!Bwxx3it zJ%C^YISpYET0&D^S0#^|RzlccE$l0rWaMGxY`Q>c`d0jyqicMmS1{=&xr%p7U{%1H0)fJ_p)V)3~gjW%Pdin z6E4FF@yqETVVEVwnSJ#6IDBva-L{J1%zg33soK7m_jx?p9K{-wKP2C(ow!|JeKPc&zuo|8q{K)8| zLQ=?VkPxClHYKuUlW{5up&}BI6_UO8imMc|_uhN&as8ej>dgCl|NZ;@?z=zENsr>X zKG%D^UeDKafb|{_<;iR&(EZXq-vufh>3<$VI-y6uway-OIY1uMEGFKj50)QXSs6*f zKouWD?&YbW&I~=g5#$86xe3|7>0oC0v4y-mi4AaU`nS2cIXIKSUn&y?lY8I>)7+UB z$t76&fH;LH9VPq`elQ{V3CfXaZg_bW+@Gg z==H3|@JFQ3J<*`R)a`VS6%)Vt$*&8r7Vl7j;M@&jmHS4n8jD)>+^cBXuS! zMM6}x-mGP>>dft8Q$^?vIzM$}FOECIW93m)UA%^pVZq2=n^`0~b>2^hm}`lk`74Bm z)*vYMfe%O1Y4-TDrqko8MjCFr*e26Q3hkrbzgGw2csRb4A`H5f+Rf4BF{&M-+eR`f zSeuiD-SWXLd&MPjl>@X3(aN?&xFaN8PPkKHg9IYj9)H44$d90;<37x&p{@yrq1idZ z4wo4!-g8y&$eF$fJf9huQB!c(jg2pkQCQIU%ZMuyr?sJR2r!3A9t3uJ|62|eR^*<< zSHeDww9}EvN)kGFIX02BO@cg;#NyjW}%@PA6zguLSlVOll6?tNOp^W4y;j@ z%Y;X=MzTUT?%l_vUB_O^yQk*PokXMpHlK5}L%ft_>+cQxiw0*B_K}8_$(Dl|6U(v& zIXS-z9GXtljBVhXSyaYj+BofJGoSk4mn|6+C4_8+x@0uSt@-qHtx`ay)y(<46RLTf zYkwkBjMPurXdknLeh6-@M*ehupb@x|Zv8AC#{)#|HPIi--zAf?+1-l3c zmo;m)Ll>vU6g}BoSC-_{#`kMAV1;=Q{&ut977WYpf&-mYvfjFX*0edMp=zr;`b=HM zRCQ~NUQN`sOiPpR3p(JOJr;Cv-o|_6osq2 zfZv5_ZDuJq+zT)p?;Mj#75#E1L3JC#!NOGPmEWs>ZknIYJQ7=%O=e=CYlEv&fAi8) zF_zS~n)S*Fbw-I@iv!ATUENU|g|PmJ&r+~n`5gQ^qtk~=JUm{F-QJ({&+%z($@h!& zushq$EFX4_vxi-I?~+&cb}ifFpv660GEPY{VVBzwh$*2%v3p!K(2v(553V@{nE#vT zl?UGtStro>l-?~y>sm>S>Vxe=c;c5TL2W#CXC}TRZ8SV|K69@7>t~j9{(7}{SX`aY z7^xZ(XPOt@hE%x@fO8rgOq=!9rsT92*#2MiYdCGAlAdCdXJJ_xS|gQL<5netWL)+f zfvf+V;nLE~6$q2KS58)9;eY#;#Phw(ChYA@Bd?L@tawhN?nyNVgwzED*X9-bM=*EBm-17{P}MkUAG=-?weDa) z%x46@zrb(*&-t@bl|)!aF>Z@MdcVO8Gw63#*W0?wA)+r}8st?eA8}o4KPgJ3x+zXw zZ2J^UjCQ<$Hc$(*Zs!5mIvuPh4m-X~2?ca)`N>VwJqVjd)4?&%kf7I; zpLA|25^cpQ_G7vk3j+};YDd<*laX|E2D_VKPkh`mjhdIA-&VvcrphTGhl{c7rH6;{ zaH>}$R6Aqct+^wQLckbDY6E0Z>&*Hq6EC=U^!Aj$Ioly^xykQSd5E(!o%?#$V_K`P zvy-H~VWz!++W(lf0ZyC_HIz~REO-BGC`K!qEwwKb-CBQr;`x>RJh;o|gbXX&Z=7b= z0@=2zc|DhoM=W~?{l2Yg$*59tr%`^u{V5R?eGRx;s^x%N{HrI{!cb}tKVD|b@&f(y zXHtyyd3o17%H@L!ZLMUYOPEbB-S~;jp%InzQ1JduXetm-CRLbuJ?hIpTQs{NiGpu8 zr8H61&yE@f%vMEHVB+jALp*C0VJXXMMX*|3QV#FB?)5lm;ZsJ=8;Ai7pRJ!3LoVM< ze~Y(d92d2?uI>*(x&`Ckcr*h8NQJ;SmJr@<*A+qScr+v#kG4!QT<%nAaMbv#h`Y&m zyzirG`)Av#lJ5SkHM{%{w=XM;1XtVB)h(~Oc*~{%W6t*d%*=dcvY`?%@z{R;*^9(u z^GBGj-zpHgdzUTT90xJ1dL(4w;I>>qeI7*}H#QDln%HLZsVWTt@?r;~*R$&rD}tDV zCPiSZCQ-STG2ls&VN{XK{*N*E%;7o^@x%&1`V17gfBO|fH-2WdYPTy#M%)qBIvWltQ|_^rKUE z%8wmmd_Cy{5&;s$Vdh+h4;XaB`LEzHd|~vPwQ9-YydZy}eY10-ai48ySnENLGS8P0 zccq9=L^kzAy0{O8h=`5(Ke2e8D5q}=k%5NST=06e(`8@da@CbTi#c$FZ-C`v(LCEI z>wzG>z*wcsUmPtV4kOmx%bGW5gTgk$U#mHDVILHl1L#BC*N4#X&NhKbE+l`UFWdp@ z3bB<(mei}D>w2G+&33tQbs7EntZIM%-kBaQ2DzNN8oaT|-dMBMb$=0rG+1CrOOK#( ziI1~+k}f70?XFq+Wl{fe6SCkPMLBSI0X}a>rCME92ur&utg>A-n4q^^F7w1Z`leXl z>l5nd0-GP^WczDGahydi=5}z+l>c?2QC#}gd!KQH(3el`LrnmDC(pY-Up+xo)=i+2 z^r$>#-1|nbDa$%kuqpPYS7)b|;SvfFL56`A@{6CWOvEeUxlDhmf1*a&Ruy|PWH75i z&x)$H$SvtfTfW0FWxs1WGQb9L$#kUMsd!yc!5-+6FlUr#4|Cj8WBPfhon_}+Df!K< z$^zH^>zH``2Z|fm<2OKGjXr^Et}}miQIRIv9M<5GIS+w`F4?gkjfKqu-Am2r8}Zd5 zj7x{2i0TtgpgYnR&=~U1whpC8h(!=@BL&{eD9@>7TV0l1rXKO5J+KHq2c1e||`*Z0DyEPQf1E?fz z#|oZ4zksl(-V&Z@oa+Z5>THH{+&_n^c0;b;OTl(#Wxu6r`3L6>KkidxXJ`L*kGNym zzes$q-!cK6o*BE}ICOphN_0OH8^8y(fgznK0$8O3n&7cuP^aE=OC$O* zr{w7nvk*~%x0Ckg>8vM343|D^pK;sGzW=BMS8R{pg0R9!ns&r}#>=4+w*%oc!&cV4 z!F}|@c3a9C`N^M`muKXc+27XZuA|?f`@GmYg1MhF`*b!AC`0RkNEv977KBI{WE(Qk zvc(d#)PF7S;e+3*G^(C1ua;sA0By|QPq3}-u#Ub)3oN4 z#6h<=18>gPAn(pvvyrNS6@^HFgYHCDO#&})~%rzCEOqY#TdJrSS6(ZuEwSe^^ z6Irz30Z}(MTUc)#2ARqd0vuc?VJ+4(#lgWvI51KB=~agHfg4S)8*EgP+8N+5JWJH2 zCpz=5N7g@d-#|9l!_wbm)-t=i5I*)YpOOr=Lsg)7oHt6llRCAtfgTnden(YFRS~Nvqp(8zd>x zH7ACOt{ST!j)ZXj*|?Sl87puJ`yHwnmGa;*RU=fesz;_bgLuB|mE9Oi+H18_i;QA_ zX`zL@S;)r5hP)j8!G+P!+%jRTKB;K}PMMRl9W$}v;k~~(oZ*bb2w1a@9_-G*Q&gjx;RdQa_CDpZBq}Zkt(vuB&dri3!p2e zTe*~Yh>$4t+tu0Vo`^;@_W`jonQGHVviMjsC)1!%d6BRXZDUgO<2qXSla^w1?<3}U z>}W0Qx$Kj4d1x&wFXw9cDI=|{>9N$1ZyO$1-a%fHu?zWeRll0eyt=GYN9UpcX z`Ku|PVLk|J(X6q#9{+n2#V?WbNj4M?Vk5&93fNLAO!f6fdp1~m@oSI+5u0ZJNNoENZ7Vvj*t?O{5;?*4bosYI5r6LP9wZ)Tvy>JC z)Aa}WCjcw7+2Mh2l!=`{omLkDHR@RQ#TH1`Tdd7)C9q*Z&CihEdo+W(@Ggd`VQMtL zR9JxFQWFm2jbfAj@gyGJAL`7sp(s z<}fbQl?`OR!``Fi3@4ZQ-M9a|>{owRTff?`wNj6ki%GiCo_;SC^cHr;G_h5e5aKD& z{RP3qr|PRgT}Db;^ai1k=4}0nx7G>F4R7^7B&pAi24LlvUT(ZMu>@ZmdrN3}gYh{$ z3>0yHeZcfMTqnpRfz?kKec*QgmQ`-qKVC6z90KHCmxAY6Y=g9xYgAX4=lMn@!9 zx*auiJbG5AjUXxXCF#g#Z*A~I6;`0{16K~}p{1&53CCI~^!TLs+r^s- zz!H7x(dqUt0@lh;=V2)gTZ`Yd_IM)s#d_Z3F}YUsP$!_BNVMEeU%t%a>~~5!)j_hQ z)1^+D!iKKXYv%BXMrF)9`E^r3m~wUrj-mfBlvuMmtIR3Y&3hO@f(`b%OBZy`gB$twlJ~D?x0dqFOast9Ulv;Gjqc>1P|df`>|2@E+5=gC zM-e|45Eru+7sV`IrehWs+PF+=!=&8bikpc@BnKz|p%IX9<+#9A(p#1fjk&v@QYZiw zTrhIRU!F5K=W8QVkq?z69vdA@!FuoglAN^e6kW${z#V~&Kzmey08r! zg#BQdj6mABIM3>LFXSSw%VF=BHm6!7)WPJ0mxbHpsDp1RmI9cnFTucq0X))#lW@Z* zp%*-2dehE@r5{_Z(tBm1qiR0wV7#NI=p&pj#68rL+{G80Tg$ zfiewN;Zc+RTf-vl-L~eMan4(7DIoQ_P-0!(Tcn+of6$F)rVIFU z{zA54$Lm*Ui8IKbw{a!o`~;4Gq-yvYj4)jj6%|KdyqJE2X{k8ZI#1S8oB2MQ0L?0` zp7RvX(l`8bm0urPUeJ$_I)GdLc2hdN+_W%zu@7fYo5M)hH6~qjK&R(A*@IlhP&p#V zr|m~N2fFEq^OSsPleumJHn8J~$d51{&al0Gdr5O5W40Y8tW%c{yYdWI!kdzJ-hx?y z%eFCvwIR8M2XncyX42kt4P2W6Tz$dpJh+#L3n#{Uby}8FdMo$7g@*5#fWVhmycUaX z4rWdRQHqo)ZI9A7O~WE@5l$c$6UDaCaxbp*UPf)(3v`IRWLA-o(O5@9*xj`-68fn9 z3p*84=X!DJl$0oKok_x|0TBL1SKGdj(1j^0L-bE;X|S-Y0m%%a55}6}oA0G( z_eTj7y^hXUuuKL4F$+L25sPB5lCa1mdWPsYJK4LgyY)Fp|Or^*8zCw=vHQhzOFVJYqt-Wor*3UZdwRL z=}IYZujkF#HJdJkGyFMi2=HdTMI2-qqqZ$JJV}~x-(I>Rxio~_0UC;HF-ti3wnSfx z>3T%NB34PsKdV#LTF4cx*Zx7D-fGYs*L5t_PB#}}gFP%AA<<`3M}=LMnf;CS?#D9H-iC-;odSH; zWE5ns9QVGgqo75l+3%x2%%k=p=8wU{{SM9{=lzBu8%Xpmd@LwiAiK>qd_8-puX^ZB z_F|W77?%%k1GUoZ0B}V6b`;9wC+sDqrKOb0g5bF=0{huSAtqVMwJ<2)F&R;f62$(K z1>zospX}P>dO3^}Xp1@LbbnPk8qKZhrlovjh179}{WqrRgx&TMt$g4XN*PCva>Dw@b?F2Z9rxgs`H$Z0*|uowgSM33#L2a{%rn7! zEU-a8`%t|(v)rJ~@|<{dY5niAclN(VL&3|uj{e?NqE7e&^pX$4 zx65vKTIoo1^wG}Yq0)N->N6@A$v(pU23y}S*3twK!A2ul3x!w(1$&`on2Ab{A_HJ` zHbuq0+#dl`7=fjbnY*;$bm?P>(pU-4QnPI~`BY6~Qj5*H z3pDzRv(foukeXg8vWr1P_I_VoT+Kl)GgUGNIs$Rh;hLy_sThRVl@E1yz`e#0+qCK$ zbs^jBwOts$d(AG5NFox)sy-1PdI#@(ZxcS5b0X1k@Bl_vG4w)a*`&oB(hzh;eNvhIg?cJ#Y+>m0$s4e88Jx)-A2hmA4 zBv~~Zl7b8|D31S2ZDbc&j_GYrPmhDzOj853^+%B-kiuS47>p$;mF+}{FZrPW4Wail zDbD)mz^&+dhIHS<$;`vBGw1iEcH$qcw0wgqs}t){_Hd~KU6U21TMB?2miY0pQ}y+k zzX4GCf(NdE|mSwwTEw8M*KNTBA*_i=UO3xl9McQb1Bd3ILy6LT#kP>o2fq z!4$s;cP{2Z)dJ+X=?}Aj$EYnM2M2e61#Eh~I?g;^ugS7a2O}3Gr4FGWLBc9EAXjIO z55Y~wS6ZNg*{>kM8;8ggb?>J*NZ{Vg;P^BZQ~?S&Sl)oerpIv__e0j4fJZQzJYR#u z^2IZ$WR%N+E}VBeH4LSWH^n^J_Q@1oD2Ak^S3)H=*4T7DBaLJjIm;zVGfFI)R)&=l zp!nwXJ-df7jOX9o9s2bwNcyC0cWm1(&>G~Zwk1LIcAUp*4i_c*QkUbDWslycIM8Qx z^hfB65AM>tfg3shHHJ#`wi{}KNUCiYNG31K0~z66oyRkhp*PiE1s9xV?PwO<**CIy zL2ea6-)(3Z+RLtzqfMeS>nA#u(e;wNhPL~M zSTm|XoM=T+R)S{BRtpH{9+u4w+< zOpa?{Rcj_BInD@M_?sn-hZd(<*dow5?_xm~T@nC8Gmt47YtdjCh{ArqV_{^5(g*E~ z?POW{Ncu?lePLj^3kB4+I(IO!>J>*#YLIgz)Yk+9XGE3GYPYM7uCA_2%gSqW@Tbz8R*s(z;8W!uKF1L~D_Ohw<;!@2&i_qO_OtnZZV>E+s z#D|l*RlDbLeLO^&+yl@-cUWZ!IXA&Ski4yhH?~4j!0hXr-=SYw0)Zp1X%XkDD_@d~ zV0cvaaxNlWAGSL&l}Lz3u3i;CFudf{FKf+R+L&}TQjURwObk5%7%X2Q#{>s2K6h*W zv&^wB;2TJmC_WH#_{wX65-H}zyAq{5pDIFig?VDNIXc{8ibsMllpIhXaU^Eqn-meYs{ z1u?ZoVX|{i1y1V*ecKe7=<`U&qv24tU7Fj!)!4_12|+Ea!%pB`bg8ecSXNW@M9K*h z5Px3NK`+$_^aK3Z7@Ho=?RcWH+5f9S5Mf()PU>}RF*&gIRu@kLI!GW;Bsws{#O;HwX z6*lH+f4sB;t^Dxj7GCvo0~kNrz};y)10P_`?PMe~-2dVHGjH#*_cwz6Ql!-G0uL*z z_5Ky-p|s&NetS8J)16_!u83{pXWqUX_A|H$6apDn%BBeh(-?_Nr~3#n2O47;_1&j2 zH9|RskTZWb8zsk{@P^;M`P3UMFqV=cgl(Ncll@PnbyM2{M<&cWoCvtt^J8Dwf!rCqm!YM=QSFy%YU09tjz=&)h0 z@zu!GYVDruT)s|ng0m{W#ePBMbJw}TGk&I1I1s6g(MtPv7O2S3YDYOrs|bMpiV zv^zI6mflU~BALucR+N4_iEV{7ro;1ntw5j+JDmkd!rPnlHF0rqal`g3F#D`U_gDbB zrE1_;FM0?mU<%wL{1}F^0BM^xC3ay<>pVn*g`;W}JRGb&RnHr8Yxi`o;p_po#vM_7mDnsS zwN(jyC8~}#qDWf+cm*Jc*edUdNpc+`Kf5Cry?8C+P_lNijG7T3wy^`s1abya<;E=p z|3wyN6+0UlIB*CWN+mEsr8Y)sbHo|j7zMyd9xI_RN$$QU6D12b%h)i+Lq>E@`#f+M zj9g77;~|rlQUDO{#XpXuB`_n85p|>r>Cg%>(@s}9x5X3Fy=z4uku9{d0W#-cL9~nw zVU-7{Xl9YlmJS|+LQQnb;iEWJb)o3N>VUBit5}wz4q6{l?EM=zK0{5(j)Sh3IAXvk zmpc6k6&a7|RRyn;GU``X=q6%|bqbMk;UMn#vTIxq!yIU@ZU%bmb~r_JmEA_GbmwY+ z#D{FE&B@6s3)gK9ObOsXTh>^Y7xiOM#fgJ7~O`jnyWF`u72 z0?aM0l)njfpR`i9Bd&J=;ExAl_;Aj{Rw9AokP`E$ff(|ZOg;_Ub4 zF;n&ZX_xR1hvI%Py1U#{YGk;xweu6Z)81gqDJ{c|D*Lw@*``9itDC0q9FHbGw&~$FZPPLXSy*b z5xnmF=e3J9+4I6Qcd)_?r7&NVeiW&cIZsT62GEFL+N@aq5tN@O0`4w!F%y+6eJr}8 zbj7x!;n&rCDpcN<04aVf^2tT%u(iPjg0?Rh>-YetW%-f7M-=_zSK z%Y~SW0nG`hY*J2E!Z}_bR=N zJ)VzqNNiH#HTRLDln9d->tpWQmNZU7Fgj8WclFrCf)wD$eJ{?5F8)sPU0gGc^FS`W zxyBm8HZ#&j5f;agqaWcu#Fv?HEb}2zSIDBS2q9g7k6U={^k}i^e@8Z&j6QY$$2I&o ziF$UjEVk)YhhJG3Bk3QWPR(Cg1ZPgalS>qhzwMGIoxsFn)pdWZSl$WS<@U9kY##rB zEOXeJI-mPI-c`3&xV!T`(jZJ_o%n2;(j1TFJmFe<9E6lBAUOU-d68p!3ypc6WsRb| zr^mF+d-MjosdXEMZxkwGicsjf6sNg>ntXfd^&$*5A2nGHRGoLA*yw|SF`R&|8hhdV zm)A>$+m>U1Ue&weYcfsSmd+8=2Wl6Zk*h^9h}4Yby2i%G*D+#C) zE-Elxy0;3`t{{Ma;K^BP8i-mxRQ-W!80?d(hd zy4`D7Y)_~hTcKVBL;+sQm}&Mw+s*~riRPvVS;H%bw6wFfqUr|P<~9J*ohZF;!r8@7 za*0PnYuS8EnKs$%N8Fn7)!Qh@$}8BNlE}AOl`X8LbUg0*55c-m(5DkHvO>D)5bi2( zpM{R(8|IFZ{Byq@YZFJR@&chrfLqPQ3m3faZcnCxVq(wfyOtuENZJ5HA9Q=npy`pL z(qY|bOLhfL0n$nM>VY!)Swtj!tEZyr9V~=JHpAu&Awyaf-?cA4u2qOT7}5F>*b!W8 zSdR%&Zd=xZ`D-M%N%@Hr<^7f6nW}TK%`p-Y((2pET5J9+6|x_TxEF%{y-CQ6rHNCE z6nj&6r2q>Wk4Nb@5H;X#{_7Q#c_`gO0`qSd&)b0CZ3y|36%lOb7`0t;u~?FS{`U5a z35jfU&F6&o!Z6Zw+Uas-qCy?X9|SaqqBXo7%+T%=5J3} zZE}x&Xqg=EL^&^>Jv2UZJ%v?Qn&v2F`@Ll zmcgAY3f#8KZiaRNwJ~$&_qSrgmrpOgY}WZa#$ytm=2gyHetI%cS@~*psjPg$I^x@6 zEl{ZN-z-c3C18sQZeomZuFtzddVPWg1PAt`KDa4IvUpC!&Vez4h}!c3ToYe5!Hcgk z#c;B>4G`{cm1{YjAvthf%jw3|o^npo_zrQ=)G*JM69|<(wUSZ{!Y1nqvWmWVR{++i z3;TH;t%0nFA}F_MbKO~nnQ-Jc8L_#z0=a)@WyyO1DTOgZO`!=~meIS{oLx7iQ*Z30 zRkh5RhQI}q-fdTzt|GEac2S9vlxW_KUgjjeXBInkXNPLC7N#E;y;aRWR94u4Dm3po zrmwfZJl=ZX5d{s0IVMGp%|Jl_EoYX3odK%U+d+~-tlAvW*bih*_tWb7;gbuYluaEc zd0!F}W363Y6&;|2ngaln*q}GmU!yO3nA)K5$(?MSR%IQgjIC`=VC>QMd{S3uX0kQ_ zTV#J+)K}6`)e1fJT*(hGkEI?~xype7eUQs!ytNe7wc+?oZ|N&A%Ng>G`Qm$e$(i-h z!*)H6sI!3c?3qy%D!{2HMW)yu|U*G7-I+;dd zq&e2EKGDOflwu%4`y+z>+67}xb(I3faCoSCG6X38HDr#!4gbp-Qi9pA;9AIZjAAGcmZTNiK*eqarOYf&2Fw0H{f5ujE zFa}9m5Ez`E%WjkZ?4|Kyo5W5_XWeL!lLDi_47Fa6DD(94^=%CKysSExPag#X@kOAr z1b+x8bIJ@oIVBqBIfzxv9c3`&>O>+?&=!IE&tKlt>-u3ryjW=$V))EY3EWj|P+$OfI}>Z5ezHK82Lv=oiK$uV?&=b|7QfK(xY ztpW|yLa{|=NuR|qq|CdE`OgOb@W0bEHP2IY;pEHIZ=ngIJA=<{Z|3Oyb4&IUIlb)7`ODcJg!vQ9%7tXtu;Q@xR(+1FlhV{Lzo5@=ofL9J<>MP)oUL2Vxr>?I}= z4w_bEec~0)_u3&LRhKHq-d;ZQ=V@J31`{trOGf3e*Yc9cP2AS5-0#FhGC?ijUL5r| z7yJ^L%wG!zRM?m4`iKek(#h=pcbi}mOU0pV(G>(95Q8O5jpo5dQ~k#9oJ74-?0E5 zj&G%&A_O{zSn%mxmwqgB9MZ9}?jyUd;;kllJVOxG;iOE}eDd21%#a(**TF)X`xqc` z8wfjop}2QI4_V^LHVX|cUSsP)$JtGd>-z~u1Lho}^iN;*fP&;$2yUA=FVh4Xm19SS zSTBC))74FSL_<`jCoX(tR-AA7k)caLuRc--XH+0!VDu6gmUNV<3XZnav6z8vG=c$i z3?NBwLR5q^Ai!|6)ofuh)l}I0k&errDi|Mp8%}ya72pvwm|@hRW(8J#GFoshvVQ*a z9i$(ZLm5!MUJFo+i#N(UVRZYBEmzca=F~Gkt3(RY>Awvn|N85$!oToQd14TdjlVHx zmd(>O+d&zH9zk#e7WXb{n2D&hDodBMj{ZE3`%{x>)E>lm7#g6F!}S#1^LmDK->r`5 z8dV%ty#eeZKVoY#UYcbiMVJhfZ}S1wxHlV8uJtIyGum zKt*1Hei*gsEi<7g5zItqFUma&(Vt?{`viqTdkwO!BOxtxOa0) z5mLgHoi&_gwIE2xzZD@!_Y%|>eOEt>=DV;d-K z6;9{*{Flz|sAb8Wt#Mm!*o|4<*-v+T(d2Ef5*n{Z>LtEwr9Pp;MzN)pdn_lg&kn`I z%G_aP%h(Ooyt|e<(=_wtCi0kYzJs&Yv1A@6i!t-gYGASi@7@FD)zCEqBVbqS>nG@V3JWlG0Y6vY%P=}h(Td<^ zu51f=zVBNBK8)1VXwkh+-o_;Yb=h8BKY+@RC>FTgpam*|C^u(19IpD<4$;96jE5}G z(9U9=Jx96t2I4Q#J*U-+KHzXO?u`NI^+n(bNdAf;zC$91oR-#*E1lSr`w_!G! z{yl7JvT|~kFQYWw7gx5~OkMNOU{_F5@A3?C<3EyNB)TVwAnUCjVjjtzo$s*AHi?O> ziHny(lrWLdqnZhweu`|`N$vdGjaj@rJfXd==)GSH*hEt0_K<+YlA zav4LB8zFAchLJYuQS2I>Zz0==9Zoauvw?0-upt~B!4tZLt_wpatmiw={cfxJh;#b4 z4Iq=y3tS011`f}PCRas%)$+j3U%tRe;83%=1}kg%wb-){3ei+jnq;sXMGp=!WVni$ zL`jim2b88GkdI-%J+jPusNem?y9&CAb3{Wt18y>F*Kd%XHHxwF(beEX`3eSp0sm1p zR#s3AmI-AdaLP&WC@!a{9N9h&CJBs4BMcVwhH| zkoa!&0qb_7U3jv*NA=~&F1@v}pCRx$t=HJAdH&}n)JE3^MTnySr~}CaYND$E&4btI z{ks5CRU_JM?A4G+E@#`Ql^0Q~b z4Lifbt!^d|IWUL;ZQi`bX*f}@DQ(Mv&+`st9v=OMvn`LPa{AE*o5!nvzHP{&lBo6R z&+<5@8Uw+Nb2P^k(-vb%%S&)?LZ>=`M&_MV(0j@Cb*|QUmbQx>S(^Fm9w4oDr?4?; z-%tRO=zwGP$pAWv0o+4}Q$`@mB5Y3glp#3&q&pP|P-O2wE28VkW!F7dsAGVRlL$wqq4LpDlD zv97%154lEJQ>N<$5O?f`(}lH+2jprDN(smZkmgkGI(=#@WCGF98-4i%r}MiB`x*yc zX|pU(`0GP6a6Oj|g+kU)k~VH>j!FzQz(DwXZru^}bNK9DVq+hMJtt-}sQ%`NIjdIH zJ0Zy+=#N)`QCN~Y7Iov)b6aVqj#7fGshWlvGt!Yq#3f4)*Pc?z86Yl_8U!|}^7Jxwmm;}lxk-%0Ux(c<>T(WL`Joy0cXfo>)vLF=xEg$ZyR=Xy z><^1{GIhVf@2VW!#P!i$3P*KxNzaMnj2gSsYyoC zCr3vpZBvdOTiHB|4y#4J4X78VE>A^-^;h)NgFTGF4LygBL8DcLxV0Nr zEr>854E5ki(Tg>JnhPW>K9Ce!EC;&4$-W?P@M)&!D>-PIrqQ++qoRLt!@Q40G0k>) zjY@Z()xnpx=S>MD3JQy1FMY&9Z3y@8LL%CXcVw@-hX<9OVQwadA?j$p4_%r)RR8NMLQ3z-Ki_#s{1q^)Q`o%n z`b#{^;%z%*8i`Bl!zYBJsgvkt2I>>pr)zJPewBuJ!+e5>I-Q3W9OvoBh(&<^YD(^3e!NHjKTvItlMGrcFjjp_qhZKTm z-h3KI??`hd>ru-v5V9P9{t&oY5?+4%edmCHSc!u)9!FCcx-*ZD7t=eRYX{QrADbSi zn@BNh?xW^Jbs{Ibakx23kwj3uF4LN~ZpCMK^)R|Vf6?O}6C7 zvCqsm;>?u-wEglGZ>O&fIG!gwFj z7=l}+Y*bu;s)wFy)Fp6@R*eMZniD6Mdqg}y_FZ3b_Y;FgSLgdD90%$6muEBAu0wY8 z9Fo%z73V;#e#~1ajxTikMCWajSWc|@g_LhI6`@3k=+WF4Us|Nlzu7_=QhP{G@a3oD ziiA!*SyCCJ?2MDC#X>>TcuK6UcG5E*lypT~key4o4*TG^hy{DS+ zBgtar<-5YPE~^aeoasoS9rQ39Ee}CJQQdY%3FTNdbyL$4uoF7CaxV9DcCsk@(K(qP z>G~~#<8hI^3;CkB_!iqe5mIMBI6A8T^zg>2Sj;*EWfb&Fj8wl@tv}c)6ES1ZDCApW zg2tM~)%rrFnP+iysf1@F81;@Y&r3Y2CgTcgAWH~gc%exP2#2`!slMZHgRbWtmS@dF zKvtO^va%5&`E%-*@Gltiba}*M{&9KGPCuKDMj)PH7oqT503A{|1fbep>LW)I16^W4 z7KPp&ZsBdJj`U})UVMpT>y`Z;=yoQd2V39KV$n0DwuX$mwIijsJjBXnkNVP%6*q34 zZ?yRa50dGqLQ#X&-sy;c9W%BzcSMHAetr6QZ>c0K%$9=-~?6e?$ zgI}0=>r?x=bcpB!v}@K#@J%IyKImAa0~onI5d5;X^->nVZWK|rE(}}s1GwD-DJ-Cx z`)Gk1Iv{(CxDo$SxgJ{HLCB9VXHN&^^}#tsw37&ww0-P83gnL4}7hs z3sjqN#nU@_PEK-rdl!&z8B`Dw1b70Bf7b7ga>Qo7tDMdnX&7cS4GBDLRn(tlGVOKdoP_sjv%FZWg#{IMT;G z^YWURZlI^6ahKvZ=oa!8oCHO;L)wWmwkJLsbdZF}Q7@eMugz z<-)eLSyI}CnuF`=)h|beY`>lrz7QgM@Fxzv#*;^Vh|>QO3J1(CKw zMzWKmr{uL_Ofrs09Lcv*Jke|;tV4_-(SIFYX@Uuo>T2ENu~CTrM}?ip@tN)mwOwCu zc3so+XJsdd=cF>hJ5giunOc}{KA#`B{f>R36Mq8NhxBYSj)GZlq`<5_KF6 zJYc}HXq&+cX#fa+B;2668KyHWwgM(dUaX1;9Rya()voPc4BZNv5)37;T&dXR0w<#q zSi*ayfZlF~UFK=?6k8sq_AfD7kG{r~h@$YdnO-vp(7mCHoevKde(~eGS>o%B#|QiO zO7wgLN+bap56lhLbll4Y9AM8-zxf->Ux>zLt$Bs`Oo0oA^H~degO~#1!$l01B^YHJ zYNp&BHd={$pV)UyMC3(2F9Gp9_{E-{B^4JlWXQODV$Rt+fdISbP^yYPq^9>2RZBQk z<%%>1GPc@3+zzMXNqoz5TMx1OD!nWX^nY`|XzcpVlMqhffJ#>rx<1PVTRkM?iKF}s z^Y!>lU4U5OJVA_P2seiE(6EC(#~ZqsYS!ej5a(h@AEo z54^(C^q#zGE5fjQv@$LHW>CVHqkN^T17sOW9ot`cISy#Iz3LufqAg2T`#^E0Hik!| zbg$p5`o)-hrN%HiaH6D+uRZ?0W>Gi{WHWgKx?iF<+jf2~Df#qi!vGhVmCENST}mWU zv9)FglnQ>zyFL5)cB5&jkZ7uFnr*{(t}Gz`1`;CZa>@ObeVssY{O@UA$YnzVVMU(z9UNP*Pg^*$ zWlv&bY#vz+1XE+ouOGIjbVy`^!R1V04*B*lWC?L}$Fv%f@?qRA71QOysbo3Z#^dbT zcqdd5q_&!-G`g#!XU{nH)Mktq2?ObHqQQm+mG}3uN5X6P#y&8urMz2zhmT-FIoU2n z5E7yLis%JC5MDexdLU0pAw(29U^1AFG?N|?oDE67Dpo3-+I$mVZl05ZsM4r(%V93_ z?k^+6KfHX9kuiI+e4W7D;2Ub?d$24j4IGD$NEOl}eye|$VL4NIDxx}hM9GlcVfLn{ zEk-EvhWk<>P4<=oKdWio=8P5RMgeF45yO>P_~pyEDsiLz3Sf}1`XT`25c*J9HxPC< zFWfQTV5#TQZ}v?IgVsdy?b2G@nQ4Un^rFD&eQQaCiI3(4QAw3~dVG^U9SX+4x(%j^Tb49nb<`TcAp(zw`a3jYC45n>f04FNZP3O4J4#K4?q(R`wE< z&=LX8V=+hC6SBFcS$TMR=6V*$TG31UMNPr2dKlvIBb>DAF-hFxgjxd`Y*Y4@W=)CL za*F{N!$2y4tJN+a=)i2s7<&D^uqwEpFTvgSCXn?cW+(ZSBUC$jp0L}j|1naLXQ_a? z#aSLbMRZCShA+S@M$+}&faPEzxsRO|6hQs`3x*4mpeidTXyy_Top6j|Dx2z$AUip) zp&XoZzhgUg$Bk}59V)l+yF?kIWB-jO)*%Oc61H)9ai}pnTzL|MRl(YJa#rj3;oEU< z=Pz8fB~ZB%Z)AK~CO|XiIr1T+TDt)nofnfOL>l|w*N}yC(`pN!|MK(Lr}quNjRiWI z=r}*3UcHa-<8n&h62Q&e+}45{sVA&JCC8H={#BTj3Ux=Q;m`XZxU4!X6hspFkQdf zmgi6q_Bdsx1kIdc>m|VrdXB|`Lu=)?4Yl2~xl6h~^am;xBM#Sr;@L4thd`SpioQPP z1GCC7TKKF^>-~5>0;IMNwus7k32X6t&@&RuRUdTWhs9c3T9!?9apE4P;A;JPz?Cbh z7hYAt=yM1{(~)(j!N`Zzw!BUarYYNgv?_Zvo8wBC?qTeUtB<-dV=!(YsQ4>DNr1M9 zwwA#Z!n%}?v&m*5KY;Do^<8Q0>vQ7Lp=&QX5h8?JX$Uac%7C%<_NwSug+%D_Au!sG zHDC6K-dE9fsR`iMF)kIz;>?;%&J#vxr=L2q$_9JJ_-a7 z#w@2Js=2cvIqv7>0x4TZ-|T#fhLN!It~5*66V87sE`ANQAxJ=&ULMEg5#!o${-*54 z&GNXQ2)!4iCmd9`G%?pn3RVpXU0NIRp|#0sqZ_4SP5cT>NmSbepAt_!S!OVVdusba}a!^1ZQZ7$?+RhM$&o!H#V36hxeNrh`vl zP#4Dl_Qo#ky$`K~z7gYum48ock3W93YIs52ruu+uLVqN)LCN&SNO!TB+;MhW;{^Wt zA0d@(OYK=^1MrNy^acOjp4UDwwhTZqx|XKJBD4iJHkN__r&i@bJwkzi16EK0V?AXs zC$_#w#-gL7oxPx7HemV{fFuOSOSL!6(4Og*mF@=>=LtIt{`K&tDPnSII`kxEDWReS zzy>?9vFzf$DLN@4HA*|WOZ_MEHc1xx#A}pp77JiQnNF0gc_065s=vRfS&M=Vwi}?h zGe)5a(iK~M?n4Wr5<9X6*$uX!9XptSV{V_uKd;$pJ+pL*3cG5tPD8m7vpDpBO@<`p z_GV@B{2)*w!7gTK>cCigJg|m>YZBnhOMK3texZ3>dO*P)C+4*j9`v%Mn zEu68$CSV4Nm}$AhvGP_-)2hhbLWQtO%e;*WRu?Ke5s_m|8$FK?eB ztm0u76%K3bGS^77Xakj>bjs9b0G~4MAw;>1W;)<`-E_;GY&4SO1u0L}s4=C?F^VZF z<@8Z~3=A<#o&$NCJ00jL)~{J!>=9_R=;5vypx^hdAo?S-Rd2K$0`oH{z)q+tNW z747DGp^p!9&$b>2DmIw!>lu!hOa{%>7>+xJVzpqE^n@vNb$2g!v3g;=qn=^W7gB?& z_GsAxNnqImP8AU76J9s~-dnqU$XOxu*6e`RwWCtavBDfZF_2T48-EX9k$BV^E4!fR z&0j`Oe|xg>zjO6OgPscS&e9II7V{Qs8LVW`w>X4`ri@QLX|N7e~o40>grql~yS zdmCmJ1?yY9HIxiy+p>>xy}_wWjORNF1sW>|k4S~P)zBjB&}9RPngXlNj!lSqMyL{r zp&p4*Lzum;UQ7?ZIbi-kBzrDSv7iK~zt<}w?8 zPgH$(0}0*|!B+q}*-?x}n~)Hp3J~MIh<*#K_&O+|7vOr(-URtpFFZioh=UOJ1hMHr zSY7GKCJKy-umf4+ksOpn2TSIPA#&dxq(-4X}1>#S{I>(gjoAx!eSex%qgwP$ym~`BPY>QgE(&ie`Unl3WsQcI37DO z;l7d^xwvwi{%IWk?{~$83qGU6m4q3PZCBCYb_uS`;FIa7D_{r%J3pzw5OfHb_UIpm z9LM+Kf|$7Y!jL}eFd)vbFF2i&!22Q3*W4to86Se|QL)?}1g6+W)Ge1ay+Cv zLK}aR6cr7XKcGA4;Je<(vvBtXw@}d;!G_V^Ic;H>25g8!I>5d)9L-VbNf}+9>tIWtN}#yvvT#U+{Z%L$TbxMa z7>8CtV+F3k`32CS=;Zt?y32054Vi$PjDAO$rVpLc`p&D=jRT*DKN%q|LOuuC<8$fEc=zZ&W?oU2{F%@3_aAGA#1)F`fg4*7 zQ;>T~4xbk}o8q)hF8z3zxY(VFD+zA;>}me`%jm*4 zZ|#*o%5Yof@>r=3};F&wTrrKP7&vV)M6$ zP5wF=G5@b0HSzYp{ZZ%t`g;HI{eSr3r`&%U$N%-OtpAz(*DwF^``>>3uPy#p|C-&I z|NX&#dtm?b9`*gRMCEz>RDF_!u+ODqZw|V{UN-r+_fgODRL974Ip}Mn5 zru+LJfB&lY|Hrle%fHT+)wdh3qdl=uGA;FE#VzAyyM{lP8d3W*uzT>~FS`>HxyQ=^8JpL!`h~|~ zL{4+fCdE%={qV#8ncj;hPj&#s6CUB{zc!q_d8?{;8@SWo5P3laW(F4e!o}>{;K4~u zxphIe`^w7gMHmj;07f8h`)N=_2`l1g$wKryj=1O=ngc?^urM32dgGuxFzx^Ue|d?* fZybP0l+XkKNjENb literal 0 HcmV?d00001 diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-05.mmd b/work/doc/通用机器人项目功能与数据流程图-png/flow-05.mmd new file mode 100644 index 0000000..3884fbf --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图-png/flow-05.mmd @@ -0,0 +1,16 @@ +flowchart TD + A[GRL Parser] -->|语法错误| D[Diagnostic] + B[Semantic Analyzer] -->|类型/单位/引用/IO/后处理错误| D + C[KDL WASM] -->|IK/限位/奇异/轨迹错误| D + E[Post Processor] -->|不支持或近似转换| D + + D --> F{severity} + F -->|error| G[阻止编译或进入 alarm/hold] + F -->|warning| H[允许继续但写入报告] + F -->|info| I[写入 trace 或调试信息] + + D --> J[sourceMap] + J --> J1[GRL file/line/column] + J --> J2[pathId/pathPointId] + J --> J3[operationId] + J --> J4[brandSource] diff --git a/work/doc/通用机器人项目功能与数据流程图-png/flow-05.png b/work/doc/通用机器人项目功能与数据流程图-png/flow-05.png new file mode 100644 index 0000000000000000000000000000000000000000..9afbf0fe6bb4b4ff865589a28b0c39c943c8032d GIT binary patch literal 251292 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

    _ttiO{0IU= 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%0Dvjq2sLVaquTy369&6Wt?~AX^BYFp_ zHSO$DM6(7%wmd;=;NTxJr2ZMut^npdtJ_D<{e08`{X<@1w^tnMP%xbBvqRZ;7CCU9BOBXZl7;y3!#yz!^WWx`wDZu^WKZm^R-c-K0-Aqck zyJys9By=cFVPj_8E7m6vy@COzR#f-%=dsaVos7Cq8=xUu&wP&*uPgXx_24e2Z0}@d zw;g@ph}+T}i_trN+%wSpd^JsTUK&=U4ug@Qn_Rxf=FF5`d{MC0J7_iTGih4bXV+y+ z>eIlGIccs@>s)U>J=fR6z_E(+VB&CTo^GHF$_ZyBV^E{gps{1^!spSYaVV;rZeUiy zd9tqyRy%9E1V>vR>y*7hlEMOx&j5*GWp)6|E@VQ=S3rbi;49h5x{L4bWb-xL0$ym^ zWQ0v#D?%unw_H0AAgc8-2ieQRvM<<7uX4WI#Dnsr+Gp?F+(Y5_UO zt%S86GH{?MVR_aTMlYb9Go{g2D-|G+mdT;-+bYe?QdfKgVx3`DOugcO?x4}q(KG%^ zM&rYpTZix0nbsvC_xM%K%!v(H!-!+U=3g0@xApGggi(7qGbga6)SC7gLgf=ZFI1_y zq0oLWFUc+%I{(@SA{5miKeZ&}(BK-fJ$^J5Zj;vD>0dawE-e_}6mn zkHUWAfLVo@ube#e#Pg95K-85M=WcK&Hb}pP3^!E^e^+*5KFv`8^W5^t2V)PQDTXg8 zFQ_1zL}NFuLwU|MvmGD0vufHecrSPjd(bz4u-ki_T3sFh4A_6jp`+O0yg{_>W4{bm zVur%a19|XkF$iNrbPz2DY9|?4!f2aMm6ef_wDat|y}|+1y#k^!(oS*9nw4!wFM&?kqj+6+=f%yBV8JA1$_fgZF|-SroksZiMMos^ozI2rUF z%x;ZIFod+8(i>XA2kKE>iZg=|<$h%)NzUCVYaDL-40L9C@*VC*iEmIP&3MMVl}qr62=ww^vot8~;>W3s15l^c9~ zmF$s~1jl{G7-~e;zT{%T6a8+-Kia$H_k=7D3WyvM``2j6&4@q>3q0WQXKvQJ?r}ky z_S%$dQ$NFVdc~xL7O?&J`n;;Xid?14UPKTO4xDs z&L=&NJrI#}N?+#G0-)Q|pvo1p_=b(jdGrYO)Jd}B6up-WF(J4z5L6Ur*3zNw3);ojLC;Y?lQ()hyS`$+ZVY?p>LTr8^2yhFek-@oSx^ z{@|Id|DIvHIqmJ@;p;>@it4AuS)(LLB_XW#3*7;Tm%30wG;mo1H3>ss3(bxKVesww z53a=#IVI%}>Hi-VAemZPSv}=k(b59{P|fL_j$0q596@psW)ZF22c$UN`}NbB1ZRW_ zNw_4XIS~FM*KqDg--U_mKTjW#WOdEmo=oga@sIQTJpuS*e7qe|jl6}C`T-Fz>{T+^ zRC$7BZz=L#4+Yu!;)loby>j9!vfGqoop|mw)`@;>{cpRy?F^nCG~b%ZkS88KwQ^X} zQ*@CaC1_id0Xf@H(lRM8$I#XIexO)%bM?FJMZF^Zb8~X8%nmg+(5tYuuysFARWPdY zEuy|e<2rh`yeos&E4iVl99$J1mEzT`$L~*@5Bb}xW&o~qa`r0MyeJ_igP{xmhMLYM z5HEs(kt?d4&94Q##Bv!0s4AR)9xt-bgVO@~TES>VFPR=TyNk59UiKEOAYN6Cq|O%r z4#O5ahtghnzRA5AffMjB%u8W;EW>h=QNhKr^c%C%fhNV;ERfylj`3iRf)>@xzhq8Y z8g<=h~47IB>1p^LaZ z(ivx0lL2macF(x{YJcIyYWp!6#5_>_oiY>-S53|TN@=W0gr-2Lryf>a--vt8-9(qI}?fC-;`p9MnLF4{ZW^I z-r-aYk!x4~{{8x`OeEq>@ys|fVno7WOh@^(eX4fOSLmI>#LW#poV!#Ycm83tBM8nP zdLKxZi1EBNGtmxW{1vYgP7RnEzSzAsaQhP1R)w?>E}ph%`eCaxf`&h*)5bdy5SeSt z;$@bWl|3Va!QUd|)8~*jygR$K8FgxT70Oav2iNn`-5CC3lV1Q&N3V3cd$1>Z>*_Cq z8?GH0u~1Jrwa18ZV?E{0Jv}T;E9kO`;D%*qxB2b2#~VPFuHc@qoEv<7iSGS%i!%Zr z44v*@`iHiCw)oZR17lwLjNcwx2Tvi@uqfVBS6kasjr?I6c7M*u&m@>VKf^q$L5F2Z zhalToj*~e6nzL?R4V&y%Tajy0R7w?#%6YE|8*h|P=@-1+yJ?ATuepT#0z-IBP zb?ZJM%Z8bnAHO^_U&^WcQ`e(tBk>zd%{E5eCljcCH`@`}dD@gILipqJJGg>F&}iVg zvO^TZe_*oJmEo(ci3krxQq1D*eF3DKe5k0HhhRWp1l^=M2=@V;0F6)oggi{ZkrL2p zp^3(`+Rwn@dPAwcK%K4Ua5bmT)^hV_#QoEt6u}%(y?W-GkRReC71218;Se=k z9z@)wp<@%pf$X#DRn~*v*j%)_K;&aOKbiy>>b^K*T0k_9??k~3G0|%!`A-!xgf|bA z!lf2PPvVw^(GCd^x07HKQ74-7>7ZLAF+Ue-F@<`#AZ?6-CW+N!gJ?;9kSd0KC4rFs ziKp)%lrBG>-Snk+7Yc6%F=N#Y{}P0?SkbpB407n!bybB+47y*Y2RGHV)@3p2OZNGI zM&m~l)M8AyG_~UgV&uhx8e+;&@c>HNTTk4u``dS9RmxvO{Yy>kX?@XZ*SAGE#x}9s zy7e8Q=ZO<3xNsPlz+rP!pPd@kLuYyrF016xsaMYq+m=IHS>5qakAJ|<4z0V)#p92J z#WWe6XuidF^w6QEz6nLB$9bJJdw3>FUB0AK#v{i=AjNGH%$U2r%P`O&enR&jPiZ=W zLnvtn6RlPx+)B_*(O;YPaKon*f368JA15&?=m)iJWL>`OC!zlfybtW zk1HRpXFlOB{yFUWcSz8w-ITw$0W|s)CHjyYb?DeJe_UH7b=r>m1e$~m*Cn}2x9Ou1 znjRwrkg&h^*Q=pu(cS8TrP|r}6g$HxmQGRGBkHLytsIz|^6xYd?fdo`*Akp}V>4l= zU^}KBi+vAJPISWG%!kjSaf}GmkN&E?^QjSsp4*=l7gmRj8{;&Zh@UHoeL=T5g%qmf zo<8kuiD9V5h}_!bMEo~wzv()3JO~s5Y7WQhRATRO0s_Ykw6|+Y$aeY9IOx1j=$VlX zfYMC)1cmc0k=c@2xIVriEphOSqo=nLul@Y-1G^QsmsPQew6VAs1Eh=A1d;%XWan+kGMK8MFfq1(4xd8tXeRASk*xt+Rrb}axzESu# zn%|fKmUDESeZP&w{B+i!Y9)=jdV#RvSPPtu-d9zx%jM>mviCmuq#E9G2qjF{2u>{uHI#?K&=0`mBQqobNe%|1iW>((&E z&ZVs4;ra9Dx%c-BXE;8BHm?E_EACY%eYfe;%Ng7v+H#i6E!3wHU_+X(x=rmu&m}*# z_2kF?Pt&Xwqzj;6K_BNhEd$C{9bpRz7i+FP&g=>KnAsN0GdKiMVqDMiWM)BLa!{V$ z`XP3+YcEm_0K5?!ppylWO8&Wj1k_flVdT+! z4YPe#k?-<#eXOGbUL5Sc2O7)n3(~04(Oo@@p;Un0^~>>gxDrAT2jDRzpxK&r>rQc) z=#r!#$7uWRTRN4byUYOC^g2a>m25H~f136Y1XjvZkQYPd+?z+AJdjvE_vN)KI6*&?6wAR)lOMx>5b9U-WIa|fztmcG6!HGf!N5nk<2<4lF&f$r1 z!t-N?)R!jN>AIIRv1>-Ir7D*m!|Kg{b+~t{eooyUw|S&f!cTd`nwx0|2j#vDkyJHd}UZtm?in> z?B0vim#U4bbnhQxrgf-f30mzmNKMb`84>x?d;_)2zfwyf!FUgk9PhRpd2Lfa&U;_< z5D#VrjL$^|?(K&6bE_a;g*(d&9B|W!(*aUCbzX8Jv(BUv&9Sk zJmJ!LC$k_5%aiVRgS+KFM_3Qnr{^)hWfuB_=wdsKi;3-U<(_d~H@=%M2o%h9sz4O^ zAElneuhsH@K#f0qnSbB%AyoyEnl9ajSvsTSw)a#k$$2$d80f&27Hr@zfK9xLiwJAE z^$pN&_L^VE4s$ww&N8e$+{}NNzny}t7(y$G?dwV9SN78%JJt(r3(H)&(Q$6cvC#SvEL{fn;nH8zl53H45XDVZs@Z@=Kis^5v@^I{e< z*}t=$y?iJi!vH4z{NpMo8UXJ-u5TYom+-q_J(ZLpJmfL4N@Xd z5GHWI%5k3Sd5!$Y{pHPC;twUM4`8!&bZT!SRBKa>qlg-5rJ$2TZF-OuPjT6vIz+(N zdDMbPgu!uP$oE5j=kZ^tVogMgAr>>afcK5s?(9+=UqnKk%F(aB7SCuZLVpmt zp}a^6EC^62jQ6O)N;k3D#G*So_TSvtu&HIrQvJP%P%5POQK5mJqSRnZ0#AOscg}(A zkzZg4dV2>xd-;;TCH;zFGY#ve26gG(`(lqM|D^%(M-J~}UiG1cKd~pibGtZ#GoH7( zgdCDn)F47_#3J2YMpizAKzEH;AobFhsH&=94Gdqq!OQ+Z{5I4w++3g!Iy0Rgaoib< z0E9atBiKO0D&G9L$s==+0GX-9>1v#Rc z!-_5@PBL4!*Rks-4iZU>6L@HfvFfbn$WLRQMVlCSVcdIe2MEZwni@^yP`vhQNY_%e z+U}2TLSbkv8#k08-u^^9FU7Baj zmJCJO5GsJC z=SuEvw$X3ddRtTkjXA8&a?P9A<4>5z4{cb9o275 zmCFzD57FmUKC=z#8khC5`!N{fvq0ZEBtqZZhr(PVt`$`;4r>(~aJe_Po0RVY!ahXD z#lN(Kf*?WyRO(6w2b!hNeNc0ct|)2PSBM-P81PP*nXPFxYQ;IKQx;R>wH%yD zmS%+bE16BT+kQzjmXcTh6~i5j^9WXyM*lGtI7GYB zbH4bs)G3CDNA#f44VQY7!(^@zJ7rfFe)HOI6MP{d%QfmjY&0FdT_5dgB^kMjIw!zb zkP1&HLgktotYp|80{s2Gbt?$rd~@#Hc_*k^PtPB0wx|}g?VpK5olzEC|NWoPliTgZ zrG79tG<2VE!m{;LM{aG48fGF+XWk6YvE=U6pFcl2#!jI?0K3vAxC6&pl44CmR&vZ4 zxyS{`-JrT}v~!w2MpT{c7#sHaANXpR&*}Fx?-!z1hxvFr=)?$mE92ikO`CkBDiY84@g?Z(V(U(m~71!-DCA+ep9ARqfgp! z{WOlRYQ*ntRxODpf{ap zQrZ+oygp;UsOeM&oup+9891A02m5FTeKyPgGO!U9qlNeJb(|=bIoVa&B>&2S?az_t zDA$y{eXC7u0+XzSVRu3RgrRpijPc}%50mnC@J#j#nD}gDBwJm7oXsQpZQZ&x-_A!i z<37@$0TTn7Wgo*L;_S1Jh4b@8Kl|ZF2=kB%`$nkiJBw44j6EWqm_AMfBB~j7`)lbZ zAUQy+NiuUON=(48x8PP6FdYPNbK@OUlSbsigiK;Eb?pvQfs&7wRA$&GJbT1Gproi4LdSw=j4I%>Lg5CpF7tf*w z79uoHh+UI-n5C5LvhhedS!A_ zxn0aXMwyCZ%g4VZIbmtq!O4%7GsCF<^(&{uJT#^I!3>H_$E z{L+GXzF4XhcTqb0BQ^@>I1(^kAAfV!sr!WlOt}gEah(=v zVA$UnIP#F#rae9%e+I@PE?j#2(ucj3b=>kYb90F>WW{MLCh(Y7B6pZaFl(f5v)6%ItRYdu_cLzMn%F<$C8MDB0i;w*=Y!(B}KK|9^fD@6a zWEV-f?kvkIFNOdg`~+)$&OY$FfKN>~B7Zdv*zBh1ZHf*RMp+lhMOiqzKNwu9g)#&g zaF=N&CNqieAvp>F-l$b5qy`(*`LukNz5KupswR$Iy;^JrpA^5kfoFqs$8P5$$ZG8Y zEU1ujo6nCyY8=69htoz1!n6!Tdtd=|yB6q5AQWMZb*bBpG(nQDw<1Oy3@DP#?LgJs zk>V*nrnZzv;{SE;+&NToZb3}stcW^*iIQ8Cl3vr_mXyu~)p82a%Mfc~GdX0L2h%Gk zbx|yG7S$_qv-13yQ(lc61li$2nzcKCbW(&jGS^-C!mhO_bny1=@h~L*@It3~P_%dB z#scQqNZBWp-3B%viHLA;UBr>G)Qza5?rZqKT9Vt$5APi0&AYAMwqr--wP``xcw;WU zxyr*!zy#+tQxPOVy@G?{wq$eO^g>bp$Z6l_3HF!2q49juHJ;kphF9-{mN9KDHKmLc zszpGHP+J(9u)js>@FSPNuI~GHw%C6l$p;{0$F^+`ttabEEnLUbZ-u`{6xip%b}GML zATKi2gJ(Z@wwctm!zio4aX>E+GRn?~Ssh5(KpomBu53VDY2ha_A4aD6x5yqcsSa4+ zvR>)3q%gJ7%O9WSC2_5@^}@H&(ef$Y;}ug*C6#x-NWi7=i6>PLx# zdYz?|y(g)eEYl6cDp-5bi-|?cu&C!D28)l;TU;y?tn48TCFw(WV;u-rBf z8f3Pyq|&H$xnQ+K>Mqmyy<1%GN)h99bIT6f)d8(0$VwM@Pi^i=V7n`4-%X4(rV4YG zFpgaBNHc#&VU=8XGojJ`_%l0lmAh)QxhedR=`YTW6Tv=vEpCA6Le3;5u!AcnB-x*z z9m+1^xRE@U!bJ74KckfHx9_ckvr+NBXd819KO&qveZym5XVo5TSB=wVmZd5jl1bbg zv{u5Uu(sl~&lJEO$(6SQ!7_YD2AGLk&L?F&69%z45QU8 zH=W6D|6u_mlFJ@KBjIWTaR1H5tL!898KbUlz6IT#;s-~d&&ZyxUbSlZiyN`~uhZYl z@|crgqIr+SEKoz$i%awhzLJvk;4H>quosvVMTa4fS{IjRo+RiZf58BVPrx0dmH21G z9S6U2EIGoAgB0HOaw1eKxcv3Jliu)pzJTpWDrS19PS_TrO1Bv?o= zl?CkLuZqd`nwm_m9Xr7o7^kXl42Ktfqx(sO<|s&- zb?VzU(c{$w_Uo!T%pKD2(uxZ8)l7gSU`Ho0LbB^39w+c$z|ptEkS2Q~Y{b7$Gt8PY z2isKn_bxoZ{$8U^#Ir1>#qK4~La0*t5D*Dk?~5jj5q5#He=W<`<*>T7deemsJBa0| zSj3fL6E$qWDv81vj2U@!*CnE_;f?B&ycU}IjzF7b=Scl=7aWCvm<~fMuJ{;L2#*O4 zWFR`G@S-fUv`9geu9A}*K?7?`DgQqs>f_oiQVSe)(yj9Ns!inOqtRJ{^TZ^0*E> zh4-PHps=&hvD8?QFY`T;u+|qOJ4x)wE{wXEcyDkLtw>6J;*#+3UrQ7%5F^E~d{>@x z#z4%M|8_AGfU^Q#u?sYp()8@JChf&4^n&`t={wj0rTVFRx(nZBp}YLCQESmh1)H+M z%s`ZC42TTQcW!PvpQI|S9qV+Rkrc|jq$8r7qe455

    kMp?YQ@ymM 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

    ?}O>2B$cN$NyETIrCQbf3ZVzVF`W-TS%D z$8)Z8U3-3e*5g{v`H%4%;~sY~1VY29wF2BC*xKYDInAZ=sFo#NvJElh_ruAoX8*`cE<;nf350j%bsw&UnZ1E_>1g&VZ`6t>%gk9GNjjQw_p z{-dQb;en)I1DJS*0&pcdbicxj_8E%`l8pr62=oaN#=z4=!!BLJ_q z_Bp>|$S-)%0X%JLfz#5wt>eqmMY$_}3KRkFdgnm|Ijp!YPE_2c8yEAS5vT|30eW%I zAJ_q@4J24xFcgZJ0FBt++Txj{r##OWf*znW^J44HswQ(PNGAOnps4Da8aDXb^WXmK zZ)byw1$3W=WvWpQVESJ?7g|8ag00xFo9YA#u9E-?3cM`hBad=az1Wb~OI^(8^reN2 zZ!h(q;Q+DeeQr8n`b?s(#>n@@HAy zS_5e&c7-X|ujBo#{iw!TuU55b+EKW&tjs4TnA++Yiahl-SGAuZd_x`UABPfMo2|Ks zJs;Tc3GV^tHL_M9OF*YA$t!uAxFU9WWDO_{nk#>FeHIS}Zov(G$!Yg1Za>GC3Qu5u zf;zmCvpxsz@@14_X6tz19s53va~u_}EZk!gN?U<`%>qdk+(eh-?&zVxqKkj{#nWrQ zLk!FQGuC={IdKvGgToHLm>G%f`(hspa;13YL*32OlUQ_Bc47S)1J{|I$q*uv`P3R> zt&)eUk?tm2rf{$S_m9robOjN(UJG6GP+)NEJJ)(>CHGs2?G0XVch)_ggum&-76Tu4 z#klu#(!D$WOtsNO+uvY5<5{2fC49ae^g7hl*>#h14G^lX7AlFq8@+gBnukYo2#Hs?>=_m3Pw%LbYS0Y|%i3R-5}>Uo4_6g+wBH03w|i zRnXeifbUXicAg2FG|S6VxCVKGeL!M)6w)*f`+Q3R&6Q*GZTX%Z=rrz6r}}KDcO_gm z-*;iK`wORQrZCx0iPnzE#45{r2);pIpahky9Q)52%z!tsImvyT`2HN@D=g-Hf0cSg z{J!=wM#N+36){O^De6D*q5tI~alF2mWB<)Z=VHwNcc1@<>G8h?-~Z)bYofcDcK^-i z<>QN8*uVRH{FgT3-~2x$7oF$7`~2&Nc*X=}{TCMS@BYyLFMrhk`62)93Ygsf|NJrg zZ{O!X|HuD%wEp+2^8e0@-}3a5C2-+^4D&V&w)wNG`Z~Ih6E2~ZyJH_lk-~Ne32xZq z4T(55&AoQgRo1qjRZfe6_*QNcC`6(`wQoowY@60*FDPj*IX0HQPv4>(GfwaLINz%EUpR~8j83p~A#XT%t45xl`U!QVDOOASHYfFkeO{kinpa)X;8o{5ur|Gc@ znSj1hiXMCn8!ul@=(f5u5=uUTUF6O-DQGxxk#uv5`Rj3TOtyN~t5QlB{l5oXxGy?l zP!|d-hW#i6w)N@LNW!_U-$1HCAZ20dvODV5FC(BNtEsjah-OYb0S;`Ri;eI9?TWvg z18*kFYOn3F;%9#D6JH*`_dlJ|BH7&h{pOYg1(#$f8F!`4V1`s6+ro5}e$@ildPILV zX_m_2HU|%i)I99~$rCf})?P>vXv8vgaG6XKIyJqC;_R$O;i1tUFVn!CZIkcDj} zRcct+olHlScD2xO9F(B!sf(D5)W~TzkM%m|@JOdLAh98yl$zhWKt#V`M60t*U5Z%~ zWxq)QXz#JVzJ|%@$<-hi+3S-Ff6b7sTekPrd2mR=b;jPX%JI-=L%A=m=%qp=;BZHW z^#BM9KYezrbPv~ z_j~pu8vz_EZ4x3fvZI47dc}cx&}lfec?(^J5%>#mM6y5aIsx+>ww+lJJhC`56Llbs zzUF>%Pz4*x;j%??hw&Gh3vm5|p30?}+Um|y(Qh0Bae@6+bo9lN4F^>Q3@)mN#j2gR zsKq~2)o}EIZsYaKmp)gnHQ0@5A-drCb|cP{x3ICM1CAHS74pwmR}C+`wrlsF4C;fS zd#y!}9wjilM<>N6Co#j;KRW9tS$VQ7pSZf_`4>Y2n>-56hug(Ior7b#2$gD#Nx_(QkPLN3p zuq?e&pjQ>s>>nE9PtzYrIkoHkMBCgP-Vv5;RPEx96z=cG(w(Sx7aP%SDj_r$MXCDN74EDxM)F!Y>S>SyI~Ie zo2Oa!o_z`2Y6e}x{wE^9w2u8X8{P@7#`)IY37x~g=b7bbz;nI6aV{IpR1nh+0Z-@C zo^EdC1l`Cy*y)2`M}O`oNkiCAO*aM%G`(ug)5wYJlCIy4J+H9SX3#0Oj-AN!J9cC% z01|JW2FO1nMM<~Aoql9L4kp#VfxnCs9Up0V449-4(A(HIjBe*gR`}uPX1X zru`si;dHUWcD!=6!A}HUAm9=@x4iX`II<2?XeiJhS#25@iF?}4hJJ>)ou_e^&)Rb^ z(?Me_GHz=z)nobVle90pEBybh1s;AYrIok2m?{Uj_Eeg*2QqN7F<|3c+Np4%{=Oy< z@8>3tQzLgO>;!=)t4s)~Lkm00M67wP;7N~-pgpg<4J?i?b#kYw9tRL0#rGmpw^rauvy+4zfFG?vSWUQ3d&jztl!>{4!ye-$y00( zcSKCgRlxR#K?W;x*4)hx;g3^3F0T|Ja@8`JW&u{wP2%$e9|&@@!GR*}nNGzweeiP? z09U+| zx3OEZa#Q}baS9dSE50yb{A83V&-TOE_&9Sliya$yS~9I3PzOwy-kIXF-b?@zbl6|G zm?vaR`x;8gS+D>U=N|aPBRO`1B-xZ3A>`r-^ig-PDNakHEfuoCEJ1OFqf0jMaUW?YFT~?TLzNEX;PMgGbxBh4 z)_kyZr)tVu(9;=PTotVPGuxpI(8B-x#LCg;X#y!nzG^-sKX&<1($_qb`1EJ3mNgNY z?Ht6&QmJ8hWRH(;9i42C5`q;+;DC7ISmU`!x2Zy`Z?}tPe#_AAd5=_zsF$htAbSyC zp4M75xE@>(z%E?gMj;h<3lY5lCORzZ(r}nsV&}YC-|c>Hot+CCEv?R2`{Iye5XoO1 z(!2u@o-PzzjMWR`GHX?EMI#dC1xe2CiUkx6FvFSpmbTF@k}^e+l47Ku*&9dFetPVo z+3U*%@6Ewxt13}^+uR%)G*ddo&kGI2yDtOh1(MA3&1~r7T}gpQ2+UGMvCsZ3?)o41 zx86|0u}q>3A>kA4NfvRar{)~KM{v$|9_Pc}eXL5gh7l+duNC!_lMZZ#a``n~@(qtO z2w*d)SNSJ9LXE`XLxOQTTfi=0JKC1y0)M7m{=VpjD5e7%pI%#E9}RWy1)pbl$7SG_ zx7ig{^dZ^zQHb;%X?QW7CN$@;QYhC46Xz)>*O(k^`X9BJ|8BV#PJONZ%v%CU*WZ6m zQc4z}1-mv%@e^sUZbFE5&IME*R+RkP-%+|i$w^(+Av|DJ)XhS|Wup*z@$=6cr|xhe zxrMIZfJ6Mx4+b|de;MU&*Em)GzGDmm&^n=hUXW%CRaJ|0s=8C2rZcfV0AsJ2rdO#N zF7G(>(|{t~uxwzQ#nk*c|6s@q1AC#C1|WKztZTAc`>ZY})3^ zg+eu(sn;t$89FAc(Zcv!-9zyc#mY7DK zC2RK54Qb~7c#?BL{(iAW+F`jmoIE*M#txL3L?^Ag&im_E2!&jla2i24pZf_({N^=P z2(^TChDMsy<4hI9&AoB4E0@>vJ_!$%m`(GMX_rjYdhGYcM+<{cHK8=*CV2w}h(W5S zN6KJ%_K|xydPB|T$J);=!>GV~(EaNR{xJ5hjue`10ypdet{q|sdD0%1oMN3^Cx&Kb zAp4zMmE-BWH|=nLo;J5t&qA!0dw<6~a$cvL*7htoA8W&RKA^y59`aB(FyF=S#pzLF zLBhM6#)`hUmN@dUz0PV+Bt+ae{tF9;r<1(YgBYJn@jN?>V`zlKDFVDoh}9pGQJiGk zjT~ri#GLy3i)msf8~n-?<1#I&IC6g7l1SoYm7AQ>sm8h@CK-0v8G%H>Pd9VE*aJP7 zHqh2KfxfFC>UVSirJ-llvOj%o>a_kT0f=C)406Xt(n~~9199v+f(WD_Bco*jti)@} z@ecz0r(NdRmJpytOzQSWvlNc ziTZmX$z=4(U0wm>l>t6^z@2&8;A>&gu7$GUCd8pJLm2;z<+Ka!1BYW~p&b@!a4JtJ zvr=9DYL4bz=p73AHt2!+l-U}z_03hL00_i zShGq5R4ntW_9snYw~dp4p=t)8U4C8E=XQ-^7}~_SrJg8KtZ+KSc^xT3p-Qkjp;J0 z+PMUGa7p*DW51Y_{6Msj6{d(}OYEloo0hhjU5kTPAmif&7sT}ZtX|e#H%HCF$n*ES z3;}ph@jyMkLEz5;mNmy0o}3AKTF?v)W^#h{;#7@+dcy13j{4KHoFVe_@>QCnVuGn472`gf$%$sq-lxb&Zv~ zaoP(#csHNUvdNxCSN1&HJB``$B7xa7qH+Ii82B4~d&Or+D8v!#dx!^|bmL21QTf}b z&!y(CFULkNpv87opUJx0^oCO&XL3;>LnJ{LJCNeUQkE>_YI}Yb5XFW)hc&u-MnX9) zxEe!Z56!H$!YGYA1kzJ3@fu1Gq`YCoXIOh-gXvA&FNq(NOAvTjKx48b8&I6_;?mtcoK~&|CH7H1n^BRuj$=7p9{f}(kZ-sD7zDo4A z8UG0Ast!iiax8H=M_qN5;*^mzO24XbWD5@S2U)RBlQr|+8t%c z%FS&VzglnM$h!g?Fq3(@#+@973SbM!s`Lr>r%uO7Y0XdUm+B92q!8^28I~}3=ka;4=mMI0%vEbw7$N`if>Hjm=F6!<*BS-DcXT*)H-u#n5J; z(@Bj#u=|mXJkY5kpseW`-OoyWk^O1wT55o}-JhS~n!WfLBbpDoM#ny6TseSOu-&hG zdr@_jMpRUE{Ze0|hkR>{T^Pmr`IAhut;irs;hntO+If3*mvPz-=Hn(ir2c`c6jc@w z<-uxL^QV)V+k1bqq2`s_uO?ME6QEL>gQ)CSJSSh#xmL%tb4?Q?v#Sn zF$rbeo}P%sJD}p^zX4Apw0Eo-2td%n5tZI_^A-1IAc&%C9tn98RZ}^P4)wG^e7#8@ z>y{|w5h?L(5c+r;%Aef`$;i)LWcfmXmEp;Oy|iRln@(S8TN zH%;3WpwZ>V4gWQ_v+?<-4m)_=F!-97yi7G#wRi_5ox9;vo|z5K{t}P;rAL;aibPuU zh%25L&#d!z%isE=9&zh$iO0&(`9&zrW;f%bjQ~34*zsrJOf{8z0uP7X@8&mscMU!8klI9+~Q!u zV-`|t)=8RtQsp?ycXIa=7ZsyZtQ3h!NYitV0WNB7T$~TjguUK2o|9Wn<>{0}5i$3B zt#Ss4iEqRO#6GD`KZ6&A;$iVcWL!x?z&psO)oSN+gR_Ac83V#gH;~&=daMpl?_|oH z;VXj1Y`0^~*nNdh$>pcDu!!H$+uLz0&p0z0opry^CL9PmK}`F`ut+;=+dQ)x*ZI=F!ezv^?P_JJhnF+IdG}}dCom`eRoI2$%%T9!_5E_QXO!f z5=JiIt4y{HVvs*Wc?G36w6y`s-)F_?diar~Pp@nNAE|`dW|RO~7}!qiBLl&7-OwMj zZDQ8no^NZvR=x&6qR-xmi9N_(91b>b&Gr|A7`q1$jis;Vh&=sy5sOI{ObDOlhv%+6 zh4zpa(3xF+2}ei%{45!yK|&;aySSp|B&7wHJkSYYa=Dg6MImXuUvZp#3Q#hrj+Aqr@8oPUjW z5iLBGPtHS%gdf7>1;Z?l)=m`jL;sWU4&Po*JvZ><%qw*Ugo<3q1p^&`YyC0rFg=-G#&7nPA_YOUhe(&!G1LF)8&DtX|TI7I#(BU;0 z*e|RW#X&&NF-Q-!m)Y;%H$g|KhW0_CBnvxaaM;jSwlsgfs>mlpWW2Zr^|dXbMkI15 zDBAqagS-H|GJHm_I)kMG<8x%#d=O-!(xT66H1pziK0WoKUhLH^1RDwadDQ288p+5? z_P~}G;A8t0CV=&IM99OKg{7(b^G4ZeAcDFBp0j^}?)?Efy%89LpnHzVzkLop!q>s6 zc#uqgmRV<+d zB;annfLCt0a?Cag_9#}u`1;{gS7!ZeF_iiFn!&YC@rc=g_G^sPJvlo**B(AQWMvM*qi)#LAOjox%1=GMcGR`8|@D z7sbkQ56EX-bx|iN;B48g6a+z44uFaL0Zz8^zDCiR)aemN!H4Ak!UB{bzhUk-xa1IU zgIo{9O$vhDpwa?-^Z8ttQ%59#%%0oI=gza4Sp#j-FO@$>@LvIo_}Qjc0hT&(4KSIA z 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

    _cSoHU#Medq+9APoUksX-VdM83$r%fyna}Tv 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 BEdBrh literal 0 HcmV?d00001 diff --git a/work/doc/通用机器人项目功能与数据流程图.md b/work/doc/通用机器人项目功能与数据流程图.md new file mode 100644 index 0000000..b193dd9 --- /dev/null +++ b/work/doc/通用机器人项目功能与数据流程图.md @@ -0,0 +1,357 @@ +# 通用机器人项目功能与数据流程图 + +版本：0.1 +日期：2026-06-27 +对标文档： + +1. `通用机器人编程语法规范.md` +2. `KDL_WASM计算接口设计.md` + +## 1. 范围说明 + +本文描述 GRL 通用机器人程序语言和 KDL WASM 计算接口之间的总体功能流程和数据传递流程。 + +核心边界： + +1. GRL 层负责程序文本、语法、语义、IR、Path、Operation、IO、wait、后处理。 +2. KDL WASM 层负责机器人模型、位姿变换、FK、IK、Jacobian、梯形速度、MOVEJ、MOVEL、MOVEC、Path 轨迹和诊断。 +3. KDL WASM 不解析 GRL，不执行流程控制、变量、IO、wait、子程序和异常逻辑。 +4. TypeScript 编译器和虚拟控制器把 GRL/IR 转换为 KDL 可执行的运动请求。 + +## 2. 总体功能流程图 + +```mermaid +flowchart TD + A[项目资源] --> A1[robots/robot.urdf] + A --> A2[targets/*.json] + A --> A3[paths/*.json] + A --> A4[operations/*.json] + A --> A5[programs/*.grl] + A --> A6[io/io_map.json] + A --> A7[post/*.profile.json] + + A5 --> B[GRL Lexer] + B --> C[GRL Parser] + C --> D[GRL AST] + D --> E[Symbol Table] + E --> F[Semantic Analyzer] + + A1 --> G[URDF Parser] + G --> H[NormalizedRobotModel] + H --> I[KDL createRobotFromModel] + I --> J[RobotHandle] + + F --> K[Executable IR] + K --> L{IR 指令类型} + + L -->|MotionInstruction| M[生成 MotionSegmentRequest] + L -->|run_path| N[展开 Path points/events] + L -->|run_operation| O[展开 start_action + path + end_action] + L -->|IO / wait / pulse| P[虚拟控制器 IO Service] + L -->|if/for/switch/call/return| Q[虚拟控制器流程执行] + L -->|alarm / raise / try/catch| R[虚拟控制器报警与异常处理] + + N --> M + O --> N + + M --> S[KdlWorkerClient] + S --> T[kdl.worker.ts] + T --> U[KDL WASM API] + + U --> U1[planMoveJ] + U --> U2[planMoveL] + U --> U3[planMoveC] + U --> U4[planPath] + U --> U5[validatePath] + + U1 --> V[TrajectoryResult] + U2 --> V + U3 --> V + U4 --> W[PathPlanResult] + U5 --> X[PathValidationResult] + + V --> Y[Motion Queue / 轨迹回放] + W --> Y + X --> Z[可达性与诊断报告] + + K --> AA[Post Processor] + AA --> AA1[ABB RAPID] + AA --> AA2[FANUC LS/TP 风格文本] + AA --> AA3[KUKA KRL] + AA --> AA4[转换报告] +``` + +## 3. GRL 编译与执行流程图 + +```mermaid +flowchart TD + A[GRL Source .grl] --> B[Lexer] + B --> C[Tokens] + C --> D[Parser] + D --> E[AST] + E --> F[Symbol Table] + F --> G[Semantic Analyzer] + + G --> G1[名称解析] + G --> G2[类型检查] + G --> G3[单位规范化] + G --> G4[tool/frame/speed/zone 解析] + G --> G5[Path/Operation 引用检查] + G --> G6[IO 地址检查] + G --> G7[运动目标可达性检查] + G --> G8[后处理能力检查] + + G1 --> H[Executable IR] + G2 --> H + G3 --> H + G4 --> H + G5 --> H + G6 --> H + G7 --> H + G8 --> H + + H --> I{IR} + I -->|MotionInstruction| J[Motion Request Builder] + I -->|WaitInstruction| K[Wait Registry] + I -->|IoInstruction| L[IO Image] + I -->|BranchInstruction| M[Program Counter] + I -->|CallInstruction| N[Call Stack] + I -->|AlarmInstruction| O[Alarm Queue] + I -->|ReturnInstruction| P[Scope/Call Stack] + + J --> Q[KDL WASM] + Q --> R[TrajectoryResult / Diagnostics] + R --> S[Motion Queue] + + H --> T[Post Processor] + T --> U[品牌程序] + T --> V[转换报告] +``` + +## 4. KDL WASM 计算流程图 + +```mermaid +flowchart TD + A[NormalizedRobotModel] --> B[createRobotFromModel] + B --> C[RobotHandle] + C --> D[KDL Chain / Solvers Cache] + + E[Motion Request] --> F{motion} + F -->|MOVEJ| G[planMoveJ] + F -->|MOVEL| H[planMoveL] + F -->|MOVEC| I[planMoveC] + F -->|PATH| J[planPath / validatePath] + + G --> G1[校验 startJoints 和限位] + G1 --> G2{target 类型} + G2 -->|joint_target| G3[qEnd = target.joints] + G2 -->|pose_target| G4[IK 求 qEnd] + G3 --> G5[关节差分] + G4 --> G5 + G5 --> G6[梯形速度曲线] + G6 --> G7[采样关节位置/速度/加速度] + G7 --> G8[FK 输出 TCP] + G8 --> R[TrajectoryResult] + + H --> H1[FK 得到起点 TCP] + H1 --> H2[applyToolAndFrame / applyOffset] + H2 --> H3[直线位置和姿态插补] + H3 --> H4[梯形速度曲线] + H4 --> H5[逐点 IK] + H5 --> H6[限位/速度/奇异性检查] + H6 --> R + + I --> I1[FK 得到起点 TCP] + I1 --> I2[via/target 位姿变换] + I2 --> I3[三点退化检查] + I3 --> I4[圆心/半径/法向/弧长] + I4 --> I5[圆弧采样] + I5 --> I6[逐点 IK] + I6 --> I7[圆弧误差和限位检查] + I7 --> R + + J --> J1[按 segment 顺序规划] + J1 --> J2[上一段终点关节作为下一段起点] + J2 --> J3[合并轨迹点和诊断] + J3 --> J4[保留 sourceMap] + J4 --> P[PathPlanResult / PathValidationResult] + + R --> D1[MotionDiagnostic] + P --> D1 + D1 --> D2[error / warning / info] +``` + +## 5. 数据传递流程图 + +```mermaid +flowchart LR + subgraph Project[项目输入数据] + A1[robot.urdf] + A2[main.grl] + A3[targets / paths / operations] + A4[io_map.json] + A5[post profile] + end + + subgraph Compile[TypeScript 编译层] + B1[URDF Parser] + B2[GRL Lexer/Parser] + B3[AST] + B4[Symbol Table] + B5[Semantic Analyzer] + B6[Executable IR] + B7[Motion Request Builder] + end + + subgraph KDL[KDL Worker / WASM] + C1[KdlRpcRequest] + C2[RobotHandle] + C3[KDL Solvers] + C4[FK / IK / Jacobian] + C5[Trap Profile] + C6[Motion Planner] + C7[KdlRpcResponse] + end + + subgraph Runtime[虚拟控制器运行层] + D1[Program Counter] + D2[Call Stack] + D3[Scope Stack] + D4[Motion Queue] + D5[IO Image] + D6[Wait Registry] + D7[Alarm Queue] + D8[Trace Buffer] + end + + subgraph Output[输出数据] + E1[TrajectoryResult] + E2[PathPlanResult] + E3[PathValidationResult] + E4[MotionDiagnostic] + E5[CycleTimeResult] + E6[ABB/FANUC/KUKA 程序] + E7[转换报告] + end + + A1 --> B1 + B1 -->|NormalizedRobotModel| C1 + C1 --> C2 + C2 --> C3 + + A2 --> B2 + A3 --> B5 + A4 --> B5 + B2 --> B3 + B3 --> B4 + B4 --> B5 + B5 --> B6 + + B6 -->|MotionInstruction| B7 + B7 -->|MoveJRequest / MoveLRequest / MoveCRequest / PathPlanRequest| C1 + C1 --> C4 + C1 --> C5 + C4 --> C6 + C5 --> C6 + C6 --> C7 + + C7 --> E1 + C7 --> E2 + C7 --> E3 + C7 --> E4 + C7 --> E5 + + B6 --> D1 + B6 --> D2 + B6 --> D3 + E1 --> D4 + E2 --> D4 + B6 -->|IO / wait / pulse| D5 + B6 -->|wait| D6 + E4 --> D7 + D4 --> D8 + D5 --> D8 + D6 --> D8 + + B6 -->|IR + post profile| A5 + A5 --> E6 + A5 --> E7 +``` + +## 6. 关键对象数据流 + +| 输入对象 | 产生阶段 | 传递到 | 输出对象 | +| --- | --- | --- | --- | +| `robot.urdf` | 项目资源 | TypeScript URDF Parser | `NormalizedRobotModel` | +| `NormalizedRobotModel` | TypeScript 编译层 | `createRobotFromModel` | `RobotHandle` | +| `tool/frame/target/speed/zone` | GRL Parser + Semantic Analyzer | IR、KDL request builder | `ToolRef`、`FrameRef`、`JointTarget`、`PoseTarget`、`SpeedSpec`、`ZoneSpec` | +| `movej` | GRL Parser | Semantic Analyzer | `MotionInstruction(joint)` | +| `movel` | GRL Parser | Semantic Analyzer | `MotionInstruction(linear)` | +| `movec` | GRL Parser | Semantic Analyzer | `MotionInstruction(circular)` | +| `path` | GRL Parser | Path compiler | `MotionSegmentRequest[]` | +| `operation` | GRL Parser | Operation compiler | start action + path + end action | +| `MotionInstruction` | IR | KDL request builder | `MoveJRequest`、`MoveLRequest`、`MoveCRequest` | +| `PathPlanRequest` | Path compiler | KDL WASM | `PathPlanResult` | +| `TrajectoryResult` | KDL WASM | Motion Queue、trace、报告 | 轨迹点、诊断、节拍输入 | +| `MotionDiagnostic` | GRL 语义检查或 KDL WASM | 编辑器、报警、报告、后处理 | error/warning/info | +| `Executable IR` | Semantic Analyzer | 虚拟控制器、后处理器 | 执行流、品牌程序 | + +## 7. KDL API 与 GRL 语法映射 + +| GRL 语法 | TypeScript 编译结果 | KDL WASM 函数 | +| --- | --- | --- | +| `target home = joint_target` | `JointTarget` | `checkJointLimits` | +| `target pick = pose_target` | `PoseTarget` | `checkReachability` | +| `pick offset z 100 mm` | `OffsetSpec` | `applyOffset` | +| `movej home` | `MoveJRequest` | `planMoveJ` | +| `movel pick` | `MoveLRequest` | `planMoveL` | +| `movec via mid target end` | `MoveCRequest` | `planMoveC` | +| `run_path pick_path` | `PathPlanRequest` | `planPath` | +| Path 可达性检查 | `PathPlanRequest` | `validatePath` | +| 节拍估算 | `TrajectoryResult/PathPlanResult` | `estimateCycleTime` | + +## 8. 不进入 KDL WASM 的数据流 + +以下 GRL 语义由 TypeScript 编译层或虚拟控制器执行，不传入 KDL WASM： + +| GRL 语义 | 执行位置 | 输出 | +| --- | --- | --- | +| `if/elseif/else` | Program Counter / BranchInstruction | 分支后的 IR 执行位置 | +| `while/for/switch` | Program Counter / BranchInstruction | 循环或选择后的 IR 执行位置 | +| `proc/func/call/return` | Call Stack / Scope Stack | 调用栈和变量作用域 | +| `io.do/di/ai/ao` | IO Image / IO Service | IO 事件和 trace | +| `wait/pulse/timer` | Wait Registry / IO Service | wait 状态、timeout、pulse trace | +| `alarm/raise/try/catch` | Alarm Queue / Exception Handler | 报警和异常处理结果 | +| `operation.process` | Operation compiler / 后处理器 | 工艺参数、转换报告 | + +## 9. 诊断传递流程 + +```mermaid +flowchart TD + A[GRL Parser] -->|语法错误| D[Diagnostic] + B[Semantic Analyzer] -->|类型/单位/引用/IO/后处理错误| D + C[KDL WASM] -->|IK/限位/奇异/轨迹错误| D + E[Post Processor] -->|不支持或近似转换| D + + D --> F{severity} + F -->|error| G[阻止编译或进入 alarm/hold] + F -->|warning| H[允许继续但写入报告] + F -->|info| I[写入 trace 或调试信息] + + D --> J[sourceMap] + J --> J1[GRL file/line/column] + J --> J2[pathId/pathPointId] + J --> J3[operationId] + J --> J4[brandSource] +``` + +## 10. 总结 + +项目的数据流以 GRL IR 为中枢： + +1. GRL 文本、Path、Operation、IO 和品牌扩展先进入 TypeScript 编译层。 +2. 编译层完成语法、语义、单位、source map 和后处理能力检查。 +3. 只有运动相关 IR 被转换为 KDL WASM request。 +4. KDL WASM 返回轨迹、节拍和结构化诊断。 +5. 虚拟控制器消费 IR 和轨迹，后处理器消费 IR 和品牌 profile。 +6. 诊断贯穿 Parser、Semantic Analyzer、KDL WASM 和 Post Processor，并通过 source map 回到 GRL、Path、Operation 或品牌源。

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