@nekzus/liop 2.4.6 → 2.5.0-beta.2

package/dist/{chunk-WCCGE4QR.js → chunk-5SWHE62F.js}

@@ -1,8 +1,9 @@
-import { sanitizeOutput } from './chunk-JIJPZFR2.js';
-import { LIOP_SCOPES, Dilithium65Wrapper, authorizeRequest, egressBlocksTotal, toolCallsTotal, fuelConsumed } from './chunk-U5BZ66VX.js';
-import { GRPC_CHANNEL_OPTIONS, liopV1, createServerCredentials } from './chunk-WSW6YJNY.js';
-import { MeshNode } from './chunk-74CISO2I.js';
-import { log } from './chunk-72MNYFR6.js';
+import { sanitizeOutput } from './chunk-Y62GORQF.js';
+import { LIOP_SCOPES, Dilithium65Wrapper, authorizeRequest } from './chunk-WPTOJYN5.js';
+import { GRPC_CHANNEL_OPTIONS, liopV1, createServerCredentials, TokenTelemetryEngine } from './chunk-UJFWPRDM.js';
+import { egressBlocksTotal, toolCallsTotal, fuelConsumed, wireEgressBytesTotal, wireSavedBytesTotal, toolCallErrorsTotal } from './chunk-PAICJCKJ.js';
+import { MeshNode } from './chunk-XRDN232O.js';
+import { log } from './chunk-K3DGJLUY.js';
 import { Buffer } from 'buffer';
 import * as crypto3 from 'crypto';
 import crypto3__default from 'crypto';
@@ -93,12 +94,23 @@ var AuditLogger = class {
   entries = [];
   lastEntryHash = GENESIS_HASH;
   filePath;
+  interceptor;
   constructor(filePath) {
     this.filePath = filePath;
     if (this.filePath && fs2.existsSync(this.filePath)) {
       this.loadFromFile(this.filePath);
     }
   }
+  /**
+   * Registers a technology-agnostic audit interceptor.
+   * The interceptor fires AFTER the entry is sealed (hash computed)
+   * and appended to the chain. It receives a frozen deep-clone
+   * that cannot tamper with the hash chain.
+   * Pass `undefined` to disable interception (zero overhead).
+   */
+  setInterceptor(interceptor) {
+    this.interceptor = interceptor;
+  }
   recordExecution(params) {
     const id = crypto3.randomUUID();
     const timestamp = params.timestamp || (/* @__PURE__ */ new Date()).toISOString();
@@ -135,6 +147,17 @@ var AuditLogger = class {
         "utf8"
       );
     }
+    if (this.interceptor) {
+      const frozenClone = Object.freeze(structuredClone(fullEntry));
+      try {
+        const result = this.interceptor(frozenClone);
+        if (result && typeof result === "object" && "catch" in result) {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
     return fullEntry;
   }
   getEntries() {
@@ -279,7 +302,9 @@ var JwtValidator = class {
       "127.0.0.1:13000",
       "localhost:13000",
       "127.0.0.1:13001",
-      "localhost:13001"
+      "localhost:13001",
+      "127.0.0.1:15000",
+      "localhost:15000"
     ];
     let issuerAuthority = "";
     try {
@@ -481,6 +506,7 @@ var TaintAnalyzer = class _TaintAnalyzer {
   ]);
   /** Reduce-family methods where the record param is the SECOND callback arg */
   static REDUCE_METHODS = /* @__PURE__ */ new Set(["reduce", "reduceRight"]);
+  currentRecordCollections = /* @__PURE__ */ new Set();
   constructor(piiFields, sensitiveKeys = []) {
     this.piiFields = new Set(piiFields.map((f) => f.toLowerCase()));
     this.sensitiveKeys = new Set(sensitiveKeys.map((f) => f.toLowerCase()));
@@ -652,6 +678,47 @@ ${sourceCode}
     }
     return false;
   }
+  /** Checks if an expression resolves to env.records, records, an alias, or a derivation chain */
+  isRecordsSource(node) {
+    if (this.isEnvRecordsAccess(node)) return true;
+    if (node.type === "Identifier" && this.currentRecordCollections.has(node.name)) {
+      return true;
+    }
+    if (node.type === "CallExpression") {
+      const call = node;
+      if (call.callee.type === "MemberExpression") {
+        const member = call.callee;
+        const method = this.getPropertyName(member);
+        if (method && (method === "slice" || method === "filter" || method === "toSorted" || method === "map" || method === "concat")) {
+          return this.isRecordsSource(member.object);
+        }
+      }
+    }
+    return false;
+  }
+  /** Gathers aliases and derivations of env.records (e.g. const accounts = env.records; const top5 = accounts.filter(...)) */
+  identifyRecordCollections(ast) {
+    this.currentRecordCollections.clear();
+    for (let pass = 0; pass < 3; pass++) {
+      const aliasVisitors = {
+        VariableDeclarator: (node) => {
+          if (!node.init || node.id.type !== "Identifier") return;
+          if (this.isRecordsSource(node.init)) {
+            this.currentRecordCollections.add(node.id.name);
+          }
+        },
+        AssignmentExpression: (node) => {
+          if (node.left.type !== "Identifier") return;
+          if (this.isRecordsSource(node.right)) {
+            this.currentRecordCollections.add(
+              node.left.name
+            );
+          }
+        }
+      };
+      simple(ast, aliasVisitors);
+    }
+  }
   /**
    * Extracts field names accessed on a record parameter within a function body.
    * e.g., in `(s, r) => s + r.balance`, extracts "balance".
@@ -733,17 +800,18 @@ ${sourceCode}
     if (call.callee.type !== "MemberExpression") return false;
     const callee = call.callee;
     const method = this.getPropertyName(callee);
-    return method === "map" && this.isEnvRecordsChain(callee.object);
+    return method === "map" && this.isRecordsSource(callee.object);
   }
   // ── Pass 1: Record-Bound Variable Identification ──────────────────
   identifyRecordBoundVars(ast, recordBoundVars) {
+    this.identifyRecordCollections(ast);
     const visitors = {
       CallExpression: (node) => {
         if (node.callee.type !== "MemberExpression") return;
         const member = node.callee;
         const methodName = this.getPropertyName(member);
         if (!methodName) return;
-        if (!this.isEnvRecordsAccess(member.object)) return;
+        if (!this.isRecordsSource(member.object)) return;
         const callback = node.arguments[0];
         if (!callback) return;
         if (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") {
@@ -762,9 +830,9 @@ ${sourceCode}
           }
         }
       },
-      // for (const r of env.records) → r is record-bound
+      // for (const r of env.records) or for (const r of accounts) → r is record-bound
       ForOfStatement: (node) => {
-        if (!this.isEnvRecordsAccess(node.right)) return;
+        if (!this.isRecordsSource(node.right)) return;
         if (node.left.type === "VariableDeclaration") {
           for (const declarator of node.left.declarations) {
             if (declarator.id.type === "Identifier") {
@@ -780,7 +848,7 @@ ${sourceCode}
         if (!node.init || node.id.type !== "Identifier") return;
         if (node.init.type === "MemberExpression" && node.init.computed) {
           const member = node.init;
-          if (this.isEnvRecordsAccess(member.object)) {
+          if (this.isRecordsSource(member.object)) {
             recordBoundVars.add(node.id.name);
           }
         }
@@ -800,6 +868,18 @@ ${sourceCode}
           }
         },
         AssignmentExpression: (node) => {
+          if (node.left.type === "MemberExpression") {
+            const member = node.left;
+            if (member.computed && this.isExpressionTainted(
+              member.property,
+              recordBoundVars,
+              taintedVars
+            )) {
+              if (member.object.type === "Identifier") {
+                taintedVars.add(member.object.name);
+              }
+            }
+          }
           if (node.left.type !== "Identifier") return;
           if (this.isExpressionTainted(node.right, recordBoundVars, taintedVars)) {
             taintedVars.add(node.left.name);
@@ -921,9 +1001,26 @@ ${sourceCode}
       }
       case "ObjectExpression": {
         const obj = node;
-        return obj.properties.some(
-          (prop) => prop.type === "Property" && this.isExpressionTainted(prop.value, recordBoundVars, taintedVars)
-        );
+        return obj.properties.some((prop) => {
+          if (prop.type === "Property") {
+            if (prop.computed && this.isExpressionTainted(prop.key, recordBoundVars, taintedVars)) {
+              return true;
+            }
+            return this.isExpressionTainted(
+              prop.value,
+              recordBoundVars,
+              taintedVars
+            );
+          }
+          if (prop.type === "SpreadElement") {
+            return this.isExpressionTainted(
+              prop.argument,
+              recordBoundVars,
+              taintedVars
+            );
+          }
+          return false;
+        });
       }
       case "ArrayExpression": {
         const arr = node;
@@ -960,7 +1057,7 @@ ${sourceCode}
     }
     if (member.object.type === "MemberExpression" && propName && this.piiFields.has(propName.toLowerCase())) {
       const parentMember = member.object;
-      if (parentMember.computed && this.isEnvRecordsAccess(parentMember.object)) {
+      if (parentMember.computed && this.isRecordsSource(parentMember.object)) {
         return true;
       }
     }
@@ -988,7 +1085,7 @@ ${sourceCode}
       if (methodName && _TaintAnalyzer.TAINT_PROPAGATING_METHODS.has(methodName) && this.isExpressionTainted(callee.object, recordBoundVars, taintedVars)) {
         return true;
       }
-      if (this.isEnvRecordsAccess(callee.object) && call.arguments[0]) {
+      if (this.isRecordsSource(callee.object) && call.arguments[0]) {
         const callback = call.arguments[0];
         if (callback.type === "ArrowFunctionExpression" || callback.type === "FunctionExpression") {
           return this.doesCallbackProduceTaint(
@@ -1061,6 +1158,11 @@ ${sourceCode}
         scopedTaintedVars
       );
     }
+    this.propagateTaint(
+      callback.body,
+      scopedRecordVars,
+      scopedTaintedVars
+    );
     let hasTaintedReturnOrYield = false;
     const returnVisitors = {
       ReturnStatement: (node) => {
@@ -2243,14 +2345,18 @@ Data structure: ${schemaDigest}. Full schema: resource liop://schema/global`;
             isError: true
           };
         }
-        const payloadValue = args.payload;
-        const bypassCache = args.__liop_bypass_ast_cache === true;
-        const payloadHash = crypto3__default.createHash("sha256").update(payloadValue).digest("hex");
+        const rawArgs = args && typeof args === "object" ? args : {};
+        const payloadValue = rawArgs.payload ?? rawArgs.envelope ?? rawArgs.code;
+        const bypassCache = rawArgs.__liop_bypass_ast_cache === true;
+        const payloadHash = crypto3__default.createHash("sha256").update(payloadValue || "").digest("hex");
         const logic = this.extractLogic(payloadValue);
         const cached = this.logicCache.get(payloadHash);
         if (!bypassCache && cached && now - cached.timestamp < this.CACHE_TTL_MS) {
           if (logic) {
-            args.payload = logic;
+            rawArgs.payload = logic;
+            if (rawArgs.envelope !== void 0) {
+              rawArgs.envelope = logic;
+            }
             const preflightReason = this.runPreflightPolicy(
               name,
               logic,
@@ -2281,10 +2387,11 @@ Data structure: ${schemaDigest}. Full schema: resource liop://schema/global`;
           };
         }
         try {
-          const logic2 = this.extractLogic(
-            args.payload
-          );
-          args.payload = logic2;
+          const logic2 = this.extractLogic(payloadValue);
+          rawArgs.payload = logic2;
+          if (rawArgs.envelope !== void 0) {
+            rawArgs.envelope = logic2;
+          }
           const preflightReason = this.runPreflightPolicy(
             name,
             logic2,
@@ -2677,6 +2784,12 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
   setSandboxData(records) {
     this.sandboxRecords = records;
   }
+  /**
+   * Returns the read-only sandbox records registered in the enclave.
+   */
+  getSandboxData() {
+    return this.sandboxRecords;
+  }
   getBoundPort() {
     return this.boundPort;
   }
@@ -2771,7 +2884,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               log.info(
                 `[LIOP-RPC] Bypass authentication for matching localTestToken: ${localTestToken}`
               );
-              import('./kyber-3ULIJSE3.js').then(
+              import('./kyber-CGOA7Q6A.js').then(
                 async ({ Kyber768Wrapper }) => {
                   const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
                   const sessionToken = crypto3__default.randomUUID();
@@ -2807,7 +2920,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               });
               return;
             }
-            import('./kyber-3ULIJSE3.js').then(
+            import('./kyber-CGOA7Q6A.js').then(
               async ({ Kyber768Wrapper }) => {
                 const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
                 const sessionToken = crypto3__default.randomUUID();
@@ -2833,7 +2946,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             });
           });
         } else {
-          import('./kyber-3ULIJSE3.js').then(async ({ Kyber768Wrapper }) => {
+          import('./kyber-CGOA7Q6A.js').then(async ({ Kyber768Wrapper }) => {
             const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
             const sessionToken = crypto3__default.randomUUID();
             this.sessions.set(sessionToken, {
@@ -2890,6 +3003,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
           const toolName = session.capability_hash;
           const toolDef = toolName ? this.tools.get(toolName) : void 0;
           const toolPolicy = toolDef?.policy;
+          let decryptedPayload = "";
           try {
             const kem = await createMlKem768();
             const sharedSecret = kem.decap(
@@ -2908,7 +3022,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             decipher.setAuthTag(authTag);
             let decrypted = decipher.update(encryptedData);
             decrypted = Buffer.concat([decrypted, decipher.final()]);
-            const decryptedPayload = decrypted.toString("utf-8");
+            decryptedPayload = decrypted.toString("utf-8");
             const logic = this.extractLogic(decryptedPayload) || decryptedPayload.trim();
             const preflightReason = this.runPreflightPolicy(
               toolName || "unknown_tool",
@@ -3057,13 +3171,56 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               status: isBlocked ? "BLOCKED_EGRESS" : "SUCCESS"
             });
             toolCallsTotal.inc({
+              capability: toolName || "unknown",
               tool: toolName || "unknown",
-              status: isBlocked ? "blocked_egress" : "success"
+              status: isBlocked ? "blocked_egress" : "success",
+              role: "executor"
             });
             fuelConsumed.observe(
-              { tool: toolName || "unknown" },
+              {
+                capability: toolName || "unknown",
+                tool: toolName || "unknown"
+              },
               workerResponse.fuel_consumed || 0
             );
+            try {
+              const egressBytes = Buffer.byteLength(response.semantic_evidence || "") + (response.cryptographic_proof ? response.cryptographic_proof.length : 0) + (response.zk_receipt ? response.zk_receipt.length : 0);
+              wireEgressBytesTotal.inc(
+                { capability: toolName || "unknown" },
+                egressBytes
+              );
+              if (this.sandboxRecords && this.sandboxRecords.length > 0) {
+                const rawDatasetString = JSON.stringify(this.sandboxRecords);
+                const rawDatasetBytes = Buffer.byteLength(rawDatasetString);
+                const savedBytes = Math.max(0, rawDatasetBytes - egressBytes);
+                if (savedBytes > 0) {
+                  wireSavedBytesTotal.inc(
+                    { capability: toolName || "unknown" },
+                    savedBytes
+                  );
+                }
+                try {
+                  const telemetry = TokenTelemetryEngine.getInstance();
+                  const originDatasetTokens = telemetry.countTokens(rawDatasetString);
+                  const outputTokens = telemetry.countTokens(
+                    response.semantic_evidence || ""
+                  );
+                  const inputTokens = telemetry.countTokens(
+                    decryptedPayload || ""
+                  );
+                  telemetry.record({
+                    type: "tool_call",
+                    method: "ExecuteLogic",
+                    toolName: toolName || "unknown",
+                    estimatedInputTokens: inputTokens,
+                    estimatedOutputTokens: outputTokens,
+                    originDatasetTokens
+                  });
+                } catch {
+                }
+              }
+            } catch {
+            }
             call.write(response, () => {
               call.end();
             });
@@ -3084,8 +3241,14 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               status: "ERROR"
             });
             toolCallsTotal.inc({
+              capability: toolName || "unknown",
               tool: toolName || "unknown",
-              status: "error"
+              status: "error",
+              role: "executor"
+            });
+            toolCallErrorsTotal.inc({
+              capability: toolName || "unknown",
+              error_type: "runtime_error"
             });
             const errorResponse = {
               semantic_evidence: errorMessage,
@@ -3516,5 +3679,5 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
 };
 
 export { AUTH_DEFAULTS, AuditLogger, GENESIS_HASH, JwtValidator, LiopRpcServer, LiopServer, NerScanner, PII_PATTERNS, PII_PRESETS, PiiScanner, computeEntryHash, createOAuthServer, globalAuditLogger };
-//# sourceMappingURL=chunk-WCCGE4QR.js.map
-//# sourceMappingURL=chunk-WCCGE4QR.js.map
+//# sourceMappingURL=chunk-5SWHE62F.js.map
+//# sourceMappingURL=chunk-5SWHE62F.js.map