@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-FL33V6U7.js

@@ -0,0 +1,421 @@
+import { HoloScriptRuntime } from './chunk-JIBL5LRK.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-FL33V6U7.js.map
+//# sourceMappingURL=chunk-FL33V6U7.js.map

package/dist/chunk-FYSPZT4V.cjs

@@ -0,0 +1,169 @@
+'use strict';
+
+var chunk5S7RKFGR_cjs = require('./chunk-5S7RKFGR.cjs');
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+
+// src/compiler/TraitCompositionCompiler.ts
+chunkKKP7JKN4_cjs.init_AgentRBAC();
+chunkKKP7JKN4_cjs.init_CompilerBase();
+chunk5S7RKFGR_cjs.init_ProvenanceSemiring();
+var CompositionConflictError = class extends Error {
+  constructor(traitA, traitB, conflictKey) {
+    super(
+      `Trait composition conflict: "${traitA}" and "${traitB}" both declare conflicting key "${conflictKey}".`
+    );
+    this.traitA = traitA;
+    this.traitB = traitB;
+    this.conflictKey = conflictKey;
+    this.name = "CompositionConflictError";
+  }
+};
+var MissingComponentError = class extends Error {
+  constructor(composedName, missingComponent) {
+    super(
+      `Composition "${composedName}" references unknown component trait "${missingComponent}". Register it in TraitBinder before compiling.`
+    );
+    this.composedName = composedName;
+    this.missingComponent = missingComponent;
+    this.name = "MissingComponentError";
+  }
+};
+var TraitCompositionCompiler = class {
+  constructor(inheritanceResolver) {
+    this.inheritanceResolver = inheritanceResolver;
+  }
+  /**
+   * Set or replace the trait inheritance resolver.
+   * Call this after constructing if the resolver becomes available later.
+   */
+  setInheritanceResolver(resolver) {
+    this.inheritanceResolver = resolver;
+  }
+  /**
+   * Compile a set of composition declarations.
+   *
+   * @param decls         - Declarations to compile.
+   * @param getHandler    - Lookup a component handler by name.
+   * @param traitGraph    - Optional TraitDependencyGraph; if supplied, new
+   *                        composed traits are registered there.
+   * @param agentToken    - JWT token proving agent identity (optional for backwards compatibility).
+   * @returns Compiled ComposedTraitDef[], in declaration order.
+   * @throws UnauthorizedTraitCompositionAccessError if token is provided but invalid.
+   */
+  compile(decls, getHandler, traitGraph, agentToken) {
+    this.validateAccess(agentToken);
+    return decls.map((decl) => this.compileOne(decl, getHandler, traitGraph));
+  }
+  // ---------------------------------------------------------------------------
+  // RBAC enforcement
+  // ---------------------------------------------------------------------------
+  /**
+   * Validate agent has permission to compile trait compositions.
+   * Skips validation when no token is provided (backwards compatibility / testing).
+   */
+  validateAccess(agentToken) {
+    if (!agentToken) return;
+    const rbac = chunkKKP7JKN4_cjs.getRBAC();
+    const decision = rbac.checkAccess({
+      token: agentToken,
+      resourceType: "ast" /* AST */,
+      operation: "read",
+      expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
+    });
+    if (!decision.allowed) {
+      throw new UnauthorizedTraitCompositionAccessError(decision, "TraitCompositionCompiler");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  compileOne(decl, getHandler, traitGraph) {
+    const handlers = decl.components.map((name) => {
+      const handler = getHandler(name);
+      if (!handler) throw new MissingComponentError(decl.name, name);
+      return { name, handler };
+    });
+    if (chunk5S7RKFGR_cjs.authorityWeight(
+      decl.provenance?.context?.authorityLevel ?? 0
+    ) < 100) {
+      this.detectConflicts(handlers);
+    }
+    const semiring = new chunk5S7RKFGR_cjs.ProvenanceSemiring();
+    const applications = [];
+    for (const { name, handler } of handlers) {
+      let configAccumulator = {};
+      if (this.inheritanceResolver && this.inheritanceResolver.hasTrait(name)) {
+        const resolvedProps = this.inheritanceResolver.getFlattenedProperties(name);
+        configAccumulator = { ...resolvedProps };
+      }
+      if (handler.defaultConfig) {
+        configAccumulator = { ...configAccumulator, ...handler.defaultConfig };
+      }
+      applications.push({ name, config: configAccumulator });
+    }
+    if (decl.overrides) {
+      applications.push({
+        name: `${decl.name}_overrides`,
+        config: decl.overrides,
+        context: { authorityLevel: Number.MAX_SAFE_INTEGER }
+        // Overrides always win!
+      });
+    }
+    const { config: merged, errors } = semiring.add(applications);
+    if (errors.length > 0) {
+      const match = errors[0].match(/Composition conflict: @(.+) and @(.+) both supply '(.+)'/);
+      if (match) {
+        throw new CompositionConflictError(match[1], match[2], match[3]);
+      } else {
+        throw new CompositionConflictError("Merge", "Failure", errors[0]);
+      }
+    }
+    if (this.inheritanceResolver && decl.components.length > 1) {
+      const diamonds = this.inheritanceResolver.detectDiamondInheritance(decl.components);
+      for (const diamond of diamonds) {
+      }
+    }
+    if (traitGraph) {
+      traitGraph.registerTrait({
+        name: decl.name,
+        requires: decl.components,
+        conflicts: []
+      });
+    }
+    return {
+      name: decl.name,
+      components: decl.components,
+      defaultConfig: merged
+    };
+  }
+  /**
+   * Naive conflict check: if handler A's `conflicts` array includes handler B's
+   * name (or vice-versa), throw.
+   */
+  detectConflicts(handlers) {
+    for (let i = 0; i < handlers.length; i++) {
+      const a = handlers[i];
+      const aConflicts = a.handler.conflicts ?? [];
+      for (let j = i + 1; j < handlers.length; j++) {
+        const b = handlers[j];
+        const bConflicts = b.handler.conflicts ?? [];
+        if (aConflicts.includes(b.name) || bConflicts.includes(a.name)) {
+          throw new CompositionConflictError(a.name, b.name, b.name);
+        }
+      }
+    }
+  }
+};
+var UnauthorizedTraitCompositionAccessError = class extends chunkKKP7JKN4_cjs.UnauthorizedCompilerAccessError {
+  constructor(decision, compilerName) {
+    super(decision, "trait composition", compilerName);
+    this.name = "UnauthorizedTraitCompositionAccessError";
+  }
+};
+
+exports.CompositionConflictError = CompositionConflictError;
+exports.MissingComponentError = MissingComponentError;
+exports.TraitCompositionCompiler = TraitCompositionCompiler;
+exports.UnauthorizedTraitCompositionAccessError = UnauthorizedTraitCompositionAccessError;
+//# sourceMappingURL=chunk-FYSPZT4V.cjs.map
+//# sourceMappingURL=chunk-FYSPZT4V.cjs.map