@moikapy/origen-zero 0.1.0

package/dist/chunk-J5UPC5XT.js

@@ -0,0 +1,115 @@
+import {
+  ZeroHTTPError,
+  ZeroTimeoutError,
+  parseCheckOutput,
+  parseFixOutput,
+  parseGraphOutput,
+  parseSizeOutput
+} from "./chunk-6RAZN3WM.js";
+
+// src/http-compiler.ts
+var DEFAULT_TIMEOUT = 3e4;
+var ZeroHTTPCompiler = class {
+  endpoint;
+  apiKey;
+  headers;
+  timeout;
+  fetchFn;
+  constructor(config) {
+    this.endpoint = config.endpoint.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.headers = config.headers ?? {};
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+  }
+  // ── Public API ──────────────────────────────────────────────────────
+  async check(source) {
+    const raw = await this.post("/check", source);
+    return parseCheckOutput(raw);
+  }
+  async graph(source) {
+    const raw = await this.post("/graph", source);
+    return parseGraphOutput(raw);
+  }
+  async size(source) {
+    const raw = await this.post("/size", source);
+    return parseSizeOutput(raw);
+  }
+  async fix(source) {
+    const raw = await this.post("/fix", source);
+    return parseFixOutput(raw);
+  }
+  async build(source, options) {
+    const body = this.sourceToBody(source);
+    if (options) body.options = options;
+    const json = await this.postJson("/build", body);
+    return {
+      ok: json.ok ?? false,
+      outputPath: json.output ?? json.outputPath,
+      diagnostics: json.diagnostics ?? []
+    };
+  }
+  async explain(diagnosticCode) {
+    const url = `${this.endpoint}/explain/${encodeURIComponent(diagnosticCode)}`;
+    const res = await this.fetchWithTimeout(url, { method: "GET" });
+    if (!res.ok) {
+      throw new ZeroHTTPError(res.status, url, await res.text());
+    }
+    return (await res.text()).trim();
+  }
+  // ── Internal ────────────────────────────────────────────────────────
+  sourceToBody(source) {
+    if (typeof source === "string") {
+      return { source };
+    }
+    return { source: source.content, path: source.path };
+  }
+  async post(path, source) {
+    const body = this.sourceToBody(source);
+    return this.postRaw(path, body);
+  }
+  async postJson(path, body) {
+    const raw = await this.postRaw(path, body);
+    return JSON.parse(raw);
+  }
+  async postRaw(path, body) {
+    const url = `${this.endpoint}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = this.apiKey;
+    }
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new ZeroHTTPError(res.status, url, await res.text());
+    }
+    return await res.text();
+  }
+  /** fetch with timeout. */
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const res = await this.fetchFn(url, { ...init, signal: controller.signal });
+      return res;
+    } catch (err) {
+      if (err.name === "AbortError") {
+        throw new ZeroTimeoutError(`HTTP ${init.method} ${url}`, this.timeout);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+export {
+  ZeroHTTPCompiler
+};
+//# sourceMappingURL=chunk-J5UPC5XT.js.map

package/dist/chunk-J5UPC5XT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/http-compiler.ts"],"sourcesContent":["/**\n * @moikapy/origen-zero — ZeroHTTPCompiler\n *\n * HTTP-based Zero compiler client that works in Cloudflare Workers\n * (and any environment with fetch). Calls a Zero compiler service\n * instead of spawning a subprocess.\n *\n * The Zero compiler service must implement these endpoints:\n *   POST /check   { source, path? } → ZeroCheckResult\n *   POST /graph   { source, path? } → ZeroGraphResult\n *   POST /size    { source, path? } → ZeroSizeResult\n *   POST /fix     { source, path? } → ZeroFixResult\n *   POST /build   { source, path?, options? } → ZeroBuildResult\n *   GET  /explain/:code → string\n */\n\nimport type {\n  ZeroHTTPCompilerConfig,\n  ZeroCompilerLike,\n  ZeroSourceFile,\n  ZeroCheckResult,\n  ZeroGraphResult,\n  ZeroSizeResult,\n  ZeroFixResult,\n  ZeroBuildResult,\n  ZeroBuildOptions,\n  ZeroDiagnostic,\n} from \"./types.js\";\nimport {\n  parseCheckOutput,\n  parseGraphOutput,\n  parseSizeOutput,\n  parseFixOutput,\n} from \"./parser.js\";\nimport { ZeroHTTPError, ZeroTimeoutError } from \"./errors.js\";\n\n// ── Defaults ────────────────────────────────────────────────────────────\n\nconst DEFAULT_TIMEOUT = 30_000;\n\n// ── ZeroHTTPCompiler ─────────────────────────────────────────────────────\n\nexport class ZeroHTTPCompiler implements ZeroCompilerLike {\n  private readonly endpoint: string;\n  private readonly apiKey: string | undefined;\n  private readonly headers: Record<string, string>;\n  private readonly timeout: number;\n  private readonly fetchFn: typeof globalThis.fetch;\n\n  constructor(config: ZeroHTTPCompilerConfig) {\n    // Strip trailing slash\n    this.endpoint = config.endpoint.replace(/\\/+$/, \"\");\n    this.apiKey = config.apiKey;\n    this.headers = config.headers ?? {};\n    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;\n    this.fetchFn = config.fetch ?? globalThis.fetch;\n  }\n\n  // ── Public API ──────────────────────────────────────────────────────\n\n  async check(source: string | ZeroSourceFile): Promise<ZeroCheckResult> {\n    const raw = await this.post(\"/check\", source);\n    return parseCheckOutput(raw);\n  }\n\n  async graph(source: string | ZeroSourceFile): Promise<ZeroGraphResult> {\n    const raw = await this.post(\"/graph\", source);\n    return parseGraphOutput(raw);\n  }\n\n  async size(source: string | ZeroSourceFile): Promise<ZeroSizeResult> {\n    const raw = await this.post(\"/size\", source);\n    return parseSizeOutput(raw);\n  }\n\n  async fix(source: string | ZeroSourceFile): Promise<ZeroFixResult> {\n    const raw = await this.post(\"/fix\", source);\n    return parseFixOutput(raw);\n  }\n\n  async build(\n    source: string | ZeroSourceFile,\n    options?: ZeroBuildOptions,\n  ): Promise<ZeroBuildResult> {\n    const body = this.sourceToBody(source);\n    if (options) body.options = options;\n    const json = await this.postJson(\"/build\", body) as {\n      ok?: boolean;\n      output?: string;\n      outputPath?: string;\n      diagnostics?: ZeroDiagnostic[];\n    };\n    return {\n      ok: json.ok ?? false,\n      outputPath: json.output ?? json.outputPath,\n      diagnostics: json.diagnostics ?? [],\n    };\n  }\n\n  async explain(diagnosticCode: string): Promise<string> {\n    const url = `${this.endpoint}/explain/${encodeURIComponent(diagnosticCode)}`;\n    const res = await this.fetchWithTimeout(url, { method: \"GET\" });\n    if (!res.ok) {\n      throw new ZeroHTTPError(res.status, url, await res.text());\n    }\n    return (await res.text()).trim();\n  }\n\n  // ── Internal ────────────────────────────────────────────────────────\n\n  private sourceToBody(\n    source: string | ZeroSourceFile,\n  ): Record<string, unknown> {\n    if (typeof source === \"string\") {\n      return { source };\n    }\n    return { source: source.content, path: source.path };\n  }\n\n  private async post(\n    path: string,\n    source: string | ZeroSourceFile,\n  ): Promise<string> {\n    const body = this.sourceToBody(source);\n    return this.postRaw(path, body);\n  }\n\n  private async postJson(\n    path: string,\n    body: Record<string, unknown>,\n  ): Promise<Record<string, unknown>> {\n    const raw = await this.postRaw(path, body);\n    return JSON.parse(raw);\n  }\n\n  private async postRaw(\n    path: string,\n    body: Record<string, unknown>,\n  ): Promise<string> {\n    const url = `${this.endpoint}${path}`;\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      ...this.headers,\n    };\n    if (this.apiKey) {\n      headers[\"Authorization\"] = this.apiKey;\n    }\n\n    const res = await this.fetchWithTimeout(url, {\n      method: \"POST\",\n      headers,\n      body: JSON.stringify(body),\n    });\n\n    if (!res.ok) {\n      throw new ZeroHTTPError(res.status, url, await res.text());\n    }\n\n    return await res.text();\n  }\n\n  /** fetch with timeout. */\n  private async fetchWithTimeout(\n    url: string,\n    init: RequestInit,\n  ): Promise<Response> {\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), this.timeout);\n    try {\n      const res = await this.fetchFn(url, { ...init, signal: controller.signal });\n      return res;\n    } catch (err) {\n      if ((err as Error).name === \"AbortError\") {\n        throw new ZeroTimeoutError(`HTTP ${init.method} ${url}`, this.timeout);\n      }\n      throw err;\n    } finally {\n      clearTimeout(timer);\n    }\n  }\n}"],"mappings":"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","names":[]}

package/dist/chunk-PJFVSOEI.js

@@ -0,0 +1,65 @@
+import {
+  createZeroWASIRuntime
+} from "./chunk-QUQPQFU6.js";
+
+// src/wasm-tool.ts
+var moduleCache = /* @__PURE__ */ new WeakMap();
+async function getModule(wasmBytes, precompiled) {
+  if (wasmBytes instanceof WebAssembly.Module) return wasmBytes;
+  if (precompiled) return precompiled;
+  const cached = moduleCache.get(wasmBytes);
+  if (cached) return cached;
+  const compiled = await WebAssembly.compile(wasmBytes);
+  moduleCache.set(wasmBytes, compiled);
+  return compiled;
+}
+function createZeroWASMTool(config) {
+  return {
+    name: config.functionName,
+    description: config.description,
+    parameters: config.parameters ?? {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async execute(args, _getD1) {
+      const module = await getModule(config.wasmBytes, config.module);
+      const wasiArgs = ["zero", JSON.stringify(args)];
+      const runtime = createZeroWASIRuntime({
+        ...config.runtimeConfig,
+        args: wasiArgs
+      });
+      const instance = await WebAssembly.instantiate(module, runtime.imports);
+      runtime.setInstance(instance);
+      if (!config.module && config.wasmBytes instanceof ArrayBuffer) {
+        config.module = module;
+      }
+      const exitCode = instance.exports.main();
+      if (exitCode !== 0) {
+        const errOutput = runtime.getStderr();
+        const stdOutput = runtime.getStdout();
+        return `Error: Zero program exited with code ${exitCode}${errOutput ? `: ${errOutput}` : ""}${stdOutput ? `
+${stdOutput}` : ""}`;
+      }
+      return runtime.getStdout();
+    }
+  };
+}
+function createZeroWASMTools(wasmBytes, options) {
+  const description = options?.descriptions?.["main"] ?? "Zero program entry point";
+  const parameters = options?.parameters?.["main"];
+  return [
+    createZeroWASMTool({
+      functionName: "main",
+      description,
+      wasmBytes,
+      parameters
+    })
+  ];
+}
+
+export {
+  createZeroWASMTool,
+  createZeroWASMTools
+};
+//# sourceMappingURL=chunk-PJFVSOEI.js.map

package/dist/chunk-PJFVSOEI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wasm-tool.ts"],"sourcesContent":["/**\n * @moikapy/origen-zero — WASM tool execution\n *\n * Executes compiled Zero WASM modules in-process via WebAssembly.instantiate().\n * Works in Cloudflare Workers, browsers, and Node.js — no subprocess needed.\n *\n * WASM modules compiled from Zero export:\n *   - `memory`: WebAssembly.Memory (1+ pages, 64KB each)\n *   - `main()`: Program entry point (returns i32, 0 = success)\n * They import WASI snapshot preview 1 functions for I/O.\n *\n * For Origen tool invocation, args are passed via WASI (args_get/args_sizes_get)\n * for wasm32-wasi targets, or encoded to memory for wasm32-web targets that\n * read from environ.\n */\n\nimport type { OrigenTool } from \"@moikapy/origen\";\nimport { createZeroWASIRuntime, type ZeroWASIRuntimeConfig } from \"./wasi-runtime.js\";\n\n// ── Types ─────────────────────────────────────────────────────────────────\n\nexport interface ZeroWASMToolConfig {\n  /** Tool function name. */\n  functionName: string;\n  /** Human-readable description for the LLM. */\n  description: string;\n  /** Compiled WASM module bytes. */\n  wasmBytes: ArrayBuffer | WebAssembly.Module;\n  /** Optional pre-instantiated module cache (for Workers global scope). */\n  module?: WebAssembly.Module;\n  /** WASI runtime config (args, env, files, dirs). */\n  runtimeConfig?: ZeroWASIRuntimeConfig;\n  /** Custom parameter schema for the OrigenTool. */\n  parameters?: Record<string, unknown>;\n}\n\n// ── Module cache ──────────────────────────────────────────────────────────\n// Per-tool module cache. Each tool config can hold its own compiled module,\n// avoiding global cache thrashing when multiple WASM tools are active.\n// The config.module field is populated on first compile and reused thereafter.\n\nconst moduleCache = new WeakMap<ArrayBuffer, WebAssembly.Module>();\n\nasync function getModule(\n  wasmBytes: ArrayBuffer | WebAssembly.Module,\n  precompiled?: WebAssembly.Module,\n): Promise<WebAssembly.Module> {\n  if (wasmBytes instanceof WebAssembly.Module) return wasmBytes;\n  if (precompiled) return precompiled;\n  // Check per-bytes cache (same ArrayBuffer reference = same module)\n  const cached = moduleCache.get(wasmBytes);\n  if (cached) return cached;\n  const compiled = await WebAssembly.compile(wasmBytes);\n  moduleCache.set(wasmBytes, compiled);\n  return compiled;\n}\n\n// ── createZeroWASMTool ───────────────────────────────────────────────────\n\n/**\n * Create an OrigenTool that executes a compiled Zero WASM module in-process.\n *\n * The tool instantiates the WASM module with a full WASI runtime,\n * passes args via WASI args_get, calls the exported main() function,\n * and returns the stdout output.\n *\n * Works in Cloudflare Workers, browsers, and Node.js.\n */\nexport function createZeroWASMTool(config: ZeroWASMToolConfig): OrigenTool {\n  return {\n    name: config.functionName,\n    description: config.description,\n    parameters: config.parameters ?? {\n      type: \"object\",\n      properties: {},\n      required: [],\n    },\n    async execute(args: Record<string, unknown>, _getD1: any): Promise<string> {\n      const module = await getModule(config.wasmBytes, config.module);\n\n      // Pass args as WASI command-line args (JSON-serialized)\n      const wasiArgs = [\"zero\", JSON.stringify(args)];\n      const runtime = createZeroWASIRuntime({\n        ...config.runtimeConfig,\n        args: wasiArgs,\n      });\n\n      const instance = await WebAssembly.instantiate(module, runtime.imports);\n      runtime.setInstance(instance);\n\n      // Execute the Zero program\n      // Cache the compiled module for subsequent invocations\n      if (!config.module && config.wasmBytes instanceof ArrayBuffer) {\n        (config as ZeroWASMToolConfig).module = module;\n      }\n\n      const exitCode = (instance.exports.main as () => number)();\n\n      if (exitCode !== 0) {\n        const errOutput = runtime.getStderr();\n        const stdOutput = runtime.getStdout();\n        return `Error: Zero program exited with code ${exitCode}${errOutput ? `: ${errOutput}` : \"\"}${stdOutput ? `\\n${stdOutput}` : \"\"}`;\n      }\n\n      return runtime.getStdout();\n    },\n  };\n}\n\n/**\n * Create multiple tools from a single Zero WASM module.\n * If the module exports a single main(), creates one tool.\n * Future: parse module exports to discover multiple functions.\n */\nexport function createZeroWASMTools(\n  wasmBytes: ArrayBuffer | WebAssembly.Module,\n  options?: { descriptions?: Record<string, string>; parameters?: Record<string, Record<string, unknown>> },\n): OrigenTool[] {\n  const description = options?.descriptions?.[\"main\"] ?? \"Zero program entry point\";\n  const parameters = options?.parameters?.[\"main\"];\n\n  return [\n    createZeroWASMTool({\n      functionName: \"main\",\n      description,\n      wasmBytes,\n      parameters,\n    }),\n  ];\n}"],"mappings":";;;;;AAyCA,IAAM,cAAc,oBAAI,QAAyC;AAEjE,eAAe,UACb,WACA,aAC6B;AAC7B,MAAI,qBAAqB,YAAY,OAAQ,QAAO;AACpD,MAAI,YAAa,QAAO;AAExB,QAAM,SAAS,YAAY,IAAI,SAAS;AACxC,MAAI,OAAQ,QAAO;AACnB,QAAM,WAAW,MAAM,YAAY,QAAQ,SAAS;AACpD,cAAY,IAAI,WAAW,QAAQ;AACnC,SAAO;AACT;AAaO,SAAS,mBAAmB,QAAwC;AACzE,SAAO;AAAA,IACL,MAAM,OAAO;AAAA,IACb,aAAa,OAAO;AAAA,IACpB,YAAY,OAAO,cAAc;AAAA,MAC/B,MAAM;AAAA,MACN,YAAY,CAAC;AAAA,MACb,UAAU,CAAC;AAAA,IACb;AAAA,IACA,MAAM,QAAQ,MAA+B,QAA8B;AACzE,YAAM,SAAS,MAAM,UAAU,OAAO,WAAW,OAAO,MAAM;AAG9D,YAAM,WAAW,CAAC,QAAQ,KAAK,UAAU,IAAI,CAAC;AAC9C,YAAM,UAAU,sBAAsB;AAAA,QACpC,GAAG,OAAO;AAAA,QACV,MAAM;AAAA,MACR,CAAC;AAED,YAAM,WAAW,MAAM,YAAY,YAAY,QAAQ,QAAQ,OAAO;AACtE,cAAQ,YAAY,QAAQ;AAI5B,UAAI,CAAC,OAAO,UAAU,OAAO,qBAAqB,aAAa;AAC7D,QAAC,OAA8B,SAAS;AAAA,MAC1C;AAEA,YAAM,WAAY,SAAS,QAAQ,KAAsB;AAEzD,UAAI,aAAa,GAAG;AAClB,cAAM,YAAY,QAAQ,UAAU;AACpC,cAAM,YAAY,QAAQ,UAAU;AACpC,eAAO,wCAAwC,QAAQ,GAAG,YAAY,KAAK,SAAS,KAAK,EAAE,GAAG,YAAY;AAAA,EAAK,SAAS,KAAK,EAAE;AAAA,MACjI;AAEA,aAAO,QAAQ,UAAU;AAAA,IAC3B;AAAA,EACF;AACF;AAOO,SAAS,oBACd,WACA,SACc;AACd,QAAM,cAAc,SAAS,eAAe,MAAM,KAAK;AACvD,QAAM,aAAa,SAAS,aAAa,MAAM;AAE/C,SAAO;AAAA,IACL,mBAAmB;AAAA,MACjB,cAAc;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/chunk-QUQPQFU6.js

@@ -0,0 +1,223 @@
+// src/wasi-runtime.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function concatUint8(arrays) {
+  const total = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+function createZeroWASIRuntime(config) {
+  const args = config?.args ?? ["zero"];
+  const env = config?.env ?? [];
+  const files = config?.files ?? /* @__PURE__ */ new Map();
+  const dirs = config?.dirs ?? /* @__PURE__ */ new Set(["."]);
+  let instance;
+  let stdout = "";
+  let stderr = "";
+  const fds = /* @__PURE__ */ new Map();
+  let nextFd = 4;
+  function view() {
+    const memory = instance.exports.memory;
+    return new DataView(memory.buffer);
+  }
+  function mem() {
+    const memory = instance.exports.memory;
+    return new Uint8Array(memory.buffer);
+  }
+  function readI32(ptr) {
+    return view().getUint32(ptr, true);
+  }
+  function writeI32(ptr, value) {
+    view().setUint32(ptr, value >>> 0, true);
+  }
+  function writeU64(ptr, value) {
+    view().setBigUint64(ptr, BigInt(value), true);
+  }
+  function readString(ptr, len) {
+    return decoder.decode(mem().subarray(ptr, ptr + len));
+  }
+  function byteLength(items) {
+    return items.reduce((total, item) => total + encoder.encode(item).length + 1, 0);
+  }
+  function writeStrings(ptrArray, ptrBytes, items) {
+    let offset = ptrBytes;
+    for (let i = 0; i < items.length; i++) {
+      const bytes = encoder.encode(items[i]);
+      writeI32(ptrArray + i * 4, offset);
+      mem().set(bytes, offset);
+      mem()[offset + bytes.length] = 0;
+      offset += bytes.length + 1;
+    }
+  }
+  function writeFileAt(entry, chunks) {
+    const incoming = concatUint8(chunks);
+    const current = files.get(entry.path) || new Uint8Array(0);
+    const end = entry.pos + incoming.length;
+    const next = new Uint8Array(Math.max(current.length, end));
+    next.set(current, 0);
+    next.set(incoming, entry.pos);
+    files.set(entry.path, next);
+    entry.pos = end;
+  }
+  const imports = {
+    wasi_snapshot_preview1: {
+      args_sizes_get(argcPtr, argvBufSizePtr) {
+        writeI32(argcPtr, args.length);
+        writeI32(argvBufSizePtr, byteLength(args));
+        return 0;
+      },
+      args_get(argvPtr, argvBufPtr) {
+        writeStrings(argvPtr, argvBufPtr, args);
+        return 0;
+      },
+      environ_sizes_get(countPtr, envBufSizePtr) {
+        writeI32(countPtr, env.length);
+        writeI32(envBufSizePtr, byteLength(env));
+        return 0;
+      },
+      environ_get(envPtr, envBufPtr) {
+        writeStrings(envPtr, envBufPtr, env);
+        return 0;
+      },
+      path_open(fd, dirflags, pathPtr, pathLen, oflags, rightsBase, rightsInheriting, fdflags, openedFdPtr) {
+        const path = readString(pathPtr, pathLen);
+        const directory = (oflags & 2) !== 0;
+        const write = (oflags & 9) !== 0 || (rightsBase & 64n) !== 0n;
+        if (directory) {
+          if (!dirs.has(path)) return 44;
+          const opened2 = nextFd++;
+          fds.set(opened2, { type: "dir", path, pos: 0 });
+          writeI32(openedFdPtr, opened2);
+          return 0;
+        }
+        if (write) files.set(path, new Uint8Array(0));
+        if (!files.has(path)) return 44;
+        const opened = nextFd++;
+        fds.set(opened, { type: "file", path, pos: 0 });
+        writeI32(openedFdPtr, opened);
+        return 0;
+      },
+      fd_read(fd, iovs, iovsLen, nread) {
+        const entry = fds.get(fd);
+        if (!entry || entry.type !== "file") return 8;
+        const source = files.get(entry.path) || new Uint8Array(0);
+        let total = 0;
+        for (let i = 0; i < iovsLen; i++) {
+          const ptr = readI32(iovs + i * 8);
+          const len = readI32(iovs + i * 8 + 4);
+          const chunk = source.subarray(entry.pos, entry.pos + len);
+          mem().set(chunk, ptr);
+          entry.pos += chunk.length;
+          total += chunk.length;
+        }
+        writeI32(nread, total);
+        return 0;
+      },
+      fd_write(fd, iovs, iovsLen, nwritten) {
+        let total = 0;
+        const chunks = [];
+        for (let i = 0; i < iovsLen; i++) {
+          const ptr = readI32(iovs + i * 8);
+          const len = readI32(iovs + i * 8 + 4);
+          chunks.push(mem().slice(ptr, ptr + len));
+          total += len;
+        }
+        if (fd === 1) {
+          stdout += decoder.decode(concatUint8(chunks));
+        } else if (fd === 2) {
+          stderr += decoder.decode(concatUint8(chunks));
+        } else {
+          const entry = fds.get(fd);
+          if (!entry || entry.type !== "file") return 8;
+          writeFileAt(entry, chunks);
+        }
+        writeI32(nwritten, total);
+        return 0;
+      },
+      fd_close(fd) {
+        fds.delete(fd);
+        return 0;
+      },
+      fd_filestat_get(fd, buf) {
+        const entry = fds.get(fd);
+        if (!entry || entry.type !== "file") return 8;
+        writeU64(buf + 32, (files.get(entry.path) || new Uint8Array(0)).length);
+        return 0;
+      },
+      fd_readdir(fd, buf, bufLen, cookie, nread) {
+        const entry = fds.get(fd);
+        if (!entry || entry.type !== "dir") return 8;
+        writeI32(nread, 0);
+        return 0;
+      },
+      path_create_directory(fd, pathPtr, pathLen) {
+        dirs.add(readString(pathPtr, pathLen));
+        return 0;
+      },
+      path_remove_directory(fd, pathPtr, pathLen) {
+        const path = readString(pathPtr, pathLen);
+        if (!dirs.has(path)) return 44;
+        dirs.delete(path);
+        return 0;
+      },
+      path_unlink_file(fd, pathPtr, pathLen) {
+        const path = readString(pathPtr, pathLen);
+        if (!files.has(path)) return 44;
+        files.delete(path);
+        return 0;
+      },
+      path_rename(oldFd, oldPtr, oldLen, newFd, newPtr, newLen) {
+        const oldPath = readString(oldPtr, oldLen);
+        const newPath = readString(newPtr, newLen);
+        if (!files.has(oldPath)) return 44;
+        files.set(newPath, files.get(oldPath));
+        files.delete(oldPath);
+        return 0;
+      },
+      // Stubs for WASI functions Zero doesn't use but may import
+      proc_exit(code) {
+        throw new Error(`Zero program exited with code ${code}`);
+      },
+      clock_time_get(clockId, precision, timePtr) {
+        if (clockId === 0) {
+          const ns = BigInt(Date.now()) * 1000000n;
+          view().setBigUint64(timePtr, ns, true);
+          return 0;
+        }
+        return 0;
+      },
+      random_get(buf, bufLen) {
+        const bytes = crypto.getRandomValues(new Uint8Array(bufLen));
+        mem().set(bytes, buf);
+        return 0;
+      },
+      sched_yield() {
+        return 0;
+      },
+      poll_oneoff(inPtr, outPtr, nsubscriptions, nevents) {
+        writeI32(nevents, 0);
+        return 0;
+      }
+    }
+  };
+  return {
+    imports,
+    getStdout: () => stdout,
+    getStderr: () => stderr,
+    getFiles: () => files,
+    getDirs: () => dirs,
+    setInstance(i) {
+      instance = i;
+    }
+  };
+}
+
+export {
+  createZeroWASIRuntime
+};
+//# sourceMappingURL=chunk-QUQPQFU6.js.map

package/dist/chunk-QUQPQFU6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wasi-runtime.ts"],"sourcesContent":["/**\n * @moikapy/origen-zero — WASI runtime for Zero WASM modules\n *\n * Full WASI snapshot preview 1 implementation matching the Zero CLI's\n * wasm-runtime-smoke.mjs. Supports: args, env, fd_read, fd_write,\n * path_open, fd_close, fd_filestat_get, fd_readdir, path_mkdir,\n * path_remove_directory, path_unlink_file, path_rename.\n *\n * Zero programs that use World (stdout/stderr), std.args, std.env,\n * or std.fs (Fs resource) all route through these WASI imports.\n *\n * Uses only Uint8Array/TextEncoder/TextDecoder — no Node.js Buffer.\n * Works in Cloudflare Workers, browsers, and Node.js.\n */\n\n// ── Portable byte utilities (Workers-compatible, no Buffer) ────────────\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\nfunction concatUint8(arrays: Uint8Array[]): Uint8Array {\n  const total = arrays.reduce((sum, a) => sum + a.length, 0);\n  const result = new Uint8Array(total);\n  let offset = 0;\n  for (const a of arrays) {\n    result.set(a, offset);\n    offset += a.length;\n  }\n  return result;\n}\n\n// ── Types ─────────────────────────────────────────────────────────────────\n\nexport interface ZeroWASIRuntimeConfig {\n  /** Command-line args (default: [\"zero\"]). */\n  args?: string[];\n  /** Environment variables (default: []). Format: \"KEY=VALUE\". */\n  env?: string[];\n  /** Pre-populated files: Map<path, Uint8Array>. */\n  files?: Map<string, Uint8Array>;\n  /** Pre-populated directories. */\n  dirs?: Set<string>;\n}\n\nexport interface ZeroWASIRuntime {\n  /** WASI imports to pass to WebAssembly.instantiate(). */\n  imports: Record<string, Record<string, WebAssembly.ImportValue>>;\n  /** Get all captured stdout output. */\n  getStdout(): string;\n  /** Get all captured stderr output. */\n  getStderr(): string;\n  /** Get the virtual filesystem state. */\n  getFiles(): Map<string, Uint8Array>;\n  /** Get the virtual directory set. */\n  getDirs(): Set<string>;\n  /** Set the instance reference (called after instantiation). */\n  setInstance(instance: WebAssembly.Instance): void;\n}\n\n// ── Implementation ────────────────────────────────────────────────────────\n\nexport function createZeroWASIRuntime(config?: ZeroWASIRuntimeConfig): ZeroWASIRuntime {\n  const args = config?.args ?? [\"zero\"];\n  const env = config?.env ?? [];\n  const files = config?.files ?? new Map<string, Uint8Array>();\n  const dirs = config?.dirs ?? new Set([\".\"]);\n\n  let instance: WebAssembly.Instance;\n  let stdout = \"\";\n  let stderr = \"\";\n  const fds = new Map<number, { type: \"file\" | \"dir\"; path: string; pos: number }>();\n  let nextFd = 4; // 0=stdin, 1=stdout, 2=stderr, 3+ available\n\n  // ── Helpers ──────────────────────────────────────────────────────────\n\n  function view(): DataView {\n    const memory = instance.exports.memory as WebAssembly.Memory;\n    return new DataView(memory.buffer);\n  }\n\n  function mem(): Uint8Array {\n    const memory = instance.exports.memory as WebAssembly.Memory;\n    return new Uint8Array(memory.buffer);\n  }\n\n  function readI32(ptr: number): number {\n    return view().getUint32(ptr, true);\n  }\n\n  function writeI32(ptr: number, value: number): void {\n    view().setUint32(ptr, value >>> 0, true);\n  }\n\n  function writeU64(ptr: number, value: number): void {\n    view().setBigUint64(ptr, BigInt(value), true);\n  }\n\n  function readString(ptr: number, len: number): string {\n    return decoder.decode(mem().subarray(ptr, ptr + len));\n  }\n\n  function byteLength(items: string[]): number {\n    return items.reduce((total, item) => total + encoder.encode(item).length + 1, 0);\n  }\n\n  function writeStrings(ptrArray: number, ptrBytes: number, items: string[]): void {\n    let offset = ptrBytes;\n    for (let i = 0; i < items.length; i++) {\n      const bytes = encoder.encode(items[i]!);\n      writeI32(ptrArray + i * 4, offset);\n      mem().set(bytes, offset);\n      mem()[offset + bytes.length] = 0; // null terminator\n      offset += bytes.length + 1;\n    }\n  }\n\n  function writeFileAt(entry: { path: string; pos: number }, chunks: Uint8Array[]): void {\n    const incoming = concatUint8(chunks);\n    const current = files.get(entry.path) || new Uint8Array(0);\n    const end = entry.pos + incoming.length;\n    const next = new Uint8Array(Math.max(current.length, end));\n    next.set(current, 0);\n    next.set(incoming, entry.pos);\n    files.set(entry.path, next);\n    entry.pos = end;\n  }\n\n  // ── WASI Imports ─────────────────────────────────────────────────────\n\n  const imports: Record<string, Record<string, WebAssembly.ImportValue>> = {\n    wasi_snapshot_preview1: {\n      args_sizes_get(argcPtr: number, argvBufSizePtr: number): number {\n        writeI32(argcPtr, args.length);\n        writeI32(argvBufSizePtr, byteLength(args));\n        return 0;\n      },\n\n      args_get(argvPtr: number, argvBufPtr: number): number {\n        writeStrings(argvPtr, argvBufPtr, args);\n        return 0;\n      },\n\n      environ_sizes_get(countPtr: number, envBufSizePtr: number): number {\n        writeI32(countPtr, env.length);\n        writeI32(envBufSizePtr, byteLength(env));\n        return 0;\n      },\n\n      environ_get(envPtr: number, envBufPtr: number): number {\n        writeStrings(envPtr, envBufPtr, env);\n        return 0;\n      },\n\n      path_open(\n        fd: number, dirflags: number, pathPtr: number, pathLen: number,\n        oflags: number, rightsBase: bigint, rightsInheriting: bigint,\n        fdflags: number, openedFdPtr: number,\n      ): number {\n        const path = readString(pathPtr, pathLen);\n        const directory = (oflags & 2) !== 0;\n        const write = (oflags & 9) !== 0 || (rightsBase & 64n) !== 0n;\n\n        if (directory) {\n          if (!dirs.has(path)) return 44; // ENOENT\n          const opened = nextFd++;\n          fds.set(opened, { type: \"dir\", path, pos: 0 });\n          writeI32(openedFdPtr, opened);\n          return 0;\n        }\n\n        if (write) files.set(path, new Uint8Array(0));\n        if (!files.has(path)) return 44; // ENOENT\n        const opened = nextFd++;\n        fds.set(opened, { type: \"file\", path, pos: 0 });\n        writeI32(openedFdPtr, opened);\n        return 0;\n      },\n\n      fd_read(fd: number, iovs: number, iovsLen: number, nread: number): number {\n        const entry = fds.get(fd);\n        if (!entry || entry.type !== \"file\") return 8; // EBADF\n        const source = files.get(entry.path) || new Uint8Array(0);\n        let total = 0;\n        for (let i = 0; i < iovsLen; i++) {\n          const ptr = readI32(iovs + i * 8);\n          const len = readI32(iovs + i * 8 + 4);\n          const chunk = source.subarray(entry.pos, entry.pos + len);\n          mem().set(chunk, ptr);\n          entry.pos += chunk.length;\n          total += chunk.length;\n        }\n        writeI32(nread, total);\n        return 0;\n      },\n\n      fd_write(fd: number, iovs: number, iovsLen: number, nwritten: number): number {\n        let total = 0;\n        const chunks: Uint8Array[] = [];\n        for (let i = 0; i < iovsLen; i++) {\n          const ptr = readI32(iovs + i * 8);\n          const len = readI32(iovs + i * 8 + 4);\n          chunks.push(mem().slice(ptr, ptr + len));\n          total += len;\n        }\n        if (fd === 1) {\n          stdout += decoder.decode(concatUint8(chunks));\n        } else if (fd === 2) {\n          stderr += decoder.decode(concatUint8(chunks));\n        } else {\n          const entry = fds.get(fd);\n          if (!entry || entry.type !== \"file\") return 8; // EBADF\n          writeFileAt(entry, chunks);\n        }\n        writeI32(nwritten, total);\n        return 0;\n      },\n\n      fd_close(fd: number): number {\n        fds.delete(fd);\n        return 0;\n      },\n\n      fd_filestat_get(fd: number, buf: number): number {\n        const entry = fds.get(fd);\n        if (!entry || entry.type !== \"file\") return 8; // EBADF\n        writeU64(buf + 32, (files.get(entry.path) || new Uint8Array(0)).length);\n        return 0;\n      },\n\n      fd_readdir(fd: number, buf: number, bufLen: number, cookie: number, nread: number): number {\n        const entry = fds.get(fd);\n        if (!entry || entry.type !== \"dir\") return 8; // EBADF\n        writeI32(nread, 0);\n        return 0;\n      },\n\n      path_create_directory(fd: number, pathPtr: number, pathLen: number): number {\n        dirs.add(readString(pathPtr, pathLen));\n        return 0;\n      },\n\n      path_remove_directory(fd: number, pathPtr: number, pathLen: number): number {\n        const path = readString(pathPtr, pathLen);\n        if (!dirs.has(path)) return 44; // ENOENT\n        dirs.delete(path);\n        return 0;\n      },\n\n      path_unlink_file(fd: number, pathPtr: number, pathLen: number): number {\n        const path = readString(pathPtr, pathLen);\n        if (!files.has(path)) return 44; // ENOENT\n        files.delete(path);\n        return 0;\n      },\n\n      path_rename(\n        oldFd: number, oldPtr: number, oldLen: number,\n        newFd: number, newPtr: number, newLen: number,\n      ): number {\n        const oldPath = readString(oldPtr, oldLen);\n        const newPath = readString(newPtr, newLen);\n        if (!files.has(oldPath)) return 44; // ENOENT\n        files.set(newPath, files.get(oldPath)!);\n        files.delete(oldPath);\n        return 0;\n      },\n\n      // Stubs for WASI functions Zero doesn't use but may import\n      proc_exit(code: number): void {\n        throw new Error(`Zero program exited with code ${code}`);\n      },\n\n      clock_time_get(clockId: number, precision: bigint, timePtr: number): number {\n        // Return current time as nanoseconds for realtime clock\n        if (clockId === 0) {\n          const ns = BigInt(Date.now()) * 1_000_000n;\n          view().setBigUint64(timePtr, ns, true);\n          return 0;\n        }\n        return 0;\n      },\n\n      random_get(buf: number, bufLen: number): number {\n        const bytes = crypto.getRandomValues(new Uint8Array(bufLen));\n        mem().set(bytes, buf);\n        return 0;\n      },\n\n      sched_yield(): number { return 0; },\n      poll_oneoff(inPtr: number, outPtr: number, nsubscriptions: number, nevents: number): number {\n        writeI32(nevents, 0);\n        return 0;\n      },\n    },\n  };\n\n  return {\n    imports,\n    getStdout: () => stdout,\n    getStderr: () => stderr,\n    getFiles: () => files,\n    getDirs: () => dirs,\n    setInstance(i: WebAssembly.Instance) { instance = i; },\n  };\n}"],"mappings":"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","names":["opened"]}

package/dist/chunk-SDOZC7ZI.js

@@ -0,0 +1,161 @@
+import {
+  ZeroCompiler
+} from "./chunk-DE5JDJKT.js";
+import {
+  ZeroExecutionError,
+  ZeroHTTPError
+} from "./chunk-6RAZN3WM.js";
+
+// src/tools.ts
+function createZeroTool(config) {
+  return {
+    name: config.functionName,
+    description: config.description,
+    parameters: config.parameters ?? {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    inputSchema: config.inputSchema,
+    async execute(args) {
+      return executeTool(config.execution, args);
+    }
+  };
+}
+async function createZeroToolsFromProgram(execution, options) {
+  const compiler = resolveCompiler(options?.compiler);
+  const source = execution.mode === "subprocess" ? { path: execution.executablePath } : { path: "program.0" };
+  const graphResult = await compiler.graph(source);
+  const functionNames = graphResult.functions.map((f) => f.name);
+  return functionNames.map(
+    (fn) => createZeroTool({
+      functionName: fn,
+      description: `Zero function: ${fn}`,
+      execution,
+      compiler,
+      verify: options?.verify
+    })
+  );
+}
+async function compileAndRegister(source, options) {
+  const compiler = resolveCompiler(options?.compiler);
+  const execution = options?.execution ?? {
+    mode: "subprocess",
+    executablePath: source.path.replace(/\.0$/, "")
+  };
+  const checkResult = await compiler.check(source);
+  if (!checkResult.ok) {
+    return { errors: checkResult.diagnostics };
+  }
+  if (execution.mode === "subprocess" && compiler instanceof ZeroCompiler) {
+    const buildResult = await compiler.build(source, {
+      ...options?.build,
+      out: options?.build?.out ?? execution.executablePath
+    });
+    if (!buildResult.ok || !buildResult.outputPath) {
+      return {
+        errors: buildResult.diagnostics.length > 0 ? buildResult.diagnostics : [
+          {
+            code: "ZERO_BUILD_FAILED",
+            severity: "error",
+            message: "Build produced no output",
+            line: 0
+          }
+        ]
+      };
+    }
+    execution.executablePath = buildResult.outputPath;
+  }
+  const graphResult = await compiler.graph(source);
+  const tools = graphResult.functions.map(
+    (f) => createZeroTool({
+      functionName: f.name,
+      description: `Zero function: ${f.name}`,
+      execution,
+      compiler
+    })
+  );
+  return { tools };
+}
+async function executeTool(execution, args) {
+  switch (execution.mode) {
+    case "subprocess":
+      return executeBinary(execution.executablePath, args);
+    case "http":
+      return executeHTTP(execution, args);
+    case "wasm": {
+      const { createZeroWASMTool } = await import("./wasm-tool.js");
+      const tool = createZeroWASMTool({
+        functionName: "main",
+        description: "Zero WASM tool",
+        wasmBytes: execution.wasmBytes
+      });
+      return tool.execute(args, async () => null);
+    }
+  }
+}
+async function executeBinary(executablePath, args) {
+  const { execFile } = await import("child_process");
+  const stdin = JSON.stringify(args);
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      executablePath,
+      [],
+      {
+        maxBuffer: 1024 * 1024
+        // 1MB
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            new ZeroExecutionError(
+              error.code ?? 1,
+              stderr || error.message
+            )
+          );
+          return;
+        }
+        resolve(stdout);
+      }
+    );
+    if (child.stdin) {
+      child.stdin.write(stdin, () => {
+        child.stdin?.end();
+      });
+    }
+  });
+}
+async function executeHTTP(execution, args) {
+  const headers = {
+    "Content-Type": "application/json",
+    ...execution.headers
+  };
+  if (execution.apiKey) {
+    headers["Authorization"] = execution.apiKey;
+  }
+  const fetchFn = execution.fetch ?? globalThis.fetch;
+  const url = `${execution.endpoint.replace(/\/+$/, "")}/execute`;
+  const res = await fetchFn(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(args)
+  });
+  if (!res.ok) {
+    throw new ZeroHTTPError(res.status, url, await res.text());
+  }
+  return await res.text();
+}
+function resolveCompiler(compiler) {
+  if (!compiler) return new ZeroCompiler();
+  if ("check" in compiler && typeof compiler.check === "function") {
+    return compiler;
+  }
+  return new ZeroCompiler(compiler);
+}
+
+export {
+  createZeroTool,
+  createZeroToolsFromProgram,
+  compileAndRegister
+};
+//# sourceMappingURL=chunk-SDOZC7ZI.js.map

package/dist/chunk-SDOZC7ZI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools.ts"],"sourcesContent":["/**\n * @moikapy/origen-zero — Tool registration\n *\n * Registers compiled Zero programs as OrigenTools and provides\n * compileAndRegister for write-compile-verify-register in one call.\n *\n * Supports two execution modes:\n *   - \"subprocess\": Spawns compiled binary (Node/Bun only)\n *   - \"http\": Calls a Zero execution service via fetch (Workers-compatible)\n */\n\nimport type { OrigenTool } from \"@moikapy/origen\";\nimport { ZeroCompiler, TEMP_DIR } from \"./compiler.js\";\nimport type {\n  ZeroCompilerLike,\n  ZeroToolConfig,\n  ZeroToolExecution,\n  ZeroSourceFile,\n  ZeroToolRegistrationSuccess,\n  ZeroToolRegistrationFailure,\n  ZeroBuildOptions,\n  ZeroCompilerConfig,\n} from \"./types.js\";\nimport { ZeroExecutionError, ZeroHTTPError } from \"./errors.js\";\n\nconst DEFAULT_VERIFY = true;\n\n// ── createZeroTool ───────────────────────────────────────────────────────\n\n/**\n * Register a compiled Zero program's function as an OrigenTool.\n *\n * In \"subprocess\" mode, executes the compiled binary via execFile.\n * In \"http\" mode, calls a Zero execution service via fetch.\n */\nexport function createZeroTool(config: ZeroToolConfig): OrigenTool {\n  return {\n    name: config.functionName,\n    description: config.description,\n    parameters: config.parameters ?? {\n      type: \"object\",\n      properties: {},\n      required: [],\n    },\n    inputSchema: config.inputSchema,\n    async execute(args: Record<string, unknown>): Promise<string> {\n      return executeTool(config.execution, args);\n    },\n  } as OrigenTool;\n}\n\n// ── createZeroToolsFromProgram ──────────────────────────────────────────\n\n/**\n * Register all exported functions from a Zero program as OrigenTools.\n * Uses the compiler's graph() to discover public functions,\n * then creates one OrigenTool per function.\n */\nexport async function createZeroToolsFromProgram(\n  execution: ZeroToolExecution,\n  options?: {\n    compiler?: ZeroCompilerLike | ZeroCompilerConfig;\n    verify?: boolean;\n  },\n): Promise<OrigenTool[]> {\n  const compiler = resolveCompiler(options?.compiler);\n\n  // Use graph to discover public functions\n  const source: ZeroSourceFile =\n    execution.mode === \"subprocess\"\n      ? { path: execution.executablePath }\n      : { path: \"program.0\" }; // HTTP mode — path is a hint\n\n  const graphResult = await compiler.graph(source);\n  const functionNames = graphResult.functions.map(f => f.name);\n\n  return functionNames.map((fn) =>\n    createZeroTool({\n      functionName: fn,\n      description: `Zero function: ${fn}`,\n      execution,\n      compiler,\n      verify: options?.verify,\n    }),\n  );\n}\n\n// ── compileAndRegister ──────────────────────────────────────────────────\n\n/**\n * Write a Zero source file, compile it, verify it, and register\n * its public functions as OrigenTools — all in one call.\n *\n * If the source has errors, returns them without registering tools.\n *\n * Note: build() only works with ZeroCompiler (subprocess), not ZeroHTTPCompiler.\n * HTTP mode requires pre-compiled binaries or a build service.\n */\nexport async function compileAndRegister(\n  source: ZeroSourceFile,\n  options?: {\n    compiler?: ZeroCompilerLike | ZeroCompilerConfig;\n    execution?: ZeroToolExecution;\n    build?: ZeroBuildOptions;\n  },\n): Promise<ZeroToolRegistrationSuccess | ZeroToolRegistrationFailure> {\n  const compiler = resolveCompiler(options?.compiler);\n  const execution: ZeroToolExecution = options?.execution ?? {\n    mode: \"subprocess\",\n    executablePath: source.path.replace(/\\.0$/, \"\"),\n  };\n\n  // Step 1: Check the source for errors\n  const checkResult = await compiler.check(source);\n\n  if (!checkResult.ok) {\n    return { errors: checkResult.diagnostics };\n  }\n\n  // Step 2: Build (only with subprocess compiler)\n  if (execution.mode === \"subprocess\" && compiler instanceof ZeroCompiler) {\n    const buildResult = await compiler.build(source, {\n      ...options?.build,\n      out: options?.build?.out ?? execution.executablePath,\n    });\n\n    if (!buildResult.ok || !buildResult.outputPath) {\n      return {\n        errors: buildResult.diagnostics.length > 0\n          ? buildResult.diagnostics\n          : [\n              {\n                code: \"ZERO_BUILD_FAILED\",\n                severity: \"error\",\n                message: \"Build produced no output\",\n                line: 0,\n              },\n            ],\n      };\n    }\n\n    // Update execution path to the built binary\n    execution.executablePath = buildResult.outputPath;\n  }\n\n  // Step 3: Discover functions via graph\n  const graphResult = await compiler.graph(source);\n\n  // Step 4: Register each function\n  const tools: OrigenTool[] = graphResult.functions.map((f) =>\n    createZeroTool({\n      functionName: f.name,\n      description: `Zero function: ${f.name}`,\n      execution,\n      compiler,\n    }),\n  );\n\n  return { tools };\n}\n\n// ── Tool execution ───────────────────────────────────────────────────────\n\n/** Execute a tool based on the execution mode. */\nasync function executeTool(\n  execution: ZeroToolExecution,\n  args: Record<string, unknown>,\n): Promise<string> {\n  switch (execution.mode) {\n    case \"subprocess\":\n      return executeBinary(execution.executablePath, args);\n    case \"http\":\n      return executeHTTP(execution, args);\n    case \"wasm\": {\n      const { createZeroWASMTool } = await import(\"./wasm-tool.js\");\n      const tool = createZeroWASMTool({\n        functionName: \"main\",\n        description: \"Zero WASM tool\",\n        wasmBytes: execution.wasmBytes,\n      });\n      return tool.execute(args, async () => null as any);\n    }\n  }\n}\n\n/** Execute a compiled Zero binary with JSON args via stdin. */\nasync function executeBinary(\n  executablePath: string,\n  args: Record<string, unknown>,\n): Promise<string> {\n  const { execFile } = await import(\"node:child_process\");\n  const stdin = JSON.stringify(args);\n\n  return new Promise((resolve, reject) => {\n    const child = execFile(\n      executablePath,\n      [],\n      {\n        maxBuffer: 1024 * 1024, // 1MB\n      },\n      (error, stdout, stderr) => {\n        if (error) {\n          reject(\n            new ZeroExecutionError(\n              ((error as any).code as number) ?? 1,\n              stderr || error.message,\n            ),\n          );\n          return;\n        }\n        resolve(stdout);\n      },\n    );\n\n    // Pipe input via stdin\n    if (child.stdin) {\n      child.stdin.write(stdin, () => {\n        child.stdin?.end();\n      });\n    }\n  });\n}\n\n/** Execute a Zero function via HTTP. */\nasync function executeHTTP(\n  execution: ZeroToolExecution & { mode: \"http\" },\n  args: Record<string, unknown>,\n): Promise<string> {\n  const headers: Record<string, string> = {\n    \"Content-Type\": \"application/json\",\n    ...execution.headers,\n  };\n  if (execution.apiKey) {\n    headers[\"Authorization\"] = execution.apiKey;\n  }\n\n  const fetchFn = execution.fetch ?? globalThis.fetch;\n  const url = `${execution.endpoint.replace(/\\/+$/, \"\")}/execute`;\n\n  const res = await fetchFn(url, {\n    method: \"POST\",\n    headers,\n    body: JSON.stringify(args),\n  });\n\n  if (!res.ok) {\n    throw new ZeroHTTPError(res.status, url, await res.text());\n  }\n\n  return await res.text();\n}\n\n// ── Compiler resolution ──────────────────────────────────────────────────\n\n/** Resolve a compiler config or instance to a ZeroCompilerLike. */\nfunction resolveCompiler(\n  compiler?: ZeroCompilerLike | ZeroCompilerConfig,\n): ZeroCompilerLike {\n  if (!compiler) return new ZeroCompiler();\n  if (\"check\" in compiler && typeof compiler.check === \"function\") {\n    return compiler as ZeroCompilerLike;\n  }\n  return new ZeroCompiler(compiler as ZeroCompilerConfig);\n}"],"mappings":"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","names":[]}