@tensorlakeai/tensorlake 0.0.0-bootstrap.0 → 0.5.145

package/dist/function-agent/main.cjs

@@ -0,0 +1,1838 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+
+// lib/libc.cjs
+var require_libc = __commonJS({
+  "lib/libc.cjs"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    function detectLinuxLibc2(fs2, executable = process.execPath) {
+      const override = process.env.TENSORLAKE_NODE_LIBC;
+      if (override != null) {
+        if (override === "gnu" || override === "musl") return override;
+        throw new Error("TENSORLAKE_NODE_LIBC must be 'gnu' or 'musl'.");
+      }
+      let fd;
+      try {
+        let read2 = function(size, offset) {
+          if (!Number.isSafeInteger(offset) || offset < 0) {
+            throw new Error("Invalid ELF offset");
+          }
+          const buffer = Buffer.alloc(size);
+          let count2 = 0;
+          while (count2 < size) {
+            const bytes = fs2.readSync(fd, buffer, count2, size - count2, offset + count2);
+            if (bytes === 0) throw new Error("Truncated ELF executable");
+            count2 += bytes;
+          }
+          return buffer;
+        };
+        var read = read2;
+        fd = fs2.openSync(executable, "r");
+        const header = read2(64, 0);
+        if (header.readUInt32BE(0) !== 2135247942 || header[4] !== 2 || header[5] !== 1) {
+          throw new Error("Expected a little-endian ELF64 executable");
+        }
+        const entrySize = header.readUInt16LE(54);
+        const count = header.readUInt16LE(56);
+        if (entrySize !== 56 || count === 0 || count > 128) {
+          throw new Error("Unsupported ELF program headers");
+        }
+        const entries = read2(entrySize * count, Number(header.readBigUInt64LE(32)));
+        for (let i = 0; i < count; i++) {
+          const offset = i * entrySize;
+          if (entries.readUInt32LE(offset) !== 3) continue;
+          const size = Number(entries.readBigUInt64LE(offset + 32));
+          if (size < 2 || size > 4096) throw new Error("Invalid ELF interpreter size");
+          const interpreter = read2(size, Number(entries.readBigUInt64LE(offset + 8)));
+          if (interpreter[size - 1] !== 0) throw new Error("Unterminated ELF interpreter");
+          const name = interpreter.subarray(0, -1).toString("utf8").split("/").at(-1);
+          if (name.startsWith("ld-musl-")) return "musl";
+          if (name.startsWith("ld-linux-")) return "gnu";
+          throw new Error("Unrecognized ELF interpreter");
+        }
+        throw new Error("No ELF interpreter (statically linked executable)");
+      } catch (cause) {
+        throw new Error(
+          "Unable to detect Linux libc from the Node executable. Set TENSORLAKE_NODE_LIBC to 'gnu' or 'musl' for a nonstandard runtime.",
+          { cause }
+        );
+      } finally {
+        if (fd != null) fs2.closeSync(fd);
+      }
+    }
+    module2.exports = { detectLinuxLibc: detectLinuxLibc2 };
+  }
+});
+
+// src/function-agent/main.ts
+var main_exports = {};
+__export(main_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(main_exports);
+init_cjs_shims();
+
+// src/native-binding.ts
+init_cjs_shims();
+var import_libc = __toESM(require_libc(), 1);
+var fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var NATIVE_PACKAGES = {
+  "darwin-arm64": "@tensorlakeai/native-darwin-arm64",
+  "linux-arm64": "@tensorlakeai/native-linux-arm64-gnu",
+  "linux-arm64-musl": "@tensorlakeai/native-linux-arm64-musl",
+  "linux-x64": "@tensorlakeai/native-linux-x64-gnu",
+  "linux-x64-musl": "@tensorlakeai/native-linux-x64-musl",
+  "win32-x64": "@tensorlakeai/native-win32-x64"
+};
+function packageRoot() {
+  const parent = (0, import_node_url.fileURLToPath)(new URL("../", importMetaUrl));
+  if (fs.existsSync(import_node_path.default.join(parent, "package.json"))) return parent;
+  const grandparent = (0, import_node_url.fileURLToPath)(new URL("../../", importMetaUrl));
+  if (fs.existsSync(import_node_path.default.join(grandparent, "package.json"))) return grandparent;
+  return parent;
+}
+var cachedLinuxLibc;
+function linuxLibcFamily(options) {
+  if (options.libc != null) return options.libc;
+  if (options.report != null) {
+    return options.report.header?.glibcVersionRuntime ? "gnu" : "musl";
+  }
+  if (cachedLinuxLibc != null) return cachedLinuxLibc;
+  cachedLinuxLibc = (0, import_libc.detectLinuxLibc)(fs);
+  return cachedLinuxLibc;
+}
+function nativeTargetId(platform = process.platform, arch = process.arch, options = {}) {
+  const target = `${platform}-${arch}`;
+  if (platform !== "linux") return target;
+  if (options.libc == null && options.report == null && platform !== process.platform) {
+    return target;
+  }
+  return linuxLibcFamily(options) === "musl" ? `${target}-musl` : target;
+}
+function nativeBindingPath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  return import_node_path.default.join(
+    options.packageRoot ?? packageRoot(),
+    "dist",
+    "native",
+    nativeTargetId(platform, arch, options),
+    "tensorlake-node.node"
+  );
+}
+function nativePackageName(platform = process.platform, arch = process.arch, options = {}) {
+  return NATIVE_PACKAGES[nativeTargetId(platform, arch, options)];
+}
+function loadNative() {
+  const target = nativeTargetId();
+  const bindingPath = nativeBindingPath();
+  const require2 = (0, import_node_module.createRequire)(importMetaUrl);
+  if (fs.existsSync(bindingPath)) return require2(bindingPath);
+  const packageName = nativePackageName();
+  if (!packageName) {
+    throw new Error(
+      `Tensorlake does not provide a native binding for ${target}.`
+    );
+  }
+  let packageEntry;
+  try {
+    packageEntry = require2.resolve(packageName);
+  } catch (cause) {
+    throw new Error(
+      `Missing native binding package ${packageName} for ${target}. Reinstall @tensorlakeai/tensorlake without omitting optional dependencies, and install dependencies on the machine where they will run.`,
+      { cause }
+    );
+  }
+  return require2(packageEntry);
+}
+
+// src/native-worker-client.ts
+init_cjs_shims();
+var import_node_module2 = require("module");
+var import_node_worker_threads = require("worker_threads");
+
+// src/native-worker-protocol.ts
+init_cjs_shims();
+var cancelNativeCall = /* @__PURE__ */ Symbol.for("tensorlake.native.cancel.v1");
+var closeNativeHandle = /* @__PURE__ */ Symbol.for("tensorlake.native.close.v1");
+
+// src/url.ts
+init_cjs_shims();
+
+// src/defaults.ts
+init_cjs_shims();
+var API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
+var API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
+var NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
+var SANDBOX_PROXY_URL = process.env.TENSORLAKE_SANDBOX_PROXY_URL ?? "https://sandbox.tensorlake.ai";
+
+// src/url.ts
+function trimTrailingSlashes(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function resolveProxyTarget(proxyUrl, sandboxId) {
+  try {
+    const parsed = new URL(proxyUrl);
+    const host = parsed.hostname;
+    if (host === "localhost" || host === "127.0.0.1") {
+      return {
+        baseUrl: trimTrailingSlashes(proxyUrl),
+        hostHeader: `${sandboxId}.local`,
+        sandboxIdHeader: void 0
+      };
+    }
+    const port = parsed.port ? `:${parsed.port}` : "";
+    return {
+      baseUrl: `${parsed.protocol}//${host}${port}`,
+      hostHeader: void 0,
+      sandboxIdHeader: sandboxId
+    };
+  } catch {
+    return {
+      baseUrl: `${trimTrailingSlashes(proxyUrl)}/${sandboxId}`,
+      hostHeader: void 0,
+      sandboxIdHeader: void 0
+    };
+  }
+}
+
+// src/native-worker-client.ts
+var NativeWorkerClient = class {
+  constructor(workerPath = () => (0, import_node_module2.createRequire)(importMetaUrl).resolve(
+    "@tensorlakeai/tensorlake/internal/native-worker"
+  )) {
+    this.workerPath = workerPath;
+  }
+  worker;
+  nextId = 1;
+  registered = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
+  finalizers = new FinalizationRegistry(
+    (id) => this.release(id)
+  );
+  handle(kind, args, parent) {
+    const handle = { id: this.nextId++, kind, args, parent };
+    this.finalizers.register(handle, handle.id);
+    let closed = false;
+    return new Proxy(
+      {},
+      {
+        get: (_target, method) => {
+          if (method === "then") return void 0;
+          if (method === closeNativeHandle)
+            return () => {
+              closed = true;
+              this.release(handle.id);
+            };
+          if (method === "connectProxy")
+            return (...proxyArgs) => {
+              if (closed) throw new Error("Tensorlake native client is closed");
+              return this.handle("NativeSandboxProxyClient", proxyArgs, handle);
+            };
+          if (method === "baseUrl")
+            return () => resolveProxyTarget(String(args[0]), String(args[1])).baseUrl;
+          if (typeof method !== "string") return void 0;
+          return (...callArgs) => {
+            if (closed)
+              return Promise.reject(
+                new Error("Tensorlake native client is closed")
+              );
+            const emit = typeof callArgs.at(-1) === "function" ? callArgs.pop() : void 0;
+            return this.call(handle, method, callArgs, emit);
+          };
+        }
+      }
+    );
+  }
+  call(handle, method, args, emit) {
+    const id = this.nextId++;
+    let worker;
+    const promise = new Promise((resolve, reject) => {
+      try {
+        worker = this.getWorker();
+        this.pending.set(id, { resolve, reject, emit, handle });
+        worker.ref();
+        if (handle) this.register(handle, worker);
+        this.send(worker, {
+          type: "call",
+          id,
+          handleId: handle?.id,
+          method,
+          args,
+          stream: !!emit
+        });
+      } catch (error) {
+        this.pending.delete(id);
+        this.unrefIfIdle();
+        reject(error);
+      }
+    });
+    promise[cancelNativeCall] = () => {
+      const pending = this.pending.get(id);
+      if (pending && worker) {
+        pending.emit = void 0;
+        this.send(worker, { type: "cancel", id });
+      }
+    };
+    return promise;
+  }
+  getWorker() {
+    if (this.worker) return this.worker;
+    const worker = new import_node_worker_threads.Worker(this.workerPath(), {
+      // The bundled worker needs no application loaders or telemetry preloads.
+      // NODE_OPTIONS is parsed independently of execArgv by Node.
+      execArgv: [],
+      env: { ...process.env, NODE_OPTIONS: "" },
+      name: "tensorlake-native"
+    });
+    this.worker = worker;
+    worker.on("message", (message) => {
+      const pending = this.pending.get(message.id);
+      if (!pending || this.worker !== worker) return;
+      if (message.type === "event") {
+        Promise.resolve().then(() => pending.emit?.(message.value)).then(
+          () => {
+            if (this.worker === worker)
+              this.send(worker, { type: "ack", id: message.id });
+          },
+          (error) => {
+            this.send(worker, { type: "cancel", id: message.id });
+            pending.reject(error);
+          }
+        );
+        return;
+      }
+      this.pending.delete(message.id);
+      if (message.type === "error") {
+        const error = new Error(message.error.message);
+        error.name = message.error.name;
+        error.stack = message.error.stack ?? error.stack;
+        pending.reject(error);
+      } else {
+        pending.resolve(message.value);
+      }
+      this.unrefIfIdle();
+    });
+    const fail = (error) => {
+      if (this.worker !== worker) return;
+      this.worker = void 0;
+      this.registered.clear();
+      for (const pending of this.pending.values()) pending.reject(error);
+      this.pending.clear();
+      void worker.terminate();
+    };
+    worker.on("error", fail);
+    worker.on("messageerror", fail);
+    worker.on(
+      "exit",
+      (code) => fail(
+        new Error(
+          `Tensorlake native worker exited (${code}); in-flight operations were not retried`
+        )
+      )
+    );
+    worker.unref();
+    return worker;
+  }
+  register(handle, worker) {
+    if (this.registered.has(handle.id)) return;
+    if (handle.parent) this.register(handle.parent, worker);
+    this.send(worker, {
+      type: "create",
+      handle: { id: handle.id, kind: handle.kind, args: handle.args },
+      parentId: handle.parent?.id
+    });
+    this.registered.add(handle.id);
+  }
+  release(handleId) {
+    if (this.worker && this.registered.delete(handleId))
+      this.send(this.worker, { type: "release", handleId });
+  }
+  send(worker, message) {
+    worker.postMessage(message);
+  }
+  unrefIfIdle() {
+    if (this.pending.size === 0) this.worker?.unref();
+  }
+};
+var runtimeKey = /* @__PURE__ */ Symbol.for(
+  `tensorlake.native.worker.${false ? "source" : "0.5.145"}.v1`
+);
+var runtimes = globalThis;
+function configureNativeWorker(workerPath) {
+  runtimes[runtimeKey] ??= new NativeWorkerClient(workerPath);
+}
+
+// src/function-agent/runner.ts
+init_cjs_shims();
+var import_node_crypto3 = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var import_node_vm = require("vm");
+var import_fflate = require("fflate");
+
+// src/applications/context.ts
+init_cjs_shims();
+var import_node_async_hooks = require("async_hooks");
+
+// src/applications/errors.ts
+init_cjs_shims();
+var SDK_USAGE_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.sdk-usage-error.v1");
+var REQUEST_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.request-error.v1");
+var FUNCTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.function-error.v1");
+var TIMEOUT_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.timeout-error.v1");
+var TensorlakeApplicationError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TensorlakeApplicationError";
+  }
+};
+var SDKUsageError = class _SDKUsageError extends TensorlakeApplicationError {
+  [SDK_USAGE_ERROR_BRAND] = true;
+  static [Symbol.hasInstance](value) {
+    if (this !== _SDKUsageError) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isSDKUsageError(value);
+  }
+  constructor(message) {
+    super(message);
+    this.name = "SDKUsageError";
+  }
+};
+function isSDKUsageError(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[SDK_USAGE_ERROR_BRAND] === true && typeof candidate.message === "string";
+}
+var SerializationError = class extends TensorlakeApplicationError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SerializationError";
+  }
+};
+var DeserializationError = class extends TensorlakeApplicationError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DeserializationError";
+  }
+};
+var FunctionError = class _FunctionError extends TensorlakeApplicationError {
+  [FUNCTION_ERROR_BRAND] = true;
+  static [Symbol.hasInstance](value) {
+    if (this !== _FunctionError) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isFunctionError(value);
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = "FunctionError";
+  }
+};
+var TimeoutError = class _TimeoutError extends TensorlakeApplicationError {
+  [TIMEOUT_ERROR_BRAND] = true;
+  static [Symbol.hasInstance](value) {
+    if (this !== _TimeoutError) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isTimeoutError(value);
+  }
+  constructor() {
+    super("Timed out.");
+    this.name = "TimeoutError";
+  }
+};
+function isTimeoutError(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[TIMEOUT_ERROR_BRAND] === true && typeof candidate.message === "string";
+}
+function isFunctionError(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[FUNCTION_ERROR_BRAND] === true && typeof candidate.message === "string";
+}
+var RequestError = class _RequestError extends TensorlakeApplicationError {
+  [REQUEST_ERROR_BRAND] = true;
+  static [Symbol.hasInstance](value) {
+    if (this !== _RequestError) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isRequestError(value);
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+function isRequestError(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[REQUEST_ERROR_BRAND] === true && typeof candidate.message === "string";
+}
+
+// src/applications/headers.ts
+init_cjs_shims();
+var HEADERS_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.headers.v1");
+var Headers = class _Headers {
+  [HEADERS_BRAND] = true;
+  #items;
+  #lookup;
+  static [Symbol.hasInstance](value) {
+    if (this !== _Headers) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isHeaders(value);
+  }
+  constructor(headers = []) {
+    const entries = headers instanceof _Headers ? [...headers] : Symbol.iterator in Object(headers) ? [...headers] : Object.entries(headers);
+    const lookup = /* @__PURE__ */ new Map();
+    this.#items = Object.freeze(entries.map(([name, value]) => {
+      if (typeof name !== "string" || typeof value !== "string") {
+        throw new TypeError("Headers require string names and values");
+      }
+      const item = Object.freeze([name, value]);
+      const key = name.toLowerCase();
+      lookup.set(key, [...lookup.get(key) ?? [], value]);
+      return item;
+    }));
+    this.#lookup = lookup;
+    Object.freeze(this);
+  }
+  get(name) {
+    return this.#lookup.get(name.toLowerCase())?.at(-1);
+  }
+  getAll(name) {
+    return Object.freeze([...this.#lookup.get(name.toLowerCase()) ?? []]);
+  }
+  has(name) {
+    return this.#lookup.has(name.toLowerCase());
+  }
+  entries() {
+    return this.#items[Symbol.iterator]();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+function isHeaders(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[HEADERS_BRAND] === true && typeof candidate.get === "function" && typeof candidate.getAll === "function" && typeof candidate.has === "function" && typeof candidate[Symbol.iterator] === "function";
+}
+
+// src/applications/serialization.ts
+init_cjs_shims();
+var import_node_crypto = require("crypto");
+
+// src/applications/file.ts
+init_cjs_shims();
+var FILE_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.file.v1");
+var File = class _File {
+  [FILE_BRAND] = true;
+  content;
+  contentType;
+  static [Symbol.hasInstance](value) {
+    if (this !== _File) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isFile(value);
+  }
+  constructor(content, contentType) {
+    if (!contentType.trim()) {
+      throw new SDKUsageError("File contentType cannot be empty");
+    }
+    this.content = content instanceof Uint8Array ? content : new Uint8Array(content);
+    this.contentType = contentType;
+  }
+};
+function isFile(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[FILE_BRAND] === true && candidate.content instanceof Uint8Array && typeof candidate.contentType === "string" && candidate.contentType.trim().length > 0;
+}
+
+// src/applications/http-body.ts
+init_cjs_shims();
+var HTTP_BODY_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.http-body.v1");
+var HttpBody = class _HttpBody {
+  [HTTP_BODY_BRAND] = true;
+  content;
+  contentType;
+  static [Symbol.hasInstance](value) {
+    if (this !== _HttpBody) {
+      return Function.prototype[Symbol.hasInstance].call(this, value);
+    }
+    return isHttpBody(value);
+  }
+  constructor(content, contentType) {
+    this.content = content instanceof Uint8Array ? content : new Uint8Array(content);
+    this.contentType = contentType;
+  }
+  text(encoding = "utf-8") {
+    return new TextDecoder(encoding, { fatal: true }).decode(this.content);
+  }
+  json() {
+    return JSON.parse(this.text());
+  }
+};
+function isHttpBody(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[HTTP_BODY_BRAND] === true && candidate.content instanceof Uint8Array && (candidate.contentType === void 0 || typeof candidate.contentType === "string");
+}
+
+// src/applications/serialization.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function assertJSONValue(value, path3, seen) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new SerializationError(`${path3} contains a non-finite number`);
+    return;
+  }
+  if (typeof value !== "object") {
+    throw new SerializationError(`${path3} contains unsupported ${typeof value}`);
+  }
+  if (isFile(value)) {
+    throw new SerializationError(`${path3} contains a nested File; File is only supported as a direct value`);
+  }
+  if (isHttpBody(value)) {
+    throw new SerializationError(
+      `${path3} contains a nested HttpBody; HttpBody is only supported as a direct value`
+    );
+  }
+  if (seen.has(value)) throw new SerializationError(`${path3} contains a cycle`);
+  if (Object.getPrototypeOf(value) !== Object.prototype && !Array.isArray(value)) {
+    throw new SerializationError(`${path3} contains unsupported ${value.constructor?.name ?? "object"}`);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(value, index)) {
+        throw new SerializationError(`${path3} contains a sparse array entry at index ${index}`);
+      }
+      assertJSONValue(value[index], `${path3}[${index}]`, seen);
+    }
+  } else {
+    for (const [key, item] of Object.entries(value)) {
+      assertJSONValue(item, `${path3}.${key}`, seen);
+    }
+  }
+  seen.delete(value);
+}
+function serializeValue(value) {
+  if (isFile(value)) {
+    return { data: value.content, contentType: value.contentType, encoding: "raw" };
+  }
+  if (isHttpBody(value)) {
+    return {
+      data: value.content,
+      contentType: value.contentType ?? "",
+      encoding: "raw"
+    };
+  }
+  try {
+    assertJSONValue(value, "value", /* @__PURE__ */ new Set());
+    return {
+      data: textEncoder.encode(JSON.stringify(value)),
+      contentType: "application/json; charset=UTF-8",
+      encoding: "json"
+    };
+  } catch (error) {
+    if (error instanceof SerializationError) throw error;
+    throw new SerializationError("Failed to serialize JSON value", { cause: error });
+  }
+}
+function deserializeJSON(data) {
+  try {
+    return JSON.parse(textDecoder.decode(data));
+  } catch (error) {
+    throw new DeserializationError("Failed to deserialize JSON value", { cause: error });
+  }
+}
+
+// src/applications/context.ts
+function validateRequestStateKey(key) {
+  if (typeof key !== "string") {
+    throw new SDKUsageError(`State key must be a string, got: ${String(key)}`);
+  }
+}
+function serializeRequestStateValue(value) {
+  const serialized = serializeValue(value);
+  if (serialized.encoding !== "json") {
+    throw new SDKUsageError("Request state values must be JSON values");
+  }
+  return serialized.data;
+}
+function validateCounterMetric(name, value) {
+  if (typeof name !== "string") {
+    throw new SDKUsageError(`Counter name must be a string, got: ${String(name)}`);
+  }
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new SDKUsageError(`Counter value must be an int, got: ${String(value)}`);
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw new SDKUsageError(`Counter value must be a safe int, got: ${String(value)}`);
+  }
+}
+function validateTimerMetric(name, value) {
+  if (typeof name !== "string") {
+    throw new SDKUsageError(`Timer name must be a string, got: ${String(name)}`);
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new SDKUsageError(`Timer value must be a finite number, got: ${String(value)}`);
+  }
+}
+function isPlainRecord(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function validateProgressUpdate(current, total, options) {
+  if (!Number.isFinite(current) || !Number.isFinite(total) || total < 0 || current < 0) {
+    throw new SDKUsageError("Progress current and total must be non-negative finite numbers");
+  }
+  if (options != null && !isPlainRecord(options)) {
+    throw new SDKUsageError("Progress options must be an object");
+  }
+  if (options?.message != null && typeof options.message !== "string") {
+    throw new SDKUsageError("Progress message must be a string");
+  }
+  if (options?.attributes != null) {
+    if (!isPlainRecord(options.attributes)) {
+      throw new SDKUsageError("Progress attributes must be an object of string key/value pairs");
+    }
+    for (const key of Reflect.ownKeys(options.attributes)) {
+      if (typeof key !== "string") {
+        throw new SDKUsageError("Progress attributes must contain only string keys and values");
+      }
+      const value = options.attributes[key];
+      if (typeof value !== "string") {
+        throw new SDKUsageError("Progress attributes must contain only string keys and values");
+      }
+    }
+  }
+}
+var REQUEST_CONTEXT_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.request-context-storage.v1"
+);
+function requestContextStorage() {
+  const target = globalThis;
+  target[REQUEST_CONTEXT_STORAGE_KEY] ??= new import_node_async_hooks.AsyncLocalStorage();
+  return target[REQUEST_CONTEXT_STORAGE_KEY];
+}
+function runWithRequestContext(context, callback) {
+  return requestContextStorage().run(context, callback);
+}
+
+// src/applications/function.ts
+init_cjs_shims();
+var import_node_async_hooks2 = require("async_hooks");
+var import_node_crypto2 = require("crypto");
+
+// src/applications/schema.ts
+init_cjs_shims();
+var import_ajv = __toESM(require("ajv"), 1);
+var import__ = __toESM(require("ajv/dist/2020.js"), 1);
+var ajvDraft7 = new import_ajv.default({ allErrors: true, strict: false });
+var ajv2020 = new import__.default({ allErrors: true, strict: false });
+var validatorCache = /* @__PURE__ */ new WeakMap();
+function compileValidator(jsonSchema) {
+  const dialect = jsonSchema.$schema;
+  const engine = typeof dialect === "string" && /\/draft-07\/schema#?$/.test(dialect) ? ajvDraft7 : ajv2020;
+  const validate = engine.compile(jsonSchema);
+  return {
+    validate,
+    errorsText: (errors) => engine.errorsText(errors, { separator: "; " })
+  };
+}
+function validateWithSchema(valueSchema, value, label) {
+  if (valueSchema._file) {
+    if (!isFile(value)) {
+      throw new SDKUsageError(`${label} must be a Tensorlake File`);
+    }
+    return value;
+  }
+  if (valueSchema._httpBody) {
+    if (!isHttpBody(value)) {
+      throw new SDKUsageError(`${label} must be a Tensorlake HttpBody`);
+    }
+    return value;
+  }
+  if (isFile(value)) {
+    throw new SDKUsageError(`${label} must use schema.file() for a Tensorlake File`);
+  }
+  if (isHttpBody(value)) {
+    throw new SDKUsageError(
+      `${label} must use schema.httpBody() for a Tensorlake HttpBody`
+    );
+  }
+  let cached = validatorCache.get(valueSchema);
+  if (cached == null) {
+    try {
+      cached = compileValidator(valueSchema.jsonSchema);
+    } catch (error) {
+      const details = error instanceof Error ? error.message : String(error);
+      throw new SDKUsageError(`${label} uses an invalid JSON schema: ${details}`);
+    }
+    validatorCache.set(valueSchema, cached);
+  }
+  if (!cached.validate(value)) {
+    const details = cached.errorsText(cached.validate.errors);
+    throw new SDKUsageError(`${label} does not match its schema: ${details}`);
+  }
+  return value;
+}
+
+// src/applications/registry.ts
+init_cjs_shims();
+
+// src/applications/function.ts
+var TAIL_CALL_BRAND = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.tail-call.v1"
+);
+var FUNCTION_RUNTIME_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.function-runtime-storage.v1"
+);
+var PROMISE_INSTRUMENTED_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.promise-instrumented.v3"
+);
+var PROMISE_THEN_INSTRUMENTED_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.promise-then-instrumented.v1"
+);
+var DURABLE_THENABLE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.durable-thenable-registry.v2"
+);
+var INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.internal-promise-aggregate-depth.v1"
+);
+function runtimeStorage() {
+  const target = globalThis;
+  target[FUNCTION_RUNTIME_STORAGE_KEY] ??= new import_node_async_hooks2.AsyncLocalStorage();
+  return target[FUNCTION_RUNTIME_STORAGE_KEY];
+}
+function currentFunctionRuntime() {
+  return runtimeStorage().getStore();
+}
+function runWithFunctionRuntime(runtime, callback) {
+  return runtimeStorage().run(runtime, callback);
+}
+function isDurableThenable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value == null) {
+    return false;
+  }
+  return durableThenableRegistry().has(value);
+}
+function isDetachedDurableThenable(value) {
+  const provenance = provenanceForDurableThenable(value);
+  return provenance?.detached === true || provenance?.assimilation != null && !provenance.assimilation.active;
+}
+function durableThenableRegistry() {
+  const target = globalThis;
+  target[DURABLE_THENABLE_REGISTRY_KEY] ??= /* @__PURE__ */ new WeakMap();
+  return target[DURABLE_THENABLE_REGISTRY_KEY];
+}
+function newDurableThenableMetadata() {
+  return {
+    aggregateExpectations: [],
+    provenanceExpectations: []
+  };
+}
+function provenanceForDurableThenable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value == null) {
+    return void 0;
+  }
+  return durableThenableRegistry().get(value);
+}
+function registerDetachedDurableThenable(value) {
+  const registry = durableThenableRegistry();
+  registry.set(value, {
+    metadata: registry.get(value)?.metadata ?? newDurableThenableMetadata(),
+    detached: true
+  });
+  return value;
+}
+function inheritDurableThenable(value, source) {
+  const provenance = durableThenableRegistry().get(source);
+  if (provenance == null) return value;
+  durableThenableRegistry().set(value, provenance);
+  if (provenance.assimilation == null) {
+    provenance.metadata.provenanceExpectations.push({
+      value,
+      creatorAsyncId: (0, import_node_async_hooks2.executionAsyncId)()
+    });
+  }
+  return value;
+}
+function associateAssimilationWithAggregate(registration, scope) {
+  if (!registration.active || scope.settled) return;
+  finishDurableAssimilation(registration);
+  registration.detach();
+}
+function finishDurableAssimilation(registration) {
+  if (!registration.active) return;
+  registration.active = false;
+}
+function trackDurableAggregate(runtime, result, durableContenders, markResult) {
+  const scope = {
+    settled: false,
+    metadata: /* @__PURE__ */ new Set()
+  };
+  if (markResult) {
+    registerDetachedDurableThenable(result);
+  }
+  const creatorAsyncId = (0, import_node_async_hooks2.executionAsyncId)();
+  for (const contender of durableContenders) {
+    const provenance = provenanceForDurableThenable(contender);
+    if (provenance == null) continue;
+    if (provenance.assimilation != null) {
+      associateAssimilationWithAggregate(provenance.assimilation, scope);
+    } else {
+      provenance.metadata.aggregateExpectations.push({
+        scope,
+        creatorAsyncId
+      });
+    }
+    if (scope.metadata.has(provenance.metadata)) continue;
+    const { metadata } = provenance;
+    scope.metadata.add(metadata);
+  }
+  const settle = () => {
+    if (scope.settled) return;
+    scope.settled = true;
+    for (const metadata of scope.metadata) {
+      for (let index = metadata.aggregateExpectations.length - 1; index >= 0; index -= 1) {
+        if (metadata.aggregateExpectations[index].scope === scope) {
+          metadata.aggregateExpectations.splice(index, 1);
+        }
+      }
+    }
+    scope.metadata.clear();
+  };
+  if (runtime.trackPromiseSettlement?.(result, settle) !== true) settle();
+}
+function promiseAggregateObservation(kind) {
+  let settleLifetime;
+  const ordinaryLifetime = new Promise((resolve) => {
+    settleLifetime = resolve;
+  });
+  let contenderCount;
+  let fulfillmentCount = 0;
+  let rejectionCount = 0;
+  let settled = false;
+  const maybeSettle = () => {
+    if (settled) return;
+    const canNoLongerAdvance = kind === "any" ? contenderCount != null && rejectionCount === contenderCount : kind === "all" ? rejectionCount > 0 || contenderCount != null && fulfillmentCount === contenderCount : contenderCount != null && fulfillmentCount + rejectionCount === contenderCount;
+    if (!canNoLongerAdvance) return;
+    settled = true;
+    settleLifetime();
+  };
+  return {
+    ordinaryLifetime,
+    allOrdinaryValuesObservable: true,
+    observeFulfillment: () => {
+      fulfillmentCount += 1;
+      maybeSettle();
+    },
+    observeRejection: () => {
+      rejectionCount += 1;
+      maybeSettle();
+    },
+    finishIteration: (count) => {
+      contenderCount = count;
+      maybeSettle();
+    }
+  };
+}
+function observePromiseAggregateContender(normalized, observation) {
+  if (typeof normalized !== "object" && typeof normalized !== "function" || normalized == null) {
+    observation.allOrdinaryValuesObservable = false;
+    return normalized;
+  }
+  let observedSettled = false;
+  const observed = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(observed, "then", {
+    configurable: true,
+    get: () => {
+      const then = Reflect.get(normalized, "then", normalized);
+      if (typeof then !== "function") return then;
+      return function observedThen(onfulfilled, onrejected) {
+        return Reflect.apply(then, normalized, [
+          function observedFulfillment(value) {
+            if (!observedSettled) {
+              observedSettled = true;
+              observation.observeFulfillment();
+            }
+            return typeof onfulfilled === "function" ? Reflect.apply(onfulfilled, this, [value]) : void 0;
+          },
+          function observedRejection(reason) {
+            if (!observedSettled) {
+              observedSettled = true;
+              observation.observeRejection();
+            }
+            if (typeof onrejected === "function") {
+              return Reflect.apply(onrejected, this, [reason]);
+            }
+            throw reason;
+          }
+        ]);
+      };
+    }
+  });
+  return observed;
+}
+function observedPromiseConstructor(constructor, observeNormalized) {
+  const facade = function PromiseAggregateObservedConstructor(executor) {
+    return Reflect.construct(
+      constructor,
+      [executor],
+      constructor
+    );
+  };
+  Object.defineProperty(facade, "resolve", {
+    configurable: true,
+    get: () => {
+      const promiseResolve = Reflect.get(constructor, "resolve", constructor);
+      if (typeof promiseResolve !== "function") return promiseResolve;
+      return (value) => {
+        const normalized = Reflect.apply(promiseResolve, constructor, [value]);
+        return observeNormalized(normalized);
+      };
+    }
+  });
+  return facade;
+}
+function isInternalPromiseAggregate() {
+  const target = globalThis;
+  return (target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] ?? 0) > 0;
+}
+function installPromiseInstrumentation() {
+  const target = globalThis;
+  if (target[PROMISE_THEN_INSTRUMENTED_KEY] !== true) {
+    const originalThen = Promise.prototype.then;
+    Object.defineProperty(Promise.prototype, "then", {
+      ...Object.getOwnPropertyDescriptor(Promise.prototype, "then"),
+      value: function then(onfulfilled, onrejected) {
+        const result = Reflect.apply(
+          originalThen,
+          this,
+          [onfulfilled, onrejected]
+        );
+        if (isDetachedDurableThenable(this)) {
+          currentFunctionRuntime()?.trackDurablePromiseConsumption?.(result);
+        }
+        return result;
+      }
+    });
+    target[PROMISE_THEN_INSTRUMENTED_KEY] = true;
+  }
+  if (target[PROMISE_INSTRUMENTED_KEY] === true) return;
+  const originalRace = Promise.race;
+  const originalAny = Promise.any;
+  const originalAll = Promise.all;
+  const originalAllSettled = Promise.allSettled;
+  const originalResolve = Promise.resolve;
+  Object.defineProperty(Promise, "resolve", {
+    ...Object.getOwnPropertyDescriptor(Promise, "resolve"),
+    value: function resolve(value) {
+      const result = Reflect.apply(originalResolve, this, [value]);
+      if (isDurableThenable(value)) inheritDurableThenable(result, value);
+      return result;
+    }
+  });
+  Object.defineProperty(Promise, "race", {
+    ...Object.getOwnPropertyDescriptor(Promise, "race"),
+    value: function race(values) {
+      const runtime = currentFunctionRuntime();
+      if (runtime?.trackMixedPromiseRace == null) {
+        return Reflect.apply(originalRace, this, [values]);
+      }
+      const durableContenders = [];
+      let ordinaryContenderCount = 0;
+      const trackedValues = {
+        *[Symbol.iterator]() {
+          for (const value of values) {
+            yield value;
+          }
+        }
+      };
+      const observedConstructor = observedPromiseConstructor(
+        this,
+        (normalized) => {
+          if (isDurableThenable(normalized)) {
+            durableContenders.push(normalized);
+          } else {
+            ordinaryContenderCount += 1;
+          }
+          return normalized;
+        }
+      );
+      const construct = () => Reflect.apply(
+        originalRace,
+        observedConstructor,
+        [trackedValues]
+      );
+      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
+      if (durableContenders.length > 0) {
+        trackDurableAggregate(
+          runtime,
+          result,
+          durableContenders,
+          !isInternalPromiseAggregate()
+        );
+      }
+      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
+        runtime.trackMixedPromiseRace(result);
+      }
+      return result;
+    }
+  });
+  Object.defineProperty(Promise, "any", {
+    ...Object.getOwnPropertyDescriptor(Promise, "any"),
+    value: function any(values) {
+      const runtime = currentFunctionRuntime();
+      if (runtime?.trackMixedPromiseRace == null) {
+        return Reflect.apply(originalAny, this, [values]);
+      }
+      const durableContenders = [];
+      let ordinaryContenderCount = 0;
+      const observation = promiseAggregateObservation("any");
+      const trackedValues = {
+        *[Symbol.iterator]() {
+          for (const value of values) {
+            yield value;
+          }
+        }
+      };
+      const observedConstructor = observedPromiseConstructor(
+        this,
+        (normalized) => {
+          if (isDurableThenable(normalized)) {
+            durableContenders.push(normalized);
+            return normalized;
+          }
+          ordinaryContenderCount += 1;
+          return observePromiseAggregateContender(normalized, observation);
+        }
+      );
+      const construct = () => Reflect.apply(
+        originalAny,
+        observedConstructor,
+        [trackedValues]
+      );
+      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
+      observation.finishIteration(ordinaryContenderCount);
+      if (durableContenders.length > 0) {
+        trackDurableAggregate(
+          runtime,
+          result,
+          durableContenders,
+          !isInternalPromiseAggregate()
+        );
+      }
+      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
+        if (observation.allOrdinaryValuesObservable) {
+          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
+        } else {
+          runtime.trackMixedPromiseRace(result);
+        }
+      }
+      return result;
+    }
+  });
+  Object.defineProperty(Promise, "all", {
+    ...Object.getOwnPropertyDescriptor(Promise, "all"),
+    value: function all(values) {
+      const runtime = currentFunctionRuntime();
+      if (runtime?.trackMixedPromiseRace == null) {
+        return Reflect.apply(originalAll, this, [values]);
+      }
+      const durableContenders = [];
+      let ordinaryContenderCount = 0;
+      const observation = promiseAggregateObservation("all");
+      const trackedValues = {
+        *[Symbol.iterator]() {
+          for (const value of values) {
+            yield value;
+          }
+        }
+      };
+      const observedConstructor = observedPromiseConstructor(
+        this,
+        (normalized) => {
+          if (isDurableThenable(normalized)) {
+            durableContenders.push(normalized);
+            return normalized;
+          }
+          ordinaryContenderCount += 1;
+          return observePromiseAggregateContender(normalized, observation);
+        }
+      );
+      const construct = () => Reflect.apply(
+        originalAll,
+        observedConstructor,
+        [trackedValues]
+      );
+      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
+      observation.finishIteration(ordinaryContenderCount);
+      if (durableContenders.length > 0) {
+        trackDurableAggregate(
+          runtime,
+          result,
+          durableContenders,
+          !isInternalPromiseAggregate()
+        );
+      }
+      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
+        if (observation.allOrdinaryValuesObservable) {
+          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
+        } else {
+          runtime.trackMixedPromiseRace(result);
+        }
+      }
+      return result;
+    }
+  });
+  Object.defineProperty(Promise, "allSettled", {
+    ...Object.getOwnPropertyDescriptor(Promise, "allSettled"),
+    value: function allSettled(values) {
+      const runtime = currentFunctionRuntime();
+      if (runtime?.trackMixedPromiseRace == null) {
+        return Reflect.apply(
+          originalAllSettled,
+          this,
+          [values]
+        );
+      }
+      const durableContenders = [];
+      let ordinaryContenderCount = 0;
+      const observation = promiseAggregateObservation("all_settled");
+      const trackedValues = {
+        *[Symbol.iterator]() {
+          for (const value of values) yield value;
+        }
+      };
+      const observedConstructor = observedPromiseConstructor(
+        this,
+        (normalized) => {
+          if (isDurableThenable(normalized)) {
+            durableContenders.push(normalized);
+            return normalized;
+          }
+          ordinaryContenderCount += 1;
+          return observePromiseAggregateContender(normalized, observation);
+        }
+      );
+      const construct = () => Reflect.apply(
+        originalAllSettled,
+        observedConstructor,
+        [trackedValues]
+      );
+      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
+      observation.finishIteration(ordinaryContenderCount);
+      if (durableContenders.length > 0) {
+        trackDurableAggregate(
+          runtime,
+          result,
+          durableContenders,
+          !isInternalPromiseAggregate()
+        );
+      }
+      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
+        if (observation.allOrdinaryValuesObservable) {
+          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
+        } else {
+          runtime.trackMixedPromiseRace(result);
+        }
+      }
+      return result;
+    }
+  });
+  target[PROMISE_INSTRUMENTED_KEY] = true;
+}
+function validateArguments(definition, supplied) {
+  const args = [...supplied];
+  if (args.length > definition.parameters.length) {
+    throw new SDKUsageError(`${definition.name} expected at most ${definition.parameters.length} arguments, received ${args.length}`);
+  }
+  definition.parameters.forEach((parameter, index) => {
+    if (index >= args.length || args[index] === void 0) {
+      if (parameter.hasDefault) args[index] = parameter.defaultValue;
+      else if (parameter.required) throw new SDKUsageError(`${definition.name} is missing argument '${parameter.name}'`);
+      return;
+    }
+    validateWithSchema(parameter.schema, args[index], `${definition.name}.${parameter.name}`);
+  });
+  return args;
+}
+async function executeHandlerResult(definition, suppliedArgs) {
+  const args = validateArguments(definition, suppliedArgs);
+  const result = definition.handler(...args);
+  if (result == null || typeof result.then !== "function") {
+    throw new SDKUsageError(`Tensorlake handler '${definition.name}' must be async and return a Promise`);
+  }
+  const output = await result;
+  if (isTailCall(output)) {
+    return output;
+  }
+  validateWithSchema(definition.returns, output, `${definition.name} return value`);
+  return output;
+}
+function isTailCall(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[TAIL_CALL_BRAND] === true && candidate.kind === "tensorlake-tail-call" && typeof candidate.definition === "object" && candidate.definition != null && Array.isArray(candidate.args);
+}
+
+// src/function-agent/runner.ts
+installPromiseInstrumentation();
+var RESERVED_ENVIRONMENT_TARGETS = /* @__PURE__ */ new Set([
+  "PYTHONFAULTHANDLER",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "PYTHONHOME",
+  "PYTHONPATH",
+  "NODE_OPTIONS",
+  "NODE_PATH"
+]);
+var nativeImport = (0, import_node_vm.compileFunction)(
+  "return import(specifier)",
+  ["specifier"],
+  { importModuleDynamically: import_node_vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER }
+);
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((resolveValue, rejectValue) => {
+    resolve = resolveValue;
+    reject = rejectValue;
+  });
+  return { promise, resolve, reject };
+}
+function durableHash(values) {
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  for (const value of values) {
+    const bytes = Buffer.from(value, "utf8");
+    const length = Buffer.alloc(8);
+    length.writeBigUInt64BE(BigInt(bytes.byteLength));
+    hash.update(length);
+    hash.update(bytes);
+    hash.update("|");
+  }
+  return hash.digest("hex");
+}
+function safeArchivePath(root, archivePath) {
+  const output = import_node_path2.default.resolve(root, archivePath);
+  if (output !== root && !output.startsWith(`${root}${import_node_path2.default.sep}`)) {
+    throw new Error(`Application archive contains unsafe path '${archivePath}'`);
+  }
+  return output;
+}
+function decodeBase64(value) {
+  return new Uint8Array(Buffer.from(value, "base64"));
+}
+function encodeBase64(value) {
+  return Buffer.from(value).toString("base64");
+}
+function deserializeValue(value) {
+  const data = decodeBase64(value.data_base64);
+  if (value.content_type.toLowerCase().includes("json")) return deserializeJSON(data);
+  return new File(data, value.content_type || "application/octet-stream");
+}
+function serializeArgument(value) {
+  const serialized = serializeValue(value);
+  return {
+    source: "data",
+    data_base64: encodeBase64(serialized.data),
+    metadata_base64: "",
+    content_type: serialized.contentType
+  };
+}
+function applyResolvedEnvironment(assignment) {
+  const rawEnvironment = assignment.resolved_environment ?? [];
+  const targets = /* @__PURE__ */ new Set();
+  for (const item of rawEnvironment) {
+    if (item == null || typeof item.target !== "string" || !/^[A-Za-z_][A-Za-z0-9_]{0,255}$/.test(item.target) || RESERVED_ENVIRONMENT_TARGETS.has(item.target) || item.target.startsWith("TENSORLAKE_") || targets.has(item.target) || typeof item.value !== "string" || item.value.includes("\0")) {
+      throw new Error("Resolved environment entry is invalid");
+    }
+    targets.add(item.target);
+  }
+  for (const item of rawEnvironment) process.env[item.target] = item.value;
+  for (const item of rawEnvironment) item.value = "";
+  assignment.resolved_environment = [];
+}
+function failureFromResult(result) {
+  if (result.outcome === "timed_out") return new TimeoutError();
+  if (result.reason === "request_error") return new RequestError("Function call failed");
+  return new FunctionError(`Function call failed: ${result.reason}`);
+}
+var FunctionAgentRunner = class {
+  constructor(core) {
+    this.core = core;
+  }
+  attempts = /* @__PURE__ */ new Map();
+  applications = /* @__PURE__ */ new Map();
+  initializationSent = false;
+  async run() {
+    for (; ; ) {
+      const input = JSON.parse(await this.core.nextInput());
+      switch (input.type) {
+        case "assignment":
+          void this.startAssignment(input.assignment);
+          break;
+        case "call_result":
+          this.attempts.get(input.attempt_id)?.deliverCallResult(
+            input.function_call_id,
+            input
+          );
+          break;
+        case "request_state_result":
+          this.attempts.get(input.result.attempt_id)?.deliverStateResult(input.result);
+          break;
+        case "cancel":
+          this.attempts.get(input.attempt_id)?.cancel();
+          break;
+        case "shutdown":
+          return;
+      }
+    }
+  }
+  async startAssignment(assignment) {
+    try {
+      applyResolvedEnvironment(assignment);
+      const application = await this.loadApplication(assignment);
+      if (!this.initializationSent) {
+        await this.submit({ type: "initialized" });
+        this.initializationSent = true;
+      }
+      const definition = application.getFunction(assignment.function);
+      const attempt = new AttemptRuntime(assignment, definition, this.submit.bind(this));
+      this.attempts.set(assignment.attempt_id, attempt);
+      await attempt.run();
+    } catch (error) {
+      if (!this.initializationSent) {
+        await this.submit({ type: "initialized" });
+        this.initializationSent = true;
+      }
+      await this.submit({
+        type: "failure",
+        attempt_id: assignment.attempt_id,
+        reason: "function_error",
+        message: error instanceof Error ? error.stack ?? error.message : String(error)
+      });
+    } finally {
+      this.attempts.delete(assignment.attempt_id);
+    }
+  }
+  loadApplication(assignment) {
+    let application = this.applications.get(assignment.application_code_sha256);
+    if (application == null) {
+      application = unpackApplication(assignment);
+      this.applications.set(assignment.application_code_sha256, application);
+    }
+    return application;
+  }
+  submit(output) {
+    return this.core.submitOutput(JSON.stringify(output));
+  }
+};
+var AttemptRuntime = class {
+  constructor(assignment, definition, submit) {
+    this.assignment = assignment;
+    this.definition = definition;
+    this.submit = submit;
+    this.previousDurableId = assignment.function_run_id;
+  }
+  controller = new AbortController();
+  callResults = /* @__PURE__ */ new Map();
+  stateResults = /* @__PURE__ */ new Map();
+  previousDurableId;
+  nextStateSequence = 1;
+  async run() {
+    try {
+      const args = await deserializeAssignmentArguments(this.definition, this.assignment.inputs);
+      const output = await runWithFunctionRuntime(
+        this,
+        () => runWithRequestContext(
+          this.requestContext(),
+          () => executeHandlerResult(this.definition, args)
+        )
+      );
+      if (isTailCall(output)) {
+        const callId = await this.createTailCall(output);
+        await this.submit({
+          type: "success",
+          attempt_id: this.assignment.attempt_id,
+          result: { type: "call_graph", output_function_call_id: callId }
+        });
+        return;
+      }
+      const serialized = serializeValue(output);
+      await this.submit({
+        type: "success",
+        attempt_id: this.assignment.attempt_id,
+        result: {
+          type: "value",
+          output_base64: encodeBase64(serialized.data),
+          metadata_base64: "",
+          content_type: serialized.contentType
+        }
+      });
+    } catch (error) {
+      if (this.controller.signal.aborted) return;
+      await this.submit({
+        type: "failure",
+        attempt_id: this.assignment.attempt_id,
+        reason: isRequestError(error) ? "request_error" : "function_error",
+        message: error instanceof Error ? error.stack ?? error.message : String(error)
+      });
+    }
+  }
+  cancel() {
+    if (!this.controller.signal.aborted) {
+      this.controller.abort(new FunctionError("Function execution was cancelled"));
+    }
+    for (const waiter of this.callResults.values()) waiter.reject(this.controller.signal.reason);
+    for (const waiter of this.stateResults.values()) waiter.reject(this.controller.signal.reason);
+    this.callResults.clear();
+    this.stateResults.clear();
+  }
+  deliverCallResult(functionCallId, result) {
+    const waiter = this.callResults.get(functionCallId);
+    if (waiter == null) return;
+    this.callResults.delete(functionCallId);
+    waiter.resolve(result);
+  }
+  deliverStateResult(result) {
+    const waiter = this.stateResults.get(result.operation_id);
+    if (waiter == null) return;
+    this.stateResults.delete(result.operation_id);
+    waiter.resolve(result);
+  }
+  invoke(definition, args) {
+    return this.runChild(definition, args, 0);
+  }
+  async runFuture(future) {
+    if (future.delaySeconds > 0) {
+      await this.submit({ type: "suspend", attempt_id: this.assignment.attempt_id });
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, future.delaySeconds * 1e3);
+        this.controller.signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          reject(this.controller.signal.reason);
+        }, { once: true });
+      });
+      await this.submit({ type: "resume", attempt_id: this.assignment.attempt_id });
+    }
+    return this.runChild(future.definition, future.args, 0);
+  }
+  async reduce(definition, items, initial, hasInitial) {
+    let values = items;
+    let accumulator = initial;
+    if (!hasInitial) {
+      if (items.length === 0) throw new SDKUsageError("reduce of empty iterable with no initial value");
+      [accumulator, ...values] = items;
+    }
+    if (values.length === 0) return accumulator;
+    const calls = [];
+    let previous;
+    for (const item of values) {
+      const id = this.nextDurableId(definition, "ReduceStep");
+      calls.push({
+        function_call_id: id,
+        function_name: definition.name,
+        inputs: [
+          previous == null ? serializeArgument(accumulator) : { source: "function_run_output", function_call_id: previous },
+          serializeArgument(item)
+        ],
+        call_metadata_base64: this.callMetadata(id, definition.name, "reduce")
+      });
+      previous = id;
+    }
+    await this.submit({ type: "call_batch", attempt_id: this.assignment.attempt_id, calls });
+    return this.watch(previous);
+  }
+  async runChild(definition, args, _delaySeconds) {
+    const id = this.nextDurableId(definition);
+    await this.submit({
+      type: "call_batch",
+      attempt_id: this.assignment.attempt_id,
+      calls: [{
+        function_call_id: id,
+        function_name: definition.name,
+        inputs: args.map(serializeArgument),
+        call_metadata_base64: this.callMetadata(id, definition.name, "call")
+      }]
+    });
+    return this.watch(id);
+  }
+  async watch(functionCallId) {
+    const result = deferred();
+    this.callResults.set(functionCallId, result);
+    await this.submit({
+      type: "watch",
+      attempt_id: this.assignment.attempt_id,
+      function_call_id: functionCallId
+    });
+    const resolved = await result.promise;
+    if (resolved.outcome !== "success") throw failureFromResult(resolved);
+    return deserializeValue({
+      data_base64: resolved.output_base64,
+      metadata_base64: resolved.metadata_base64,
+      content_type: resolved.content_type
+    });
+  }
+  async createTailCall(tailCall) {
+    const id = this.nextDurableId(tailCall.definition);
+    await this.submit({
+      type: "call_batch",
+      attempt_id: this.assignment.attempt_id,
+      calls: [{
+        function_call_id: id,
+        function_name: tailCall.definition.name,
+        inputs: tailCall.args.map(serializeArgument),
+        call_metadata_base64: this.callMetadata(id, tailCall.definition.name, "tail_call")
+      }]
+    });
+    return id;
+  }
+  nextDurableId(definition, operation = "FunctionCall") {
+    const id = durableHash([
+      this.assignment.function_run_id,
+      this.previousDurableId,
+      operation,
+      definition.name
+    ]);
+    this.previousDurableId = id;
+    return id;
+  }
+  callMetadata(id, functionName, operation) {
+    return Buffer.from(JSON.stringify({
+      format: "tensorlake.typescript.function-call.v1",
+      id,
+      functionName,
+      operation
+    })).toString("base64");
+  }
+  requestContext() {
+    return {
+      requestId: this.assignment.request_id,
+      headers: new Headers(
+        (this.assignment.request_headers ?? []).map(({ name, value }) => [name, value])
+      ),
+      signal: this.controller.signal,
+      state: {
+        get: async (key, defaultValue) => {
+          validateRequestStateKey(key);
+          const result = await this.requestState({ operation: "get", key });
+          if (result.result !== "get" || result.value_base64 == null) return defaultValue;
+          return deserializeJSON(decodeBase64(result.value_base64));
+        },
+        set: async (key, value) => {
+          validateRequestStateKey(key);
+          const encoded = encodeBase64(serializeRequestStateValue(value));
+          await this.requestState({ operation: "set", key, value_base64: encoded });
+        }
+      },
+      metrics: {
+        counter: async (name, value = 1) => validateCounterMetric(name, value),
+        timer: async (name, value) => validateTimerMetric(name, value)
+      },
+      progress: {
+        update: async (current, total, options) => {
+          validateProgressUpdate(current, total, options);
+          await this.submit({
+            type: "progress",
+            attempt_id: this.assignment.attempt_id,
+            message: JSON.stringify({ current, total, ...options })
+          });
+        }
+      }
+    };
+  }
+  async requestState(operation) {
+    const operationId = `${this.assignment.attempt_id}:state:${this.nextStateSequence}`;
+    this.nextStateSequence += 1;
+    const result = deferred();
+    this.stateResults.set(operationId, result);
+    await this.submit({
+      type: "request_state",
+      attempt_id: this.assignment.attempt_id,
+      operation_id: operationId,
+      operation
+    });
+    return result.promise;
+  }
+};
+async function unpackApplication(assignment) {
+  const archive = decodeBase64(assignment.application_code_base64);
+  const actualHash = (0, import_node_crypto3.createHash)("sha256").update(archive).digest("hex");
+  if (actualHash !== assignment.application_code_sha256) {
+    throw new Error(
+      `Application code hash mismatch: expected ${assignment.application_code_sha256}, got ${actualHash}`
+    );
+  }
+  const root = await (0, import_promises.mkdtemp)(import_node_path2.default.join(import_node_os.default.tmpdir(), "tensorlake-typescript-app-"));
+  const files = (0, import_fflate.unzipSync)(archive);
+  for (const [name, content] of Object.entries(files)) {
+    const destination = safeArchivePath(root, name);
+    if (name.endsWith("/")) {
+      await (0, import_promises.mkdir)(destination, { recursive: true });
+      continue;
+    }
+    await (0, import_promises.mkdir)(import_node_path2.default.dirname(destination), { recursive: true });
+    await (0, import_promises.writeFile)(destination, content, { mode: 384 });
+  }
+  const manifest = JSON.parse(
+    await (0, import_promises.readFile)(import_node_path2.default.join(root, ".tensorlake_code_manifest.json"), "utf8")
+  );
+  if (manifest.format_version !== 2 || manifest.runtime !== "typescript") {
+    throw new Error("Application code is not a Tensorlake TypeScript bundle");
+  }
+  const nodeMajor = Number(process.versions.node.split(".")[0]);
+  if ((manifest.minimum_node_major ?? 24) > nodeMajor) {
+    throw new Error(`Application requires Node ${manifest.minimum_node_major} or newer; runner has ${nodeMajor}`);
+  }
+  if (manifest.module == null) throw new Error("Application manifest does not name a runtime module");
+  const modulePath = safeArchivePath(root, manifest.module);
+  const runtime = await nativeImport((0, import_node_url2.pathToFileURL)(modulePath).href);
+  if (typeof runtime.__tensorlakeGetFunction !== "function") {
+    throw new Error("Application runtime does not export __tensorlakeGetFunction");
+  }
+  return {
+    root,
+    getFunction(name) {
+      if (manifest.functions?.[name] == null) {
+        throw new Error(`Function '${name}' is not present in the application bundle`);
+      }
+      const definition = runtime.__tensorlakeGetFunction?.(name);
+      if (definition?.name !== name) {
+        throw new Error(`Application runtime resolved '${name}' as '${String(definition?.name)}'`);
+      }
+      return definition;
+    }
+  };
+}
+async function deserializeAssignmentArguments(definition, inputs) {
+  if (inputs.length === 0) return [];
+  if (inputs.some((input) => input.source_function_call_id != null) || inputs.length > 1) {
+    return inputs.map(deserializeValue);
+  }
+  let data = decodeBase64(inputs[0].data_base64);
+  let contentType = inputs[0].content_type;
+  if (contentType.toLowerCase().startsWith("message/http")) {
+    const marker = Buffer.from("\r\n\r\n");
+    const bytes = Buffer.from(data);
+    const split = bytes.indexOf(marker);
+    if (split < 0) throw new Error("Invalid message/http application input");
+    const lines = bytes.subarray(0, split).toString("utf8").split("\r\n");
+    lines.shift();
+    for (const line of lines) {
+      const colon = line.indexOf(":");
+      if (colon > 0 && line.slice(0, colon).trim().toLowerCase() === "content-type") {
+        contentType = line.slice(colon + 1).trim();
+      }
+    }
+    data = new Uint8Array(bytes.subarray(split + marker.byteLength));
+  }
+  if (definition.parameters.length === 0) return [];
+  const first = definition.parameters[0];
+  if (definition.parameters.length === 1 && first?.schema._httpBody) {
+    return [new HttpBody(data, contentType)];
+  }
+  if (data.byteLength === 0 && !first?.schema._file) return [];
+  if (first?.schema._file) return [new File(data, contentType || "application/octet-stream")];
+  if (!contentType.toLowerCase().includes("json")) {
+    throw new Error(`Expected application/json input, got ${contentType}`);
+  }
+  return [deserializeJSON(data)];
+}
+
+// src/function-agent/main.ts
+function parseArgs(args) {
+  const values = /* @__PURE__ */ new Map();
+  for (let index = 0; index < args.length; index += 1) {
+    const key = args[index];
+    const value = args[index + 1];
+    if (!key?.startsWith("--") || value == null || value.startsWith("--")) {
+      throw new Error(`Expected --name value argument, got '${key ?? ""}'`);
+    }
+    values.set(key.slice(2), value);
+    index += 1;
+  }
+  const functionServiceUrl = values.get("function-service-url");
+  const registrationToken = values.get("registration-token");
+  if (functionServiceUrl == null || registrationToken == null) {
+    throw new Error("--function-service-url and --registration-token are required");
+  }
+  return {
+    functionServiceUrl,
+    registrationToken,
+    ...values.has("agent-id") ? { agentId: values.get("agent-id") } : {},
+    ...values.has("incarnation") ? { incarnation: values.get("incarnation") } : {},
+    ...values.has("secret-service-workload-url") ? { secretServiceWorkloadUrl: values.get("secret-service-workload-url") } : {},
+    ...values.has("credential-request-timeout-ms") ? { credentialRequestTimeoutMs: Number(values.get("credential-request-timeout-ms")) } : {}
+  };
+}
+async function main(args = process.argv.slice(2)) {
+  configureNativeWorker(() => new URL("../native-worker.cjs", importMetaUrl));
+  const binding = loadNative();
+  const core = new binding.FunctionAgentCore(parseArgs(args));
+  return new FunctionAgentRunner(core).run();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});
+//# sourceMappingURL=main.cjs.map