@nekzus/liop 1.0.0-alpha.1

package/dist/protocol/liop_core.proto

@@ -0,0 +1,47 @@
+// Copyright 2026 Nekzus Solutions and contributors
+// SPDX-License-Identifier: Apache-2.0
+
+syntax = "proto3";
+package liop.v1;
+
+// LogicMesh (formerly NeuralMesh) is the next-generation binary transport protocol for Logic-on-Origin AI
+service LogicMesh {
+  // Intent negotiation before transferring data or execution logic
+  // Validates Identity, Capability Hashes and Cryptographic signatures
+  rpc NegotiateIntent (IntentRequest) returns (IntentResponse);
+  
+  // Execution of Logic-on-Origin in a secure remote (WASM / WASI) sandbox
+  rpc ExecuteLogic (LogicRequest) returns (stream LogicResponse);
+}
+
+// Request to negotiate an intent to execute a WASM capability
+message IntentRequest {
+  string agent_did = 1;         // Decentralized Identifier (DID) e.g., spiffe:// or Noise PeerID
+  string capability_hash = 2;   // Cryptographic hash of the targeted capability / tool
+  bytes proof_of_intent = 3;    // Cryptographic signature of the task intent
+}
+
+// Response from the host confirming or denying the intent negotiation
+message IntentResponse {
+  bool accepted = 1;            // True if the zero-trust host allows the execution
+  string session_token = 2;     // Ephemeral token to be used on ExecuteLogic stream
+  string error_message = 3;     // Capability Violation message if any
+  bytes kyber_public_key = 4;   // Post-Quantum Kyber (ML-KEM-768) Public Key (1184 bytes)
+}
+
+// Request to push a WASM module down to the origin for execution
+message LogicRequest {
+  string session_token = 1;      // Token acquired from NegotiateIntent
+  bytes wasm_binary = 2;         // AES-GCM Encrypted .wasm Logic-on-Origin filter code
+  map<string, bytes> inputs = 3; // AES-GCM Encrypted input parameters
+  bytes pqc_ciphertext = 4;      // Kyber (ML-KEM-768) Ciphertext encapsulating the AES shared secret
+  bytes aes_nonce = 5;           // 12-byte nonce for AES-GCM
+}
+
+// Streamed Response back to the LLM agent containing reduced, semantically rich semantic responses
+message LogicResponse {
+  string semantic_evidence = 1;  // Condensed semantic result for the LLM
+  bytes cryptographic_proof = 2; // Integrity signature (SHA256)
+  bytes zk_receipt = 3;          // Zero-Knowledge Proof Receipt (e.g. risc0 zkVM) for Computational Integrity
+  bool is_error = 4;             // Execution status
+}

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+export { b as AggregationPolicy, L as LiopServer, a as LiopServerOptions, i as LogicExecutionPolicy, N as NerScanner, j as OutputSanitizerConfig, P as PII_PATTERNS, k as PII_PRESETS, l as PiiRule, m as PiiScanner, T as ToolHandler, s as sanitizeOutput } from './index-DoW2gzBZ.js';
+import 'zod';
+import './node-B0b2vUFS.js';
+import './types-lJIxBlWF.js';
+import 'jose';

package/dist/server.js

@@ -0,0 +1,9 @@
+export { LiopServer, NerScanner, PII_PATTERNS, PII_PRESETS, PiiScanner } from './chunk-HD2N3IJX.js';
+export { sanitizeOutput } from './chunk-Y62GORQF.js';
+import './chunk-VH4K4U45.js';
+import './chunk-TKRX6CFI.js';
+import './chunk-PAICJCKJ.js';
+import './chunk-7RXOIDXP.js';
+import './chunk-HA6YZ42O.js';
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"server.js"}

package/dist/types-lJIxBlWF.d.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+import * as jose from 'jose';
+
+/**
+ * LIOP JWT Validator — Token Verification Engine
+ *
+ * Validates JWT Access Tokens using the `jose` library.
+ * Supports two modes:
+ *   - Local JWKS (Nexus role): Keys in memory, zero network latency.
+ *   - Remote JWKS (Node role): Fetched from Nexus /oidc/jwks with 10min cache.
+ *
+ * Standards: NIST SP 800-207 (continuous verification), OWASP API-A01
+ * Source: panva/jose DeepWiki — createRemoteJWKSet, jwtVerify
+ */
+
+/**
+ * Authorization context extracted from a validated JWT.
+ * Compatible with MCP TypeScript SDK AuthInfo interface.
+ */
+interface AuthInfo {
+    /** Raw JWT string. */
+    token: string;
+    /** Subject claim (client_id for M2M flows). */
+    clientId: string;
+    /** Space-delimited scopes parsed into an array. */
+    scopes: string[];
+    /** Token expiration timestamp (Unix seconds). */
+    expiresAt?: number;
+}
+/**
+ * JWT Validator with dual-mode JWKS resolution.
+ *
+ * - Nexus role: `new JwtValidator(issuer, audience, localJwks)` (createLocalJWKSet)
+ * - Node role: `new JwtValidator(issuer, audience, new URL(jwksUri))` (createRemoteJWKSet)
+ */
+declare class JwtValidator {
+    private readonly jwksResolver;
+    private readonly issuer;
+    private readonly audience;
+    constructor(issuer: string, audience: string, jwksSource: URL | jose.JSONWebKeySet);
+    /**
+     * Validates a JWT access token and extracts authorization context.
+     *
+     * Checks performed (jose.jwtVerify):
+     * - Cryptographic signature verification (EdDSA or ES256)
+     * - Issuer claim matches configured issuer
+     * - Audience claim matches configured audience
+     * - Token is not expired (with clock tolerance for mesh skew)
+     * - Required claims (sub, scope) are present
+     *
+     * @throws JOSEError if validation fails (expired, wrong issuer, bad signature, etc.)
+     */
+    validate(token: string): Promise<AuthInfo>;
+    /**
+     * Builds a complete set of issuer URL aliases for the LIOP demo topology.
+     *
+     * The LIOP mesh runs on Docker Desktop with the following network layout:
+     *   Container hostnames: "nexus", "liop-nexus" (internal port 3000)
+     *   Host-published ports: 13000 (HTTP/MCP), 13001 (libp2p TCP)
+     *   Loopback addresses: 127.0.0.1, localhost
+     *
+     * The Nexus OAuth server may set its issuer to any of these depending on
+     * how it was configured, and nodes may resolve it via LIOP_NEXUS_URL
+     * which varies by context. This method generates all equivalent aliases
+     * so that jose.jwtVerify accepts the token regardless of which alias
+     * was used as `iss` in the JWT.
+     *
+     * Security note: This does NOT weaken validation — the cryptographic
+     * signature is still verified against the same JWKS keys. Only the
+     * string comparison of the `iss` claim is relaxed across known aliases.
+     */
+    private buildIssuerAliases;
+    /**
+     * Returns the configured issuer URL for PRM (RFC 9728) metadata.
+     */
+    getIssuer(): string;
+    /**
+     * Returns the configured audience for PRM metadata.
+     */
+    getAudience(): string;
+}
+
+/**
+ * @mcp-legacy ENTIRE FILE — MCP 2025-era backward compatibility layer.
+ * Remove this file when MCP v1 (2025-11-25) reaches EOL.
+ *
+ * SUNSET INSTRUCTION: Delete this file, then grep for "@mcp-legacy" in the
+ * codebase to find and remove all remaining legacy seams.
+ */
+/**
+ * @mcp-legacy Master kill switch for MCP 2025-era backward compatibility.
+ * Set to `false` when MCP v1 reaches End-of-Life (EOL) to disable all legacy seams.
+ */
+declare const MCP_LEGACY_SUPPORT_ENABLED = true;
+/**
+ * @mcp-legacy Legacy protocol version constant.
+ */
+declare const MCP_PROTOCOL_VERSION_LEGACY: "2025-11-25";
+
+/**
+ * Protocol Version Identifiers
+ */
+declare const MCP_PROTOCOL_VERSION: "2026-07-28";
+
+/**
+ * Protocol Era Classification
+ */
+type McpEra = "legacy" | "modern";
+/**
+ * Caching Hints for MCP 2026-07-28 Spec
+ */
+interface CacheableResult {
+    ttlMs?: number;
+    cacheScope?: "public" | "private";
+}
+/**
+ * Multi-Round-Trip Requests (MRTR) Specification Types
+ */
+interface InputRequest {
+    id: string;
+    message: string;
+    schema?: Record<string, unknown>;
+}
+interface InputResponse {
+    id: string;
+    value: unknown;
+}
+interface InputRequiredResult {
+    resultType: "input_required";
+    inputRequests: InputRequest[];
+    requestState?: string;
+}
+/**
+ * Modern Envelope Metadata (_meta)
+ */
+interface McpRequestMeta {
+    "io.modelcontextprotocol/protocolVersion"?: string;
+    "io.modelcontextprotocol/clientInfo"?: {
+        name: string;
+        version: string;
+    };
+    "io.modelcontextprotocol/clientCapabilities"?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Base Protocol Types representing parity with Model Context Protocol
+ */
+declare const ToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type Tool = z.infer<typeof ToolSchema>;
+declare const ResourceSchema: z.ZodObject<{
+    uri: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Resource = z.infer<typeof ResourceSchema>;
+declare const PromptSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    arguments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Prompt = z.infer<typeof PromptSchema>;
+interface CallToolRequest {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface CallToolResult {
+    content: Array<{
+        type: "text" | "image" | "resource";
+        text?: string;
+        data?: string;
+        mimeType?: string;
+        resource?: {
+            uri: string;
+            text?: string;
+            blob?: string;
+        };
+    }>;
+    isError?: boolean;
+}
+interface GetPromptRequest {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface GetPromptResult {
+    description?: string;
+    messages: Array<{
+        role: "user" | "assistant";
+        content: {
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text?: string;
+                blob?: string;
+            };
+        };
+    }>;
+}
+interface ServerInfo {
+    name: string;
+    version: string;
+    capabilities?: {
+        prompts?: {
+            listChanged?: boolean;
+        };
+        resources?: {
+            subscribe?: boolean;
+            listChanged?: boolean;
+        };
+        tools?: {
+            listChanged?: boolean;
+        };
+        /** @mcp-legacy @deprecated Deprecated in MCP 2026-07-28 spec */
+        logging?: Record<string, unknown>;
+    };
+}
+interface DiscoverResult {
+    resultType: "complete";
+    supportedVersions: string[];
+    capabilities: ServerInfo["capabilities"];
+    serverInfo: ServerInfo;
+    instructions?: string;
+}
+interface McpRequest {
+    method: string;
+    params?: unknown;
+    id?: string | number | null;
+    jsonrpc?: "2.0";
+}
+interface McpResponse {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+
+export { type AuthInfo as A, type CallToolRequest as C, type DiscoverResult as D, type GetPromptRequest as G, type InputRequest as I, JwtValidator as J, type McpEra as M, type Prompt as P, type Resource as R, type ServerInfo as S, type Tool as T, type CallToolResult as a, type McpRequest as b, type McpResponse as c, type GetPromptResult as d, type CacheableResult as e, type InputRequiredResult as f, type InputResponse as g, MCP_LEGACY_SUPPORT_ENABLED as h, MCP_PROTOCOL_VERSION as i, MCP_PROTOCOL_VERSION_LEGACY as j, type McpRequestMeta as k, PromptSchema as l, ResourceSchema as m, ToolSchema as n };

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+import 'zod';
+export { A as AuthInfo, e as CacheableResult, C as CallToolRequest, a as CallToolResult, D as DiscoverResult, G as GetPromptRequest, d as GetPromptResult, I as InputRequest, f as InputRequiredResult, g as InputResponse, h as MCP_LEGACY_SUPPORT_ENABLED, i as MCP_PROTOCOL_VERSION, j as MCP_PROTOCOL_VERSION_LEGACY, M as McpEra, b as McpRequest, k as McpRequestMeta, c as McpResponse, P as Prompt, l as PromptSchema, R as Resource, m as ResourceSchema, S as ServerInfo, T as Tool, n as ToolSchema } from './types-lJIxBlWF.js';
+import 'jose';

package/dist/types.js

@@ -0,0 +1,3 @@
+export { MCP_LEGACY_SUPPORT_ENABLED, MCP_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION_LEGACY, PromptSchema, ResourceSchema, ToolSchema } from './chunk-EG46XMJT.js';
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/verifier-COnid_dg.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LIOP Tier-0 Industrial Verifier
+ *
+ * This engine is responsible for the trustless verification of remote logic execution.
+ * It validates both the integrity of the code (ZkImageID) and the mathematical proof
+ * of its execution (ZkSeal), as well as hardware-level attestation (TEE).
+ */
+declare class LiopVerifier {
+    private static zkWorkerPool;
+    private getZkPool;
+    /**
+     * Verifies a Zero-Knowledge Receipt from a remote LIOP node via Worker Pool.
+     *
+     * @param logicPayload The raw WASM or JS logic that was sent to the provider.
+     * @param remoteImageIdHex The ImageID reported by the provider (must match our local calculation).
+     * @param zkReceipt The mathematical proof (Seal + Journal) from the zkVM.
+     */
+    verifyZkReceipt(logicPayload: Buffer, remoteImageIdHex: string, zkReceipt: Buffer, sessionSecret?: Buffer, expectedOutput?: unknown): Promise<boolean>;
+    /**
+     * Verifies if a node is running inside an authenticated TEE (e.g. AWS Nitro).
+     *
+     * @param attestationReport The COSE-signed attestation document from the hardware.
+     */
+    verifyTeeAttestation(attestationReport: Buffer): Promise<boolean>;
+    /**
+     * Derives the ImageID of a logic payload following the LIOP v1 Standard.
+     */
+    deriveImageId(logicPayload: Buffer): Buffer;
+}
+
+export { LiopVerifier as L };

package/dist/verifier-HRFXBKT5.js

@@ -0,0 +1,6 @@
+export { LiopVerifier } from './chunk-PEN3KFLF.js';
+import './chunk-IK7CGWAZ.js';
+import './chunk-PAICJCKJ.js';
+import './chunk-HA6YZ42O.js';
+//# sourceMappingURL=verifier-HRFXBKT5.js.map
+//# sourceMappingURL=verifier-HRFXBKT5.js.map

package/dist/verifier-HRFXBKT5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"verifier-HRFXBKT5.js"}

package/dist/workers/logic-execution.d.ts

@@ -0,0 +1,26 @@
+interface WorkerData {
+    isWarmup?: boolean;
+    ciphertext?: Uint8Array;
+    secretKeyObj?: ArrayLike<number>;
+    kyberPublicKey?: Uint8Array;
+    wasmBinary?: Uint8Array;
+    inputs?: Record<string, Uint8Array>;
+    records?: Record<string, unknown>[];
+    sessionToken?: string;
+    sessionTimestamp?: number;
+    isEncrypted?: boolean;
+    aesNonce?: Uint8Array;
+    dpConfig?: {
+        epsilon: number;
+        sensitivity: number;
+        smallDatasetThreshold: number;
+    };
+}
+declare function processLogicExecution(data: WorkerData): Promise<{
+    image_id: string;
+    output: unknown;
+    fuel_consumed: number;
+    zk_receipt?: string;
+}>;
+
+export { type WorkerData, processLogicExecution as default };

package/dist/workers/logic-execution.js

@@ -0,0 +1,272 @@
+import { ASTGuardian, WasiSandbox } from '../chunk-7BSCUYUE.js';
+import { sanitizeOutput } from '../chunk-Y62GORQF.js';
+import { normalizeLogicSource, deriveLogicImageDigest } from '../chunk-IK7CGWAZ.js';
+import { Buffer } from 'buffer';
+import crypto2 from 'crypto';
+import { createMlKem768 } from 'mlkem';
+
+var DEFAULT_DP_CONFIG = {
+  epsilon: 1,
+  sensitivity: 1,
+  smallDatasetThreshold: 50
+};
+var EPSILON_FLOOR = 1;
+var EPSILON_FLOOR_THRESHOLD = 10;
+function laplaceSample(scale, prngState) {
+  let u;
+  do {
+    if (prngState) {
+      const hash = crypto2.createHash("sha256").update(`${prngState.seed}:${prngState.counter++}`).digest();
+      u = hash.readUInt32BE(0) / 4294967296 - 0.5;
+    } else {
+      const buf = crypto2.randomBytes(4);
+      const rawVal = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
+      const cleanVal = Number.parseInt(rawVal.toString(10), 10);
+      u = cleanVal / 4294967296;
+    }
+  } while (u === 0 || u === -0.5);
+  return -scale * Math.sign(u) * Math.log(1 - 2 * Math.abs(u));
+}
+function addLaplaceNoise(value, config = {}, prngState) {
+  const merged = { ...DEFAULT_DP_CONFIG, ...config };
+  const scale = merged.sensitivity / merged.epsilon;
+  const noisyValue = value + laplaceSample(scale, prngState);
+  return Math.round(noisyValue * 1e4) / 1e4;
+}
+function deriveFieldSensitivity(key, globalSensitivity, recordCount) {
+  if (!key) return globalSensitivity;
+  const lk = key.toLowerCase();
+  const isCountWord = /count|length|size|num|gainer|loser|positive|negative|nan_|null_|empty_|finite_|non_finite_|instruments|tickers|users|records/i.test(
+    lk
+  );
+  const isTotalCount = lk === "total" || lk === "n" || lk === "total_records" || lk.startsWith("total_") || // Catch total_tickers, total_users
+  lk.startsWith("num_") || // Catch num_records, num_ticks
+  /total.*(count|items|entries|rows|records|tickers)/i.test(lk);
+  if (isCountWord || isTotalCount) return 1;
+  if (/avg|mean|average|var|variance|std|stddev|ratio|bps|drift|pct|percent|imbalance/i.test(
+    lk
+  ) && recordCount > 0) {
+    return globalSensitivity / recordCount;
+  }
+  return globalSensitivity;
+}
+function applyDpToOutput(output, config = {}, recordCount) {
+  const merged = { ...DEFAULT_DP_CONFIG, ...config };
+  if (recordCount >= merged.smallDatasetThreshold) {
+    return output;
+  }
+  if (recordCount < EPSILON_FLOOR_THRESHOLD && merged.epsilon < EPSILON_FLOOR) {
+    merged.epsilon = EPSILON_FLOOR;
+  }
+  let prngState;
+  if (merged.seed) {
+    prngState = { seed: merged.seed, counter: 0 };
+  }
+  return walkAndNoise(output, merged, recordCount, void 0, prngState);
+}
+function walkAndNoise(node, config, recordCount, currentKey, prngState) {
+  if (typeof node === "number" && Number.isFinite(node)) {
+    const fieldSensitivity = deriveFieldSensitivity(
+      currentKey,
+      config.sensitivity,
+      recordCount
+    );
+    let noisyValue = addLaplaceNoise(
+      node,
+      {
+        ...config,
+        sensitivity: fieldSensitivity
+      },
+      prngState
+    );
+    const isCountKey = currentKey != null && deriveFieldSensitivity(currentKey, config.sensitivity, recordCount) === 1;
+    if (Number.isInteger(node) || isCountKey) {
+      noisyValue = Math.round(noisyValue);
+    }
+    if (node >= 0) {
+      noisyValue = Math.max(0, noisyValue);
+    }
+    return noisyValue;
+  }
+  if (Array.isArray(node)) {
+    return node.map(
+      (item) => walkAndNoise(item, config, recordCount, currentKey, prngState)
+    );
+  }
+  if (node !== null && typeof node === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(
+      node
+    )) {
+      result[key] = walkAndNoise(value, config, recordCount, key, prngState);
+    }
+    return result;
+  }
+  return node;
+}
+
+// src/workers/logic-execution.ts
+async function processLogicExecution(data) {
+  if (typeof Object.prototype === "object" && !Object.isFrozen(Object.prototype)) {
+    Object.freeze(Object.prototype);
+    Object.freeze(Array.prototype);
+    Object.freeze(String.prototype);
+    Object.freeze(Number.prototype);
+    Object.freeze(Boolean.prototype);
+    Object.freeze(RegExp.prototype);
+    Object.freeze(Map.prototype);
+    Object.freeze(Set.prototype);
+    Object.freeze(Promise.prototype);
+    Object.freeze(Error.prototype);
+  }
+  if (data.isWarmup) {
+    return {
+      image_id: "",
+      output: "warm",
+      fuel_consumed: 0
+    };
+  }
+  if (data.sessionTimestamp !== void 0) {
+    const MAX_SESSION_KEY_LIFETIME_MS = 3600 * 1e3;
+    const age = Date.now() - data.sessionTimestamp;
+    if (age > MAX_SESSION_KEY_LIFETIME_MS) {
+      throw new Error(
+        `[LIOP-PQC] Session secret expired: Age (${Math.round(age / 1e3)}s) exceeds 3600s TTL limit.`
+      );
+    }
+    if (data.sessionTimestamp > Date.now() + 6e4) {
+      throw new Error(
+        "[LIOP-PQC] Session secret invalid: Timestamp is in the future."
+      );
+    }
+  }
+  const {
+    ciphertext,
+    secretKeyObj,
+    wasmBinary,
+    inputs,
+    aesNonce,
+    records,
+    isEncrypted = true,
+    dpConfig
+  } = data;
+  let decryptedPayload;
+  const decryptedInputs = {};
+  let sessionSecret = Buffer.alloc(32);
+  if (isEncrypted) {
+    const sk = new Uint8Array(secretKeyObj);
+    const ct = new Uint8Array(ciphertext);
+    const kem = await createMlKem768();
+    const sharedSecret = kem.decap(ct, sk);
+    const aesKey = Buffer.from(sharedSecret);
+    sessionSecret = aesKey;
+    const wasmBuffer = Buffer.from(wasmBinary);
+    const authTag = wasmBuffer.subarray(-16);
+    const encryptedData = wasmBuffer.subarray(0, -16);
+    const decipher = crypto2.createDecipheriv(
+      "aes-256-gcm",
+      aesKey,
+      Buffer.from(aesNonce || new Uint8Array(12))
+    );
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encryptedData);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    decryptedPayload = decrypted;
+    for (const [key, encValue] of Object.entries(inputs || {})) {
+      const valBuffer = Buffer.from(encValue);
+      const inputNonce = valBuffer.subarray(0, 12);
+      const valTag = valBuffer.subarray(-16);
+      const valData = valBuffer.subarray(12, -16);
+      const valDecipher = crypto2.createDecipheriv(
+        "aes-256-gcm",
+        aesKey,
+        inputNonce
+      );
+      valDecipher.setAuthTag(valTag);
+      let valDecrypted = valDecipher.update(valData);
+      valDecrypted = Buffer.concat([valDecrypted, valDecipher.final()]);
+      decryptedInputs[key] = JSON.parse(valDecrypted.toString("utf-8"));
+    }
+  } else {
+    if (wasmBinary[0] === 0 && wasmBinary[1] === 97 && wasmBinary[2] === 115 && wasmBinary[3] === 109) {
+      decryptedPayload = Buffer.from(wasmBinary);
+    } else {
+      decryptedPayload = Buffer.from(wasmBinary).toString("utf-8");
+    }
+  }
+  const isWasm = decryptedPayload[0] === 0 && decryptedPayload[1] === 97 && decryptedPayload[2] === 115 && decryptedPayload[3] === 109;
+  if (decryptedPayload instanceof Buffer && isWasm) {
+    const wasmBytes = new Uint8Array(decryptedPayload);
+    const compiledModule = await WebAssembly.compile(wasmBytes);
+    ASTGuardian.analyze(compiledModule);
+  } else if (decryptedPayload instanceof Buffer && !isWasm) {
+    decryptedPayload = decryptedPayload.toString("utf-8");
+  }
+  if (typeof decryptedPayload === "string") {
+    decryptedPayload = normalizeLogicSource(decryptedPayload);
+  }
+  const sandbox = new WasiSandbox();
+  await sandbox.init();
+  try {
+    const result = await sandbox.execute(
+      decryptedPayload,
+      records,
+      decryptedInputs
+    );
+    let finalOutput = result.output;
+    let logicBytes;
+    if (typeof decryptedPayload === "string") {
+      logicBytes = Buffer.from(decryptedPayload, "utf-8");
+    } else {
+      logicBytes = new Uint8Array(decryptedPayload);
+    }
+    const imageId = deriveLogicImageDigest(logicBytes).toString("hex");
+    const datasetHash = crypto2.createHash("sha256").update(JSON.stringify(records || [])).digest("hex");
+    if (dpConfig) {
+      finalOutput = applyDpToOutput(
+        finalOutput,
+        {
+          ...dpConfig,
+          seed: `${datasetHash}:${imageId}`
+        },
+        records?.length || 0
+      );
+    }
+    finalOutput = sanitizeOutput(finalOutput);
+    const journal = Buffer.from(
+      JSON.stringify({
+        image_id: imageId,
+        dataset_hash: datasetHash,
+        output_hash: crypto2.createHash("sha256").update(
+          typeof finalOutput === "string" ? finalOutput : finalOutput === void 0 ? "undefined" : JSON.stringify(finalOutput)
+        ).digest("hex"),
+        fuel: result.fuelConsumed,
+        ts: Date.now()
+      })
+    );
+    const seal = crypto2.createHmac("sha256", sessionSecret).update(journal).digest();
+    const journalLen = Buffer.alloc(2);
+    journalLen.writeUInt16BE(journal.length);
+    const receiptBuf = Buffer.concat([
+      Buffer.from([1]),
+      // Receipt format v1
+      journalLen,
+      journal,
+      seal
+      // 32 bytes HMAC
+    ]);
+    const zkReceipt = receiptBuf.toString("base64");
+    return {
+      image_id: imageId,
+      zk_receipt: zkReceipt,
+      output: finalOutput,
+      fuel_consumed: result.fuelConsumed
+    };
+  } finally {
+    await sandbox.teardown();
+  }
+}
+
+export { processLogicExecution as default };
+//# sourceMappingURL=logic-execution.js.map
+//# sourceMappingURL=logic-execution.js.map