@holoscript/core 6.0.4 → 6.1.2

package/dist/{chunk-CS2EMTGF.js → chunk-QAVXL2IH.js}

@@ -1,7 +1,10 @@
+import { computeContentHash } from './chunk-4R6SBXDB.js';
+import { init_AgentRBAC, init_CompilerBase, getRBAC, UnauthorizedCompilerAccessError } from './chunk-QTPMJRGS.js';
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
 import { createHash } from 'crypto';
-import { getRBAC, WorkflowStep, ResourceType } from '@holoscript/platform';
 
 // src/compiler/TraitDependencyGraph.ts
+init_safeJsonParse();
 function hashConfig(config) {
   const keys = Object.keys(config).sort();
   const parts = [];
@@ -501,7 +504,7 @@ var TraitDependencyGraph = class _TraitDependencyGraph {
    */
   static deserialize(json) {
     const graph = new _TraitDependencyGraph();
-    const data = JSON.parse(json);
+    const data = readJson(json);
     if (data.version !== 1 && data.version !== 2) {
       throw new Error(`Unsupported trait graph version: ${data.version}`);
     }
@@ -722,7 +725,7 @@ var ImportResolver = class {
           throw new Error(`File not found: '${canonicalPath}' (imported from '${importedBy}')`);
         }
       }
-      const { HoloScriptPlusParser } = await import('./parser.js');
+      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-F2Z56FJR.js');
       const parser = new HoloScriptPlusParser({ enableTypeScriptImports: true });
       const result = parser.parse(source);
       if (!result.success && result.errors.length > 0) {
@@ -781,10 +784,21 @@ var ImportResolver = class {
       throw new Error(`Unknown CRDT namespace. Only crdt://holomesh/feed is supported.`);
     }
     try {
-      const fs = await import('fs/promises');
-      const path = await import('path');
+      const fsModule = "fs/promises";
+      const pathModule = "path";
+      const fs = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        fsModule
+      );
+      const path = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        pathModule
+      );
       const pkgName = "@loro/loro";
       const { LoroDoc } = await import(
+        /* webpackIgnore: true */
         /* @vite-ignore */
         pkgName
       );
@@ -869,7 +883,12 @@ var ImportResolver = class {
   _defaultReader() {
     return async (filePath) => {
       try {
-        const fs = await import('fs/promises');
+        const fsModule = "fs/promises";
+        const fs = await import(
+          /* webpackIgnore: true */
+          /* @vite-ignore */
+          fsModule
+        );
         return await fs.readFile(filePath, "utf-8");
       } catch {
         throw new Error(
@@ -892,6 +911,9 @@ var ImportResolver = class {
     return this.cache.get(canonicalPath);
   }
 };
+
+// src/compiler/SemanticCache.ts
+init_safeJsonParse();
 function hashSourceCode(source) {
   return createHash("sha256").update(source, "utf8").digest("hex");
 }
@@ -992,7 +1014,7 @@ var SemanticCache = class {
       if (this.redis && this.redisConnected) {
         const raw = await this.redis.get(key);
         if (raw) {
-          entry = JSON.parse(raw);
+          entry = readJson(raw);
         }
       } else {
         const memEntry = this.memoryCache.get(key);
@@ -1242,6 +1264,11 @@ var SemanticCache = class {
 function createSemanticCache(options) {
   return new SemanticCache(options);
 }
+
+// src/compiler/IncrementalCompiler.ts
+init_AgentRBAC();
+init_CompilerBase();
+init_safeJsonParse();
 function hashContent(content) {
   let hash = 0;
   for (let i = 0; i < content.length; i++) {
@@ -1285,7 +1312,10 @@ var IncrementalCompiler = class _IncrementalCompiler {
     this.stateSnapshot = null;
     this.dependencyGraph = /* @__PURE__ */ new Map();
     this.semanticCache = null;
+    /** Persistent disk cache keyed by provenance content-hash (paper-10). */
+    this.buildCache = null;
     this.traitGraph = traitGraph || globalTraitGraph;
+    this.buildCache = options?.buildCache ?? null;
     if (options?.enableSemanticCache) {
       this.semanticCache = createSemanticCache({
         redisUrl: options.redisUrl,
@@ -1743,9 +1773,9 @@ var IncrementalCompiler = class _IncrementalCompiler {
     const rbac = getRBAC();
     const decision = rbac.checkAccess({
       token: agentToken,
-      resourceType: ResourceType.AST,
+      resourceType: "ast" /* AST */,
       operation: "read",
-      expectedWorkflowStep: WorkflowStep.GENERATE_ASSEMBLY
+      expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
     });
     if (!decision.allowed) {
       throw new UnauthorizedIncrementalCompilerAccessError(decision, "IncrementalCompiler");
@@ -1777,6 +1807,7 @@ var IncrementalCompiler = class _IncrementalCompiler {
     this.collectObjects(newAST, allObjects);
     for (const [name, obj] of allObjects) {
       const hash = hashContent(serializeObject(obj));
+      const provenanceHash = computeContentHash(serializeObject(obj));
       const traitUsages = this.extractTraitUsages(obj.traits || []);
       this.traitGraph.registerObject({
         objectName: name,
@@ -1784,6 +1815,17 @@ var IncrementalCompiler = class _IncrementalCompiler {
         traits: traitUsages,
         template: obj.template
       });
+      if (this.buildCache) {
+        const provResult = await this.buildCache.getByProvenanceHash(
+          provenanceHash,
+          "compiled"
+        );
+        if (provResult.hit) {
+          cachedObjects.push(name);
+          compiledParts.push(provResult.entry.data);
+          continue;
+        }
+      }
       if (skipUnchanged && !recompileSet.has(name)) {
         if (this.semanticCache) {
           const astHash = hashASTSubtree(obj);
@@ -1805,6 +1847,11 @@ var IncrementalCompiler = class _IncrementalCompiler {
       recompiledObjects.push(name);
       compiledParts.push(compiled);
       this.setCached(name, hash, compiled, []);
+      if (this.buildCache) {
+        await this.buildCache.setByProvenanceHash(provenanceHash, "compiled", compiled, {
+          tags: ["incremental-compiler", newAST.name || "unknown"]
+        });
+      }
       if (this.semanticCache) {
         const astHash = hashASTSubtree(obj);
         await this.semanticCache.set(astHash, "compiled-object", compiled, {
@@ -1904,7 +1951,7 @@ var IncrementalCompiler = class _IncrementalCompiler {
    * Restore compiler state from serialized data
    */
   static deserialize(json) {
-    const data = JSON.parse(json);
+    const data = readJson(json);
     if (data.version !== 1) {
       throw new Error(`Unsupported cache version: ${data.version}`);
     }
@@ -1934,7 +1981,7 @@ function serializeCache(compiler) {
   return JSON.stringify(data);
 }
 function deserializeCache(json) {
-  const data = JSON.parse(json);
+  const data = readJson(json);
   if (data.version !== 1) {
     throw new Error(`Unsupported cache version: ${data.version}`);
   }
@@ -1948,19 +1995,13 @@ function deserializeCache(json) {
   }
   return compiler;
 }
-var UnauthorizedIncrementalCompilerAccessError = class extends Error {
+var UnauthorizedIncrementalCompilerAccessError = class extends UnauthorizedCompilerAccessError {
   constructor(decision, compilerName) {
-    super(
-      `[${compilerName}] Unauthorized access: ${decision.reason || "Access denied"}
-Agent Role: ${decision.agentRole || "unknown"}
-Required Permission: ${decision.requiredPermission || "unknown"}`
-    );
-    this.decision = decision;
-    this.compilerName = compilerName;
+    super(decision, "incremental compilation", compilerName);
     this.name = "UnauthorizedIncrementalCompilerAccessError";
   }
 };
 
 export { IncrementalCompiler, TraitDependencyGraph, UnauthorizedIncrementalCompilerAccessError, createIncrementalCompiler, deserializeCache, globalTraitGraph, serializeCache };
-//# sourceMappingURL=chunk-CS2EMTGF.js.map
-//# sourceMappingURL=chunk-CS2EMTGF.js.map
+//# sourceMappingURL=chunk-QAVXL2IH.js.map
+//# sourceMappingURL=chunk-QAVXL2IH.js.map