@holoscript/core 7.0.0 → 8.0.0

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