@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-XHIV6326.cjs

@@ -0,0 +1,793 @@
+'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(`    // ABSORB-STUB: 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(`  // ABSORB-STUB: 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-XHIV6326.cjs.map
+//# sourceMappingURL=chunk-XHIV6326.cjs.map