@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-L3Z2HIWJ.cjs

@@ -1,793 +0,0 @@
-'use strict';
-
-var fs = require('fs');
-var path = require('path');
-var events = require('events');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-
-// src/traits/AbsorbTrait.ts
-var AbsorbProcessor = class {
-  /**
-   * Absorb a source file into .hsplus
-   */
-  absorb(source) {
-    const result = {
-      functions: [],
-      classes: [],
-      imports: [],
-      constants: [],
-      generatedHSPlus: "",
-      sourceLanguage: source.language,
-      warnings: []
-    };
-    switch (source.language) {
-      case "python":
-        this.extractPython(source.content, result);
-        break;
-      case "typescript":
-      case "javascript":
-        this.extractTypeScript(source.content, result);
-        break;
-    }
-    result.generatedHSPlus = this.generateHSPlus(result, source.filePath);
-    return result;
-  }
-  /**
-   * Extract structure from Python source
-   */
-  extractPython(content, result) {
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const importMatch = line.match(/^(?:from\s+(\S+)\s+)?import\s+(.+)/);
-      if (importMatch) {
-        result.imports.push({
-          source: importMatch[1] || importMatch[2].trim(),
-          specifiers: importMatch[2].split(",").map((s) => s.trim()),
-          isDefault: !importMatch[1]
-        });
-      }
-    }
-    const funcRegex = /^(async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*(\w+))?:/gm;
-    let funcMatch;
-    while ((funcMatch = funcRegex.exec(content)) !== null) {
-      const params = funcMatch[3].split(",").filter((p) => p.trim() && p.trim() !== "self").map((p) => {
-        const parts = p.trim().split(":");
-        return { name: parts[0].trim(), type: parts[1]?.trim() };
-      });
-      result.functions.push({
-        name: funcMatch[2],
-        params,
-        returnType: funcMatch[4] || void 0,
-        isAsync: !!funcMatch[1],
-        isExported: !funcMatch[2].startsWith("_")
-      });
-    }
-    const classRegex = /^class\s+(\w+)(?:\(([^)]*)\))?:/gm;
-    let classMatch;
-    while ((classMatch = classRegex.exec(content)) !== null) {
-      const cls = {
-        name: classMatch[1],
-        methods: [],
-        properties: [],
-        isExported: !classMatch[1].startsWith("_"),
-        baseClass: classMatch[2]?.trim()
-      };
-      const classStartIdx = classMatch.index + classMatch[0].length;
-      const classBody = content.substring(classStartIdx);
-      const methodRegex = /^(\s+)(async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*(\w+))?:/gm;
-      let methodMatch;
-      while ((methodMatch = methodRegex.exec(classBody)) !== null) {
-        const beforeMethod = classBody.substring(0, methodMatch.index);
-        const lastNewline = beforeMethod.lastIndexOf("\n");
-        if (lastNewline >= 0) {
-          const lineStart = beforeMethod.substring(lastNewline + 1);
-          if (lineStart.length > 0 && !lineStart.startsWith(" ") && !lineStart.startsWith("	"))
-            break;
-        }
-        const params = methodMatch[4].split(",").filter((p) => p.trim() && p.trim() !== "self" && p.trim() !== "cls").map((p) => {
-          const parts = p.trim().split(":");
-          return { name: parts[0].trim(), type: parts[1]?.trim() };
-        });
-        cls.methods.push({
-          name: methodMatch[3],
-          params,
-          returnType: methodMatch[5] || void 0,
-          isAsync: !!methodMatch[2],
-          isExported: !methodMatch[3].startsWith("_")
-        });
-        if (methodMatch[3] === "__init__") {
-          const initBody = classBody.substring(
-            methodMatch.index + methodMatch[0].length,
-            methodMatch.index + methodMatch[0].length + 500
-          );
-          const propRegex = /self\.(\w+)\s*=\s*(.+)/g;
-          let propMatch;
-          while ((propMatch = propRegex.exec(initBody)) !== null) {
-            cls.properties.push({
-              name: propMatch[1],
-              value: propMatch[2].trim()
-            });
-          }
-        }
-      }
-      result.classes.push(cls);
-    }
-    const constRegex = /^([A-Z_][A-Z0-9_]*)\s*[=:]\s*(.+)/gm;
-    let constMatch;
-    while ((constMatch = constRegex.exec(content)) !== null) {
-      result.constants.push({
-        name: constMatch[1],
-        value: constMatch[2].trim()
-      });
-    }
-  }
-  /**
-   * Extract structure from TypeScript/JavaScript source
-   */
-  extractTypeScript(content, result) {
-    const importRegex = /import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
-    let importMatch;
-    while ((importMatch = importRegex.exec(content)) !== null) {
-      result.imports.push({
-        source: importMatch[3],
-        specifiers: importMatch[1] ? importMatch[1].split(",").map((s) => s.trim()) : [importMatch[2]],
-        isDefault: !!importMatch[2]
-      });
-    }
-    const funcRegex = /(?:export\s+)?(async\s+)?function\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*(\w+))?/g;
-    let funcMatch;
-    while ((funcMatch = funcRegex.exec(content)) !== null) {
-      const params = funcMatch[3].split(",").filter((p) => p.trim()).map((p) => {
-        const parts = p.trim().split(":");
-        return { name: parts[0].trim(), type: parts[1]?.trim() };
-      });
-      result.functions.push({
-        name: funcMatch[2],
-        params,
-        returnType: funcMatch[4] || void 0,
-        isAsync: !!funcMatch[1],
-        isExported: content.includes(`export`) && content.includes(funcMatch[2])
-      });
-    }
-    const classRegex = /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?\s*\{/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(content)) !== null) {
-      const cls = {
-        name: classMatch[1],
-        methods: [],
-        properties: [],
-        isExported: content.includes(`export class ${classMatch[1]}`),
-        baseClass: classMatch[2]?.trim()
-      };
-      const bodyStart = classMatch.index + classMatch[0].length;
-      let depth = 1;
-      let bodyEnd = bodyStart;
-      while (depth > 0 && bodyEnd < content.length) {
-        if (content[bodyEnd] === "{") depth++;
-        if (content[bodyEnd] === "}") depth--;
-        bodyEnd++;
-      }
-      const classBody = content.substring(bodyStart, bodyEnd - 1);
-      const methodRegex = /(?:public|private|protected)?\s*(async\s+)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*(\w+))?\s*\{/g;
-      let methodMatch;
-      while ((methodMatch = methodRegex.exec(classBody)) !== null) {
-        const name = methodMatch[2];
-        if (name === "if" || name === "else" || name === "for" || name === "while" || name === "switch")
-          continue;
-        const params = methodMatch[3].split(",").filter((p) => p.trim()).map((p) => {
-          const parts = p.trim().split(":");
-          return { name: parts[0].trim(), type: parts[1]?.trim() };
-        });
-        cls.methods.push({
-          name,
-          params,
-          returnType: methodMatch[4] || void 0,
-          isAsync: !!methodMatch[1],
-          isExported: true
-        });
-      }
-      const propRegex = /(?:public|private|protected)?\s+(\w+)(?:\s*:\s*(\w+))?\s*=\s*([^;]+);/g;
-      let propMatch;
-      while ((propMatch = propRegex.exec(classBody)) !== null) {
-        cls.properties.push({
-          name: propMatch[1],
-          type: propMatch[2],
-          value: propMatch[3]?.trim()
-        });
-      }
-      result.classes.push(cls);
-    }
-    const constRegex = /(?:export\s+)?const\s+([A-Z_][A-Z0-9_]*)\s*(?::\s*\w+)?\s*=\s*(.+)/g;
-    let constMatch;
-    while ((constMatch = constRegex.exec(content)) !== null) {
-      result.constants.push({
-        name: constMatch[1],
-        value: constMatch[2].replace(/;$/, "").trim()
-      });
-    }
-  }
-  /**
-   * Generate .hsplus from absorbed structure
-   */
-  generateHSPlus(result, sourceFile) {
-    const lines = [
-      `// @absorb: auto-generated from ${sourceFile}`,
-      `// Source language: ${result.sourceLanguage}`,
-      `// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      ""
-    ];
-    for (const c of result.constants) {
-      lines.push(`state ${c.name}: ${c.type || "dynamic"} = ${c.value}`);
-    }
-    if (result.constants.length > 0) lines.push("");
-    for (const cls of result.classes) {
-      lines.push(`template "${cls.name}" {`);
-      if (cls.baseClass) {
-        lines.push(`  @extends "${cls.baseClass}"`);
-      }
-      lines.push(`  @agent { type: "absorbed"; source: "${result.sourceLanguage}" }`);
-      for (const prop of cls.properties) {
-        lines.push(`  ${prop.name}: ${prop.value || `"${prop.type || "dynamic"}"`}`);
-      }
-      for (const method of cls.methods) {
-        const params = method.params.map((p) => p.name).join(", ");
-        lines.push(`  on ${method.name}(${params}) {`);
-        lines.push(`    // TODO: port ${method.name} logic`);
-        lines.push(`  }`);
-      }
-      lines.push(`}`);
-      lines.push("");
-    }
-    for (const fn of result.functions) {
-      if (!fn.isExported) continue;
-      const params = fn.params.map((p) => p.name).join(", ");
-      const asyncPrefix = fn.isAsync ? "async " : "";
-      lines.push(
-        `${asyncPrefix}fn ${fn.name}(${params})${fn.returnType ? ` -> ${fn.returnType}` : ""} {`
-      );
-      lines.push(`  // TODO: port ${fn.name} logic from ${result.sourceLanguage}`);
-      lines.push(`}`);
-      lines.push("");
-    }
-    if (result.warnings.length > 0) {
-      lines.push("// WARNINGS:");
-      for (const w of result.warnings) {
-        lines.push(`//   ${w}`);
-      }
-    }
-    return lines.join("\n");
-  }
-};
-var ABSORB_TRAIT = {
-  name: "absorb",
-  category: "interop",
-  description: "Reverse-mode: convert legacy Python/TS/JS code into typed .hsplus agents",
-  compileTargets: ["node", "python", "headless"],
-  requiresRenderer: false,
-  parameters: [
-    { name: "source", type: "string", required: true, description: "Path to source file" },
-    {
-      name: "language",
-      type: "string",
-      required: false,
-      description: "Source language (auto-detected from extension)"
-    },
-    { name: "output", type: "string", required: false, description: "Output .hsplus file path" }
-  ]
-};
-var absorbHandler = {
-  name: "absorb",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new AbsorbProcessor();
-    node.__absorb_instance = instance;
-    ctx.emit("absorb_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__absorb_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("absorb_detached", { node });
-    delete node.__absorb_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__absorb_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "absorb_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("absorb_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__absorb_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-var HotReloadWatcher = class extends events.EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.watchers = [];
-    this.debounceTimers = /* @__PURE__ */ new Map();
-    this.running = false;
-    this.reloadCount = 0;
-    this.config = {
-      watchPaths: config.watchPaths ?? ["."],
-      debounceMs: config.debounceMs ?? 300,
-      mode: config.mode ?? "soft",
-      extensions: config.extensions ?? [".hs", ".hsplus", ".holo"]
-    };
-  }
-  /**
-   * Start watching for file changes
-   */
-  start() {
-    if (this.running) return;
-    this.running = true;
-    for (const watchPath of this.config.watchPaths) {
-      const resolved = path__namespace.resolve(watchPath);
-      if (!fs__namespace.existsSync(resolved)) {
-        this.emit("warning", `Watch path does not exist: ${resolved}`);
-        continue;
-      }
-      try {
-        const watcher = fs__namespace.watch(resolved, { recursive: true }, (eventType, filename) => {
-          if (!filename) return;
-          const ext = path__namespace.extname(filename).toLowerCase();
-          if (!this.config.extensions.includes(ext)) return;
-          const fullPath = path__namespace.join(resolved, filename);
-          this.handleChange(fullPath, eventType);
-        });
-        this.watchers.push(watcher);
-      } catch (err) {
-        this.emit("error", err);
-      }
-    }
-    this.emit("started", { paths: this.config.watchPaths });
-  }
-  /**
-   * Stop watching
-   */
-  stop() {
-    if (!this.running) return;
-    this.running = false;
-    for (const watcher of this.watchers) {
-      watcher.close();
-    }
-    this.watchers = [];
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.debounceTimers.clear();
-    this.emit("stopped", { reloadCount: this.reloadCount });
-  }
-  /**
-   * Handle a file change event (with debouncing)
-   */
-  handleChange(filePath, eventType) {
-    if (this.debounceTimers.has(filePath)) {
-      clearTimeout(this.debounceTimers.get(filePath));
-    }
-    this.debounceTimers.set(
-      filePath,
-      setTimeout(() => {
-        this.debounceTimers.delete(filePath);
-        this.reloadCount++;
-        const event = {
-          type: eventType === "rename" ? "add" : "change",
-          filePath,
-          timestamp: Date.now()
-        };
-        this.emit("reload", event);
-      }, this.config.debounceMs)
-    );
-  }
-  /**
-   * Get current stats
-   */
-  getStats() {
-    return {
-      running: this.running,
-      reloadCount: this.reloadCount,
-      watchedPaths: this.watchers.length
-    };
-  }
-  /**
-   * Check if currently watching
-   */
-  isRunning() {
-    return this.running;
-  }
-};
-var HOT_RELOAD_TRAIT = {
-  name: "hot_reload",
-  category: "devtools",
-  description: "Live-reload .hs, .hsplus, and .holo files when they change on disk",
-  compileTargets: ["node", "headless"],
-  requiresRenderer: false,
-  parameters: [
-    { name: "watch", type: "string[]", required: false, description: "Glob patterns to watch" },
-    {
-      name: "debounce_ms",
-      type: "number",
-      required: false,
-      default: 300,
-      description: "Debounce interval"
-    },
-    {
-      name: "on_reload",
-      type: "string",
-      required: false,
-      default: "soft",
-      description: '"soft" (re-parse) or "hard" (full restart)'
-    }
-  ]
-};
-var hotReloadHandler = {
-  name: "hot_reload",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new HotReloadWatcher(config);
-    node.__hot_reload_instance = instance;
-    ctx.emit("hot_reload_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__hot_reload_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("hot_reload_detached", { node });
-    delete node.__hot_reload_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__hot_reload_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "hot_reload_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("hot_reload_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__hot_reload_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-// src/traits/ScriptTestTrait.ts
-var ScriptTestRunner = class {
-  constructor(options = {}) {
-    this.tests = [];
-    this.options = {
-      debug: options.debug ?? false,
-      timeout: options.timeout ?? 5e3,
-      bail: options.bail ?? false,
-      runtimeState: options.runtimeState ?? {}
-    };
-  }
-  /**
-   * Bind runtime state for live assertion resolution
-   */
-  setRuntimeState(state) {
-    this.options.runtimeState = state;
-  }
-  /**
-   * Register a test block
-   */
-  addTest(test) {
-    this.tests.push(test);
-  }
-  /**
-   * Run all registered tests
-   */
-  runAll() {
-    const results = [];
-    for (const test of this.tests) {
-      if (test.skip) {
-        results.push({
-          name: test.name,
-          status: "skipped",
-          durationMs: 0,
-          assertions: test.assertions.length,
-          passedAssertions: 0
-        });
-        continue;
-      }
-      const result = this.runSingle(test);
-      results.push(result);
-      if (this.options.bail && result.status === "failed") {
-        break;
-      }
-    }
-    return results;
-  }
-  /**
-   * Run a single test block
-   */
-  runSingle(test) {
-    const start = Date.now();
-    let passedAssertions = 0;
-    try {
-      if (test.setup) {
-        test.setup();
-      }
-      for (const action of test.actions) {
-        action();
-      }
-      for (const assertion of test.assertions) {
-        const passed = assertion.check();
-        if (passed) {
-          passedAssertions++;
-        } else {
-          return {
-            name: test.name,
-            status: "failed",
-            durationMs: Date.now() - start,
-            error: `Assertion failed: ${assertion.description}`,
-            assertions: test.assertions.length,
-            passedAssertions
-          };
-        }
-      }
-      if (test.teardown) {
-        test.teardown();
-      }
-      return {
-        name: test.name,
-        status: "passed",
-        durationMs: Date.now() - start,
-        assertions: test.assertions.length,
-        passedAssertions
-      };
-    } catch (error) {
-      return {
-        name: test.name,
-        status: "failed",
-        durationMs: Date.now() - start,
-        error: error instanceof Error ? error.message : String(error),
-        assertions: test.assertions.length,
-        passedAssertions
-      };
-    }
-  }
-  /**
-   * Parse @script_test blocks from .hs source and run them
-   */
-  runTestsFromSource(source, _filePath) {
-    const testBlocks = this.extractTestBlocks(source);
-    if (this.options.debug) {
-      console.log(`[script_test] Found ${testBlocks.length} test blocks`);
-    }
-    this.tests = testBlocks;
-    return this.runAll();
-  }
-  /**
-   * Extract @script_test blocks from source text
-   */
-  extractTestBlocks(source) {
-    const blocks = [];
-    const regex = /@script_test\s+"([^"]+)"\s*\{/g;
-    let match;
-    while ((match = regex.exec(source)) !== null) {
-      const name = match[1];
-      const startIdx = match.index + match[0].length;
-      let depth = 1;
-      let endIdx = startIdx;
-      while (depth > 0 && endIdx < source.length) {
-        if (source[endIdx] === "{") depth++;
-        if (source[endIdx] === "}") depth--;
-        endIdx++;
-      }
-      const body = source.substring(startIdx, endIdx - 1).trim();
-      const assertions = [];
-      const assertRegex = /assert\s*\{([^}]+)\}/g;
-      let assertMatch;
-      while ((assertMatch = assertRegex.exec(body)) !== null) {
-        const assertBody = assertMatch[1].trim();
-        assertions.push({
-          description: assertBody,
-          check: () => this.evaluateExpression(assertBody)
-        });
-      }
-      blocks.push({
-        name,
-        assertions,
-        actions: []
-      });
-    }
-    return blocks;
-  }
-  /**
-   * Evaluate a simple assertion expression from @script_test blocks
-   * Supports: true, false, numeric comparisons, string equality, property access
-   */
-  evaluateExpression(expr) {
-    const trimmed = expr.trim();
-    if (trimmed === "true") return true;
-    if (trimmed === "false") return false;
-    const comparisonOps = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
-    for (const op of comparisonOps) {
-      const idx = trimmed.indexOf(op);
-      if (idx !== -1) {
-        const left = this.resolveValue(trimmed.substring(0, idx).trim());
-        const right = this.resolveValue(trimmed.substring(idx + op.length).trim());
-        switch (op) {
-          case "===":
-            return left === right;
-          case "!==":
-            return left !== right;
-          case "==":
-            return left == right;
-          case "!=":
-            return left != right;
-          case ">=":
-            return Number(left) >= Number(right);
-          case "<=":
-            return Number(left) <= Number(right);
-          case ">":
-            return Number(left) > Number(right);
-          case "<":
-            return Number(left) < Number(right);
-        }
-      }
-    }
-    const value = this.resolveValue(trimmed);
-    return !!value;
-  }
-  /**
-   * Resolve a value token to a primitive
-   */
-  resolveValue(token) {
-    const t = token.trim();
-    if (t === "true") return true;
-    if (t === "false") return false;
-    if (t === "null" || t === "nil") return null;
-    if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
-    if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
-      return t.slice(1, -1);
-    }
-    const state = this.options.runtimeState;
-    if (state && Object.keys(state).length > 0) {
-      if (t in state) {
-        const val = state[t];
-        if (val === null || val === void 0) return null;
-        if (typeof val === "number" || typeof val === "boolean" || typeof val === "string")
-          return val;
-        return String(val);
-      }
-      if (t.includes(".")) {
-        const parts = t.split(".");
-        let current = state;
-        for (const part of parts) {
-          if (current == null || typeof current !== "object") {
-            current = void 0;
-            break;
-          }
-          current = current[part];
-        }
-        if (current !== void 0) {
-          if (current === null) return null;
-          if (typeof current === "number" || typeof current === "boolean" || typeof current === "string")
-            return current;
-          return String(current);
-        }
-      }
-    }
-    return t;
-  }
-  /**
-   * Bind a HeadlessRuntime so @script_test assertions can read live scene state.
-   * Snapshots the runtime's state into runtimeState before each test run.
-   *
-   * Usage:
-   * ```ts
-   * import { createHeadlessRuntime } from '@holoscript/engine/runtime/HeadlessRuntime';
-   * const runtime = createHeadlessRuntime(ast);
-   * runtime.setState('balance', 500);
-   * runner.bindHeadlessRuntime(runtime);
-   * // Now @script_test assertions like `assert { balance == 500 }` work
-   * ```
-   */
-  bindHeadlessRuntime(runtime) {
-    this.options.runtimeState = runtime.getAllState();
-  }
-};
-var SCRIPT_TEST_TRAIT = {
-  name: "script_test",
-  category: "testing",
-  description: "Headless unit testing for HoloScript logic",
-  compileTargets: ["node", "python", "ros2", "headless"],
-  requiresRenderer: false,
-  parameters: [
-    { name: "name", type: "string", required: true, description: "Test name" },
-    {
-      name: "timeout",
-      type: "number",
-      required: false,
-      default: 5e3,
-      description: "Timeout in ms"
-    },
-    {
-      name: "skip",
-      type: "boolean",
-      required: false,
-      default: false,
-      description: "Skip this test"
-    }
-  ]
-};
-var scriptTestHandler = {
-  name: "script_test",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new ScriptTestRunner(config);
-    node.__script_test_instance = instance;
-    ctx.emit("script_test_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__script_test_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("script_test_detached", { node });
-    delete node.__script_test_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__script_test_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "script_test_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("script_test_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__script_test_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-exports.ABSORB_TRAIT = ABSORB_TRAIT;
-exports.AbsorbProcessor = AbsorbProcessor;
-exports.HOT_RELOAD_TRAIT = HOT_RELOAD_TRAIT;
-exports.HotReloadWatcher = HotReloadWatcher;
-exports.SCRIPT_TEST_TRAIT = SCRIPT_TEST_TRAIT;
-exports.ScriptTestRunner = ScriptTestRunner;
-exports.absorbHandler = absorbHandler;
-exports.hotReloadHandler = hotReloadHandler;
-exports.scriptTestHandler = scriptTestHandler;
-//# sourceMappingURL=chunk-L3Z2HIWJ.cjs.map
-//# sourceMappingURL=chunk-L3Z2HIWJ.cjs.map