@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-G7CT3EMP.cjs

@@ -1,1002 +0,0 @@
-'use strict';
-
-var path = require('path');
-var crypto = require('crypto');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var path__default = /*#__PURE__*/_interopDefault(path);
-
-// src/stdlib/StdlibActions.ts
-var DEFAULT_STDLIB_POLICY = {
-  allowedPaths: ["compositions", "data", "src", "packages"],
-  maxFileBytes: 2 * 1024 * 1024,
-  allowShell: false,
-  allowedShellCommands: [],
-  maxShellOutputBytes: 100 * 1024,
-  shellTimeoutMs: 6e4,
-  allowNetwork: false,
-  allowedHosts: [],
-  rootDir: ".",
-  allowMediaDecode: false,
-  allowDepthInference: false,
-  allowGpuCompute: false,
-  maxGifFrames: 500,
-  maxVideoDurationSec: 300,
-  maxMediaResolution: 4096
-};
-function resolveRepoRelativePath(targetPath, rootDir) {
-  const normalized = targetPath.replace(/\\/g, "/").replace(/^\.\//, "").trim();
-  if (!normalized) return { ok: false, error: "Path is required" };
-  const abs = path__default.default.resolve(rootDir, normalized);
-  const rel = path__default.default.relative(rootDir, abs).replace(/\\/g, "/");
-  if (!rel || rel.startsWith("..") || path__default.default.isAbsolute(rel)) {
-    return { ok: false, error: "Path escapes repository root" };
-  }
-  return { ok: true, rel, abs };
-}
-function isPathAllowed(relPath, allowedRoots) {
-  const normalized = relPath.replace(/\\/g, "/");
-  return allowedRoots.some((root) => normalized === root || normalized.startsWith(`${root}/`));
-}
-function parseHostFromUrl(url) {
-  try {
-    return new URL(url).hostname.toLowerCase();
-  } catch {
-    return null;
-  }
-}
-function truncateText(value, max) {
-  const str = typeof value === "string" ? value : String(value ?? "");
-  if (!Number.isFinite(max) || max <= 0 || str.length <= max) return str;
-  return `${str.slice(0, max)}
-...[truncated ${str.length - max} chars]`;
-}
-function toStringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
-}
-function resolveInto(params, defaultPrefix) {
-  return typeof params.into === "string" && params.into.trim().length > 0 ? params.into.trim() : defaultPrefix;
-}
-function createStdlibActions(options) {
-  const { policy, hostCapabilities: caps, debug } = options;
-  const log = debug ? (msg) => console.log(`  [stdlib] ${msg}`) : () => {
-  };
-  return {
-    // ── File System ──────────────────────────────────────────────────────
-    fs_read: async (params, bb) => {
-      const prefix = resolveInto(params, "fs_read");
-      const filePath = typeof params.path === "string" ? params.path : "";
-      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
-      if (!resolved.ok) {
-        bb[`${prefix}_error`] = resolved.error;
-        return false;
-      }
-      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
-        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
-        return false;
-      }
-      if (!caps?.fileSystem) {
-        bb[`${prefix}_error`] = "fileSystem capability not available";
-        return false;
-      }
-      const exists = caps.fileSystem.exists ? await Promise.resolve(caps.fileSystem.exists(resolved.rel)) : true;
-      if (!exists) {
-        bb[`${prefix}_error`] = `file not found: ${resolved.rel}`;
-        bb[`${prefix}_exists`] = false;
-        return false;
-      }
-      const content = await Promise.resolve(caps.fileSystem.readFile(resolved.rel));
-      if (Buffer.byteLength(content, "utf-8") > policy.maxFileBytes) {
-        bb[`${prefix}_error`] = `file exceeds max size (${policy.maxFileBytes} bytes)`;
-        return false;
-      }
-      bb[`${prefix}_content`] = content;
-      bb[`${prefix}_exists`] = true;
-      log(`fs_read: ${resolved.rel} (${Buffer.byteLength(content, "utf-8")} bytes)`);
-      return true;
-    },
-    fs_write: async (params, bb) => {
-      const prefix = resolveInto(params, "fs_write");
-      const filePath = typeof params.path === "string" ? params.path : "";
-      const content = typeof params.content === "string" ? params.content : null;
-      const append = params.append === true;
-      if (content === null) {
-        bb[`${prefix}_error`] = "content is required";
-        return false;
-      }
-      if (Buffer.byteLength(content, "utf-8") > policy.maxFileBytes) {
-        bb[`${prefix}_error`] = `content exceeds max size (${policy.maxFileBytes} bytes)`;
-        return false;
-      }
-      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
-      if (!resolved.ok) {
-        bb[`${prefix}_error`] = resolved.error;
-        return false;
-      }
-      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
-        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
-        return false;
-      }
-      if (!caps?.fileSystem) {
-        bb[`${prefix}_error`] = "fileSystem capability not available";
-        return false;
-      }
-      let finalContent = content;
-      if (append && caps.fileSystem.exists) {
-        const exists = await Promise.resolve(caps.fileSystem.exists(resolved.rel));
-        if (exists) {
-          const current = await Promise.resolve(caps.fileSystem.readFile(resolved.rel));
-          finalContent = `${current}${content}`;
-        }
-      }
-      await Promise.resolve(caps.fileSystem.writeFile(resolved.rel, finalContent));
-      bb[`${prefix}_path`] = resolved.rel;
-      bb[`${prefix}_bytes`] = Buffer.byteLength(content, "utf-8");
-      log(`fs_write: ${resolved.rel} (${bb[`${prefix}_bytes`]} bytes, append=${append})`);
-      return true;
-    },
-    fs_exists: async (params, bb) => {
-      const prefix = resolveInto(params, "fs_exists");
-      const filePath = typeof params.path === "string" ? params.path : "";
-      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
-      if (!resolved.ok) {
-        bb[`${prefix}_error`] = resolved.error;
-        return false;
-      }
-      if (!caps?.fileSystem?.exists) {
-        bb[`${prefix}_error`] = "fileSystem.exists capability not available";
-        return false;
-      }
-      const exists = await Promise.resolve(caps.fileSystem.exists(resolved.rel));
-      bb[`${prefix}_exists`] = exists;
-      log(`fs_exists: ${resolved.rel} \u2192 ${exists}`);
-      return true;
-    },
-    fs_delete: async (params, bb) => {
-      const prefix = resolveInto(params, "fs_delete");
-      const filePath = typeof params.path === "string" ? params.path : "";
-      const resolved = resolveRepoRelativePath(filePath, policy.rootDir);
-      if (!resolved.ok) {
-        bb[`${prefix}_error`] = resolved.error;
-        return false;
-      }
-      if (!isPathAllowed(resolved.rel, policy.allowedPaths)) {
-        bb[`${prefix}_error`] = `path "${resolved.rel}" is outside allowed roots`;
-        return false;
-      }
-      if (!caps?.fileSystem?.deleteFile) {
-        bb[`${prefix}_error`] = "fileSystem.deleteFile capability not available";
-        return false;
-      }
-      await Promise.resolve(caps.fileSystem.deleteFile(resolved.rel));
-      log(`fs_delete: ${resolved.rel}`);
-      return true;
-    },
-    // ── Process Execution ─────────────────────────────────────────────────
-    process_exec: async (params, bb) => {
-      const prefix = resolveInto(params, "process_exec");
-      if (!policy.allowShell) {
-        bb[`${prefix}_error`] = `${prefix} is disabled by policy`;
-        return false;
-      }
-      const command = typeof params.cmd === "string" ? params.cmd.trim() : "";
-      const args = toStringArray(params.args);
-      if (!command) {
-        bb[`${prefix}_error`] = "cmd is required";
-        return false;
-      }
-      if (policy.allowedShellCommands.length > 0) {
-        const executable = command.split(/\s+/)[0].toLowerCase();
-        const allowed = policy.allowedShellCommands.some((c) => c.toLowerCase() === executable);
-        if (!allowed) {
-          bb[`${prefix}_error`] = `command "${executable}" is not allowlisted`;
-          return false;
-        }
-      }
-      if (!caps?.process?.exec) {
-        bb[`${prefix}_error`] = "process.exec capability not available";
-        return false;
-      }
-      const timeoutMs = typeof params.timeout === "number" && Number.isFinite(params.timeout) ? Math.max(1e3, Math.min(policy.shellTimeoutMs, Math.floor(params.timeout))) : policy.shellTimeoutMs;
-      const cwd = typeof params.cwd === "string" ? params.cwd : policy.rootDir;
-      const result = await Promise.resolve(caps.process.exec(command, args, { cwd, timeoutMs }));
-      bb[`${prefix}_code`] = result.code ?? -1;
-      bb[`${prefix}_stdout`] = truncateText(result.stdout, policy.maxShellOutputBytes);
-      bb[`${prefix}_stderr`] = truncateText(result.stderr, policy.maxShellOutputBytes);
-      log(`process_exec: ${command} ${args.join(" ")} \u2192 code ${result.code}`);
-      return result.code === 0;
-    },
-    // ── Network ───────────────────────────────────────────────────────────
-    net_fetch: async (params, bb) => {
-      const prefix = resolveInto(params, "net_fetch");
-      const url = typeof params.url === "string" ? params.url.trim() : "";
-      if (!url) {
-        bb[`${prefix}_error`] = "url is required";
-        return false;
-      }
-      if (!policy.allowNetwork) {
-        bb[`${prefix}_error`] = "network access is disabled by policy";
-        return false;
-      }
-      const hostName = parseHostFromUrl(url);
-      if (!hostName) {
-        bb[`${prefix}_error`] = "invalid url";
-        return false;
-      }
-      if (policy.allowedHosts.length > 0) {
-        const allowed = policy.allowedHosts.includes(hostName) || policy.allowedHosts.some((h) => hostName.endsWith(`.${h}`));
-        if (!allowed) {
-          bb[`${prefix}_error`] = `host "${hostName}" is not allowlisted`;
-          return false;
-        }
-      }
-      if (caps?.network?.fetch) {
-        try {
-          const response = await Promise.resolve(
-            caps.network.fetch(url, {
-              method: typeof params.method === "string" ? params.method : "GET",
-              headers: typeof params.headers === "object" && params.headers ? params.headers : void 0,
-              body: typeof params.body === "string" ? params.body : void 0
-            })
-          );
-          bb[`${prefix}_status`] = response.status;
-          bb[`${prefix}_body`] = truncateText(response.text ?? "", policy.maxShellOutputBytes);
-          bb[`${prefix}_ok`] = response.ok;
-          log(`net_fetch: ${url} \u2192 ${response.status}`);
-          return response.ok;
-        } catch (error) {
-          bb[`${prefix}_error`] = error.message;
-          return false;
-        }
-      }
-      try {
-        const response = await globalThis.fetch(url, {
-          method: typeof params.method === "string" ? params.method : "GET",
-          headers: typeof params.headers === "object" && params.headers ? params.headers : void 0
-        });
-        const text = await response.text();
-        bb[`${prefix}_status`] = response.status;
-        bb[`${prefix}_body`] = truncateText(text, policy.maxShellOutputBytes);
-        bb[`${prefix}_ok`] = response.ok;
-        log(`net_fetch: ${url} \u2192 ${response.status}`);
-        return response.ok;
-      } catch (error) {
-        bb[`${prefix}_error`] = error.message;
-        return false;
-      }
-    }
-  };
-}
-function registerStdlib(runtime, options) {
-  const actions = createStdlibActions(options);
-  for (const [name, handler] of Object.entries(actions)) {
-    runtime.registerAction(name, handler);
-  }
-}
-
-// src/traits/TestTrait.ts
-var CompositionTestRunner = class {
-  constructor(initialState, computedDefs = [], config = {}) {
-    this.initialState = { ...initialState };
-    this.computedDefs = computedDefs;
-    this.config = {
-      bail: config.bail ?? false,
-      debug: config.debug ?? false,
-      timeout: config.timeout ?? 5e3
-    };
-  }
-  /**
-   * Extract and run all @test blocks from .hsplus source
-   */
-  runTestsFromSource(source) {
-    const tests = this.extractTestBlocks(source);
-    if (this.config.debug) {
-      console.debug(`[composition_test] Found ${tests.length} @test blocks`);
-    }
-    return this.runAll(tests);
-  }
-  /**
-   * Run all test blocks
-   */
-  runAll(tests) {
-    const results = [];
-    for (const test of 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.config.bail && result.status === "failed") {
-        break;
-      }
-    }
-    return results;
-  }
-  /**
-   * Run a single test block:
-   * 1. Clone initial state
-   * 2. Apply setup assignments
-   * 3. Evaluate computed values
-   * 4. Check assertions
-   */
-  runSingle(test) {
-    const start = Date.now();
-    let passedAssertions = 0;
-    try {
-      const state = { ...this.initialState };
-      for (const { variable, expression } of test.setupAssignments) {
-        const value = this.evaluateValue(expression, state);
-        state[variable] = value;
-      }
-      const computed = this.evaluateComputedValues(state);
-      const fullState = { ...state, ...computed };
-      if (this.config.debug) {
-        console.debug(`[composition_test] "${test.name}" state:`, fullState);
-      }
-      for (const assertion of test.assertions) {
-        const passed = this.evaluateAssertion(assertion.expression, fullState);
-        if (passed) {
-          passedAssertions++;
-        } else {
-          return {
-            name: test.name,
-            status: "failed",
-            durationMs: Date.now() - start,
-            error: `Assertion failed: ${assertion.expression}`,
-            assertions: test.assertions.length,
-            passedAssertions
-          };
-        }
-      }
-      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
-      };
-    }
-  }
-  // ─── Extraction ──────────────────────────────────────────────────────────────
-  /**
-   * Extract @test { name: "...", setup: { ... }, assert: { ... } } blocks
-   */
-  extractTestBlocks(source) {
-    const blocks = [];
-    const regex = /@test\s*\{/g;
-    let match;
-    while ((match = regex.exec(source)) !== null) {
-      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 block = this.parseTestBody(body);
-      if (block) blocks.push(block);
-    }
-    return blocks;
-  }
-  /**
-   * Parse the body of a @test block into structured data
-   */
-  parseTestBody(body) {
-    const nameMatch = body.match(/name:\s*"([^"]+)"/);
-    if (!nameMatch) return null;
-    const name = nameMatch[1];
-    const skipMatch = body.match(/skip:\s*(true|false)/);
-    const skip = skipMatch?.[1] === "true";
-    const setupAssignments = [];
-    const setupMatch = body.match(/setup:\s*\{([^}]+)\}/);
-    if (setupMatch) {
-      const setupBody = setupMatch[1].trim();
-      const assignRegex = /\$([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.+)/g;
-      let assignMatch;
-      while ((assignMatch = assignRegex.exec(setupBody)) !== null) {
-        setupAssignments.push({
-          variable: assignMatch[1],
-          expression: assignMatch[2].trim().replace(/[,;]\s*$/, "")
-        });
-      }
-    }
-    const assertions = [];
-    const assertRegex = /assert:\s*\{([^}]+)\}/g;
-    let assertMatch;
-    while ((assertMatch = assertRegex.exec(body)) !== null) {
-      const assertBody = assertMatch[1].trim();
-      const lines = assertBody.split(/[;\n]/).map((l) => l.trim()).filter(Boolean);
-      for (const line of lines) {
-        assertions.push({ expression: line });
-      }
-    }
-    return { name, setupAssignments, assertions, skip };
-  }
-  // ─── Evaluation ──────────────────────────────────────────────────────────────
-  /**
-   * Evaluate a single value expression, resolving $vars from state
-   */
-  evaluateValue(expr, state) {
-    const trimmed = expr.trim();
-    if (trimmed === "true") return true;
-    if (trimmed === "false") return false;
-    if (trimmed === "null") return null;
-    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
-    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-      return trimmed.slice(1, -1);
-    }
-    if (trimmed.startsWith("$")) {
-      const varName = trimmed.slice(1);
-      return state[varName];
-    }
-    try {
-      const transformed = trimmed.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, varName) => varName);
-      const keys = Object.keys(state);
-      const values = Object.values(state);
-      const fn = new Function(
-        ...keys,
-        "Math",
-        "String",
-        "Number",
-        "Boolean",
-        "Date",
-        "JSON",
-        `"use strict"; return (${transformed})`
-      );
-      return fn(...values, Math, String, Number, Boolean, Date, JSON);
-    } catch {
-      return trimmed;
-    }
-  }
-  /**
-   * Evaluate an assertion expression against state.
-   * Supports: $var == value, $var != value, $var > value, etc.
-   */
-  evaluateAssertion(expr, state) {
-    const trimmed = expr.trim();
-    const transformed = trimmed.replace(/\$([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, varName) => varName);
-    try {
-      const keys = Object.keys(state);
-      const values = Object.values(state);
-      const fn = new Function(
-        ...keys,
-        "Math",
-        "String",
-        "Number",
-        "Boolean",
-        "Date",
-        "JSON",
-        `"use strict"; return !!(${transformed})`
-      );
-      return fn(...values, Math, String, Number, Boolean, Date, JSON);
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Evaluate computed values from their definitions
-   */
-  evaluateComputedValues(state) {
-    const result = {};
-    for (const def of this.computedDefs) {
-      try {
-        const transformed = def.expression.replace(
-          /\$([a-zA-Z_][a-zA-Z0-9_]*)/g,
-          (_, varName) => varName
-        );
-        const keys = Object.keys(state);
-        const values = Object.values(state);
-        const fn = new Function(
-          ...keys,
-          "Math",
-          "String",
-          "Number",
-          "Boolean",
-          "Date",
-          "JSON",
-          `"use strict"; return (${transformed})`
-        );
-        result[def.name] = fn(...values, Math, String, Number, Boolean, Date, JSON);
-      } catch {
-        result[def.name] = void 0;
-      }
-    }
-    return result;
-  }
-  // ─── Static helpers ──────────────────────────────────────────────────────────
-  /**
-   * Extract state block from .hsplus source.
-   * Handles nested objects { ... } and arrays [ ... ].
-   */
-  static extractStateFromSource(source) {
-    const result = {};
-    const stateMatch = source.match(/\bstate\s*\{/);
-    if (stateMatch) {
-      const startIdx = stateMatch.index + stateMatch[0].length;
-      const body = extractBracedBody(source, startIdx);
-      Object.assign(result, parseNestedBlock(body));
-    }
-    const inlineRegex = /^\s*state\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*\w+\s*=\s*(.+)$/gm;
-    let inlineMatch;
-    while ((inlineMatch = inlineRegex.exec(source)) !== null) {
-      const key = inlineMatch[1];
-      if (!(key in result)) {
-        result[key] = parseStateValue(inlineMatch[2].trim());
-      }
-    }
-    return result;
-  }
-  /**
-   * Extract computed definitions from .hsplus source
-   */
-  static extractComputedFromSource(source) {
-    const defs = [];
-    const computedMatch = source.match(/\bcomputed\s*\{/);
-    if (!computedMatch) return defs;
-    const startIdx = computedMatch.index + computedMatch[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);
-    const lines = body.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("//")) continue;
-      const kvMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?)\s*$/);
-      if (kvMatch) {
-        defs.push({ name: kvMatch[1], expression: kvMatch[2] });
-      }
-    }
-    return defs;
-  }
-};
-function extractBracedBody(source, startIdx) {
-  let depth = 1;
-  let i = startIdx;
-  while (depth > 0 && i < source.length) {
-    if (source[i] === "{") depth++;
-    if (source[i] === "}") depth--;
-    i++;
-  }
-  return source.substring(startIdx, i - 1);
-}
-function parseNestedBlock(body) {
-  const result = {};
-  let i = 0;
-  while (i < body.length) {
-    while (i < body.length && /\s/.test(body[i])) i++;
-    if (i >= body.length) break;
-    if (body[i] === "/" && body[i + 1] === "/") {
-      while (i < body.length && body[i] !== "\n") i++;
-      continue;
-    }
-    const keyMatch = body.slice(i).match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*/);
-    if (!keyMatch) {
-      i++;
-      continue;
-    }
-    const key = keyMatch[1];
-    i += keyMatch[0].length;
-    while (i < body.length && /\s/.test(body[i])) i++;
-    if (body[i] === "{") {
-      i++;
-      const nestedBody = extractBracedBody(body, i);
-      i += nestedBody.length + 1;
-      result[key] = parseNestedBlock(nestedBody);
-    } else if (body[i] === "[") {
-      const arrStart = i;
-      let depth = 1;
-      i++;
-      while (depth > 0 && i < body.length) {
-        if (body[i] === "[") depth++;
-        if (body[i] === "]") depth--;
-        i++;
-      }
-      const arrStr = body.substring(arrStart, i).trim();
-      try {
-        result[key] = JSON.parse(arrStr);
-      } catch {
-        result[key] = arrStr;
-      }
-    } else {
-      const valMatch = body.slice(i).match(/^(.+?)(?:\n|$)/);
-      if (valMatch) {
-        const raw = valMatch[1].trim().replace(/,\s*$/, "");
-        result[key] = parseStateValue(raw);
-        i += valMatch[0].length;
-      } else {
-        i++;
-      }
-    }
-  }
-  return result;
-}
-function parseStateValue(raw) {
-  const v = raw.trim().replace(/,\s*$/, "");
-  if (v === "true") return true;
-  if (v === "false") return false;
-  if (v === "null") return null;
-  if (/^-?\d+(\.\d+)?$/.test(v)) return Number(v);
-  if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
-    return v.slice(1, -1);
-  }
-  return v;
-}
-var TEST_TRAIT = {
-  name: "test",
-  category: "testing",
-  description: "Native composition testing with $stateVar syntax",
-  compileTargets: ["node", "python", "ros2", "headless"],
-  requiresRenderer: false,
-  parameters: [
-    { name: "name", type: "string", required: true, description: "Test name" },
-    { name: "setup", type: "object", required: false, description: "State setup assignments" },
-    { name: "assert", type: "object", required: true, description: "Assertion expressions" },
-    {
-      name: "skip",
-      type: "boolean",
-      required: false,
-      default: false,
-      description: "Skip this test"
-    }
-  ]
-};
-var testHandler = {
-  name: "test",
-  defaultConfig: { bail: false, debug: false, timeout: 5e3 },
-  onAttach(node, config, ctx) {
-    const instance = new CompositionTestRunner({}, [], config);
-    node.__test_instance = instance;
-    ctx.emit?.("test:attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    delete node.__test_instance;
-    ctx.emit?.("test:detached", { node });
-  },
-  onUpdate() {
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__test_instance;
-    if (!instance) return;
-    const eventType = typeof event === "string" ? event : event.type;
-    if (eventType === "test:run" && event.source) {
-      const results = instance.runTestsFromSource(event.source);
-      ctx.emit?.("test:results", { results });
-    }
-  }
-};
-function computeContentHash(source) {
-  const normalized = source.replace(/\r\n/g, "\n");
-  return crypto.createHash("sha256").update(normalized, "utf8").digest("hex");
-}
-function classifyPublishMode(ast) {
-  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
-  const hasImports = Array.isArray(imports) && imports.length > 0;
-  if (!hasImports) return "original";
-  const body = ast?.body ?? ast?.ast?.body ?? [];
-  const hasOwnContent = Array.isArray(body) && body.some(
-    (node) => node.type === "composition" || node.type === "ObjectDeclaration" || node.type === "scene" || node.type === "object" || node.type === "character" || node.type === "environment"
-  );
-  if (hasOwnContent) return "remix";
-  return "curated";
-}
-function extractImports(ast) {
-  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
-  if (!Array.isArray(imports)) return [];
-  return imports.map((imp) => ({
-    // @ts-expect-error
-    path: imp.path ?? imp.source ?? "",
-    // @ts-expect-error
-    hash: imp.hash,
-    // @ts-expect-error
-    author: imp.author
-  })).filter((imp) => imp.path.length > 0);
-}
-function generateProvenance(source, ast, options) {
-  return {
-    author: options.author,
-    created: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    hash: computeContentHash(source),
-    license: options.license,
-    version: 1,
-    publishMode: classifyPublishMode(ast),
-    imports: extractImports(ast)
-  };
-}
-
-// src/deploy/license-checker.ts
-var RESTRICTIVENESS = {
-  free: 0,
-  cc_by: 1,
-  cc_by_sa: 2,
-  cc_by_nc: 3,
-  commercial: 4,
-  exclusive: 5
-};
-function checkLicenseCompatibility(compositionLicense, importedLicenses) {
-  const errors = [];
-  const warnings = [];
-  let forcedLicense;
-  if (importedLicenses.length === 0) {
-    return { compatible: true, errors: [], warnings: [] };
-  }
-  for (const imp of importedLicenses) {
-    if (imp.license === "exclusive") {
-      errors.push(
-        `Cannot import "${imp.path}" \u2014 license is "exclusive" (view-only, no import allowed)`
-      );
-      continue;
-    }
-    if (imp.license === "commercial") {
-      warnings.push(
-        `Import "${imp.path}" has "commercial" license \u2014 ensure purchase is verified before publishing`
-      );
-      continue;
-    }
-    if (imp.license === "cc_by_sa") {
-      const compositionLevel = RESTRICTIVENESS[compositionLicense];
-      const requiredLevel = RESTRICTIVENESS.cc_by_sa;
-      if (compositionLevel < requiredLevel) {
-        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < requiredLevel) {
-          forcedLicense = "cc_by_sa";
-        }
-        warnings.push(
-          `Import "${imp.path}" is "cc_by_sa" \u2014 your composition license forced to "cc_by_sa" (share-alike)`
-        );
-      }
-    }
-    if (imp.license === "cc_by_nc") {
-      if (compositionLicense === "free" || compositionLicense === "cc_by") {
-        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < RESTRICTIVENESS.cc_by_nc) {
-          forcedLicense = "cc_by_nc";
-        }
-        warnings.push(
-          `Import "${imp.path}" is "cc_by_nc" \u2014 your composition license forced to "cc_by_nc" (non-commercial)`
-        );
-      }
-    }
-    if (imp.license === "cc_by") {
-      if (compositionLicense === "free") {
-        if (!forcedLicense || RESTRICTIVENESS[forcedLicense] < RESTRICTIVENESS.cc_by) {
-          forcedLicense = "cc_by";
-        }
-        warnings.push(
-          `Import "${imp.path}" is "cc_by" \u2014 your composition license forced to at least "cc_by" (attribution required)`
-        );
-      }
-    }
-  }
-  const hasShareAlike = importedLicenses.some((i) => i.license === "cc_by_sa");
-  const hasNonCommercial = importedLicenses.some((i) => i.license === "cc_by_nc");
-  if (hasShareAlike && hasNonCommercial) {
-    errors.push(
-      'License conflict: cannot mix "cc_by_sa" (share-alike) and "cc_by_nc" (non-commercial) imports \u2014 cc_by_sa requires derivatives use the same license, but cc_by_nc requires non-commercial use'
-    );
-  }
-  return {
-    compatible: errors.length === 0,
-    errors,
-    warnings,
-    forcedLicense
-  };
-}
-
-// src/deploy/protocol-types.ts
-var PROTOCOL_CONSTANTS = {
-  /** Platform fee in basis points (2.5%) */
-  PLATFORM_FEE_BPS: 250,
-  /** Import royalty per level in basis points (5% per level) */
-  IMPORT_ROYALTY_BPS: 500,
-  /** Maximum import depth for revenue distribution */
-  MAX_IMPORT_DEPTH: 3,
-  /** Default referral reward in basis points (2%) */
-  DEFAULT_REFERRAL_BPS: 200,
-  /** Basis points denominator */
-  BPS_DENOMINATOR: 1e4,
-  /** Zora mint fee per edition (in wei) */
-  ZORA_MINT_FEE_WEI: 777000000000000n,
-  // 0.000777 ETH
-  /** Chain configuration */
-  CHAIN: {
-    id: 8453,
-    name: "base",
-    testnet: {
-      id: 84532,
-      name: "base-sepolia"
-    }
-  },
-  /** Protocol registry base URL */
-  REGISTRY_BASE_URL: "https://holoscript.net",
-  /** Zora 1155 factory address (same on all chains) */
-  ZORA_1155_FACTORY: "0x777777C338d93e2C7adf08D102d45CA7CC4Ed021",
-  /** Environment variable names */
-  ENV: {
-    WALLET_KEY: "HOLOSCRIPT_WALLET_KEY",
-    COLLECTION_ADDRESS: "HOLOSCRIPT_COLLECTION_ADDRESS",
-    SERVER_URL: "HOLOSCRIPT_SERVER_URL"
-  }
-};
-
-// src/deploy/revenue-splitter.ts
-function calculateRevenueDistribution(collectPrice, creator, importChain, options = {}) {
-  const {
-    platformFeeBps = PROTOCOL_CONSTANTS.PLATFORM_FEE_BPS,
-    importRoyaltyBps = PROTOCOL_CONSTANTS.IMPORT_ROYALTY_BPS,
-    maxImportDepth = PROTOCOL_CONSTANTS.MAX_IMPORT_DEPTH,
-    referralBps = PROTOCOL_CONSTANTS.DEFAULT_REFERRAL_BPS,
-    referrer,
-    platformAddress = "platform"
-  } = options;
-  const flows = [];
-  if (collectPrice === 0n) {
-    return { totalPrice: 0n, flows: [] };
-  }
-  const bpsDenom = BigInt(PROTOCOL_CONSTANTS.BPS_DENOMINATOR);
-  let remaining = collectPrice;
-  const platformFee = collectPrice * BigInt(platformFeeBps) / bpsDenom;
-  if (platformFee > 0n) {
-    flows.push({
-      recipient: platformAddress,
-      amount: platformFee,
-      reason: "platform",
-      bps: platformFeeBps
-    });
-    remaining -= platformFee;
-  }
-  if (referrer) {
-    const referralAmount = collectPrice * BigInt(referralBps) / bpsDenom;
-    if (referralAmount > 0n) {
-      flows.push({
-        recipient: referrer,
-        amount: referralAmount,
-        reason: "referral",
-        bps: referralBps
-      });
-      remaining -= referralAmount;
-    }
-  }
-  const flattenedByDepth = flattenImportsByDepth(importChain, maxImportDepth);
-  for (const [depth, nodes] of flattenedByDepth.entries()) {
-    if (nodes.length === 0) continue;
-    const levelRoyalty = collectPrice * BigInt(importRoyaltyBps) / bpsDenom;
-    const perImportRoyalty = levelRoyalty / BigInt(nodes.length);
-    const dust = levelRoyalty - perImportRoyalty * BigInt(nodes.length);
-    for (let i = 0; i < nodes.length; i++) {
-      const amount = i === 0 ? perImportRoyalty + dust : perImportRoyalty;
-      if (amount > 0n) {
-        flows.push({
-          recipient: nodes[i].author,
-          amount,
-          reason: "import_royalty",
-          depth,
-          bps: Math.floor(importRoyaltyBps / nodes.length)
-        });
-        remaining -= amount;
-      }
-    }
-  }
-  if (remaining > 0n) {
-    const creatorBps = PROTOCOL_CONSTANTS.BPS_DENOMINATOR - platformFeeBps - (referrer ? referralBps : 0) - importRoyaltyBps * flattenedByDepth.size;
-    flows.push({
-      recipient: creator,
-      amount: remaining,
-      reason: "creator",
-      bps: Math.max(creatorBps, 0)
-    });
-  }
-  return { totalPrice: collectPrice, flows };
-}
-function flattenImportsByDepth(chain, maxDepth) {
-  const byDepth = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  function walk(nodes, depth) {
-    if (depth > maxDepth) return;
-    for (const node of nodes) {
-      if (seen.has(node.contentHash)) continue;
-      seen.add(node.contentHash);
-      const list = byDepth.get(depth) ?? [];
-      list.push(node);
-      byDepth.set(depth, list);
-      if (node.children.length > 0) {
-        walk(node.children, depth + 1);
-      }
-    }
-  }
-  walk(chain, 1);
-  return byDepth;
-}
-async function resolveImportChain(imports, resolver, maxDepth = PROTOCOL_CONSTANTS.MAX_IMPORT_DEPTH) {
-  const seen = /* @__PURE__ */ new Set();
-  async function resolve(importList, depth) {
-    if (depth > maxDepth) return [];
-    const nodes = [];
-    for (const imp of importList) {
-      const hash = imp.hash;
-      if (!hash || seen.has(hash)) continue;
-      seen.add(hash);
-      const record = await resolver(hash);
-      const author = record?.author ?? imp.author ?? "unknown";
-      const children = record && depth < maxDepth ? await resolve(
-        record.importHashes.map((h) => ({ hash: h, path: "", author: "" })),
-        depth + 1
-      ) : [];
-      nodes.push({
-        contentHash: hash,
-        author,
-        depth,
-        children
-      });
-    }
-    return nodes;
-  }
-  return resolve(imports, 1);
-}
-function formatRevenueDistribution(dist) {
-  if (dist.totalPrice === 0n) return ["Free collect \u2014 no revenue distribution"];
-  return dist.flows.map((flow) => {
-    const pct = (Number(flow.amount) / Number(dist.totalPrice) * 100).toFixed(1);
-    const depthLabel = flow.depth ? `, depth ${flow.depth}` : "";
-    return `${pct}% \u2192 ${flow.recipient} (${flow.reason}${depthLabel})`;
-  });
-}
-function ethToWei(eth) {
-  const parts = eth.split(".");
-  const whole = parts[0] || "0";
-  const fraction = (parts[1] || "").padEnd(18, "0").slice(0, 18);
-  return BigInt(whole) * 10n ** 18n + BigInt(fraction);
-}
-function weiToEth(wei) {
-  const str = wei.toString().padStart(19, "0");
-  const whole = str.slice(0, str.length - 18) || "0";
-  const fraction = str.slice(str.length - 18).replace(/0+$/, "") || "0";
-  return `${whole}.${fraction}`;
-}
-
-exports.CompositionTestRunner = CompositionTestRunner;
-exports.DEFAULT_STDLIB_POLICY = DEFAULT_STDLIB_POLICY;
-exports.PROTOCOL_CONSTANTS = PROTOCOL_CONSTANTS;
-exports.TEST_TRAIT = TEST_TRAIT;
-exports.calculateRevenueDistribution = calculateRevenueDistribution;
-exports.checkLicenseCompatibility = checkLicenseCompatibility;
-exports.classifyPublishMode = classifyPublishMode;
-exports.computeContentHash = computeContentHash;
-exports.createStdlibActions = createStdlibActions;
-exports.ethToWei = ethToWei;
-exports.extractImports = extractImports;
-exports.formatRevenueDistribution = formatRevenueDistribution;
-exports.generateProvenance = generateProvenance;
-exports.isPathAllowed = isPathAllowed;
-exports.parseHostFromUrl = parseHostFromUrl;
-exports.registerStdlib = registerStdlib;
-exports.resolveImportChain = resolveImportChain;
-exports.resolveRepoRelativePath = resolveRepoRelativePath;
-exports.testHandler = testHandler;
-exports.toStringArray = toStringArray;
-exports.truncateText = truncateText;
-exports.weiToEth = weiToEth;
-//# sourceMappingURL=chunk-G7CT3EMP.cjs.map
-//# sourceMappingURL=chunk-G7CT3EMP.cjs.map