@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-NV4VMVXU.js

@@ -0,0 +1,421 @@
+import { HoloScriptRuntime } from './chunk-3NFFOWGG.js';
+import { HoloScriptCodeParser } from './chunk-URG2SJLK.js';
+
+// src/HoloScriptDebugger.ts
+var HoloScriptDebugger = class {
+  constructor(runtime) {
+    this.breakpoints = /* @__PURE__ */ new Map();
+    this.callStack = [];
+    this.currentAST = [];
+    this.currentNodeIndex = 0;
+    this.frameIdCounter = 0;
+    this.breakpointIdCounter = 0;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.state = {
+      status: "stopped",
+      currentLine: 0,
+      currentColumn: 0,
+      currentNode: null,
+      callStack: [],
+      breakpoints: []
+    };
+    this.runtime = runtime || new HoloScriptRuntime();
+    this.parser = new HoloScriptCodeParser();
+  }
+  /**
+   * Load source code for debugging
+   */
+  loadSource(code, file) {
+    const parseResult = this.parser.parse(code);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        errors: parseResult.errors.map((e) => `Line ${e.line}: ${e.message}`)
+      };
+    }
+    this.currentAST = parseResult.ast;
+    this.currentNodeIndex = 0;
+    this.state.status = "stopped";
+    this.callStack = [];
+    if (file) {
+      for (const node of this.currentAST) {
+        node.file = file;
+      }
+    }
+    return { success: true };
+  }
+  /**
+   * Set a breakpoint at a line
+   */
+  setBreakpoint(line, options = {}) {
+    const id = `bp_${++this.breakpointIdCounter}`;
+    const breakpoint = {
+      id,
+      line,
+      column: options.column,
+      condition: options.condition,
+      hitCount: 0,
+      enabled: options.enabled !== false,
+      file: options.file
+    };
+    this.breakpoints.set(id, breakpoint);
+    this.updateBreakpointList();
+    return breakpoint;
+  }
+  /**
+   * Remove a breakpoint by ID
+   */
+  removeBreakpoint(id) {
+    const removed = this.breakpoints.delete(id);
+    if (removed) {
+      this.updateBreakpointList();
+    }
+    return removed;
+  }
+  /**
+   * Remove all breakpoints at a line
+   */
+  removeBreakpointsAtLine(line) {
+    let removed = 0;
+    for (const [id, bp] of this.breakpoints) {
+      if (bp.line === line) {
+        this.breakpoints.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      this.updateBreakpointList();
+    }
+    return removed;
+  }
+  /**
+   * Toggle breakpoint enabled state
+   */
+  toggleBreakpoint(id) {
+    const bp = this.breakpoints.get(id);
+    if (bp) {
+      bp.enabled = !bp.enabled;
+      this.updateBreakpointList();
+      return bp.enabled;
+    }
+    return false;
+  }
+  /**
+   * Get all breakpoints
+   */
+  getBreakpoints() {
+    return Array.from(this.breakpoints.values());
+  }
+  /**
+   * Clear all breakpoints
+   */
+  clearBreakpoints() {
+    this.breakpoints.clear();
+    this.updateBreakpointList();
+  }
+  /**
+   * Start debugging from the beginning
+   */
+  async start() {
+    this.currentNodeIndex = 0;
+    this.callStack = [];
+    this.frameIdCounter = 0;
+    this.runtime.reset();
+    this.state.status = "running";
+    await this.runUntilBreakpoint();
+  }
+  /**
+   * Continue execution until next breakpoint or end
+   */
+  async continue() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "running";
+    this.currentNodeIndex++;
+    await this.runUntilBreakpoint();
+  }
+  /**
+   * Step into the next node
+   */
+  async stepInto() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("into");
+  }
+  /**
+   * Step over the current node
+   */
+  async stepOver() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("over");
+  }
+  /**
+   * Step out of the current function
+   */
+  async stepOut() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("out");
+  }
+  /**
+   * Stop debugging
+   */
+  stop() {
+    this.state.status = "stopped";
+    this.callStack = [];
+    this.currentNodeIndex = 0;
+    this.emitEvent({ type: "state-change", data: { status: "stopped" } });
+  }
+  /**
+   * Pause execution
+   */
+  pause() {
+    if (this.state.status === "running") {
+      this.state.status = "paused";
+      this.emitEvent({ type: "state-change", data: { status: "paused" } });
+    }
+  }
+  /**
+   * Get current debug state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get call stack
+   */
+  getCallStack() {
+    return [...this.callStack];
+  }
+  /**
+   * Get variables at a specific stack frame
+   */
+  getVariables(frameId) {
+    if (frameId !== void 0) {
+      const frame = this.callStack.find((f) => f.id === frameId);
+      return frame?.variables || /* @__PURE__ */ new Map();
+    }
+    return new Map(this.runtime.getContext().variables);
+  }
+  /**
+   * Evaluate an expression in the current context
+   */
+  async evaluate(expression) {
+    try {
+      const varValue = this.runtime.getVariable(expression);
+      if (varValue !== void 0) {
+        return { value: varValue };
+      }
+      const parseResult = this.parser.parse(expression);
+      if (!parseResult.success) {
+        return { value: void 0, error: parseResult.errors[0]?.message };
+      }
+      const results = await this.runtime.executeProgram(parseResult.ast);
+      const lastResult = results[results.length - 1];
+      return { value: lastResult?.output };
+    } catch (error) {
+      return { value: void 0, error: String(error) };
+    }
+  }
+  /**
+   * Set a watch expression
+   */
+  watch(expression) {
+    const id = `watch_${Date.now()}`;
+    return { id, expression };
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(handler);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Get the underlying runtime
+   */
+  getRuntime() {
+    return this.runtime;
+  }
+  // Private methods
+  async runUntilBreakpoint() {
+    while (this.currentNodeIndex < this.currentAST.length) {
+      if (this.state.status === "stopped") break;
+      const node = this.currentAST[this.currentNodeIndex];
+      if (this.shouldBreakAt(node)) {
+        this.state.status = "paused";
+        this.updateCurrentState(node);
+        const bp = this.findBreakpointAtLine(node.line ?? 0);
+        if (bp) {
+          bp.hitCount++;
+          this.emitEvent({
+            type: "breakpoint-hit",
+            data: { breakpoint: bp, node, line: node.line ?? 0 }
+          });
+        }
+        return;
+      }
+      await this.executeNode(node);
+      this.currentNodeIndex++;
+    }
+    this.state.status = "stopped";
+    this.emitEvent({ type: "state-change", data: { status: "stopped", reason: "complete" } });
+  }
+  async executeStep(mode) {
+    const startStackDepth = this.callStack.length;
+    if (this.currentNodeIndex >= this.currentAST.length) {
+      this.state.status = "stopped";
+      return;
+    }
+    const node = this.currentAST[this.currentNodeIndex];
+    switch (mode) {
+      case "into":
+        await this.executeNode(node);
+        this.currentNodeIndex++;
+        break;
+      case "over":
+        await this.executeNode(node);
+        this.currentNodeIndex++;
+        break;
+      case "out":
+        while (this.currentNodeIndex < this.currentAST.length) {
+          await this.executeNode(this.currentAST[this.currentNodeIndex]);
+          this.currentNodeIndex++;
+          if (this.callStack.length < startStackDepth) {
+            break;
+          }
+        }
+        break;
+    }
+    if (this.currentNodeIndex < this.currentAST.length) {
+      this.state.status = "paused";
+      this.updateCurrentState(this.currentAST[this.currentNodeIndex]);
+      this.emitEvent({
+        type: "step-complete",
+        data: { mode, node: this.currentAST[this.currentNodeIndex] }
+      });
+    } else {
+      this.state.status = "stopped";
+      this.emitEvent({ type: "state-change", data: { status: "stopped", reason: "complete" } });
+    }
+  }
+  async executeNode(node) {
+    if (node.type === "function") {
+      const funcNode = node;
+      this.pushStackFrame(funcNode.name, node);
+    }
+    try {
+      const result = await this.runtime.executeNode(node);
+      if (!result.success && result.error) {
+        this.emitEvent({
+          type: "exception",
+          data: { error: result.error, node, line: node.line }
+        });
+      }
+      if (result.output !== void 0) {
+        this.emitEvent({
+          type: "output",
+          data: { output: result.output, node }
+        });
+      }
+    } catch (error) {
+      this.emitEvent({
+        type: "exception",
+        data: { error: String(error), node, line: node.line }
+      });
+    }
+    if (node.type === "function") {
+      this.popStackFrame();
+    }
+  }
+  shouldBreakAt(node) {
+    const line = node.line;
+    for (const bp of this.breakpoints.values()) {
+      if (!bp.enabled) continue;
+      if (bp.line !== line) continue;
+      if (bp.condition) {
+        try {
+          const value = this.runtime.getVariable(bp.condition);
+          if (!value) continue;
+        } catch {
+          continue;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  findBreakpointAtLine(line) {
+    for (const bp of this.breakpoints.values()) {
+      if (bp.line === line && bp.enabled) {
+        return bp;
+      }
+    }
+    return null;
+  }
+  pushStackFrame(name, node) {
+    const frame = {
+      id: ++this.frameIdCounter,
+      name,
+      file: node.file,
+      line: node.line ?? 0,
+      column: node.column ?? 0,
+      variables: new Map(this.runtime.getContext().variables),
+      node
+    };
+    this.callStack.push(frame);
+    this.state.callStack = [...this.callStack];
+  }
+  popStackFrame() {
+    const frame = this.callStack.pop();
+    this.state.callStack = [...this.callStack];
+    return frame;
+  }
+  updateCurrentState(node) {
+    this.state.currentLine = node.line ?? 0;
+    this.state.currentColumn = node.column ?? 0;
+    this.state.currentNode = node;
+  }
+  updateBreakpointList() {
+    this.state.breakpoints = Array.from(this.breakpoints.values());
+  }
+  emitEvent(event) {
+    const handlers = this.eventHandlers.get(event.type) || [];
+    for (const handler of handlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Debug event handler error:", error);
+      }
+    }
+    const allHandlers = this.eventHandlers.get("all") || [];
+    for (const handler of allHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Debug event handler error:", error);
+      }
+    }
+  }
+};
+function createDebugger(runtime) {
+  return new HoloScriptDebugger(runtime);
+}
+
+export { HoloScriptDebugger, createDebugger };
+//# sourceMappingURL=chunk-NV4VMVXU.js.map
+//# sourceMappingURL=chunk-NV4VMVXU.js.map

package/dist/chunk-NW5G5FBQ.js

@@ -0,0 +1,215 @@
+// src/testing/DeterminismHarness.ts
+function getGlobal() {
+  return globalThis ?? {};
+}
+function detectRuntime() {
+  const g = getGlobal();
+  if (typeof g.window !== "undefined" && typeof g.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof g.process !== "undefined" && g.process.versions?.node) {
+    return "node";
+  }
+  return "unknown";
+}
+function detectBrowserFromUserAgent(ua) {
+  if (!ua) return {};
+  let browser;
+  let os;
+  if (/Firefox\//.test(ua)) browser = "firefox";
+  else if (/Edg\//.test(ua)) browser = "edge";
+  else if (/Chrome\//.test(ua)) browser = "chromium";
+  else if (/Safari\//.test(ua)) browser = "safari";
+  if (/Windows NT/.test(ua)) os = "windows";
+  else if (/Mac OS X/.test(ua)) os = "macos";
+  else if (/Linux/.test(ua)) os = "linux";
+  else if (/Android/.test(ua)) os = "android";
+  else if (/iPhone|iPad/.test(ua)) os = "ios";
+  return { browser, os };
+}
+async function captureEnvironment(annotations = {}) {
+  const runtime = detectRuntime();
+  const g = getGlobal();
+  const info = { runtime };
+  if (Object.keys(annotations).length > 0) info.annotations = { ...annotations };
+  if (runtime === "browser") {
+    const nav = g.navigator;
+    const ua = nav?.userAgent;
+    info.browser = { userAgent: ua, ...detectBrowserFromUserAgent(ua) };
+    if (nav?.gpu?.requestAdapter) {
+      try {
+        const adapter = await nav.gpu.requestAdapter();
+        let gpuInfo = adapter?.info;
+        if (!gpuInfo && adapter?.requestAdapterInfo) {
+          gpuInfo = await adapter.requestAdapterInfo();
+        }
+        if (gpuInfo) {
+          info.gpu = {
+            vendor: gpuInfo.vendor,
+            architecture: gpuInfo.architecture,
+            device: gpuInfo.device,
+            description: gpuInfo.description,
+            backend: "webgpu"
+          };
+        }
+      } catch {
+      }
+    }
+  } else if (runtime === "node") {
+    const proc = g.process;
+    if (proc) {
+      info.node = {
+        version: proc.versions?.node ?? "unknown",
+        arch: proc.arch ?? "unknown",
+        platform: proc.platform ?? "unknown"
+      };
+    }
+  }
+  return info;
+}
+function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(input);
+  }
+  const bytes = new Uint8Array(input.length);
+  for (let i = 0; i < input.length; i++) bytes[i] = input.charCodeAt(i) & 255;
+  return bytes;
+}
+function fnv1a64Hex(bytes) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let i = 0; i < bytes.length; i++) {
+    hash = (hash ^ BigInt(bytes[i])) & mask;
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+async function hashBytes(input, algo = "sha256") {
+  const bytes = toUint8Array(input);
+  if (algo === "sha256") {
+    const g = getGlobal();
+    const subtle = g.crypto?.subtle;
+    if (subtle && typeof subtle.digest === "function") {
+      try {
+        const digest = await subtle.digest("SHA-256", bytes);
+        const view = new Uint8Array(digest);
+        let hex = "";
+        for (let i = 0; i < view.length; i++) hex += view[i].toString(16).padStart(2, "0");
+        return `sha256:${hex}`;
+      } catch {
+      }
+    }
+  }
+  return `fnv1a-64:${fnv1a64Hex(bytes)}`;
+}
+var DeterminismHarness = class {
+  constructor(options = {}) {
+    this.options = {
+      captureOutput: options.captureOutput ?? false,
+      hashAlgorithm: options.hashAlgorithm ?? "sha256",
+      annotations: options.annotations ?? {}
+    };
+  }
+  /**
+   * Run a probe function, capture environment, hash the output,
+   * return a structured ProbeResult. Never throws — errors are
+   * caught and reported on the result's `error` field with a
+   * sentinel outputHash of `error:<message>`.
+   */
+  async probe(name, fn, annotations = {}) {
+    const timestamp = Date.now();
+    const mergedAnnotations = { ...this.options.annotations, ...annotations };
+    const environment = await captureEnvironment(mergedAnnotations);
+    const started = typeof performance !== "undefined" ? performance.now() : timestamp;
+    let output;
+    let error;
+    try {
+      output = await fn();
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    }
+    const ended = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const durationMs = Math.max(0, ended - started);
+    if (error !== void 0 || output === void 0) {
+      return {
+        name,
+        timestamp,
+        environment,
+        durationMs,
+        outputHash: `error:${error ?? "no-output"}`,
+        outputSize: 0,
+        error
+      };
+    }
+    const outputHash = await hashBytes(output, this.options.hashAlgorithm);
+    const outputSize = output instanceof Uint8Array ? output.byteLength : toUint8Array(output).byteLength;
+    const result = {
+      name,
+      timestamp,
+      environment,
+      durationMs,
+      outputHash,
+      outputSize
+    };
+    if (this.options.captureOutput) result.output = output;
+    return result;
+  }
+  /**
+   * Compare a collection of probe results and report whether they
+   * agree. Groups results by hash so the caller can see which
+   * environments produced which outputs.
+   */
+  static compareResults(results) {
+    if (results.length === 0) {
+      return {
+        probeName: "(empty)",
+        totalResults: 0,
+        uniqueHashes: 0,
+        divergent: false,
+        groups: [],
+        summary: "No results supplied to compare."
+      };
+    }
+    const probeName = results[0].name;
+    const byHash = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      const existing = byHash.get(r.outputHash);
+      if (existing) existing.push(r);
+      else byHash.set(r.outputHash, [r]);
+    }
+    const groups = Array.from(byHash.entries()).map(([hash, rs]) => ({
+      hash,
+      results: rs,
+      environments: rs.map((r) => describeEnvironment(r.environment))
+    }));
+    const divergent = groups.length > 1;
+    const summary = divergent ? `DIVERGENT: ${groups.length} distinct hashes across ${results.length} runs of "${probeName}".` : `CONVERGENT: all ${results.length} runs of "${probeName}" produced hash ${groups[0].hash}.`;
+    return {
+      probeName,
+      totalResults: results.length,
+      uniqueHashes: groups.length,
+      divergent,
+      groups,
+      summary
+    };
+  }
+};
+function describeEnvironment(env) {
+  const parts = [env.runtime];
+  if (env.browser?.browser) parts.push(env.browser.browser);
+  if (env.browser?.os) parts.push(env.browser.os);
+  if (env.node) parts.push(`node ${env.node.version} ${env.node.platform}/${env.node.arch}`);
+  if (env.gpu?.vendor) parts.push(`gpu:${env.gpu.vendor}${env.gpu.architecture ? "/" + env.gpu.architecture : ""}`);
+  if (env.annotations) {
+    for (const [k, v] of Object.entries(env.annotations)) {
+      parts.push(`${k}=${v}`);
+    }
+  }
+  return parts.join(" | ");
+}
+
+export { DeterminismHarness, captureEnvironment, describeEnvironment, hashBytes };
+//# sourceMappingURL=chunk-NW5G5FBQ.js.map
+//# sourceMappingURL=chunk-NW5G5FBQ.js.map