@nekzus/liop 2.2.0 → 2.3.0

package/dist/{chunk-2JLG4DET.js → chunk-UBOQZVV5.js}

@@ -1,10 +1,12 @@
-import { LIOP_SCOPES, authorizeRequest } from './chunk-IJHTRIZC.js';
-import { liopV1, createServerCredentials } from './chunk-RDWCGZ2A.js';
-import { MeshNode } from './chunk-NJRSFFD7.js';
+import { sanitizeOutput } from './chunk-JIJPZFR2.js';
+import { LIOP_SCOPES, Dilithium65Wrapper, authorizeRequest, egressBlocksTotal, toolCallsTotal, fuelConsumed } from './chunk-OIMJZ64E.js';
+import { GRPC_CHANNEL_OPTIONS, liopV1, createServerCredentials } from './chunk-WSW6YJNY.js';
+import { MeshNode } from './chunk-74CISO2I.js';
 import { log } from './chunk-72MNYFR6.js';
 import { Buffer } from 'buffer';
-import crypto2 from 'crypto';
-import * as fs from 'fs';
+import * as crypto3 from 'crypto';
+import crypto3__default from 'crypto';
+import * as fs2 from 'fs';
 import { createRequire } from 'module';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
@@ -17,14 +19,6 @@ import Provider from 'oidc-provider';
 import * as acorn from 'acorn';
 import { simple } from 'acorn-walk';
 
-var GRPC_CHANNEL_OPTIONS = {
-  "grpc.keepalive_time_ms": 3e4,
-  "grpc.keepalive_timeout_ms": 1e4,
-  "grpc.keepalive_permit_without_calls": 1,
-  "grpc.max_send_message_length": -1,
-  "grpc.max_receive_message_length": -1,
-  "grpc.enable_retries": 1
-};
 var LiopRpcServer = class {
   server;
   constructor() {
@@ -53,15 +47,145 @@ var LiopRpcServer = class {
       );
     });
   }
-  async stop() {
+  async gracefulShutdown(timeoutMs = 5e3) {
     return new Promise((resolve) => {
+      let resolved = false;
+      const timer = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          log.warn(
+            `[LIOP-RPC] tryShutdown timed out after ${timeoutMs}ms \u2014 forcing shutdown`
+          );
+          this.server.forceShutdown();
+          resolve();
+        }
+      }, timeoutMs);
       this.server.tryShutdown(() => {
-        log.info("[LIOP-RPC] Server shut down");
-        resolve();
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          log.info("[LIOP-RPC] Server gracefully shut down");
+          resolve();
+        }
       });
     });
   }
+  async stop() {
+    return this.gracefulShutdown(5e3);
+  }
+};
+var GENESIS_HASH = "0".repeat(64);
+function canonicalize(obj) {
+  const sortedKeys = Object.keys(obj).sort();
+  const canonicalObj = {};
+  for (const key of sortedKeys) {
+    canonicalObj[key] = obj[key];
+  }
+  return JSON.stringify(canonicalObj);
+}
+function computeEntryHash(entryWithoutHash) {
+  const canonical = canonicalize(
+    entryWithoutHash
+  );
+  return crypto3.createHash("sha256").update(canonical).digest("hex");
+}
+var AuditLogger = class {
+  entries = [];
+  lastEntryHash = GENESIS_HASH;
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+    if (this.filePath && fs2.existsSync(this.filePath)) {
+      this.loadFromFile(this.filePath);
+    }
+  }
+  recordExecution(params) {
+    const id = crypto3.randomUUID();
+    const timestamp = params.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const traceId = params.traceId || crypto3.randomBytes(16).toString("hex");
+    const datasetHash = params.datasetHash || crypto3.createHash("sha256").update("").digest("hex");
+    const outputHash = params.outputHash || crypto3.createHash("sha256").update("").digest("hex");
+    const zkReceiptSig = params.zkReceiptSig || "";
+    const partialEntry = {
+      id,
+      timestamp,
+      traceId,
+      agentDid: params.agentDid,
+      peerId: params.peerId,
+      toolName: params.toolName,
+      datasetHash,
+      fuelConsumed: params.fuelConsumed,
+      outputHash,
+      zkReceiptSig,
+      status: params.status,
+      prevEntryHash: this.lastEntryHash
+    };
+    const entryHash = computeEntryHash(partialEntry);
+    const fullEntry = {
+      ...partialEntry,
+      entryHash
+    };
+    this.entries.push(fullEntry);
+    this.lastEntryHash = entryHash;
+    if (this.filePath) {
+      fs2.appendFileSync(
+        this.filePath,
+        `${JSON.stringify(fullEntry)}
+`,
+        "utf8"
+      );
+    }
+    return fullEntry;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  getEntryCount() {
+    return this.entries.length;
+  }
+  verifyIntegrity() {
+    let expectedPrevHash = GENESIS_HASH;
+    for (let i = 0; i < this.entries.length; i++) {
+      const entry = this.entries[i];
+      if (entry.prevEntryHash !== expectedPrevHash) {
+        return {
+          valid: false,
+          totalEntries: this.entries.length,
+          brokenIndex: i,
+          reason: `Broken hash chain at index ${i}: expected prevHash ${expectedPrevHash}, got ${entry.prevEntryHash}`
+        };
+      }
+      const { entryHash, ...withoutHash } = entry;
+      const recalculated = computeEntryHash(withoutHash);
+      if (recalculated !== entryHash) {
+        return {
+          valid: false,
+          totalEntries: this.entries.length,
+          brokenIndex: i,
+          reason: `Tampered entry at index ${i}: hash mismatch (expected ${recalculated}, stored ${entryHash})`
+        };
+      }
+      expectedPrevHash = entryHash;
+    }
+    return {
+      valid: true,
+      totalEntries: this.entries.length
+    };
+  }
+  exportJsonl() {
+    return this.entries.map((e) => JSON.stringify(e)).join("\n");
+  }
+  loadFromFile(path2) {
+    const content = fs2.readFileSync(path2, "utf8");
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+      const entry = JSON.parse(line);
+      this.entries.push(entry);
+      this.lastEntryHash = entry.entryHash;
+    }
+  }
 };
+var globalAuditLogger = new AuditLogger();
 
 // src/security/auth-config.ts
 var AUTH_DEFAULTS = {
@@ -206,10 +330,10 @@ var JwtValidator = class {
   }
 };
 function createOAuthServer(config) {
-  const { privateKey, publicKey } = crypto2.generateKeyPairSync("ed25519");
+  const { privateKey, publicKey } = crypto3__default.generateKeyPairSync("ed25519");
   const privateJwk = privateKey.export({ format: "jwk" });
   const publicJwk = publicKey.export({ format: "jwk" });
-  const kid = crypto2.createHash("sha256").update(publicJwk.x || "").digest("hex").slice(0, 16);
+  const kid = crypto3__default.createHash("sha256").update(publicJwk.x || "").digest("hex").slice(0, 16);
   const privateJwkComplete = {
     ...privateJwk,
     kid,
@@ -286,7 +410,7 @@ function createOAuthServer(config) {
     },
     // Allow HTTP locally for development/Docker testnets (production MUST use HTTPS in proxy)
     cookies: {
-      keys: [crypto2.randomBytes(32).toString("hex")]
+      keys: [crypto3__default.randomBytes(32).toString("hex")]
     },
     // Map scopes directly into the JWT token claims during client_credentials grant
     extraTokenClaims: (_ctx, token) => {
@@ -1133,54 +1257,6 @@ var NerScanner = class _NerScanner {
   }
 };
 
-// src/server/output-sanitizer.ts
-var DEFAULT_CONFIG = {
-  maxDecimalPlaces: 4,
-  clampNonNegative: true
-};
-function sanitizeOutput(output, config) {
-  const merged = { ...DEFAULT_CONFIG, ...config };
-  const seen = /* @__PURE__ */ new WeakSet();
-  function walk(node) {
-    if (node === null || node === void 0) {
-      return node;
-    }
-    if (typeof node === "number") {
-      if (!Number.isFinite(node)) {
-        return node;
-      }
-      let value = node;
-      if (merged.clampNonNegative && value < 0) {
-        value = 0;
-      }
-      const factor = 10 ** merged.maxDecimalPlaces;
-      value = Math.round(value * factor) / factor;
-      return value;
-    }
-    if (typeof node === "string" || typeof node === "boolean") {
-      return node;
-    }
-    if (typeof node === "object") {
-      if (seen.has(node)) {
-        return node;
-      }
-      seen.add(node);
-      if (Array.isArray(node)) {
-        return node.map((item) => walk(item));
-      }
-      const result = {};
-      for (const [key, val] of Object.entries(
-        node
-      )) {
-        result[key] = walk(val);
-      }
-      return result;
-    }
-    return node;
-  }
-  return walk(output);
-}
-
 // src/server/pii.ts
 function isLuhnValid(cardNumber) {
   const digits = cardNumber.replace(/\D/g, "");
@@ -1610,6 +1686,7 @@ var LiopServer = class _LiopServer {
     ];
     const sensitiveKeys = this.config?.security?.sensitiveKeys ?? [];
     this.taintAnalyzer = new TaintAnalyzer(forbiddenKeys, sensitiveKeys);
+    this.auditLogger = this.config?.auditLogger || globalAuditLogger;
     const isTS = import.meta.url.endsWith(".ts");
     const workerExt = isTS ? ".ts" : ".js";
     let execArgv = [];
@@ -1635,7 +1712,7 @@ var LiopServer = class _LiopServer {
       path.resolve(__dirname2, `../workers/logic-execution${workerExt}`)
       // Original src/
     ];
-    const workerFilename = workerPaths.find((p) => fs.existsSync(p)) || workerPaths[1];
+    const workerFilename = workerPaths.find((p) => fs2.existsSync(p)) || workerPaths[1];
     this.workerPool = new Piscina({
       filename: workerFilename,
       minThreads: this.config?.workerPool?.minThreads ?? (isTest ? 0 : 2),
@@ -1730,10 +1807,16 @@ var LiopServer = class _LiopServer {
   sessions = /* @__PURE__ */ new Map();
   revokedTokenHashes = /* @__PURE__ */ new Set();
   lastRevocationLoadTime = 0;
+  pqcKeyPair = Dilithium65Wrapper.generateKeyPair();
+  auditLogger;
+  getDatasetHash() {
+    return crypto3__default.createHash("sha256").update(JSON.stringify(this.sandboxRecords || [])).digest("hex");
+  }
   // Compact envelope: @LIOP{target,name}\n<code>\n@END
-  static LIOP_COMPACT_REGEX = /@LIOP\{(?<target>[^,}]+)(?:,(?<name>[^}]*))?\}\n(?<logic>[\s\S]*?)\n@END/m;
+  static LIOP_COMPACT_REGEX = /@LIOP\{(?<target>[^,}]+)(?:,\s*(?<name>[^}]*))?\}[\r\n]+(?<logic>[\s\S]*?)[\r\n]+@END/m;
   extractLogic(payload) {
-    const compact = payload.match(_LiopServer.LIOP_COMPACT_REGEX);
+    if (!payload || typeof payload !== "string") return null;
+    const compact = payload.trim().match(_LiopServer.LIOP_COMPACT_REGEX);
     return compact?.groups?.logic ? compact.groups.logic.trim() : null;
   }
   parseUnknownJson(input) {
@@ -1780,6 +1863,9 @@ var LiopServer = class _LiopServer {
     }
     const extractedFields = this.taintAnalyzer.extractQueriedFields(logic);
     if (extractedFields.length > 0) {
+      if (clientId === "__proto__" || clientId === "constructor" || clientId === "prototype" || _toolName === "__proto__" || _toolName === "constructor" || _toolName === "prototype") {
+        return "Preflight policy rejected: invalid property key names (prototype pollution guard).";
+      }
       const storePath = policy?.budgetStorePath || this.config?.budgetStorePath;
       if (storePath) {
         try {
@@ -2157,7 +2243,7 @@ Data structure: ${schemaDigest}. Full schema: resource liop://schema/global`;
         }
         const payloadValue = args.payload;
         const bypassCache = args.__liop_bypass_ast_cache === true;
-        const payloadHash = crypto2.createHash("sha256").update(payloadValue).digest("hex");
+        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) {
@@ -2621,7 +2707,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
         mimeType: r.mimeType,
         text: typeof r.content === "string" ? r.content : r.description
       }));
-      return {
+      const unsignedManifest = {
         peerId: meshNodeRef.getPeerId(),
         grpcPort: port,
         tools,
@@ -2635,6 +2721,16 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
           executionTypes: this.config.taxonomy.executionTypes || []
         } : void 0
       };
+      const attestation = Dilithium65Wrapper.signManifest(
+        unsignedManifest,
+        this.pqcKeyPair.secretKey,
+        this.pqcKeyPair.publicKey
+      );
+      return {
+        ...unsignedManifest,
+        pqcSignature: attestation.signature,
+        pqcPublicKey: attestation.publicKey
+      };
     });
     for (const tool of this.listTools()) {
       await this.meshNode.announceCapability(tool.name).catch(log.info);
@@ -2657,7 +2753,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             return;
           }
           const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
-          const tokenHash = crypto2.createHash("sha256").update(token).digest("hex").toLowerCase();
+          const tokenHash = crypto3__default.createHash("sha256").update(token).digest("hex").toLowerCase();
           this.loadRevocationList();
           if (this.revokedTokenHashes.has(tokenHash)) {
             callback({
@@ -2676,12 +2772,13 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               import('./kyber-3ULIJSE3.js').then(
                 async ({ Kyber768Wrapper }) => {
                   const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
-                  const sessionToken = crypto2.randomUUID();
+                  const sessionToken = crypto3__default.randomUUID();
                   this.sessions.set(sessionToken, {
                     capability_hash: request.capability_hash,
                     kyber_sk: secretKey,
                     agent_did: request.agent_did,
-                    tokenHash
+                    tokenHash,
+                    createdAt: Date.now()
                   });
                   callback(null, {
                     accepted: true,
@@ -2711,12 +2808,13 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             import('./kyber-3ULIJSE3.js').then(
               async ({ Kyber768Wrapper }) => {
                 const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
-                const sessionToken = crypto2.randomUUID();
+                const sessionToken = crypto3__default.randomUUID();
                 this.sessions.set(sessionToken, {
                   capability_hash: request.capability_hash,
                   kyber_sk: secretKey,
                   agent_did: request.agent_did,
-                  tokenHash
+                  tokenHash,
+                  createdAt: Date.now()
                 });
                 callback(null, {
                   accepted: true,
@@ -2735,11 +2833,12 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
         } else {
           import('./kyber-3ULIJSE3.js').then(async ({ Kyber768Wrapper }) => {
             const { publicKey, secretKey } = await Kyber768Wrapper.generateKeyPair();
-            const sessionToken = crypto2.randomUUID();
+            const sessionToken = crypto3__default.randomUUID();
             this.sessions.set(sessionToken, {
               capability_hash: request.capability_hash,
               kyber_sk: secretKey,
-              agent_did: request.agent_did
+              agent_did: request.agent_did,
+              createdAt: Date.now()
             });
             callback(null, {
               accepted: true,
@@ -2764,6 +2863,18 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             });
             return;
           }
+          const MAX_SESSION_KEY_LIFETIME_MS = 3600 * 1e3;
+          if (session.createdAt) {
+            const sessionAge = Date.now() - session.createdAt;
+            if (sessionAge > MAX_SESSION_KEY_LIFETIME_MS) {
+              this.sessions.delete(request.session_token);
+              call.emit("error", {
+                code: grpc2.status.UNAUTHENTICATED,
+                details: `[LIOP-PQC] Session secret expired: Age (${Math.round(sessionAge / 1e3)}s) exceeds 3600s TTL limit. Re-handshake required.`
+              });
+              return;
+            }
+          }
           if (session.tokenHash) {
             this.loadRevocationList();
             if (this.revokedTokenHashes.has(session.tokenHash)) {
@@ -2787,7 +2898,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             const wasmBuffer = Buffer.from(request.wasm_binary);
             const authTag = wasmBuffer.subarray(-16);
             const encryptedData = wasmBuffer.subarray(0, -16);
-            const decipher = crypto2.createDecipheriv(
+            const decipher = crypto3__default.createDecipheriv(
               "aes-256-gcm",
               aesKey,
               Buffer.from(request.aes_nonce || new Uint8Array(12))
@@ -2839,6 +2950,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               aesNonce: request.aes_nonce,
               records: this.sandboxRecords,
               sessionToken: request.session_token,
+              sessionTimestamp: session.createdAt,
               isEncrypted: true,
               dpConfig
               // Apply DP noise inside worker before ZK-Receipt commitment
@@ -2920,14 +3032,36 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
               toolPolicy?.enforceAggregationFirst,
               this.sandboxRecords?.length
             );
-            if (violation || aggregationViolation) {
+            const isBlocked = Boolean(violation || aggregationViolation);
+            if (isBlocked) {
               const internalReason = violation || "Aggregation-First Policy Violation";
               log.info(
                 `[LIOP-RPC] Secure egress blocked in gRPC stream: ${internalReason}`
               );
               response.semantic_evidence = "[LIOP] Egress Security Violation. Output blocked due to policy enforcement.";
               response.is_error = true;
+              egressBlocksTotal.inc({
+                reason: violation ? "pii_scanner" : "aggregation_policy"
+              });
             }
+            this.auditLogger.recordExecution({
+              agentDid: session.agent_did || "unknown",
+              peerId: session.tokenHash || "unknown",
+              toolName: toolName || "unknown",
+              datasetHash: this.getDatasetHash(),
+              fuelConsumed: workerResponse.fuel_consumed || 0,
+              outputHash: crypto3__default.createHash("sha256").update(response.semantic_evidence).digest("hex"),
+              zkReceiptSig: workerResponse.zk_receipt || "",
+              status: isBlocked ? "BLOCKED_EGRESS" : "SUCCESS"
+            });
+            toolCallsTotal.inc({
+              tool: toolName || "unknown",
+              status: isBlocked ? "blocked_egress" : "success"
+            });
+            fuelConsumed.observe(
+              { tool: toolName || "unknown" },
+              workerResponse.fuel_consumed || 0
+            );
             call.write(response, () => {
               call.end();
             });
@@ -2937,6 +3071,20 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             const detail = e.message || String(error);
             log.error(`[LIOP-RPC] Execution Error: ${detail}`);
             const errorMessage = isDev ? `Execution Error: ${detail}` : "[LIOP] Execution Failed. The injected logic violated runtime constraints or encountered a fatal error.";
+            this.auditLogger.recordExecution({
+              agentDid: session.agent_did || "unknown",
+              peerId: session.tokenHash || "unknown",
+              toolName: toolName || "unknown",
+              datasetHash: this.getDatasetHash(),
+              fuelConsumed: 0,
+              outputHash: crypto3__default.createHash("sha256").update(errorMessage).digest("hex"),
+              zkReceiptSig: "",
+              status: "ERROR"
+            });
+            toolCallsTotal.inc({
+              tool: toolName || "unknown",
+              status: "error"
+            });
             const errorResponse = {
               semantic_evidence: errorMessage,
               cryptographic_proof: Buffer.from(""),
@@ -2962,7 +3110,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
             return;
           }
           const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
-          const tokenHash = crypto2.createHash("sha256").update(token).digest("hex").toLowerCase();
+          const tokenHash = crypto3__default.createHash("sha256").update(token).digest("hex").toLowerCase();
           this.loadRevocationList();
           if (this.revokedTokenHashes.has(tokenHash)) {
             call.emit("error", {
@@ -3137,12 +3285,12 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
     const rPath = this.config?.auth?.revocationPath;
     if (!rPath) return;
     try {
-      if (fs.existsSync(rPath)) {
-        const stats = fs.statSync(rPath);
+      if (fs2.existsSync(rPath)) {
+        const stats = fs2.statSync(rPath);
         if (stats.mtimeMs <= this.lastRevocationLoadTime) {
           return;
         }
-        const content = fs.readFileSync(rPath, "utf-8");
+        const content = fs2.readFileSync(rPath, "utf-8");
         const list = JSON.parse(content);
         if (Array.isArray(list)) {
           this.revokedTokenHashes.clear();
@@ -3158,10 +3306,10 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
         }
       } else {
         const dir = path.dirname(rPath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
         }
-        fs.writeFileSync(rPath, JSON.stringify([], null, 2), "utf-8");
+        fs2.writeFileSync(rPath, JSON.stringify([], null, 2), "utf-8");
         this.lastRevocationLoadTime = Date.now();
         log.info(
           `[LiopServer] Created empty local revocation list at ${rPath}`
@@ -3175,7 +3323,7 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
   }
   revokeToken(token) {
     if (!token) return;
-    const hash = crypto2.createHash("sha256").update(token).digest("hex").toLowerCase();
+    const hash = crypto3__default.createHash("sha256").update(token).digest("hex").toLowerCase();
     this.revokeTokenHash(hash);
   }
   revokeTokenHash(hash) {
@@ -3187,12 +3335,12 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
     if (rPath) {
       try {
         const dir = path.dirname(rPath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
         }
         const hashes = Array.from(this.revokedTokenHashes);
-        fs.writeFileSync(rPath, JSON.stringify(hashes, null, 2), "utf-8");
-        const stats = fs.statSync(rPath);
+        fs2.writeFileSync(rPath, JSON.stringify(hashes, null, 2), "utf-8");
+        const stats = fs2.statSync(rPath);
         this.lastRevocationLoadTime = stats.mtimeMs;
         log.info(
           `[LiopServer] Persisted revocation for hash ${normalizedHash} to ${rPath}`
@@ -3213,6 +3361,12 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
    * Uses file-level locking for safe concurrent access.
    */
   resetFieldBudget(clientId, toolName) {
+    if (clientId === "__proto__" || clientId === "constructor" || clientId === "prototype" || toolName && (toolName === "__proto__" || toolName === "constructor" || toolName === "prototype")) {
+      log.warn(
+        `[LiopServer] Blocked resetFieldBudget call due to prototype pollution keys.`
+      );
+      return;
+    }
     if (toolName) {
       const clientBudget = this.fieldQueryBudget.get(clientId);
       if (clientBudget) {
@@ -3246,10 +3400,10 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
   }
   getPersistentBudget(storePath) {
     try {
-      if (!fs.existsSync(storePath)) {
+      if (!fs2.existsSync(storePath)) {
         return {};
       }
-      const content = fs.readFileSync(storePath, "utf-8");
+      const content = fs2.readFileSync(storePath, "utf-8");
       return JSON.parse(content || "{}");
     } catch {
       return {};
@@ -3258,26 +3412,26 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
   savePersistentBudget(storePath, budget) {
     const tempPath = `${storePath}.tmp`;
     const dir = path.dirname(storePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(tempPath, JSON.stringify(budget, null, 2), "utf-8");
-    fs.renameSync(tempPath, storePath);
+    fs2.writeFileSync(tempPath, JSON.stringify(budget, null, 2), "utf-8");
+    fs2.renameSync(tempPath, storePath);
   }
   executeWithBudgetLock(storePath, action) {
     const lockPath = `${storePath}.lock`;
     const maxRetries = 100;
     let attempts = 0;
     const dir = path.dirname(storePath);
-    if (!fs.existsSync(dir)) {
+    if (!fs2.existsSync(dir)) {
       try {
-        fs.mkdirSync(dir, { recursive: true });
+        fs2.mkdirSync(dir, { recursive: true });
       } catch {
       }
     }
     while (attempts < maxRetries) {
       try {
-        fs.writeFileSync(lockPath, process.pid.toString(), { flag: "wx" });
+        fs2.writeFileSync(lockPath, process.pid.toString(), { flag: "wx" });
         break;
       } catch (e) {
         if (e && typeof e === "object" && "code" in e && e.code === "EEXIST") {
@@ -3301,8 +3455,8 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
       return result;
     } finally {
       try {
-        if (fs.existsSync(lockPath)) {
-          fs.unlinkSync(lockPath);
+        if (fs2.existsSync(lockPath)) {
+          fs2.unlinkSync(lockPath);
         }
       } catch {
       }
@@ -3349,6 +3503,6 @@ Data structure: ${schemaDigest}. Full schema: resource ${uri}. Guidelines: resou
   }
 };
 
-export { AUTH_DEFAULTS, JwtValidator, LiopRpcServer, LiopServer, NerScanner, PII_PATTERNS, PII_PRESETS, PiiScanner, createOAuthServer, sanitizeOutput };
-//# sourceMappingURL=chunk-2JLG4DET.js.map
-//# sourceMappingURL=chunk-2JLG4DET.js.map
+export { AUTH_DEFAULTS, AuditLogger, GENESIS_HASH, JwtValidator, LiopRpcServer, LiopServer, NerScanner, PII_PATTERNS, PII_PRESETS, PiiScanner, computeEntryHash, createOAuthServer, globalAuditLogger };
+//# sourceMappingURL=chunk-UBOQZVV5.js.map
+//# sourceMappingURL=chunk-UBOQZVV5.js.map