@tensorlakeai/tensorlake 0.0.0-bootstrap.0 → 0.5.145

package/dist/applications/index.cjs

@@ -0,0 +1,4821 @@
+"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();
+  }
+});
+
+// src/defaults.ts
+var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TIMEOUT_MS, MAX_RETRIES, RETRY_BACKOFF_MS;
+var init_defaults = __esm({
+  "src/defaults.ts"() {
+    "use strict";
+    init_cjs_shims();
+    SDK_VERSION = "0.5.145";
+    API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
+    API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
+    NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
+    SANDBOX_PROXY_URL = process.env.TENSORLAKE_SANDBOX_PROXY_URL ?? "https://sandbox.tensorlake.ai";
+    DEFAULT_HTTP_TIMEOUT_MS = 3e5;
+    MAX_RETRIES = 3;
+    RETRY_BACKOFF_MS = 500;
+  }
+});
+
+// src/models.ts
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
+}
+function parseTimestamp(v) {
+  if (v == null) return void 0;
+  if (v instanceof Date) return v;
+  if (typeof v === "string") {
+    const parsed = Date.parse(v);
+    return Number.isNaN(parsed) ? void 0 : new Date(parsed);
+  }
+  const ts = Number(v);
+  if (isNaN(ts)) return void 0;
+  if (ts > 1e15) return new Date(ts / 1e3);
+  if (ts > 1e12) return new Date(ts);
+  return new Date(ts * 1e3);
+}
+function fromSnakeKeys(obj, idField) {
+  if (Array.isArray(obj))
+    return obj.map((item) => fromSnakeKeys(item, idField));
+  if (obj !== null && typeof obj === "object" && !(obj instanceof Date)) {
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      let key;
+      if (k === "id" && idField) {
+        key = idField;
+      } else {
+        key = snakeToCamel(k);
+      }
+      if (key.endsWith("At") || key === "timestamp" || key === "startedAt" || key === "endedAt") {
+        result[key] = parseTimestamp(v);
+      } else if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+        result[key] = fromSnakeKeys(v);
+      } else if (Array.isArray(v)) {
+        result[key] = v.map((item) => fromSnakeKeys(item));
+      } else {
+        result[key] = v === null ? void 0 : v;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+var init_models = __esm({
+  "src/models.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/errors.ts
+function formatErrorDetails(errorDetails) {
+  if (errorDetails == null) return void 0;
+  if (typeof errorDetails === "string") {
+    const detail = errorDetails.trim();
+    return detail || void 0;
+  }
+  if (Array.isArray(errorDetails)) {
+    const parts = errorDetails.map((item) => formatErrorDetails(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("; ") : JSON.stringify(errorDetails);
+  }
+  if (typeof errorDetails === "object") {
+    for (const key of ["message", "detail", "error", "reason"]) {
+      const value = errorDetails[key];
+      if (typeof value === "string" && value.trim()) {
+        return value.trim();
+      }
+    }
+    return JSON.stringify(errorDetails);
+  }
+  return String(errorDetails);
+}
+var SandboxException, SandboxError, SandboxResizeError, SandboxConnectionError, SandboxNotFoundError, PoolNotFoundError, PoolInUseError, RemoteAPIError, RequestNotFinishedError, RequestFailedError, RequestExecutionError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    SandboxException = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SandboxException";
+      }
+    };
+    SandboxError = class extends SandboxException {
+      reason;
+      sandboxId;
+      constructor(message, options) {
+        super(message);
+        this.name = "SandboxError";
+        if (options?.reason !== void 0) this.reason = options.reason;
+        if (options?.sandboxId !== void 0) this.sandboxId = options.sandboxId;
+      }
+    };
+    SandboxResizeError = class extends SandboxError {
+      generation;
+      info;
+      constructor(payload) {
+        const resources = payload.info?.resources;
+        const allocation = resources ? `${resources.cpus} CPUs, ${resources.memoryMb} MiB memory, ${resources.diskMb} MiB disk` : "unavailable";
+        super(
+          `Sandbox ${payload.sandboxId} resize generation ${payload.generation}: ${payload.message}; last confirmed allocation: ${allocation}`,
+          { reason: payload.reason, sandboxId: payload.sandboxId }
+        );
+        this.name = "SandboxResizeError";
+        this.generation = payload.generation;
+        this.info = payload.info ?? void 0;
+      }
+      /** Last confirmed allocation, if an observation was available. */
+      get confirmedResources() {
+        return this.info?.resources;
+      }
+    };
+    SandboxConnectionError = class extends SandboxError {
+      constructor(message, options) {
+        super(`Connection error: ${message}`);
+        this.name = "SandboxConnectionError";
+        if (options?.cause !== void 0) this.cause = options.cause;
+      }
+    };
+    SandboxNotFoundError = class extends SandboxError {
+      constructor(sandboxId) {
+        super(`Sandbox not found: ${sandboxId}`, { sandboxId });
+        this.name = "SandboxNotFoundError";
+      }
+    };
+    PoolNotFoundError = class extends SandboxError {
+      poolId;
+      constructor(poolId) {
+        super(`Sandbox pool not found: ${poolId}`);
+        this.name = "PoolNotFoundError";
+        this.poolId = poolId;
+      }
+    };
+    PoolInUseError = class extends SandboxError {
+      poolId;
+      constructor(poolId, message) {
+        const base = `Cannot delete pool ${poolId}: pool is in use`;
+        super(message ? `${base} - ${message}` : base);
+        this.name = "PoolInUseError";
+        this.poolId = poolId;
+      }
+    };
+    RemoteAPIError = class extends SandboxError {
+      statusCode;
+      /** Original response body, retained for compatibility and diagnostics. */
+      responseMessage;
+      errorDetails;
+      constructor(statusCode, message) {
+        let failure;
+        try {
+          const payload = JSON.parse(message);
+          if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+            const record = payload;
+            if (typeof record.sandbox_id === "string" && record.sandbox_id.trim() && (record.status === "failed" || record.status === "terminated"))
+              failure = record;
+          }
+        } catch {
+        }
+        const sandboxId = failure?.sandbox_id;
+        const rawReason = failure?.reason ?? failure?.termination_reason;
+        const reason = typeof rawReason === "string" ? rawReason : void 0;
+        const errorDetails = failure?.error_details;
+        let displayMessage = message;
+        if (failure) {
+          displayMessage = `Sandbox ${sandboxId} ${failure.status}`;
+          if (reason) displayMessage += ` (${reason})`;
+          const detail = formatErrorDetails(errorDetails);
+          if (detail) displayMessage += `: ${detail}`;
+          if (!reason && !detail) displayMessage = message;
+        }
+        super(`API error (status ${statusCode}): ${displayMessage}`, {
+          reason,
+          sandboxId
+        });
+        this.errorDetails = errorDetails;
+        this.name = "RemoteAPIError";
+        this.statusCode = statusCode;
+        this.responseMessage = message;
+      }
+    };
+    RequestNotFinishedError = class extends Error {
+      constructor() {
+        super("Request has not finished yet");
+        this.name = "RequestNotFinishedError";
+      }
+    };
+    RequestFailedError = class extends Error {
+      failure;
+      constructor(failure) {
+        super(`Request failed: ${failure}`);
+        this.name = "RequestFailedError";
+        this.failure = failure;
+      }
+    };
+    RequestExecutionError = class extends Error {
+      functionName;
+      constructor(message, functionName) {
+        super(
+          functionName ? `Request error in ${functionName}: ${message}` : message
+        );
+        this.name = "RequestExecutionError";
+        this.functionName = functionName;
+      }
+    };
+  }
+});
+
+// src/native-worker-protocol.ts
+var cancelNativeCall, closeNativeHandle;
+var init_native_worker_protocol = __esm({
+  "src/native-worker-protocol.ts"() {
+    "use strict";
+    init_cjs_shims();
+    cancelNativeCall = /* @__PURE__ */ Symbol.for("tensorlake.native.cancel.v1");
+    closeNativeHandle = /* @__PURE__ */ Symbol.for("tensorlake.native.close.v1");
+  }
+});
+
+// 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
+    };
+  }
+}
+var init_url = __esm({
+  "src/url.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_defaults();
+  }
+});
+
+// src/native-worker-client.ts
+function createWorkerBinding(runtime) {
+  return {
+    NativeCloudClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeCloudClient", args);
+      }
+    },
+    NativeSandboxClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeSandboxClient", args);
+      }
+    },
+    NativeSandboxProxyClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeSandboxProxyClient", args);
+      }
+    },
+    NativeRepositoryClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeRepositoryClient", args);
+      }
+    },
+    validateManagedName: (name) => runtime.call(void 0, "validateManagedName", [name])
+  };
+}
+function workerBinding() {
+  return createWorkerBinding(
+    runtimes[runtimeKey] ??= new NativeWorkerClient()
+  );
+}
+function releaseNativeHandle(handle) {
+  handle?.[closeNativeHandle]?.();
+}
+var import_node_module, import_node_worker_threads, NativeWorkerClient, runtimeKey, runtimes;
+var init_native_worker_client = __esm({
+  "src/native-worker-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_module = require("module");
+    import_node_worker_threads = require("worker_threads");
+    init_native_worker_protocol();
+    init_url();
+    NativeWorkerClient = class {
+      constructor(workerPath = () => (0, import_node_module.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();
+      }
+    };
+    runtimeKey = /* @__PURE__ */ Symbol.for(
+      `tensorlake.native.worker.${false ? "source" : "0.5.145"}.v1`
+    );
+    runtimes = globalThis;
+  }
+});
+
+// src/native-sandbox.ts
+function loadNativeSandboxBinding() {
+  return cachedBinding ??= workerBinding();
+}
+function parseNativeError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message) return null;
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed && typeof parsed.category === "string") {
+      return {
+        category: parsed.category,
+        status: typeof parsed.status === "number" ? parsed.status : null,
+        message: typeof parsed.message === "string" ? parsed.message : message
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function translateNativeError(error, context) {
+  const payload = parseNativeError(error);
+  if (!payload) {
+    if (error instanceof Error) return error;
+    return new SandboxError(String(error));
+  }
+  const { category, status, message } = payload;
+  if (category === "resize") {
+    return new SandboxResizeError(
+      fromSnakeKeys(JSON.parse(message), "sandboxId")
+    );
+  }
+  if (category === "connection") {
+    return new SandboxConnectionError(message, { cause: error });
+  }
+  if (status === 404) {
+    if (context?.notFoundKind === "pool" && context.poolId) {
+      return new PoolNotFoundError(context.poolId);
+    }
+    if (context?.notFoundKind === "sandbox" && context.sandboxId) {
+      return new SandboxNotFoundError(context.sandboxId);
+    }
+    return new RemoteAPIError(404, message);
+  }
+  if (status === 409 && context?.poolId) {
+    return new PoolInUseError(context.poolId, message);
+  }
+  if (typeof status === "number") {
+    return new RemoteAPIError(status, message);
+  }
+  return new SandboxError(message);
+}
+async function callNative(fn, context) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw translateNativeError(error, context);
+  }
+}
+async function* nativeEventStream(start, context, signal) {
+  if (signal?.aborted) return;
+  const queue = [];
+  let wake;
+  let finished = false;
+  let stopped = false;
+  let failure;
+  const notify = () => {
+    const resolve = wake;
+    wake = void 0;
+    resolve?.();
+  };
+  const emit = (value) => {
+    if (stopped) return Promise.resolve();
+    return new Promise((consumed) => {
+      queue.push({ value, consumed });
+      notify();
+    });
+  };
+  let call;
+  const onAbort = () => {
+    stopped = true;
+    call?.[cancelNativeCall]?.();
+    notify();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    call = start(emit);
+    void call.catch((error) => {
+      failure = error;
+    }).finally(() => {
+      finished = true;
+      notify();
+    });
+    while (!stopped) {
+      const event = queue.shift();
+      if (event) {
+        try {
+          yield JSON.parse(event.value);
+        } finally {
+          event.consumed();
+        }
+      } else if (finished) {
+        break;
+      } else {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+    }
+    if (!stopped && failure !== void 0) throw translateNativeError(failure, context);
+  } finally {
+    stopped = true;
+    signal?.removeEventListener("abort", onAbort);
+    call?.[cancelNativeCall]?.();
+    for (const event of queue) event.consumed();
+  }
+}
+var cachedBinding;
+var init_native_sandbox = __esm({
+  "src/native-sandbox.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_models();
+    init_errors();
+    init_native_worker_client();
+    init_native_worker_protocol();
+  }
+});
+
+// src/native-cloud.ts
+async function serializeRequest(method, path3, options) {
+  const headers = { ...options?.headers };
+  let body = options?.body;
+  if (options?.json !== void 0) {
+    body = JSON.stringify(options.json);
+    if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const request = {
+    method,
+    path: path3,
+    headersJson: JSON.stringify(headers),
+    statusOnlyCodes: [...options?.statusOnlyCodes ?? []]
+  };
+  if (body instanceof FormData) {
+    request.parts = [];
+    for (const [name, value] of body.entries()) {
+      request.parts.push(typeof value === "string" ? { name, data: Buffer.from(value) } : { name, data: Buffer.from(await value.arrayBuffer()), filename: value.name, contentType: value.type || "application/octet-stream" });
+    }
+  } else if (body !== void 0) {
+    if (body instanceof Blob) request.body = Buffer.from(await body.arrayBuffer());
+    else if (typeof body === "string") request.body = Buffer.from(body);
+    else if (body instanceof ArrayBuffer) request.body = Buffer.from(new Uint8Array(body));
+    else request.body = Buffer.from(body);
+  }
+  return request;
+}
+var NativeCloudTransport;
+var init_native_cloud = __esm({
+  "src/native-cloud.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_native_sandbox();
+    init_native_worker_client();
+    NativeCloudTransport = class {
+      constructor(options) {
+        this.options = options;
+        if (!Number.isSafeInteger(options.maxRetries) || options.maxRetries < 0 || options.maxRetries > 4294967295) {
+          throw new RangeError("maxRetries must be a non-negative 32-bit integer");
+        }
+        if (!Number.isFinite(options.retryBackoffMs) || options.retryBackoffMs < 0) {
+          throw new RangeError("retryBackoffMs must be a non-negative finite number");
+        }
+      }
+      native;
+      closed = false;
+      client() {
+        if (this.closed) throw new Error("Tensorlake native client is closed");
+        if (this.native) return this.native;
+        const ctor = loadNativeSandboxBinding().NativeCloudClient;
+        if (!ctor) throw new Error("Native binding does not export NativeCloudClient; rebuild with 'npm run build:native'");
+        return this.native = new ctor(JSON.stringify(this.options));
+      }
+      close() {
+        this.closed = true;
+        releaseNativeHandle(this.native ?? null);
+        this.native = void 0;
+      }
+      async requestResponse(method, path3, options) {
+        const request = await serializeRequest(method, path3, options);
+        const raw = await callNative(() => this.client().request(request));
+        const response = new Response(
+          [204, 205, 304].includes(raw.status) ? null : Uint8Array.from(raw.data).buffer,
+          { status: raw.status, headers: JSON.parse(raw.headersJson) }
+        );
+        return Object.assign(response, { traceId: raw.traceId });
+      }
+      async requestJson(method, path3) {
+        const response = await this.requestResponse(method, path3);
+        const text = await response.text();
+        const value = text ? JSON.parse(text) : null;
+        return Object.assign(value ?? {}, { traceId: response.traceId });
+      }
+      async *stream(method, path3, signal) {
+        if (signal?.aborted) return;
+        const request = await serializeRequest(method, path3, { headers: { Accept: "text/event-stream" } });
+        yield* nativeEventStream((emit) => this.client().stream(request, emit), void 0, signal);
+      }
+    };
+  }
+});
+
+// src/cloud-client.ts
+function secretFromMetadata(metadata) {
+  return {
+    id: metadata.id,
+    name: metadata.name,
+    createdAt: new Date(metadata.created_at_ms)
+  };
+}
+function applicationAllowsUnauthenticatedRequests(manifest) {
+  return Array.isArray(manifest.allow) && manifest.allow.includes(UNAUTHENTICATED_REQUESTS);
+}
+function publicEndpointIdFromManifest(manifest) {
+  for (const key of ["public_endpoint_id", "publicEndpointId"]) {
+    const value = manifest[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function generatePublicEndpointId() {
+  return `endpoint_${(0, import_nanoid.nanoid)()}`;
+}
+function createApplicationBuildForm(request, imageContexts) {
+  const contextsByPartName = /* @__PURE__ */ new Map();
+  for (const context of imageContexts) {
+    if (contextsByPartName.has(context.contextTarPartName)) {
+      throw new Error(
+        `duplicate image context part name '${context.contextTarPartName}'`
+      );
+    }
+    contextsByPartName.set(context.contextTarPartName, context);
+  }
+  const form = new FormData();
+  form.append(
+    "app_version",
+    new Blob([JSON.stringify(request)], { type: "application/json" }),
+    "app_version"
+  );
+  for (const image of request.images) {
+    const context = contextsByPartName.get(image.contextTarPartName);
+    if (!context) {
+      throw new Error(
+        `missing image context for part '${image.contextTarPartName}'`
+      );
+    }
+    form.append(
+      image.contextTarPartName,
+      new Blob([toBlobPart(context.contextTarGz)]),
+      `${image.contextTarPartName}.tar.gz`
+    );
+  }
+  for (const context of imageContexts) {
+    if (!request.images.some((image) => image.contextTarPartName === context.contextTarPartName)) {
+      throw new Error(
+        `unexpected image context for part '${context.contextTarPartName}'`
+      );
+    }
+  }
+  return form;
+}
+function trimTrailingSlashes2(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function nextRequestPath(next) {
+  const schemeIndex = next.indexOf("://");
+  if (schemeIndex !== -1) {
+    const afterScheme = next.slice(schemeIndex + 3);
+    const slashIndex = afterScheme.indexOf("/");
+    return slashIndex === -1 ? "/" : afterScheme.slice(slashIndex);
+  }
+  return next.startsWith("/") ? next : `/${next}`;
+}
+function toBlobPart(data) {
+  if (typeof data === "string" || data instanceof Blob) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Uint8Array.from(data).buffer;
+  }
+  return data;
+}
+function toRequestBody(data) {
+  return toBlobPart(data);
+}
+async function parseJsonResponse(response) {
+  const text = await response.text();
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+var import_nanoid, CloudClient, UNAUTHENTICATED_REQUESTS;
+var init_cloud_client = __esm({
+  "src/cloud-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_nanoid = require("nanoid");
+    init_defaults();
+    init_native_cloud();
+    init_models();
+    CloudClient = class _CloudClient {
+      transport;
+      organizationId;
+      projectId;
+      namespace;
+      constructor(options) {
+        this.organizationId = options?.organizationId;
+        this.projectId = options?.projectId;
+        this.namespace = options?.namespace ?? NAMESPACE;
+        this.transport = new NativeCloudTransport({
+          baseUrl: options?.apiUrl ?? API_URL,
+          apiKey: options?.apiKey ?? API_KEY,
+          organizationId: this.organizationId,
+          projectId: this.projectId,
+          maxRetries: options?.maxRetries ?? MAX_RETRIES,
+          retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS,
+          timeoutMs: DEFAULT_HTTP_TIMEOUT_MS,
+          userAgent: `tensorlake-typescript-sdk/${SDK_VERSION}`
+        });
+      }
+      static forCloud(options) {
+        return new _CloudClient(options);
+      }
+      close() {
+        this.transport.close();
+      }
+      async upsertApplication(manifest, codeZip, upgradeRunningRequests = false) {
+        const applicationManifest = { ...manifest };
+        let publicEndpointId = publicEndpointIdFromManifest(applicationManifest);
+        if (applicationAllowsUnauthenticatedRequests(applicationManifest) && publicEndpointId === void 0) {
+          const applicationName = applicationManifest.name;
+          if (typeof applicationName === "string" && applicationName.length > 0) {
+            publicEndpointId = await this.existingApplicationPublicEndpointId(applicationName);
+          }
+          publicEndpointId ??= generatePublicEndpointId();
+        }
+        if (publicEndpointId !== void 0) {
+          applicationManifest.public_endpoint_id = publicEndpointId;
+          delete applicationManifest.publicEndpointId;
+        }
+        const form = new FormData();
+        form.append(
+          "code",
+          new Blob([toBlobPart(codeZip)], { type: "application/zip" }),
+          "code.zip"
+        );
+        form.append("code_content_type", "application/zip");
+        form.append("application", JSON.stringify(applicationManifest));
+        form.append(
+          "upgrade_requests_to_latest_code",
+          String(upgradeRunningRequests)
+        );
+        await this.transport.requestResponse("POST", this.namespacePath("applications"), {
+          body: form
+        });
+      }
+      async deleteApplication(applicationName) {
+        await this.transport.requestResponse(
+          "DELETE",
+          this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
+        );
+      }
+      async deleteSandboxImage(imageName) {
+        await this.transport.requestResponse(
+          "DELETE",
+          this.namespacePath(`sandbox-images/${encodeURIComponent(imageName)}`)
+        );
+      }
+      /**
+       * Look up a registered sandbox image (template) by its registered name.
+       *
+       * Returns the template, or `null` when no image with that name exists.
+       * API-key clients may omit organization/project IDs and use the
+       * token-scoped Platform API route directly. Explicit scope remains
+       * available for PAT callers.
+       */
+      async findSandboxImageByName(imageName, options) {
+        const base = this.platformProjectPath(
+          "sandbox-templates",
+          options?.organizationId,
+          options?.projectId
+        );
+        const response = await this.transport.requestResponse(
+          "GET",
+          `${base}/by-name/${encodeURIComponent(imageName)}`,
+          { statusOnlyCodes: /* @__PURE__ */ new Set([404]) }
+        );
+        if (response.status === 404) {
+          return null;
+        }
+        const raw = await parseJsonResponse(response);
+        return fromSnakeKeys(raw);
+      }
+      /**
+       * List all registered sandbox images (templates), following pagination to
+       * the end. API-key clients may omit organization/project IDs and use the
+       * token-scoped Platform API route directly.
+       */
+      async listSandboxImages(options) {
+        const base = this.platformProjectPath(
+          "sandbox-templates",
+          options?.organizationId,
+          options?.projectId
+        );
+        let path3 = `${base}?pageSize=100`;
+        const templates = [];
+        while (path3 !== null) {
+          const page = await this.transport.requestJson(
+            "GET",
+            path3
+          );
+          for (const item of page.items ?? []) {
+            templates.push(fromSnakeKeys(item));
+          }
+          const next = page.pagination?.next;
+          path3 = next ? nextRequestPath(next) : null;
+        }
+        return templates;
+      }
+      async applications() {
+        const raw = await this.transport.requestJson(
+          "GET",
+          this.namespacePath("applications")
+        );
+        return (raw.applications ?? []).map(
+          (application) => fromSnakeKeys(application)
+        );
+      }
+      async applicationManifest(applicationName) {
+        const raw = await this.transport.requestJson(
+          "GET",
+          this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
+        );
+        return fromSnakeKeys(raw);
+      }
+      async runRequest(applicationName, inputs = []) {
+        const path3 = this.namespacePath(
+          `applications/${encodeURIComponent(applicationName)}`
+        );
+        const response = inputs.length === 0 ? await this.transport.requestResponse("POST", path3, {
+          body: new Uint8Array(),
+          headers: { Accept: "application/json" }
+        }) : inputs.length === 1 && inputs[0].name === "0" ? await this.transport.requestResponse("POST", path3, {
+          body: toRequestBody(inputs[0].data),
+          headers: {
+            Accept: "application/json",
+            "Content-Type": inputs[0].contentType
+          }
+        }) : await this.runMultipartRequest(path3, inputs);
+        const body = await parseJsonResponse(response);
+        const requestId = body?.request_id;
+        if (!requestId) {
+          throw new Error("missing request_id in run request response body");
+        }
+        return requestId;
+      }
+      async waitOnRequestCompletion(applicationName, requestId) {
+        const stream = this.transport.stream(
+          "GET",
+          this.namespacePath(
+            `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/progress`
+          )
+        );
+        for await (const event of stream) {
+          if (Object.prototype.hasOwnProperty.call(event, "RequestFinished")) {
+            return;
+          }
+        }
+        throw new Error("progress stream ended before request completion");
+      }
+      async requestMetadata(applicationName, requestId) {
+        const raw = await this.transport.requestJson(
+          "GET",
+          this.namespacePath(
+            `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}`
+          )
+        );
+        return fromSnakeKeys(raw);
+      }
+      async requestOutput(applicationName, requestId) {
+        const response = await this.transport.requestResponse(
+          "GET",
+          this.namespacePath(
+            `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/output`
+          )
+        );
+        const serializedValue = new Uint8Array(await response.arrayBuffer());
+        const contentType = response.headers.get("content-type") ?? "";
+        return {
+          serializedValue,
+          contentType
+        };
+      }
+      async listSecrets(options) {
+        const base = this.secretCollectionPath(
+          options?.organizationId,
+          options?.projectId
+        );
+        const raw = await this.transport.requestJson("GET", base);
+        const pageSize = Math.max(0, options?.pageSize ?? 100);
+        return Object.assign(
+          {
+            items: raw.slice(0, pageSize).map(secretFromMetadata),
+            pagination: { total: raw.length }
+          },
+          { traceId: raw.traceId }
+        );
+      }
+      async getSecret(secretId, options) {
+        const base = this.secretCollectionPath(
+          options?.organizationId,
+          options?.projectId
+        );
+        const raw = await this.transport.requestJson(
+          "GET",
+          `${base}/${encodeURIComponent(secretId)}`
+        );
+        return Object.assign(secretFromMetadata(raw), { traceId: raw.traceId });
+      }
+      async upsertSecrets(secrets, options) {
+        const base = this.secretCollectionPath(
+          options?.organizationId,
+          options?.projectId
+        );
+        if (Array.isArray(secrets)) {
+          const results = [];
+          for (const secret of secrets) {
+            results.push(await this.upsertSecret(base, secret));
+          }
+          return results;
+        }
+        return this.upsertSecret(base, secrets);
+      }
+      async deleteSecret(secretId, options) {
+        const base = this.secretCollectionPath(
+          options?.organizationId,
+          options?.projectId
+        );
+        await this.transport.requestResponse(
+          "DELETE",
+          `${base}/${encodeURIComponent(secretId)}`
+        );
+      }
+      async upsertSecret(base, secret) {
+        let response = await this.transport.requestResponse("POST", base, {
+          json: secret,
+          headers: { "Idempotency-Key": (0, import_nanoid.nanoid)() },
+          statusOnlyCodes: /* @__PURE__ */ new Set([409])
+        });
+        if (response.status === 409) {
+          const prefix = base.slice(0, -"/secrets".length);
+          const existing = await this.transport.requestJson(
+            "GET",
+            `${prefix}/secret-names/${encodeURIComponent(secret.name)}`
+          );
+          response = await this.transport.requestResponse(
+            "POST",
+            `${base}/${encodeURIComponent(existing.id)}/versions`,
+            {
+              json: { value: secret.value },
+              headers: { "Idempotency-Key": (0, import_nanoid.nanoid)() }
+            }
+          );
+        }
+        const metadata = await parseJsonResponse(response);
+        return Object.assign(secretFromMetadata(metadata), {
+          traceId: response.traceId
+        });
+      }
+      async startImageBuild(buildServicePath, request) {
+        const form = new FormData();
+        form.append("graph_name", request.applicationName);
+        form.append("graph_version", request.applicationVersion);
+        form.append("graph_function_name", request.functionName);
+        form.append("image_name", request.imageName);
+        form.append("image_id", request.imageId);
+        form.append(
+          "context",
+          new Blob([toBlobPart(request.buildContext)]),
+          "context.tar.gz"
+        );
+        const response = await this.transport.requestResponse(
+          "PUT",
+          `${trimTrailingSlashes2(buildServicePath)}/builds`,
+          { body: form }
+        );
+        const raw = await parseJsonResponse(response);
+        return fromSnakeKeys(raw);
+      }
+      async createApplicationBuild(buildServicePath, request, imageContexts) {
+        const form = createApplicationBuildForm(request, imageContexts);
+        const response = await this.transport.requestResponse(
+          "POST",
+          trimTrailingSlashes2(buildServicePath),
+          { body: form }
+        );
+        const raw = await parseJsonResponse(response);
+        return fromSnakeKeys(raw);
+      }
+      async applicationBuildInfo(buildServicePath, applicationBuildId) {
+        const raw = await this.transport.requestJson(
+          "GET",
+          `${trimTrailingSlashes2(buildServicePath)}/${encodeURIComponent(applicationBuildId)}`
+        );
+        return fromSnakeKeys(raw);
+      }
+      async cancelApplicationBuild(buildServicePath, applicationBuildId) {
+        const raw = await this.transport.requestJson(
+          "POST",
+          `${trimTrailingSlashes2(buildServicePath)}/${encodeURIComponent(applicationBuildId)}/cancel`
+        );
+        return fromSnakeKeys(raw);
+      }
+      async buildInfo(buildServicePath, buildId) {
+        const raw = await this.transport.requestJson(
+          "GET",
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}`
+        );
+        return fromSnakeKeys(raw);
+      }
+      async cancelBuild(buildServicePath, buildId) {
+        await this.transport.requestResponse(
+          "POST",
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}/cancel`
+        );
+      }
+      async *streamBuildLogs(buildServicePath, buildId, signal) {
+        const stream = this.transport.stream(
+          "GET",
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}/logs`,
+          signal
+        );
+        for await (const event of stream) {
+          yield fromSnakeKeys(event);
+        }
+      }
+      async runMultipartRequest(path3, inputs) {
+        const form = new FormData();
+        for (const input of inputs) {
+          form.append(
+            input.name,
+            new Blob([toBlobPart(input.data)], { type: input.contentType }),
+            input.name
+          );
+        }
+        return this.transport.requestResponse("POST", path3, {
+          body: form,
+          headers: { Accept: "application/json" }
+        });
+      }
+      namespacePath(subpath) {
+        return `/v1/namespaces/${encodeURIComponent(this.namespace)}/${subpath.replace(/^\/+/, "")}`;
+      }
+      async existingApplicationPublicEndpointId(applicationName) {
+        const response = await this.transport.requestResponse(
+          "GET",
+          this.namespacePath(`applications/${encodeURIComponent(applicationName)}`),
+          { statusOnlyCodes: /* @__PURE__ */ new Set([404]) }
+        );
+        if (response.status === 404) {
+          return void 0;
+        }
+        const application = await parseJsonResponse(response);
+        return publicEndpointIdFromManifest(application);
+      }
+      platformProjectPath(resource, organizationId, projectId) {
+        const resolvedOrganizationId = organizationId ?? this.organizationId;
+        const resolvedProjectId = projectId ?? this.projectId;
+        if (!resolvedOrganizationId && !resolvedProjectId) {
+          return `/platform/v1/${resource}`;
+        }
+        if (!resolvedOrganizationId || !resolvedProjectId) {
+          throw new Error(
+            "organizationId and projectId must be provided together"
+          );
+        }
+        return `/platform/v1/organizations/${encodeURIComponent(resolvedOrganizationId)}/projects/${encodeURIComponent(resolvedProjectId)}/${resource}`;
+      }
+      secretCollectionPath(organizationId, projectId) {
+        const resolvedOrganizationId = organizationId ?? this.organizationId;
+        const resolvedProjectId = projectId ?? this.projectId;
+        if (!resolvedOrganizationId && !resolvedProjectId) {
+          return this.namespacePath("secrets");
+        }
+        if (!resolvedOrganizationId || !resolvedProjectId) {
+          throw new Error("organizationId and projectId must be provided together");
+        }
+        return this.namespacePath("secrets");
+      }
+    };
+    UNAUTHENTICATED_REQUESTS = "unauthenticated_requests";
+  }
+});
+
+// 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/native-binding.ts
+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;
+}
+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_module2.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);
+}
+var import_libc, fs, import_node_module2, import_node_path, import_node_url, NATIVE_PACKAGES, cachedLinuxLibc;
+var init_native_binding = __esm({
+  "src/native-binding.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_libc = __toESM(require_libc(), 1);
+    fs = __toESM(require("fs"), 1);
+    import_node_module2 = require("module");
+    import_node_path = __toESM(require("path"), 1);
+    import_node_url = require("url");
+    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"
+    };
+  }
+});
+
+// src/sandbox-image.ts
+var sandbox_image_exports = {};
+__export(sandbox_image_exports, {
+  __setNativeBindingForTest: () => __setNativeBindingForTest,
+  buildContextFromEnv: () => buildContextFromEnv,
+  createSandboxImage: () => createSandboxImage,
+  deleteSandboxImage: () => deleteSandboxImage,
+  findSandboxImageByName: () => findSandboxImageByName,
+  importSandboxImage: () => importSandboxImage,
+  listSandboxImages: () => listSandboxImages,
+  runCreateSandboxImageCli: () => runCreateSandboxImageCli,
+  runImportSandboxImageCli: () => runImportSandboxImageCli
+});
+function loadNativeBinding() {
+  if (cachedNativeBinding) return cachedNativeBinding;
+  if (cachedNativeBindingError) throw cachedNativeBindingError;
+  try {
+    cachedNativeBinding = loadNative();
+    return cachedNativeBinding;
+  } catch (error) {
+    cachedNativeBindingError = error instanceof Error ? error : new Error(String(error));
+    throw cachedNativeBindingError;
+  }
+}
+function __setNativeBindingForTest(binding) {
+  cachedNativeBinding = binding;
+  cachedNativeBindingError = void 0;
+}
+function nonEmpty(value) {
+  return value && value.length > 0 ? value : void 0;
+}
+function buildContextFromEnv() {
+  const debugRaw = (process.env.TENSORLAKE_DEBUG ?? "").toLowerCase();
+  const debug = ["1", "true", "yes", "on"].includes(debugRaw);
+  return {
+    apiUrl: nonEmpty(process.env.TENSORLAKE_API_URL) ?? "https://api.tensorlake.ai",
+    apiKey: nonEmpty(process.env.TENSORLAKE_API_KEY),
+    personalAccessToken: nonEmpty(process.env.TENSORLAKE_PAT),
+    namespace: nonEmpty(process.env.INDEXIFY_NAMESPACE) ?? "default",
+    organizationId: nonEmpty(process.env.TENSORLAKE_ORGANIZATION_ID),
+    projectId: nonEmpty(process.env.TENSORLAKE_PROJECT_ID),
+    debug
+  };
+}
+function defaultRegisteredName(dockerfilePath) {
+  const parsed = import_node_path2.default.parse(dockerfilePath);
+  if (parsed.name.toLowerCase() === "dockerfile") {
+    const parentName = import_node_path2.default.basename(import_node_path2.default.dirname(dockerfilePath)).trim();
+    return parentName || "sandbox-image";
+  }
+  return parsed.name || "sandbox-image";
+}
+function defaultRegisteredNameFromImage(imageReference) {
+  const withoutDigest = imageReference.split("@", 1)[0] ?? imageReference;
+  const lastSegment = withoutDigest.split("/").pop() ?? withoutDigest;
+  const colonIndex = lastSegment.lastIndexOf(":");
+  const name = colonIndex > 0 && colonIndex < lastSegment.length - 1 ? lastSegment.slice(0, colonIndex) : lastSegment;
+  return name || "imported-image";
+}
+function noopEmit(_event) {
+}
+function stderrEmit(event) {
+  const message = typeof event.message === "string" ? event.message : "";
+  const type = typeof event.type === "string" ? event.type : "";
+  if (type === "build_log") {
+    const stream = typeof event.stream === "string" ? event.stream : "stdout";
+    process.stderr.write(`[${stream}] ${message}
+`);
+  } else if (message) {
+    process.stderr.write(`[${type}] ${message}
+`);
+  }
+}
+function ndjsonStdoutEmit(event) {
+  process.stdout.write(`${JSON.stringify(event)}
+`);
+}
+function eventToEmitDict(event) {
+  const out = {
+    type: event.eventType,
+    message: event.message
+  };
+  if (event.stream != null) out.stream = event.stream;
+  return out;
+}
+function runOpMountsContext(op) {
+  if (op.type !== ImageBuildOperationType.RUN) {
+    return false;
+  }
+  const mount = op.options.mount;
+  if (mount == null || mount === "") {
+    return false;
+  }
+  const fields = {};
+  for (const token of mount.split(",")) {
+    const eq = token.indexOf("=");
+    const key = (eq === -1 ? token : token.slice(0, eq)).trim();
+    const value = eq === -1 ? "" : token.slice(eq + 1).trim();
+    fields[key] = value;
+  }
+  if ((fields.type ?? "bind") !== "bind") {
+    return false;
+  }
+  return !("from" in fields);
+}
+function opReferencesHostFiles(op) {
+  if (op.type === ImageBuildOperationType.RUN) {
+    return runOpMountsContext(op);
+  }
+  if (op.type !== ImageBuildOperationType.COPY && op.type !== ImageBuildOperationType.ADD) {
+    return false;
+  }
+  if (op.options.from != null) {
+    return false;
+  }
+  if (op.type === ImageBuildOperationType.ADD && (op.args[0].startsWith("http://") || op.args[0].startsWith("https://"))) {
+    return false;
+  }
+  return true;
+}
+function imageRequiresContext(image) {
+  return image.buildOperations.some(opReferencesHostFiles);
+}
+async function createSandboxImage(source, options = {}, deps = {}) {
+  const emit = deps.emit ?? (options.verbose ? stderrEmit : noopEmit);
+  const context = buildContextFromEnv();
+  let dockerfilePath;
+  let dockerfileText;
+  let nativeContextDir;
+  let effectiveName;
+  let tempContextDir;
+  if (source instanceof Image) {
+    if (!source.baseImage) {
+      throw new Error("Image must have a baseImage to build");
+    }
+    let resolvedContext;
+    if (options.contextDir != null) {
+      resolvedContext = import_node_path2.default.resolve(options.contextDir);
+    } else if (imageRequiresContext(source)) {
+      throw new Error(
+        "This image reads files from the host (via COPY/ADD or a RUN bind mount), so it needs a build context. Pass `contextDir` pointing at the directory that contains those sources; they resolve relative to it, like `docker build <contextDir>`."
+      );
+    } else {
+      tempContextDir = (0, import_node_fs.mkdtempSync)(import_node_path2.default.join(import_node_os.default.tmpdir(), "tl-build-context-"));
+      resolvedContext = tempContextDir;
+    }
+    dockerfilePath = import_node_path2.default.join(resolvedContext, "Dockerfile");
+    let text = dockerfileContent(source);
+    if (!text.endsWith("\n")) text += "\n";
+    dockerfileText = text;
+    nativeContextDir = resolvedContext;
+    effectiveName = options.registeredName ?? source.name;
+  } else if (typeof source === "string") {
+    const resolvedPath = import_node_path2.default.resolve(source);
+    if (!(0, import_node_fs.existsSync)(resolvedPath)) {
+      throw new Error(`Dockerfile not found: ${source}`);
+    }
+    dockerfilePath = resolvedPath;
+    dockerfileText = void 0;
+    nativeContextDir = void 0;
+    effectiveName = options.registeredName ?? defaultRegisteredName(resolvedPath);
+  } else {
+    throw new TypeError(
+      `source must be an Image or a Dockerfile path, got ${typeof source}`
+    );
+  }
+  try {
+    if (effectiveName === DEFAULT_IMAGE_NAME) {
+      console.warn(
+        `Building sandbox image with the default name "${DEFAULT_IMAGE_NAME}". Pass \`registeredName\` or \`Image({ name })\` to avoid collisions with other default-named images in this project.`
+      );
+    }
+    const usePat = deps._allowPat === true && context.apiKey == null;
+    const bearerToken = context.apiKey ?? (usePat ? context.personalAccessToken : void 0);
+    if (!bearerToken) {
+      if (context.personalAccessToken && !deps._allowPat) {
+        throw new Error(
+          "Sandbox image SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+        );
+      }
+      throw new Error(
+        deps._allowPat ? "Missing TENSORLAKE_API_KEY or TENSORLAKE_PAT credentials." : "Missing TENSORLAKE_API_KEY credentials."
+      );
+    }
+    emit({ type: "status", message: `Building image '${effectiveName}'...` });
+    const binding = loadNativeBinding();
+    let emitError;
+    const resultJson = await binding.buildSandboxImage(
+      {
+        apiUrl: context.apiUrl,
+        bearerToken,
+        dockerfilePath,
+        registeredName: effectiveName,
+        diskMb: options.diskMb,
+        builderDiskMb: options.builderDiskMb,
+        cpus: options.cpus,
+        memoryMb: options.memoryMb,
+        isPublic: options.isPublic ?? false,
+        organizationId: usePat ? context.organizationId : void 0,
+        projectId: usePat ? context.projectId : void 0,
+        namespace: context.namespace,
+        useScopeHeaders: usePat,
+        userAgent: void 0,
+        dockerCompat: options.dockerCompat ?? false,
+        dockerfileText,
+        contextDir: nativeContextDir
+      },
+      (event) => {
+        try {
+          emit(eventToEmitDict(event));
+        } catch (error) {
+          emitError ??= error;
+        }
+      }
+    );
+    if (emitError != null) {
+      throw emitError;
+    }
+    let result = {};
+    if (resultJson.trim().length > 0) {
+      result = JSON.parse(resultJson);
+    }
+    emit({
+      type: "image_registered",
+      name: effectiveName,
+      image_id: typeof result.id === "string" && result.id || typeof result.templateId === "string" && result.templateId || ""
+    });
+    emit({ type: "done" });
+    return result;
+  } finally {
+    if (tempContextDir != null) {
+      (0, import_node_fs.rmSync)(tempContextDir, { recursive: true, force: true });
+    }
+  }
+}
+async function importSandboxImage(imageReference, options = {}, deps = {}) {
+  const emit = deps.emit ?? (options.verbose ? stderrEmit : noopEmit);
+  if (typeof imageReference !== "string" || imageReference.trim().length === 0) {
+    throw new Error("image reference to import must not be empty");
+  }
+  const reference = imageReference.trim();
+  const context = buildContextFromEnv();
+  const effectiveName = options.registeredName ?? defaultRegisteredNameFromImage(reference);
+  if (effectiveName === DEFAULT_IMAGE_NAME) {
+    console.warn(
+      `Importing sandbox image with the default name "${DEFAULT_IMAGE_NAME}". Pass \`registeredName\` to avoid collisions with other default-named images in this project.`
+    );
+  }
+  const usePat = deps._allowPat === true && context.apiKey == null;
+  const bearerToken = context.apiKey ?? (usePat ? context.personalAccessToken : void 0);
+  if (!bearerToken) {
+    if (context.personalAccessToken && !deps._allowPat) {
+      throw new Error(
+        "Sandbox image SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+      );
+    }
+    throw new Error(
+      deps._allowPat ? "Missing TENSORLAKE_API_KEY or TENSORLAKE_PAT credentials." : "Missing TENSORLAKE_API_KEY credentials."
+    );
+  }
+  emit({
+    type: "status",
+    message: `Importing image '${reference}' as '${effectiveName}'...`
+  });
+  const binding = loadNativeBinding();
+  let emitError;
+  const resultJson = await binding.importSandboxImage(
+    {
+      apiUrl: context.apiUrl,
+      bearerToken,
+      imageReference: reference,
+      registeredName: effectiveName,
+      diskMb: options.diskMb,
+      builderDiskMb: options.builderDiskMb,
+      cpus: options.cpus,
+      memoryMb: options.memoryMb,
+      isPublic: options.isPublic ?? false,
+      organizationId: usePat ? context.organizationId : void 0,
+      projectId: usePat ? context.projectId : void 0,
+      namespace: context.namespace,
+      useScopeHeaders: usePat,
+      userAgent: void 0,
+      dockerCompat: options.dockerCompat ?? false
+    },
+    (event) => {
+      try {
+        emit(eventToEmitDict(event));
+      } catch (error) {
+        emitError ??= error;
+      }
+    }
+  );
+  if (emitError != null) {
+    throw emitError;
+  }
+  let result = {};
+  if (resultJson.trim().length > 0) {
+    result = JSON.parse(resultJson);
+  }
+  emit({
+    type: "image_registered",
+    name: effectiveName,
+    image_id: typeof result.id === "string" && result.id || typeof result.templateId === "string" && result.templateId || ""
+  });
+  emit({ type: "done" });
+  return result;
+}
+async function deleteSandboxImage(imageName) {
+  if (typeof imageName !== "string" || imageName.length === 0) {
+    throw new TypeError("imageName must be a non-empty string");
+  }
+  const context = buildContextFromEnv();
+  const bearerToken = context.apiKey;
+  if (!bearerToken) {
+    if (context.personalAccessToken) {
+      throw new Error(
+        "Sandbox image SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+      );
+    }
+    throw new Error("Missing TENSORLAKE_API_KEY credentials.");
+  }
+  const client = new CloudClient({
+    apiUrl: context.apiUrl,
+    apiKey: bearerToken,
+    namespace: context.namespace
+  });
+  try {
+    await client.deleteSandboxImage(imageName);
+  } finally {
+    client.close();
+  }
+}
+async function findSandboxImageByName(imageName) {
+  if (typeof imageName !== "string" || imageName.length === 0) {
+    throw new TypeError("imageName must be a non-empty string");
+  }
+  const context = buildContextFromEnv();
+  const bearerToken = context.apiKey;
+  if (!bearerToken) {
+    if (context.personalAccessToken) {
+      throw new Error(
+        "Sandbox image SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+      );
+    }
+    throw new Error("Missing TENSORLAKE_API_KEY credentials.");
+  }
+  const client = new CloudClient({
+    apiUrl: context.apiUrl,
+    apiKey: bearerToken,
+    namespace: context.namespace
+  });
+  try {
+    return await client.findSandboxImageByName(imageName);
+  } finally {
+    client.close();
+  }
+}
+async function listSandboxImages() {
+  const context = buildContextFromEnv();
+  const bearerToken = context.apiKey;
+  if (!bearerToken) {
+    if (context.personalAccessToken) {
+      throw new Error(
+        "Sandbox image SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+      );
+    }
+    throw new Error("Missing TENSORLAKE_API_KEY credentials.");
+  }
+  const client = new CloudClient({
+    apiUrl: context.apiUrl,
+    apiKey: bearerToken,
+    namespace: context.namespace
+  });
+  try {
+    return await client.listSandboxImages();
+  } finally {
+    client.close();
+  }
+}
+async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
+  const parsed = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      name: { type: "string", short: "n" },
+      cpus: { type: "string" },
+      memory: { type: "string" },
+      disk_mb: { type: "string" },
+      builder_disk_mb: { type: "string" },
+      docker_compat: { type: "boolean", default: false },
+      public: { type: "boolean", default: false }
+    }
+  });
+  const dockerfilePath = parsed.positionals[0];
+  if (!dockerfilePath) {
+    throw new Error(
+      "Usage: tensorlake-create-sandbox-image <dockerfile_path> [--name NAME] [--cpus N] [--memory MiB] [--disk_mb MiB] [--builder_disk_mb MiB] [--docker_compat] [--public]"
+    );
+  }
+  const cpus = parsed.values.cpus != null ? Number(parsed.values.cpus) : void 0;
+  const memoryMb = parsed.values.memory != null ? Number(parsed.values.memory) : void 0;
+  const diskMb = parsed.values.disk_mb != null ? Number(parsed.values.disk_mb) : void 0;
+  const builderDiskMb = parsed.values.builder_disk_mb != null ? Number(parsed.values.builder_disk_mb) : void 0;
+  if (cpus != null && !Number.isFinite(cpus)) {
+    throw new Error(`Invalid --cpus value: ${parsed.values.cpus}`);
+  }
+  if (memoryMb != null && !Number.isInteger(memoryMb)) {
+    throw new Error(`Invalid --memory value: ${parsed.values.memory}`);
+  }
+  if (diskMb != null && !Number.isInteger(diskMb)) {
+    throw new Error(`Invalid --disk_mb value: ${parsed.values.disk_mb}`);
+  }
+  if (builderDiskMb != null && !Number.isInteger(builderDiskMb)) {
+    throw new Error(
+      `Invalid --builder_disk_mb value: ${parsed.values.builder_disk_mb}`
+    );
+  }
+  await createSandboxImage(
+    dockerfilePath,
+    {
+      registeredName: parsed.values.name,
+      cpus,
+      memoryMb,
+      diskMb,
+      builderDiskMb,
+      dockerCompat: parsed.values.docker_compat,
+      isPublic: parsed.values.public
+    },
+    { emit: ndjsonStdoutEmit, _allowPat: true }
+  );
+}
+async function runImportSandboxImageCli(argv = process.argv.slice(2)) {
+  const parsed = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      name: { type: "string", short: "n" },
+      cpus: { type: "string" },
+      memory: { type: "string" },
+      disk_mb: { type: "string" },
+      builder_disk_mb: { type: "string" },
+      docker_compat: { type: "boolean", default: false },
+      public: { type: "boolean", default: false }
+    }
+  });
+  const imageReference = parsed.positionals[0];
+  if (!imageReference) {
+    throw new Error(
+      "Usage: tensorlake-import-sandbox-image <image_reference> [--name NAME] [--cpus N] [--memory MiB] [--disk_mb MiB] [--builder_disk_mb MiB] [--docker_compat] [--public]"
+    );
+  }
+  const cpus = parsed.values.cpus != null ? Number(parsed.values.cpus) : void 0;
+  const memoryMb = parsed.values.memory != null ? Number(parsed.values.memory) : void 0;
+  const diskMb = parsed.values.disk_mb != null ? Number(parsed.values.disk_mb) : void 0;
+  const builderDiskMb = parsed.values.builder_disk_mb != null ? Number(parsed.values.builder_disk_mb) : void 0;
+  if (cpus != null && !Number.isFinite(cpus)) {
+    throw new Error(`Invalid --cpus value: ${parsed.values.cpus}`);
+  }
+  if (memoryMb != null && !Number.isInteger(memoryMb)) {
+    throw new Error(`Invalid --memory value: ${parsed.values.memory}`);
+  }
+  if (diskMb != null && !Number.isInteger(diskMb)) {
+    throw new Error(`Invalid --disk_mb value: ${parsed.values.disk_mb}`);
+  }
+  if (builderDiskMb != null && !Number.isInteger(builderDiskMb)) {
+    throw new Error(
+      `Invalid --builder_disk_mb value: ${parsed.values.builder_disk_mb}`
+    );
+  }
+  await importSandboxImage(
+    imageReference,
+    {
+      registeredName: parsed.values.name,
+      cpus,
+      memoryMb,
+      diskMb,
+      builderDiskMb,
+      dockerCompat: parsed.values.docker_compat,
+      isPublic: parsed.values.public
+    },
+    { emit: ndjsonStdoutEmit, _allowPat: true }
+  );
+}
+var import_node_path2, import_node_os, import_node_fs, import_node_util, cachedNativeBinding, cachedNativeBindingError, DEFAULT_IMAGE_NAME;
+var init_sandbox_image = __esm({
+  "src/sandbox-image.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path2 = __toESM(require("path"), 1);
+    import_node_os = __toESM(require("os"), 1);
+    import_node_fs = require("fs");
+    import_node_util = require("util");
+    init_cloud_client();
+    init_image();
+    init_native_binding();
+    DEFAULT_IMAGE_NAME = "default";
+  }
+});
+
+// src/image.ts
+function cloneOperation(op) {
+  return {
+    type: op.type,
+    args: [...op.args],
+    options: { ...op.options }
+  };
+}
+function renderOptions(options) {
+  const entries = Object.entries(options);
+  if (entries.length === 0) {
+    return "";
+  }
+  return ` ${entries.map(([key, value]) => `--${key}=${value}`).join(" ")}`;
+}
+function renderBuildOp(op) {
+  const options = renderOptions(op.options);
+  if (op.type === ImageBuildOperationType.ENV) {
+    return `ENV${options} ${op.args[0]}=${JSON.stringify(op.args[1])}`;
+  }
+  return `${op.type}${options} ${op.args.join(" ")}`;
+}
+function dockerfileContent(image) {
+  const lines = image.baseImage == null ? [] : [`FROM ${image.baseImage}`];
+  lines.push(...image.buildOperations.map((op) => renderBuildOp(op)));
+  return lines.join("\n");
+}
+var import_node_crypto2, DEFAULT_IMAGE_NAME2, ImageBuildOperationType, Image;
+var init_image = __esm({
+  "src/image.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto2 = require("crypto");
+    DEFAULT_IMAGE_NAME2 = "default";
+    ImageBuildOperationType = {
+      ADD: "ADD",
+      COPY: "COPY",
+      ENV: "ENV",
+      RUN: "RUN",
+      WORKDIR: "WORKDIR"
+    };
+    Image = class {
+      _id;
+      _name;
+      _tag;
+      _baseImage;
+      _buildOperations;
+      constructor(nameOrOptions = {}, tag = "latest", baseImage = null) {
+        this._id = (0, import_node_crypto2.randomUUID)();
+        this._buildOperations = [];
+        if (typeof nameOrOptions === "string") {
+          this._name = nameOrOptions;
+          this._tag = tag;
+          this._baseImage = baseImage;
+          return;
+        }
+        this._name = nameOrOptions.name ?? DEFAULT_IMAGE_NAME2;
+        this._tag = nameOrOptions.tag ?? "latest";
+        this._baseImage = nameOrOptions.baseImage ?? null;
+      }
+      get name() {
+        return this._name;
+      }
+      get tag() {
+        return this._tag;
+      }
+      get baseImage() {
+        return this._baseImage;
+      }
+      get buildOperations() {
+        return this._buildOperations.map(cloneOperation);
+      }
+      add(src, dest, options = void 0) {
+        return this._addOperation({
+          type: ImageBuildOperationType.ADD,
+          args: [src, dest],
+          options: options == null ? {} : { ...options }
+        });
+      }
+      copy(src, dest, options = void 0) {
+        return this._addOperation({
+          type: ImageBuildOperationType.COPY,
+          args: [src, dest],
+          options: options == null ? {} : { ...options }
+        });
+      }
+      env(key, value) {
+        return this._addOperation({
+          type: ImageBuildOperationType.ENV,
+          args: [key, value],
+          options: {}
+        });
+      }
+      run(commands, options = void 0) {
+        return this._addOperation({
+          type: ImageBuildOperationType.RUN,
+          args: Array.isArray(commands) ? [...commands] : [commands],
+          options: options == null ? {} : { ...options }
+        });
+      }
+      workdir(directory) {
+        return this._addOperation({
+          type: ImageBuildOperationType.WORKDIR,
+          args: [directory],
+          options: {}
+        });
+      }
+      /**
+       * Build this image as a sandbox template and register it.
+       *
+       * Materializes the image in a build sandbox, snapshots the filesystem,
+       * and registers the snapshot as a named sandbox template.
+       */
+      async build(options = {}) {
+        const { createSandboxImage: createSandboxImage2 } = await Promise.resolve().then(() => (init_sandbox_image(), sandbox_image_exports));
+        return createSandboxImage2(this, options);
+      }
+      _addOperation(op) {
+        this._buildOperations.push(op);
+        return this;
+      }
+    };
+  }
+});
+
+// src/applications/index.ts
+var applications_exports = {};
+__export(applications_exports, {
+  DeserializationError: () => DeserializationError,
+  File: () => File,
+  FunctionError: () => FunctionError,
+  Future: () => FunctionFuture,
+  Headers: () => Headers,
+  HttpBody: () => HttpBody,
+  Image: () => Image,
+  LocalRequest: () => LocalRequest,
+  RemoteRequest: () => RemoteRequest,
+  ReplayMismatchError: () => ReplayMismatchError,
+  RequestContext: () => RequestContext,
+  RequestError: () => RequestError,
+  SDKUsageError: () => SDKUsageError,
+  SDK_VERSION: () => SDK_VERSION,
+  SerializationError: () => SerializationError,
+  TensorlakeApplicationError: () => TensorlakeApplicationError,
+  TimeoutError: () => TimeoutError,
+  createApplicationManifest: () => createApplicationManifest,
+  createApplicationManifests: () => createApplicationManifests,
+  createCodeManifest: () => createCodeManifest,
+  decodeDescriptor: () => decodeDescriptor,
+  getApplications: () => getApplications,
+  getFunction: () => getFunction,
+  getFunctions: () => getFunctions,
+  registerApplication: () => registerApplication,
+  registerFunction: () => registerFunction,
+  remoteOptions: () => remoteOptions,
+  retries: () => retries,
+  runLocal: () => runLocal,
+  runRemote: () => runRemote,
+  schema: () => schema
+});
+module.exports = __toCommonJS(applications_exports);
+init_cjs_shims();
+
+// src/applications/function.ts
+init_cjs_shims();
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+
+// 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";
+}
+var ReplayMismatchError = class extends TensorlakeApplicationError {
+  constructor(message = "Function execution diverged from its durable event history") {
+    super(message);
+    this.name = "ReplayMismatchError";
+  }
+};
+
+// src/applications/schema.ts
+init_cjs_shims();
+var import_ajv = __toESM(require("ajv"), 1);
+var import__ = __toESM(require("ajv/dist/2020.js"), 1);
+
+// 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/schema.ts
+var ajvDraft7 = new import_ajv.default({ allErrors: true, strict: false });
+var ajv2020 = new import__.default({ allErrors: true, strict: false });
+function snapshotJSONValue(value, label, ancestors, freeze) {
+  if (value == null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new SDKUsageError(`${label} contains a non-finite number`);
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new SDKUsageError(`${label} contains unsupported ${typeof value}`);
+  }
+  if (ancestors.has(value)) {
+    throw new SDKUsageError(`${label} contains a cycle`);
+  }
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new SDKUsageError(
+      `${label} contains unsupported ${value.constructor?.name ?? "object"}`
+    );
+  }
+  ancestors.add(value);
+  let result;
+  if (Array.isArray(value)) {
+    result = [];
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(value, index)) {
+        throw new SDKUsageError(`${label} contains a sparse array entry at index ${index}`);
+      }
+      result.push(snapshotJSONValue(
+        value[index],
+        `${label}[${index}]`,
+        ancestors,
+        freeze
+      ));
+    }
+  } else {
+    result = Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        snapshotJSONValue(item, `${label}.${key}`, ancestors, freeze)
+      ])
+    );
+  }
+  ancestors.delete(value);
+  return freeze ? Object.freeze(result) : result;
+}
+function snapshotJSONSchema(jsonSchema) {
+  return snapshotJSONValue(
+    jsonSchema,
+    "JSON schema",
+    /* @__PURE__ */ new Set(),
+    true
+  );
+}
+function snapshotDefault(valueSchema, value) {
+  if (valueSchema._file) {
+    if (!isFile(value)) {
+      throw new SDKUsageError("parameter default must be a Tensorlake File");
+    }
+    return new File(new Uint8Array(value.content), value.contentType);
+  }
+  if (valueSchema._httpBody) {
+    if (!isHttpBody(value)) {
+      throw new SDKUsageError("parameter default must be a Tensorlake HttpBody");
+    }
+    return new HttpBody(new Uint8Array(value.content), value.contentType);
+  }
+  return snapshotJSONValue(
+    value,
+    "parameter default",
+    /* @__PURE__ */ new Set(),
+    false
+  );
+}
+function makeSchema(jsonSchema, rawBody) {
+  return Object.freeze({
+    jsonSchema: snapshotJSONSchema(jsonSchema),
+    _file: rawBody === "file",
+    _httpBody: rawBody === "httpBody"
+  });
+}
+function rejectRawBodyComposition(operation, values) {
+  const rawBody = values.find((value) => value._file || value._httpBody);
+  if (rawBody != null) {
+    const factory = rawBody._httpBody ? "httpBody" : "file";
+    const type = rawBody._httpBody ? "HttpBody" : "File";
+    const supportedPosition = rawBody._httpBody ? "as a direct application parameter" : "as a direct parameter or return value";
+    throw new SDKUsageError(
+      `schema.${operation} cannot contain schema.${factory}(); ${type} is only supported ${supportedPosition}`
+    );
+  }
+}
+function parameter(name, valueSchema, options = {}) {
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) {
+    throw new SDKUsageError(`Invalid parameter name '${name}'`);
+  }
+  const hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
+  if (hasDefault) validateWithSchema(valueSchema, options.default, `default for '${name}'`);
+  const defaultSnapshot = hasDefault ? snapshotDefault(valueSchema, options.default) : void 0;
+  return Object.freeze({
+    name,
+    schema: valueSchema,
+    description: options.description,
+    required: options.optional !== true && !hasDefault,
+    hasDefault,
+    // Defaults cross two public boundaries: callers can inspect the registered
+    // definition, and every invocation receives the default when an argument is
+    // omitted. Return a fresh boundary copy so neither path can mutate the
+    // registration snapshot, later invocations, or generated manifests.
+    get defaultValue() {
+      return hasDefault ? snapshotDefault(valueSchema, defaultSnapshot) : void 0;
+    }
+  });
+}
+var schema = {
+  /** Any JSON-serializable value. Useful when strict runtime validation is not needed. */
+  json: () => makeSchema({}),
+  string: (options = {}) => makeSchema({ ...options, type: "string" }),
+  number: (options = {}) => makeSchema({ ...options, type: "number" }),
+  integer: (options = {}) => makeSchema({ ...options, type: "integer" }),
+  boolean: () => makeSchema({ type: "boolean" }),
+  null: () => makeSchema({ type: "null" }),
+  literal: (value) => makeSchema({ const: value }),
+  enum: (values) => makeSchema({ enum: [...values] }),
+  array: (item, options = {}) => {
+    rejectRawBodyComposition("array", [item]);
+    return makeSchema({ ...options, type: "array", items: item.jsonSchema });
+  },
+  tuple: (items) => {
+    rejectRawBodyComposition("tuple", items);
+    return makeSchema({
+      type: "array",
+      prefixItems: items.map((item) => item.jsonSchema),
+      minItems: items.length,
+      maxItems: items.length
+    });
+  },
+  record: (value) => {
+    rejectRawBodyComposition("record", [value]);
+    return makeSchema({
+      type: "object",
+      additionalProperties: value.jsonSchema
+    });
+  },
+  object: (properties) => {
+    rejectRawBodyComposition("object", Object.values(properties));
+    return makeSchema({
+      type: "object",
+      properties: Object.fromEntries(
+        Object.entries(properties).map(([key, item]) => [key, item.jsonSchema])
+      ),
+      required: Object.keys(properties),
+      additionalProperties: false
+    });
+  },
+  union: (...choices) => {
+    rejectRawBodyComposition("union", choices);
+    return makeSchema({ anyOf: choices.map((choice) => choice.jsonSchema) });
+  },
+  nullable: (value) => {
+    rejectRawBodyComposition("nullable", [value]);
+    return makeSchema({ anyOf: [value.jsonSchema, { type: "null" }] });
+  },
+  file: () => makeSchema({ type: "tensorlake_file" }, "file"),
+  httpBody: () => makeSchema({ type: "tensorlake_http_body" }, "httpBody"),
+  custom: (jsonSchema) => makeSchema({ ...jsonSchema }),
+  parameter
+};
+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;
+}
+function parameterJSONSchema(parameter2) {
+  const result = {
+    ...parameter2.schema.jsonSchema,
+    title: parameter2.name,
+    parameter_kind: "POSITIONAL_OR_KEYWORD"
+  };
+  if (parameter2.description != null) result.description = parameter2.description;
+  if (parameter2.hasDefault) {
+    result.default = parameter2.schema._file || parameter2.schema._httpBody ? true : parameter2.defaultValue;
+  }
+  return result;
+}
+
+// src/applications/registry.ts
+init_cjs_shims();
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("tensorlake.applications.registry.v1");
+function registry() {
+  const target = globalThis;
+  target[REGISTRY_KEY] ??= { functions: /* @__PURE__ */ new Map(), applications: /* @__PURE__ */ new Map() };
+  return target[REGISTRY_KEY];
+}
+function registerDefinition(definition, isApplication) {
+  const state = registry();
+  const existing = state.functions.get(definition.name);
+  if (existing != null && existing !== definition) {
+    throw new SDKUsageError(`Multiple Tensorlake functions are named '${definition.name}'`);
+  }
+  state.functions.set(definition.name, definition);
+  if (isApplication) {
+    const app = state.applications.get(definition.name);
+    if (app != null && app !== definition) {
+      throw new SDKUsageError(`Multiple Tensorlake applications are named '${definition.name}'`);
+    }
+    state.applications.set(definition.name, definition);
+  }
+}
+function getFunction(name) {
+  const result = registry().functions.get(name);
+  if (result == null) throw new SDKUsageError(`Tensorlake function '${name}' is not registered`);
+  return result;
+}
+function getFunctions() {
+  return [...registry().functions.values()];
+}
+function getApplications() {
+  return [...registry().applications.values()];
+}
+
+// src/applications/function.ts
+function retries(options) {
+  if (typeof options !== "object" || options == null || !Number.isInteger(options.maxRetries) || options.maxRetries < 0 || options.maxRetries > 10) {
+    throw new SDKUsageError("maxRetries must be an integer between 0 and 10");
+  }
+  return Object.freeze({ ...options });
+}
+var TAIL_CALL_BRAND = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.tail-call.v1"
+);
+var DURABLE_PROMISE_OBSERVER = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.durable-promise-observer.v1"
+);
+var DURABLE_PROMISE_INTERNAL_THEN = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.durable-promise-internal-then.v1"
+);
+var FUNCTION_RUNTIME_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.function-runtime-storage.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"
+);
+var futureCompletionCounter = 0;
+function runtimeStorage() {
+  const target = globalThis;
+  target[FUNCTION_RUNTIME_STORAGE_KEY] ??= new import_node_async_hooks.AsyncLocalStorage();
+  return target[FUNCTION_RUNTIME_STORAGE_KEY];
+}
+function currentFunctionRuntime() {
+  return runtimeStorage().getStore();
+}
+function runWithFunctionRuntime(runtime, callback) {
+  return runtimeStorage().run(runtime, callback);
+}
+var FunctionFuture = class _FunctionFuture {
+  id = (0, import_node_crypto.randomUUID)();
+  definition;
+  args;
+  promise;
+  startDelaySeconds = 0;
+  completionOrder;
+  failed = false;
+  exception;
+  done = false;
+  constructor(definition, args) {
+    this.definition = definition;
+    this.args = args;
+    registerDurableThenable(this);
+  }
+  run() {
+    if (this.promise != null) throw new SDKUsageError(`Future ${this.id} is already running`);
+    const runtime = currentFunctionRuntime();
+    const promise = runtime == null ? executeHandler(this.definition, this.args) : runtime.runFuture(this);
+    registerDurableThenable(promise, this);
+    this.promise = promise;
+    const onfulfilled = (value) => {
+      this.done = true;
+      this.completionOrder = futureCompletionCounter;
+      futureCompletionCounter += 1;
+      return value;
+    };
+    const onrejected = (error) => {
+      this.done = true;
+      this.failed = true;
+      this.exception = error;
+      this.completionOrder = futureCompletionCounter;
+      futureCompletionCounter += 1;
+    };
+    const observer = promise[DURABLE_PROMISE_OBSERVER];
+    if (observer != null) {
+      observer.call(promise, onfulfilled, onrejected);
+    } else {
+      void promise.then(
+        (value) => {
+          onfulfilled(value);
+        },
+        (error) => {
+          onrejected(error);
+        }
+      );
+    }
+    return this;
+  }
+  runLater(delaySeconds) {
+    if (!Number.isFinite(delaySeconds) || delaySeconds < 0) {
+      throw new SDKUsageError("Future delay must be a non-negative finite number");
+    }
+    if (this.promise != null) {
+      throw new SDKUsageError(`Future ${this.id} is already running`);
+    }
+    this.startDelaySeconds = delaySeconds;
+    return this.run();
+  }
+  get delaySeconds() {
+    return this.startDelaySeconds;
+  }
+  result() {
+    if (this.promise == null) this.run();
+    return this.promise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.result().then(onfulfilled, onrejected);
+  }
+  static wait(futures, options = {}) {
+    const completion = _FunctionFuture.waitForFutures(futures, options);
+    return currentFunctionRuntime()?.wrapFutureWait?.(completion) ?? completion;
+  }
+  static async waitForFutures(futures, options) {
+    const returnWhen = options.returnWhen ?? "all_completed";
+    if (!["all_completed", "first_completed", "first_failure"].includes(returnWhen)) {
+      throw new SDKUsageError(`Unsupported Future.wait returnWhen value '${returnWhen}'`);
+    }
+    if (options.timeout != null && (!Number.isFinite(options.timeout) || options.timeout < 0)) {
+      throw new SDKUsageError("Future.wait timeout must be a non-negative finite number");
+    }
+    futures.forEach((future) => {
+      if (future.promise == null) future.run();
+    });
+    const alreadyDone = futures.filter((future) => future.done);
+    if (alreadyDone.length > 0 && (returnWhen === "first_completed" || returnWhen === "first_failure" && alreadyDone.some((future) => future.failed))) {
+      return {
+        done: alreadyDone,
+        notDone: futures.filter((future) => !future.done)
+      };
+    }
+    const pending = futures.filter((future) => !future.done);
+    if (pending.length === 0) {
+      return { done: [...futures], notDone: [] };
+    }
+    let wait;
+    if (returnWhen === "all_completed") {
+      wait = internalPromiseAll(
+        pending.map((future) => internalDurableThen(
+          future.result(),
+          () => void 0,
+          () => void 0
+        ))
+      ).then(() => ({ kind: "all_completed" }));
+    } else if (returnWhen === "first_completed") {
+      wait = internalPromiseRace(
+        pending.map((future) => internalDurableThen(
+          future.result(),
+          () => ({ kind: "cutoff", future }),
+          () => ({ kind: "cutoff", future })
+        ))
+      );
+    } else {
+      wait = new Promise((resolve) => {
+        let remaining = pending.length;
+        for (const future of pending) {
+          void internalDurableThen(
+            future.result(),
+            () => {
+              remaining -= 1;
+              if (remaining === 0) resolve({ kind: "all_completed" });
+            },
+            () => resolve({ kind: "cutoff", future })
+          );
+        }
+      });
+    }
+    const outcome = await waitUntilOrTimeout(wait, options.timeout);
+    if (outcome.kind === "cutoff") {
+      const completionCutoff = outcome.future.completionOrder;
+      if (completionCutoff == null) {
+        throw new SDKUsageError("Future.wait winner has no completion order");
+      }
+      const doneSet = new Set(alreadyDone);
+      for (const future of pending) {
+        if (future.done && future.completionOrder != null && future.completionOrder <= completionCutoff) {
+          doneSet.add(future);
+        }
+      }
+      return {
+        done: futures.filter((future) => doneSet.has(future)),
+        notDone: futures.filter((future) => !doneSet.has(future))
+      };
+    }
+    return {
+      done: futures.filter((future) => future.done),
+      notDone: futures.filter((future) => !future.done)
+    };
+  }
+};
+async function waitUntilOrTimeout(promise, timeoutSeconds) {
+  if (timeoutSeconds == null) {
+    return promise;
+  }
+  let timer;
+  try {
+    return await internalPromiseRace([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutSeconds * 1e3);
+      })
+    ]);
+  } finally {
+    if (timer != null) clearTimeout(timer);
+  }
+}
+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 registerDurableThenable(value, source) {
+  const registry2 = durableThenableRegistry();
+  const metadata = source == null ? registry2.get(value)?.metadata ?? newDurableThenableMetadata() : registry2.get(source)?.metadata ?? newDurableThenableMetadata();
+  registry2.set(value, { metadata });
+  if (source != null && !registry2.has(source)) registry2.set(source, { metadata });
+  return value;
+}
+function internalDurableThen(promise, onfulfilled, onrejected) {
+  const internalThen = promise[DURABLE_PROMISE_INTERNAL_THEN];
+  if (internalThen != null) {
+    return internalThen.call(
+      promise,
+      onfulfilled,
+      onrejected
+    );
+  }
+  return promise.then(onfulfilled, onrejected);
+}
+function internalAwaitable(value) {
+  if ((typeof value === "object" || typeof value === "function") && value != null) {
+    const internalThen = value[DURABLE_PROMISE_INTERNAL_THEN];
+    if (internalThen != null) {
+      return internalThen.call(
+        value,
+        (resolved) => resolved,
+        (error) => {
+          throw error;
+        }
+      );
+    }
+  }
+  return Promise.resolve(value);
+}
+async function resolveAwaitableIterable(items) {
+  const iterable = await internalAwaitable(items);
+  return internalPromiseAll([...iterable].map((item) => internalAwaitable(item)));
+}
+function wrapDurableAggregate(completion) {
+  return currentFunctionRuntime()?.wrapFutureWait?.(completion) ?? completion;
+}
+function runInternalPromiseAggregate(callback) {
+  const target = globalThis;
+  target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] = (target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] ?? 0) + 1;
+  try {
+    return callback();
+  } finally {
+    const remaining = (target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] ?? 1) - 1;
+    if (remaining === 0) delete target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY];
+    else target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] = remaining;
+  }
+}
+function internalPromiseAll(values) {
+  return runInternalPromiseAggregate(() => Promise.all(values));
+}
+function internalPromiseRace(values) {
+  return runInternalPromiseAggregate(() => Promise.race(values));
+}
+function normalizeOptions(options) {
+  validateGPUOption(options.gpu);
+  if (options.secrets != null && !Array.isArray(options.secrets)) {
+    throw new SDKUsageError("secrets must be an array of non-empty strings");
+  }
+  const normalizedRetries = options.retries == null ? void 0 : retries(options.retries);
+  const result = {
+    description: options.description ?? "",
+    cpu: options.cpu ?? 1,
+    memory: options.memory ?? 1,
+    ephemeralDisk: options.ephemeralDisk ?? 10,
+    gpu: Array.isArray(options.gpu) ? [...options.gpu] : options.gpu ?? null,
+    timeout: options.timeout ?? 300,
+    image: options.image,
+    secrets: [...options.secrets ?? []],
+    retries: normalizedRetries,
+    region: options.region,
+    warmContainers: options.warmContainers,
+    minContainers: options.minContainers,
+    maxContainers: options.maxContainers
+  };
+  if (!Number.isFinite(result.cpu) || result.cpu <= 0) throw new SDKUsageError("cpu must be greater than zero");
+  if (!Number.isFinite(result.memory) || result.memory <= 0) throw new SDKUsageError("memory must be greater than zero");
+  if (!Number.isFinite(result.ephemeralDisk) || result.ephemeralDisk <= 0) throw new SDKUsageError("ephemeralDisk must be greater than zero");
+  if (!Number.isInteger(result.timeout) || result.timeout <= 0 || result.timeout > 86400) {
+    throw new SDKUsageError("timeout must be an integer between 1 and 86400 seconds");
+  }
+  for (const [label, value] of [
+    ["warmContainers", result.warmContainers],
+    ["minContainers", result.minContainers],
+    ["maxContainers", result.maxContainers]
+  ]) {
+    if (value != null && (!Number.isInteger(value) || value < 0)) {
+      throw new SDKUsageError(`${label} must be a non-negative integer`);
+    }
+  }
+  if (result.minContainers != null && result.maxContainers != null && result.minContainers > result.maxContainers) {
+    throw new SDKUsageError("minContainers cannot exceed maxContainers");
+  }
+  if (result.warmContainers != null && result.maxContainers != null && result.warmContainers > result.maxContainers) {
+    throw new SDKUsageError("warmContainers cannot exceed maxContainers");
+  }
+  if (result.region != null && !["us-east-1", "eu-west-1"].includes(result.region)) {
+    throw new SDKUsageError(`Unsupported region '${result.region}'`);
+  }
+  if (result.secrets.some((secret) => typeof secret !== "string" || secret.length === 0)) {
+    throw new SDKUsageError("secrets must contain non-empty strings");
+  }
+  return result;
+}
+function validateGPUOption(value) {
+  if (value == null) return;
+  const values = Array.isArray(value) ? value : [value];
+  for (const setting of values) {
+    if (typeof setting !== "string") {
+      throw new SDKUsageError("gpu must be a GPU model or an array of GPU models");
+    }
+    const [model, countText, ...extra] = setting.split(":");
+    const count = countText == null ? 1 : Number(countText);
+    if (!model || extra.length > 0 || !Number.isInteger(count) || count <= 0 || countText != null && String(count) !== countText) {
+      throw new SDKUsageError(`Invalid GPU setting '${setting}'`);
+    }
+  }
+}
+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((parameter2, index) => {
+    if (index >= args.length || args[index] === void 0) {
+      if (parameter2.hasDefault) args[index] = parameter2.defaultValue;
+      else if (parameter2.required) throw new SDKUsageError(`${definition.name} is missing argument '${parameter2.name}'`);
+      return;
+    }
+    validateWithSchema(parameter2.schema, args[index], `${definition.name}.${parameter2.name}`);
+  });
+  return args;
+}
+async function executeHandler(definition, suppliedArgs) {
+  const output = await executeHandlerResult(definition, suppliedArgs);
+  if (isTailCall(output)) {
+    const runtime = currentFunctionRuntime();
+    if (runtime == null) return executeHandler(output.definition, output.args);
+    return runtime.invoke(output.definition, output.args);
+  }
+  return output;
+}
+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);
+}
+function createRegisteredFunction(definition) {
+  const callable = ((...args) => {
+    const runtime = currentFunctionRuntime();
+    return runtime == null ? executeHandler(definition, args) : runtime.invoke(definition, args);
+  });
+  Object.defineProperties(callable, {
+    definition: { value: definition, enumerable: true },
+    future: { value: (...args) => new FunctionFuture(definition, args) },
+    map: {
+      value: (items) => {
+        const completion = (async () => {
+          const resolvedItems = await resolveAwaitableIterable(items);
+          return internalPromiseAll(
+            resolvedItems.map(
+              (item) => internalAwaitable(callable(...[item]))
+            )
+          );
+        })();
+        return wrapDurableAggregate(completion);
+      }
+    },
+    reduce: {
+      value: (items, ...initialValues) => {
+        const completion = (async () => {
+          let values = await resolveAwaitableIterable(items);
+          const hasInitial = initialValues.length > 0;
+          let initial = initialValues[0];
+          const runtime = currentFunctionRuntime();
+          if (runtime != null) {
+            return internalAwaitable(
+              runtime.reduce(definition, values, initial, hasInitial)
+            );
+          }
+          if (!hasInitial) {
+            if (values.length === 0) {
+              throw new SDKUsageError("reduce of empty iterable with no initial value");
+            }
+            [initial, ...values] = values;
+          }
+          let accumulator = initial;
+          for (const item of values) {
+            accumulator = await internalAwaitable(
+              callable(...[accumulator, item])
+            );
+          }
+          return accumulator;
+        })();
+        return wrapDurableAggregate(completion);
+      }
+    },
+    tailCall: {
+      value: (...args) => ({
+        [TAIL_CALL_BRAND]: true,
+        kind: "tensorlake-tail-call",
+        definition,
+        args
+      })
+    }
+  });
+  return callable;
+}
+function register(handler, options, application) {
+  const name = options.name ?? handler.name;
+  if (!name) throw new SDKUsageError("Anonymous Tensorlake handlers require an explicit name");
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) throw new SDKUsageError(`Invalid Tensorlake function name '${name}'`);
+  let applicationRetries;
+  if (application) {
+    const appOptions = options;
+    applicationRetries = retries(appOptions.applicationRetries ?? { maxRetries: 0 });
+    if (appOptions.allow != null && (!Array.isArray(appOptions.allow) || appOptions.allow.some(
+      (capability) => capability !== "unauthenticated_requests"
+    ))) {
+      throw new SDKUsageError(
+        "Application allow must contain only 'unauthenticated_requests'"
+      );
+    }
+    const tags = appOptions.tags;
+    const tagsPrototype = tags == null || typeof tags !== "object" ? void 0 : Object.getPrototypeOf(tags);
+    if (tags != null && (typeof tags !== "object" || Array.isArray(tags) || tagsPrototype !== Object.prototype && tagsPrototype !== null || Reflect.ownKeys(tags).some(
+      (key) => typeof key !== "string" || !key || typeof tags[key] !== "string"
+    ))) {
+      throw new SDKUsageError("Application tags require non-empty string keys and string values");
+    }
+  }
+  if (!Array.isArray(options.parameters)) {
+    throw new SDKUsageError("Tensorlake registration parameters must be an array");
+  }
+  if (typeof options.returns !== "object" || options.returns == null || typeof options.returns.jsonSchema !== "object" || options.returns.jsonSchema == null) {
+    throw new SDKUsageError("Tensorlake registration returns must be a schema");
+  }
+  const parameterNames = /* @__PURE__ */ new Set();
+  for (const parameter2 of options.parameters) {
+    if (typeof parameter2 !== "object" || parameter2 == null || typeof parameter2.name !== "string" || typeof parameter2.schema !== "object" || parameter2.schema == null || typeof parameter2.schema.jsonSchema !== "object" || parameter2.schema.jsonSchema == null || typeof parameter2.required !== "boolean" || typeof parameter2.hasDefault !== "boolean") {
+      throw new SDKUsageError(
+        "Tensorlake registration parameters must be created with schema.parameter()"
+      );
+    }
+    if (parameterNames.has(parameter2.name)) {
+      throw new SDKUsageError(`Duplicate Tensorlake parameter name '${parameter2.name}'`);
+    }
+    parameterNames.add(parameter2.name);
+  }
+  const httpBodyParameter = options.parameters.find(
+    (parameter2) => parameter2.schema._httpBody
+  );
+  if (httpBodyParameter != null && !application) {
+    throw new SDKUsageError(
+      "HttpBody is only supported for application parameters"
+    );
+  }
+  if (options.returns._httpBody) {
+    throw new SDKUsageError(
+      "HttpBody is only supported for application parameters; use schema.file() or a JSON-compatible return schema instead"
+    );
+  }
+  const definition = {
+    name,
+    handler,
+    parameters: [...options.parameters],
+    returns: options.returns,
+    options: normalizeOptions(options),
+    application: application ? {
+      tags: { ...options.tags ?? {} },
+      retries: applicationRetries,
+      allow: [...options.allow ?? []],
+      version: (0, import_node_crypto.randomUUID)().replaceAll("-", "")
+    } : void 0
+  };
+  registerDefinition(definition, application);
+  return createRegisteredFunction(definition);
+}
+function hasExplicitSchemas(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const hasParameters = Object.prototype.hasOwnProperty.call(value, "parameters");
+  const hasReturns = Object.prototype.hasOwnProperty.call(value, "returns");
+  if (hasParameters !== hasReturns) {
+    throw new SDKUsageError("Tensorlake registrations must specify both parameters and returns");
+  }
+  return hasParameters;
+}
+function skipJavaScriptLiteral(source, start) {
+  const quote = source[start];
+  let escaped = false;
+  for (let index = start + 1; index < source.length; index += 1) {
+    const character = source[index];
+    if (escaped) {
+      escaped = false;
+    } else if (character === "\\") {
+      escaped = true;
+    } else if (character === quote) {
+      return index;
+    }
+  }
+  return source.length - 1;
+}
+function skipJavaScriptComment(source, start) {
+  if (source[start] !== "/") return void 0;
+  if (source[start + 1] === "/") {
+    const newline = source.indexOf("\n", start + 2);
+    return newline < 0 ? source.length - 1 : newline;
+  }
+  if (source[start + 1] === "*") {
+    const end = source.indexOf("*/", start + 2);
+    return end < 0 ? source.length - 1 : end + 1;
+  }
+  return void 0;
+}
+function skipJavaScriptTrivia(source, start) {
+  let index = start;
+  while (index < source.length) {
+    while (index < source.length && /\s/.test(source[index])) index += 1;
+    const commentEnd = skipJavaScriptComment(source, index);
+    if (commentEnd == null) break;
+    index = commentEnd + 1;
+  }
+  return index;
+}
+var REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
+  "await",
+  "case",
+  "delete",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "throw",
+  "typeof",
+  "void",
+  "yield"
+]);
+function regexLiteralStartsAt(source, start) {
+  let expectsExpression = true;
+  for (let index = 0; index < start; index += 1) {
+    const character = source[index];
+    if (/\s/.test(character)) continue;
+    if (character === '"' || character === "'" || character === "`") {
+      index = skipJavaScriptLiteral(source, index);
+      expectsExpression = false;
+      continue;
+    }
+    const commentEnd = skipJavaScriptComment(source, index);
+    if (commentEnd != null) {
+      index = commentEnd;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(character)) {
+      let tokenEnd = index + 1;
+      while (tokenEnd < start && /[A-Za-z0-9_$]/.test(source[tokenEnd])) tokenEnd += 1;
+      expectsExpression = REGEX_PREFIX_KEYWORDS.has(source.slice(index, tokenEnd));
+      index = tokenEnd - 1;
+      continue;
+    }
+    if (/[0-9]/.test(character) || character === "." && /[0-9]/.test(source[index + 1])) {
+      while (index + 1 < start && /[A-Za-z0-9_.]/.test(source[index + 1])) index += 1;
+      expectsExpression = false;
+      continue;
+    }
+    if (character === "/") {
+      if (expectsExpression) {
+        index = skipJavaScriptRegex(source, index);
+        expectsExpression = false;
+      } else {
+        if (source[index + 1] === "=") index += 1;
+        expectsExpression = true;
+      }
+      continue;
+    }
+    if (character === ")" || character === "]" || character === "}") {
+      expectsExpression = false;
+      continue;
+    }
+    if (character === ".") {
+      if (source.slice(index, index + 3) === "...") {
+        index += 2;
+        expectsExpression = true;
+      } else {
+        expectsExpression = false;
+      }
+      continue;
+    }
+    if ((character === "+" || character === "-") && source[index + 1] === character) {
+      index += 1;
+      continue;
+    }
+    expectsExpression = true;
+  }
+  return expectsExpression;
+}
+function skipJavaScriptRegex(source, start) {
+  let escaped = false;
+  let characterClass = false;
+  for (let index = start + 1; index < source.length; index += 1) {
+    const character = source[index];
+    if (escaped) {
+      escaped = false;
+    } else if (character === "\\") {
+      escaped = true;
+    } else if (character === "[") {
+      characterClass = true;
+    } else if (character === "]") {
+      characterClass = false;
+    } else if (character === "/" && !characterClass) {
+      while (index + 1 < source.length && /[A-Za-z]/.test(source[index + 1])) index += 1;
+      return index;
+    }
+  }
+  return source.length - 1;
+}
+function skipJavaScriptValue(source, index) {
+  const character = source[index];
+  if (character === '"' || character === "'" || character === "`") {
+    return skipJavaScriptLiteral(source, index);
+  }
+  const commentEnd = skipJavaScriptComment(source, index);
+  if (commentEnd != null) return commentEnd;
+  if (character === "/" && regexLiteralStartsAt(source, index)) {
+    return skipJavaScriptRegex(source, index);
+  }
+  return void 0;
+}
+function findTopLevelArrow(source) {
+  let parentheses = 0;
+  let brackets = 0;
+  let braces = 0;
+  for (let index = 0; index < source.length - 1; index += 1) {
+    const character = source[index];
+    const valueEnd = skipJavaScriptValue(source, index);
+    if (valueEnd != null) {
+      index = valueEnd;
+      continue;
+    }
+    if (character === "(") parentheses += 1;
+    else if (character === ")") parentheses -= 1;
+    else if (character === "[") brackets += 1;
+    else if (character === "]") brackets -= 1;
+    else if (character === "{") {
+      if (parentheses === 0 && brackets === 0 && braces === 0) return -1;
+      braces += 1;
+    } else if (character === "}") braces -= 1;
+    else if (character === "=" && source[index + 1] === ">" && parentheses === 0 && brackets === 0 && braces === 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findClosingParenthesis(source, open) {
+  let depth = 0;
+  for (let index = open; index < source.length; index += 1) {
+    const character = source[index];
+    const valueEnd = skipJavaScriptValue(source, index);
+    if (valueEnd != null) {
+      index = valueEnd;
+      continue;
+    }
+    if (character === "(") depth += 1;
+    else if (character === ")" && --depth === 0) return index;
+  }
+  return -1;
+}
+function findOpeningParenthesis(source) {
+  for (let index = 0; index < source.length; index += 1) {
+    const valueEnd = skipJavaScriptValue(source, index);
+    if (valueEnd != null) {
+      index = valueEnd;
+      continue;
+    }
+    if (source[index] === "(") return index;
+  }
+  return -1;
+}
+function splitTopLevelParameters(source) {
+  if (source.trim() === "") return [];
+  const result = [];
+  let start = 0;
+  let parentheses = 0;
+  let brackets = 0;
+  let braces = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    const valueEnd = skipJavaScriptValue(source, index);
+    if (valueEnd != null) {
+      index = valueEnd;
+      continue;
+    }
+    if (character === "(") parentheses += 1;
+    else if (character === ")") parentheses -= 1;
+    else if (character === "[") brackets += 1;
+    else if (character === "]") brackets -= 1;
+    else if (character === "{") braces += 1;
+    else if (character === "}") braces -= 1;
+    else if (character === "," && parentheses === 0 && brackets === 0 && braces === 0) {
+      result.push(source.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  const final = source.slice(start).trim();
+  if (final !== "") result.push(final);
+  return result;
+}
+function hasTopLevelDefault(source) {
+  let parentheses = 0;
+  let brackets = 0;
+  let braces = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    const valueEnd = skipJavaScriptValue(source, index);
+    if (valueEnd != null) {
+      index = valueEnd;
+      continue;
+    }
+    if (character === "(") parentheses += 1;
+    else if (character === ")") parentheses -= 1;
+    else if (character === "[") brackets += 1;
+    else if (character === "]") brackets -= 1;
+    else if (character === "{") braces += 1;
+    else if (character === "}") braces -= 1;
+    else if (character === "=" && parentheses === 0 && brackets === 0 && braces === 0) return true;
+  }
+  return false;
+}
+function declaredHandlerParameters(handler) {
+  const source = Function.prototype.toString.call(handler).trim();
+  if (source.includes("[native code]")) {
+    throw new SDKUsageError("Schema-free registration cannot inspect a native or bound handler; specify parameters and returns");
+  }
+  const arrow = findTopLevelArrow(source);
+  if (arrow >= 0) {
+    let header = source.slice(0, arrow).trim();
+    if (header.startsWith("async") && !/[A-Za-z0-9_$]/.test(header["async".length] ?? "")) {
+      header = header.slice(skipJavaScriptTrivia(header, "async".length));
+    }
+    if (!header.startsWith("(")) return [header];
+    const close2 = findClosingParenthesis(header, 0);
+    if (close2 < 0) throw new SDKUsageError("Schema-free registration could not inspect handler parameters");
+    return splitTopLevelParameters(header.slice(1, close2));
+  }
+  const open = findOpeningParenthesis(source);
+  const close = open < 0 ? -1 : findClosingParenthesis(source, open);
+  if (open < 0 || close < 0) {
+    throw new SDKUsageError("Schema-free registration could not inspect handler parameters");
+  }
+  return splitTopLevelParameters(source.slice(open + 1, close));
+}
+function inferredJSONParameters(handler) {
+  const parameters = declaredHandlerParameters(handler);
+  if (parameters.some((parameter2) => {
+    let index = 0;
+    while (index < parameter2.length) {
+      while (index < parameter2.length && /\s/.test(parameter2[index])) index += 1;
+      const commentEnd = skipJavaScriptComment(parameter2, index);
+      if (commentEnd == null) break;
+      index = commentEnd + 1;
+    }
+    return parameter2.slice(index).startsWith("...");
+  })) {
+    throw new SDKUsageError(
+      "Schema-free registration does not support rest parameters; specify explicit parameters and returns"
+    );
+  }
+  return parameters.map((parameter2, index) => schema.parameter(
+    parameters.length === 1 ? "input" : `arg${index}`,
+    schema.json(),
+    hasTopLevelDefault(parameter2) ? { optional: true } : {}
+  ));
+}
+function registerWithDefaults(name, handler, options, application) {
+  return register(
+    handler,
+    {
+      ...options,
+      name,
+      parameters: inferredJSONParameters(handler),
+      returns: schema.json()
+    },
+    application
+  );
+}
+function registerFunction(handlerOrName, handlerOrOptions, options = {}) {
+  if (typeof handlerOrName === "string") {
+    if (typeof handlerOrOptions !== "function") {
+      throw new SDKUsageError("registerFunction(name, handler) requires an async handler");
+    }
+    return registerWithDefaults(
+      handlerOrName,
+      handlerOrOptions,
+      options,
+      false
+    );
+  }
+  if (typeof handlerOrName !== "function") {
+    throw new SDKUsageError("registerFunction requires an async handler");
+  }
+  const handler = handlerOrName;
+  if (typeof handlerOrOptions === "function") {
+    throw new SDKUsageError("registerFunction received an unexpected second handler");
+  }
+  if (hasExplicitSchemas(handlerOrOptions)) {
+    return register(
+      handler,
+      handlerOrOptions,
+      false
+    );
+  }
+  throw new SDKUsageError(
+    "Schema-free functions require an explicit stable name: registerFunction(name, handler)"
+  );
+}
+function registerApplication(handlerOrName, handlerOrOptions, options = {}) {
+  if (typeof handlerOrName === "string") {
+    if (typeof handlerOrOptions !== "function") {
+      throw new SDKUsageError("registerApplication(name, handler) requires an async handler");
+    }
+    return registerWithDefaults(
+      handlerOrName,
+      handlerOrOptions,
+      options,
+      true
+    );
+  }
+  if (typeof handlerOrName !== "function") {
+    throw new SDKUsageError("registerApplication requires an async handler");
+  }
+  const handler = handlerOrName;
+  if (typeof handlerOrOptions === "function") {
+    throw new SDKUsageError("registerApplication received an unexpected second handler");
+  }
+  if (hasExplicitSchemas(handlerOrOptions)) {
+    return register(
+      handler,
+      handlerOrOptions,
+      true
+    );
+  }
+  throw new SDKUsageError(
+    "Schema-free applications require an explicit stable name: registerApplication(name, handler)"
+  );
+}
+
+// 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/index.ts
+init_image();
+init_defaults();
+
+// src/applications/context.ts
+init_cjs_shims();
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/applications/serialization.ts
+init_cjs_shims();
+var import_node_crypto3 = require("crypto");
+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 });
+  }
+}
+function jsonRoundTrip(value) {
+  const serialized = serializeValue(value);
+  if (serialized.encoding !== "json") return value;
+  return deserializeJSON(serialized.data);
+}
+
+// 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_hooks2.AsyncLocalStorage();
+  return target[REQUEST_CONTEXT_STORAGE_KEY];
+}
+var RequestContext = class {
+  static get() {
+    const context = requestContextStorage().getStore();
+    if (context == null) {
+      throw new SDKUsageError("RequestContext.get() can only be called from a running Tensorlake function");
+    }
+    return context;
+  }
+};
+function runWithRequestContext(context, callback) {
+  return requestContextStorage().run(context, callback);
+}
+async function waitWithAbortSignal(value, signal) {
+  if (signal.aborted) throw signal.reason;
+  let onAbort;
+  try {
+    return await Promise.race([
+      value,
+      new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort != null) signal.removeEventListener("abort", onAbort);
+  }
+}
+var MemoryRequestContext = class {
+  constructor(requestId, options = {}) {
+    this.requestId = requestId;
+    this.headers = new Headers(options.headers);
+    this.signal = options.signal ?? new AbortController().signal;
+  }
+  headers;
+  signal;
+  values = /* @__PURE__ */ new Map();
+  counters = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  lastProgress;
+  state = {
+    set: async (key, value) => {
+      validateRequestStateKey(key);
+      this.values.set(key, serializeRequestStateValue(value).slice());
+    },
+    get: async (key, defaultValue) => {
+      validateRequestStateKey(key);
+      const value = this.values.get(key);
+      return value == null ? defaultValue : deserializeJSON(value);
+    }
+  };
+  metrics = {
+    counter: async (name, value = 1) => {
+      validateCounterMetric(name, value);
+      this.counters.set(name, (this.counters.get(name) ?? 0) + value);
+    },
+    timer: async (name, value) => {
+      validateTimerMetric(name, value);
+      const values = this.timers.get(name) ?? [];
+      values.push(value);
+      this.timers.set(name, values);
+    }
+  };
+  progress = {
+    update: async (current, total, options) => {
+      validateProgressUpdate(current, total, options);
+      this.lastProgress = { current, total, options };
+    }
+  };
+};
+
+// src/applications/local.ts
+init_cjs_shims();
+var import_node_crypto4 = require("crypto");
+var LocalRequest = class {
+  constructor(id, value, cancelRequest) {
+    this.id = id;
+    this.value = value;
+    this.cancelRequest = cancelRequest;
+  }
+  output() {
+    return this.value;
+  }
+  cancel(reason) {
+    this.cancelRequest(reason);
+  }
+};
+function boundaryCopy(value) {
+  if (isFile(value)) {
+    return new File(new Uint8Array(value.content), value.contentType);
+  }
+  if (isHttpBody(value)) {
+    return new HttpBody(new Uint8Array(value.content), value.contentType);
+  }
+  return jsonRoundTrip(value);
+}
+var LocalRuntime = class {
+  requestContext;
+  application;
+  controller = new AbortController();
+  constructor(application, requestId = `local-${(0, import_node_crypto4.randomUUID)()}`) {
+    this.application = application;
+    this.requestContext = new MemoryRequestContext(requestId, {
+      signal: this.controller.signal
+    });
+  }
+  cancel(reason = new FunctionError("Local request was cancelled")) {
+    if (!this.controller.signal.aborted) this.controller.abort(reason);
+  }
+  invoke(definition, args) {
+    return this.execute(definition, args);
+  }
+  async runFuture(future) {
+    if (future.delaySeconds > 0) {
+      let timer;
+      try {
+        await waitWithAbortSignal(
+          new Promise((resolve) => {
+            timer = setTimeout(resolve, future.delaySeconds * 1e3);
+          }),
+          this.requestContext.signal
+        );
+      } finally {
+        if (timer != null) clearTimeout(timer);
+      }
+    }
+    return this.execute(future.definition, future.args);
+  }
+  async reduce(definition, items, initial, hasInitial) {
+    let reduceItems = items;
+    let reduceInitial = initial;
+    if (!hasInitial) {
+      if (items.length === 0) {
+        throw new SDKUsageError("reduce of empty iterable with no initial value");
+      }
+      [reduceInitial, ...reduceItems] = items;
+    }
+    let accumulator = boundaryCopy(reduceInitial);
+    for (const item of reduceItems) {
+      accumulator = await this.execute(definition, [accumulator, item]);
+    }
+    return accumulator;
+  }
+  async execute(definition, rawArgs) {
+    const originalArgs = rawArgs.map(boundaryCopy);
+    const maxRetries = definition.options.retries?.maxRetries ?? this.application.application?.retries.maxRetries ?? 0;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      const args = originalArgs.map(boundaryCopy);
+      try {
+        const value = await runWithFunctionRuntime(
+          this,
+          () => runWithRequestContext(
+            this.requestContext,
+            () => waitWithAbortSignal(
+              this.withTimeout(executeHandler(definition, args), definition.options.timeout),
+              this.controller.signal
+            )
+          )
+        );
+        return boundaryCopy(value);
+      } catch (error) {
+        if (isRequestError(error)) throw error;
+        if (this.controller.signal.aborted) throw this.controller.signal.reason;
+        lastError = error;
+      }
+    }
+    throw lastError instanceof Error ? new FunctionError(`${definition.name} failed: ${lastError.message}`, { cause: lastError }) : new FunctionError(`${definition.name} failed`);
+  }
+  async withTimeout(promise, timeoutSeconds) {
+    let timer;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new TimeoutError()),
+            timeoutSeconds * 1e3
+          );
+        })
+      ]);
+    } finally {
+      if (timer != null) clearTimeout(timer);
+    }
+  }
+};
+async function runLocal(application, ...args) {
+  if (application.definition.application == null) {
+    throw new SDKUsageError(`${application.definition.name} is not a Tensorlake application`);
+  }
+  const runtime = new LocalRuntime(application.definition);
+  const output = runtime.invoke(application.definition, args);
+  return new LocalRequest(
+    runtime.requestContext.requestId,
+    output,
+    (reason) => runtime.cancel(reason)
+  );
+}
+
+// src/applications/remote.ts
+init_cjs_shims();
+
+// src/api-client.ts
+init_cjs_shims();
+init_cloud_client();
+
+// src/filesystem.ts
+init_cjs_shims();
+var import_node_crypto5 = require("crypto");
+
+// src/mount-cli.ts
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+var import_node_util2 = require("util");
+
+// src/filesystem-models.ts
+init_cjs_shims();
+var GIT_MODE_DIR = 16384;
+var GIT_MODE_SYMLINK = 40960;
+function trimSlashes(path3) {
+  let start = 0;
+  let end = path3.length;
+  while (start < end && path3.charCodeAt(start) === 47) start += 1;
+  while (end > start && path3.charCodeAt(end - 1) === 47) end -= 1;
+  return path3.slice(start, end);
+}
+function fileEntryFromWire(entry, dirPath) {
+  const mode = entry.mode ?? 33188;
+  const prefix = trimSlashes(dirPath);
+  return {
+    name: entry.name,
+    path: prefix ? `${prefix}/${entry.name}` : entry.name,
+    contentId: entry.oid ?? "",
+    kind: mode === GIT_MODE_DIR ? "directory" : mode === GIT_MODE_SYMLINK ? "symlink" : "file",
+    executable: mode === 33261,
+    size: entry.size ?? null,
+    isDir: mode === GIT_MODE_DIR,
+    isSymlink: mode === GIT_MODE_SYMLINK
+  };
+}
+function mountStatusFromRaw(raw, localPath) {
+  const mounted = "mounted" in raw ? Boolean(raw.mounted) : "active" in raw ? Boolean(raw.active) : true;
+  const path3 = String(raw.path || raw.mount_path || localPath || "");
+  const filesystem = raw.filesystem || raw.file_system || raw.repository || null;
+  return { path: path3, filesystem, mounted, raw };
+}
+var FilesystemError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FilesystemError";
+  }
+};
+var FilesystemNotFoundError = class extends FilesystemError {
+  filesystemName;
+  constructor(name) {
+    super(`Filesystem not found: ${name}`);
+    this.name = "FilesystemNotFoundError";
+    this.filesystemName = name;
+  }
+};
+var FileNotFoundInFilesystemError = class extends FilesystemError {
+  filesystem;
+  path;
+  constructor(filesystem, path3) {
+    super(`File not found in filesystem ${filesystem}: ${path3}`);
+    this.name = "FileNotFoundInFilesystemError";
+    this.filesystem = filesystem;
+    this.path = path3;
+  }
+};
+var FilesystemAPIError = class extends FilesystemError {
+  statusCode;
+  constructor(statusCode, message) {
+    super(`API error (status ${statusCode}): ${message}`);
+    this.name = "FilesystemAPIError";
+    this.statusCode = statusCode;
+  }
+};
+var MountError = class extends FilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "MountError";
+  }
+};
+var ReadOnlyMountNotSupportedError = class extends MountError {
+  constructor() {
+    super(
+      "read-only local mounts are not supported: `tl fs mount` has no --ro mode. Mount the filesystem into a sandbox read-only instead (readOnly: true / `tl sbx create -f NAME:PATH:ro`), or use `tl git mount --ro` for repositories."
+    );
+    this.name = "ReadOnlyMountNotSupportedError";
+  }
+};
+var CliNotFoundError = class extends MountError {
+  constructor(detail, command = "fs") {
+    super(
+      `Mount operations require the Tensorlake CLI (\`tl\`) with \`tl ${command}\` support: ${detail}. Install or upgrade it with: curl -fsSL https://tensorlake.ai/install.sh | sh`
+    );
+    this.name = "CliNotFoundError";
+  }
+};
+
+// src/mount-cli.ts
+var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process.execFile);
+var MountCli = class {
+  constructor(command, envOverrides) {
+    this.command = command;
+    this.envOverrides = envOverrides;
+  }
+  binary = null;
+  async findCli() {
+    const candidates = [];
+    if (process.env.TENSORLAKE_CLI) candidates.push(process.env.TENSORLAKE_CLI);
+    candidates.push("tl");
+    const installed = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".tensorlake", "bin", "tl");
+    try {
+      (0, import_node_fs2.accessSync)(installed, import_node_fs2.constants.F_OK);
+      candidates.push(installed);
+    } catch {
+    }
+    const support = this.command === "git" ? "git mount" : "fs";
+    const probe = this.command === "git" ? ["git", "mount", "--help"] : ["fs", "--help"];
+    let unsupported = null;
+    for (const candidate of candidates) {
+      try {
+        await execFileAsync(candidate, probe, { timeout: 15e3 });
+        return candidate;
+      } catch (error) {
+        if (error.code !== "ENOENT") unsupported = candidate;
+      }
+    }
+    throw new CliNotFoundError(
+      unsupported ? `\`tl\` at ${unsupported} does not support \`tl ${support}\` (upgrade required)` : "`tl` was not found on PATH",
+      support
+    );
+  }
+  async run(args, timeoutMs = 3e5) {
+    if (this.binary === null) this.binary = await this.findCli();
+    try {
+      const { stdout } = await execFileAsync(this.binary, [this.command, ...args], {
+        timeout: timeoutMs,
+        env: { ...process.env, ...this.envOverrides },
+        maxBuffer: 16 * 1024 * 1024
+      });
+      return stdout;
+    } catch (error) {
+      const failure = error;
+      if (failure.killed) {
+        throw new MountError(`\`tl ${this.command} ${args[0]}\` timed out after ${timeoutMs}ms`);
+      }
+      const detail = (failure.stderr || failure.stdout || String(error)).trim();
+      throw new MountError(`\`tl ${this.command} ${args.join(" ")}\` failed: ${detail}`);
+    }
+  }
+};
+
+// src/filesystem.ts
+init_defaults();
+init_native_sandbox();
+init_sandbox_image();
+var FILESYSTEM_REPO_KIND = "filesystem";
+function translateNativeError2(error, notFound) {
+  const message = error instanceof Error ? error.message : String(error);
+  let payload;
+  try {
+    payload = JSON.parse(message);
+  } catch {
+    return error instanceof Error ? error : new FilesystemError(message);
+  }
+  if (!payload || typeof payload.category !== "string") {
+    return error instanceof Error ? error : new FilesystemError(message);
+  }
+  const detail = typeof payload.message === "string" ? payload.message : message;
+  if (payload.category === "connection") {
+    return new FilesystemError(detail);
+  }
+  if (payload.status === 404 && notFound !== void 0) {
+    return notFound;
+  }
+  if (typeof payload.status === "number") {
+    return new FilesystemAPIError(payload.status, detail);
+  }
+  return new FilesystemError(detail);
+}
+async function callNative2(fn, notFound) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw translateNativeError2(error, notFound);
+  }
+}
+var FsCli = class extends MountCli {
+  constructor(envOverrides) {
+    super("fs", envOverrides);
+  }
+  // Flags always precede a `--` end-of-options separator so caller-supplied
+  // names/paths can never be parsed as CLI flags (e.g. a path literally
+  // named "--discard" must stay a path, not become the destructive flag).
+  async mount(filesystem, localPath, readonly) {
+    if (readonly) {
+      throw new ReadOnlyMountNotSupportedError();
+    }
+    await this.run(["mount", "--", filesystem, localPath]);
+  }
+  async unmount(localPath, discard) {
+    const args = ["unmount"];
+    if (discard) args.push("--discard");
+    args.push("--", localPath);
+    await this.run(args);
+  }
+  async snapshot(localPath, message) {
+    const args = ["snapshot"];
+    if (message) args.push(`--message=${message}`);
+    args.push("--", localPath);
+    await this.run(args);
+  }
+  async status(localPath) {
+    const args = ["status", "--json"];
+    if (localPath) args.push("--", localPath);
+    const output = await this.run(args, 6e4);
+    try {
+      const payload = JSON.parse(output);
+      return typeof payload === "object" && payload !== null ? payload : { status: payload };
+    } catch {
+      throw new MountError(
+        `\`tl fs status --json\` returned invalid JSON: ${output.slice(0, 200)}`
+      );
+    }
+  }
+};
+var FilesystemClient = class {
+  native;
+  cli;
+  /**
+   * The SDK authenticates with `apiKey` or `TENSORLAKE_API_KEY`. Project scope is selected by
+   * ingress from the API key; no organization/project lookup is performed. Organization/project
+   * options are retained only for the separately installed `tl` CLI used by local mounts.
+   */
+  constructor(options = {}) {
+    const context = buildContextFromEnv();
+    const token = options.apiKey ?? context.apiKey;
+    if (!token) {
+      if (context.personalAccessToken) {
+        throw new FilesystemError(
+          "Filesystem SDKs require TENSORLAKE_API_KEY. Personal access tokens are CLI-only."
+        );
+      }
+      throw new FilesystemError(
+        "Missing TENSORLAKE_API_KEY credentials."
+      );
+    }
+    const organizationId = options.organizationId ?? context.organizationId;
+    const projectId = options.projectId ?? context.projectId;
+    if (options.nativeClient) {
+      this.native = options.nativeClient;
+    } else {
+      const binding = loadNativeSandboxBinding();
+      if (typeof binding.NativeRepositoryClient !== "function") {
+        throw new FilesystemError(
+          "native binding does not export the repository client; rebuild with 'npm run build:native'"
+        );
+      }
+      this.native = new binding.NativeRepositoryClient(
+        options.apiUrl ?? context.apiUrl,
+        token,
+        null,
+        null,
+        `tensorlake-typescript-sdk/${SDK_VERSION}`,
+        null
+      );
+    }
+    const envOverrides = {
+      TENSORLAKE_API_KEY: token,
+      // The CLI must target the same deployment the data plane does, or a
+      // mount could resolve a same-named filesystem in the wrong environment.
+      TENSORLAKE_API_URL: options.apiUrl ?? context.apiUrl
+    };
+    if (organizationId) envOverrides.TENSORLAKE_ORGANIZATION_ID = organizationId;
+    if (projectId) envOverrides.TENSORLAKE_PROJECT_ID = projectId;
+    this.cli = new FsCli(envOverrides);
+  }
+  // -- lifecycle --------------------------------------------------------------
+  /** Create a filesystem; region fixes its storage placement. Forks inherit placement. */
+  async create(name, options = {}) {
+    if (typeof name !== "string") {
+      throw new TypeError("name must be a string");
+    }
+    if (name.length === 0) {
+      throw new FilesystemError("filesystem name must not be empty");
+    }
+    const { region } = options;
+    if (region !== void 0 && (typeof region !== "string" || region.length === 0 || region.trim() !== region)) {
+      throw new FilesystemError(
+        "region must be a nonempty string without surrounding whitespace"
+      );
+    }
+    const raw = await callNative2(() => region === void 0 ? this.native.createFilesystem(name) : this.native.createFilesystem(name, region));
+    const created = JSON.parse(raw);
+    return new Filesystem(
+      this,
+      this.native,
+      this.cli,
+      name,
+      created.default_branch || "main"
+    );
+  }
+  /**
+   * Fork a filesystem at its live head or an explicit retained snapshot.
+   * The server shares immutable content and publishes only metadata.
+   */
+  async fork(name, baseFilesystem, snapshot) {
+    if (!name || !baseFilesystem) {
+      throw new FilesystemError(
+        "fork and base filesystem names must not be empty"
+      );
+    }
+    await callNative2(
+      () => this.native.forkFilesystem(
+        name,
+        baseFilesystem,
+        snapshot ?? null
+      ),
+      new FilesystemNotFoundError(baseFilesystem)
+    );
+    return new Filesystem(this, this.native, this.cli, name, "main");
+  }
+  /** Return a handle to an existing filesystem (verifies it exists). */
+  async get(name) {
+    const traced = await callNative2(
+      () => this.native.filesystemMeta(name),
+      new FilesystemNotFoundError(name)
+    );
+    const meta = JSON.parse(traced.json);
+    if ((meta.kind ?? FILESYSTEM_REPO_KIND) !== FILESYSTEM_REPO_KIND) {
+      throw new FilesystemNotFoundError(name);
+    }
+    return new Filesystem(
+      this,
+      this.native,
+      this.cli,
+      name,
+      meta.default_branch || "main"
+    );
+  }
+  /** List all filesystems in the project. */
+  async list() {
+    const traced = await callNative2(() => this.native.listFilesystems());
+    const page = JSON.parse(traced.json);
+    return (page.repos ?? []).map((repo) => ({
+      name: String(repo.name ?? ""),
+      fullName: String(repo.full_name ?? ""),
+      status: String(repo.status ?? ""),
+      kind: String(repo.kind ?? FILESYSTEM_REPO_KIND)
+    }));
+  }
+  /** Permanently delete a filesystem and all its snapshots. */
+  async delete(name) {
+    await callNative2(
+      () => this.native.deleteFilesystem(name),
+      new FilesystemNotFoundError(name)
+    );
+  }
+  // -- local mounts -------------------------------------------------------------
+  /**
+   * Mount a filesystem to a local path (requires the `tl` CLI).
+   *
+   * `readonly: true` is not supported for local mounts and throws
+   * {@link ReadOnlyMountNotSupportedError}; use a sandbox read-only mount
+   * (`readOnly: true`) or `tl git mount --ro` instead.
+   */
+  async mount(name, localPath, readonly = false) {
+    await this.cli.mount(name, localPath, readonly);
+    return new FilesystemMount(this, this.cli, name, localPath, readonly);
+  }
+  /**
+   * Unmount a locally mounted filesystem.
+   *
+   * `discard: true` drops local changes that were not yet uploaded.
+   */
+  async unmount(localPath, discard = false) {
+    await this.cli.unmount(localPath, discard);
+  }
+  /** Status of a local mount (defaults to the mount containing CWD). */
+  async mountStatus(localPath) {
+    return mountStatusFromRaw(await this.cli.status(localPath), localPath);
+  }
+};
+function toBuffer(data) {
+  return typeof data === "string" ? Buffer.from(data, "utf-8") : Buffer.from(data);
+}
+var Filesystem = class {
+  client;
+  native;
+  cli;
+  name;
+  defaultBranch;
+  /** @internal — obtain instances via `FilesystemClient.create()` / `.get()`. */
+  constructor(client, native, cli, name, defaultBranch = null) {
+    this.client = client;
+    this.native = native;
+    this.cli = cli;
+    this.name = name;
+    this.defaultBranch = defaultBranch;
+  }
+  /**
+   * The filesystem's default branch — the target of every write and the
+   * default version of every read, so writes and `status()` can never
+   * silently disagree on a non-"main" filesystem.
+   */
+  async branch() {
+    if (!this.defaultBranch) {
+      const traced = await callNative2(
+        () => this.native.filesystemMeta(this.name),
+        new FilesystemNotFoundError(this.name)
+      );
+      const meta = JSON.parse(traced.json);
+      this.defaultBranch = meta.default_branch || "main";
+    }
+    return this.defaultBranch;
+  }
+  // -- writes -------------------------------------------------------------------
+  /** Write one file. Returns the snapshot (version) the write produced. */
+  async writeFile(path3, data, message) {
+    return await this.writeFiles(/* @__PURE__ */ new Map([[path3, data]]), message);
+  }
+  /** Write several files (and/or delete paths) in one atomic snapshot. */
+  async writeFiles(files, message, deletes = []) {
+    const entries = files instanceof Map ? [...files.entries()] : Object.entries(files);
+    if (entries.length === 0 && deletes.length === 0) {
+      throw new FilesystemError("nothing to write: no files or deletions given");
+    }
+    const writes = entries.map(([path3, data]) => ({
+      path: path3,
+      content: toBuffer(data)
+    }));
+    const resolvedMessage = message || `write ${writes.length} file(s) via SDK`;
+    return await this.publishChanges(
+      writes,
+      deletes,
+      [],
+      [],
+      resolvedMessage
+    );
+  }
+  /**
+   * Stream one local file directly to object storage in bounded parts.
+   * This is the memory-bounded API for multi-GiB files.
+   */
+  async writeFileFromPath(path3, localPath, message) {
+    return await this.writeFilesFromPaths(
+      /* @__PURE__ */ new Map([[path3, localPath]]),
+      message
+    );
+  }
+  /**
+   * Atomically publish local files without loading their complete payloads
+   * into JavaScript or Rust memory.
+   */
+  async writeFilesFromPaths(files, message) {
+    const entries = files instanceof Map ? [...files.entries()] : Object.entries(files);
+    if (entries.length === 0) {
+      throw new FilesystemError("nothing to write: no local files given");
+    }
+    const writes = entries.map(([path3, localPath]) => ({ path: path3, localPath }));
+    const resolvedMessage = message || `write ${writes.length} local file(s) via SDK`;
+    const branch = await this.branch();
+    const traced = await callNative2(
+      () => this.native.pushFilesystemPaths(
+        this.name,
+        writes,
+        resolvedMessage,
+        branch,
+        (0, import_node_crypto5.randomBytes)(16).toString("hex")
+      ),
+      new FilesystemNotFoundError(this.name)
+    );
+    const report = JSON.parse(traced.json);
+    const versionId = String(report.version_id ?? "");
+    const previousVersionId = report.previous_version_id == null ? null : String(report.previous_version_id);
+    return {
+      versionId,
+      previousVersionId,
+      created: previousVersionId !== versionId,
+      message: resolvedMessage
+    };
+  }
+  /**
+   * Move a file or directory without downloading or re-uploading its bytes.
+   * The source removal and destination creation publish as one atomic snapshot.
+   */
+  async moveFile(from, to, message) {
+    return await this.publishChanges(
+      [],
+      [],
+      [{ from, to }],
+      [],
+      message || `move ${from} to ${to} via SDK`
+    );
+  }
+  /**
+   * Copy a file or directory by reusing immutable content references. No
+   * payload bytes traverse the client, API server, or object store.
+   */
+  async copyFile(from, to, message) {
+    return await this.publishChanges(
+      [],
+      [],
+      [],
+      [{ from, to }],
+      message || `copy ${from} to ${to} via SDK`
+    );
+  }
+  async publishChanges(writes, deletes, moves, copies, message) {
+    const branch = await this.branch();
+    const traced = await callNative2(
+      () => this.native.pushFilesystemFiles(
+        this.name,
+        writes,
+        deletes,
+        moves,
+        copies,
+        message,
+        branch,
+        // One key per logical write: a retried submit reattaches to the
+        // same durable commit job instead of double-committing.
+        (0, import_node_crypto5.randomBytes)(16).toString("hex")
+      ),
+      new FilesystemNotFoundError(this.name)
+    );
+    const report = JSON.parse(traced.json);
+    const versionId = String(report.version_id ?? "");
+    const previousVersionId = report.previous_version_id == null ? null : String(report.previous_version_id);
+    return {
+      versionId,
+      previousVersionId,
+      created: previousVersionId !== versionId,
+      message
+    };
+  }
+  /** Delete one file. Returns the durable version the deletion produced. */
+  async deleteFile(path3, message) {
+    return await this.writeFiles(
+      /* @__PURE__ */ new Map(),
+      message || `delete ${path3} via SDK`,
+      [path3]
+    );
+  }
+  /**
+   * Return the filesystem's current version as a snapshot.
+   *
+   * Writes publish durable live versions. This retains the current head
+   * permanently in one metadata-only server operation without changing or
+   * copying any content.
+   */
+  async snapshot(message = "snapshot via SDK") {
+    const resolvedMessage = message || "snapshot via SDK";
+    const traced = await callNative2(
+      () => this.native.retainFilesystemSnapshot(
+        this.name,
+        resolvedMessage,
+        (0, import_node_crypto5.randomBytes)(16).toString("hex")
+      ),
+      new FilesystemNotFoundError(this.name)
+    );
+    const retained = JSON.parse(traced.json);
+    return {
+      id: String(retained.snapshot_id ?? ""),
+      message: retained.message || resolvedMessage
+    };
+  }
+  /** List explicitly retained snapshots without reading filesystem contents. */
+  async listSnapshots() {
+    const traced = await callNative2(
+      () => this.native.listFilesystemSnapshots(this.name),
+      new FilesystemNotFoundError(this.name)
+    );
+    const payload = JSON.parse(traced.json);
+    return (payload.snapshots ?? []).map((snapshot) => ({
+      id: String(snapshot.snapshot_id ?? ""),
+      createdAt: new Date(Number(snapshot.created_at_ms ?? 0)),
+      message: String(snapshot.message ?? "")
+    }));
+  }
+  /** Delete one permanent retention point; shared/head-reachable bytes remain. */
+  async deleteSnapshot(snapshot) {
+    await callNative2(
+      () => this.native.deleteFilesystemSnapshot(this.name, snapshot),
+      new FilesystemNotFoundError(this.name)
+    );
+  }
+  // -- reads --------------------------------------------------------------------
+  /**
+   * Read a file's bytes at `version` (the current `main` head or a retained
+   * snapshot id; defaults to the filesystem's current head).
+   */
+  async readFile(path3, version) {
+    return (await this.readFileWithMetadata(path3, { version })).data;
+  }
+  /**
+   * Read bytes and immutable metadata in one request. A range is executed by
+   * Artifact Storage, so callers never download the unrequested remainder.
+   */
+  async readFileWithMetadata(path3, options = {}) {
+    if (trimSlashes(path3) === "") {
+      throw new FilesystemError("file path must not be empty");
+    }
+    const range = options.range;
+    if (range !== void 0 && (!Number.isSafeInteger(range.offset) || range.offset < 0 || !Number.isSafeInteger(range.length) || range.length <= 0)) {
+      throw new FilesystemError(
+        "range requires a non-negative integer offset and positive integer length"
+      );
+    }
+    const resolvedVersion = options.version || await this.branch();
+    const traced = await callNative2(
+      () => this.native.readFilesystemFile(
+        this.name,
+        path3,
+        resolvedVersion,
+        range?.offset,
+        range?.length
+      ),
+      new FileNotFoundInFilesystemError(this.name, path3)
+    );
+    const fullSize = traced.fullSize;
+    if (!traced.contentId || fullSize === void 0 || !Number.isSafeInteger(fullSize) || fullSize < 0 || traced.data.byteLength > fullSize) {
+      throw new FilesystemError(
+        "filesystem read response omitted content identity or total size"
+      );
+    }
+    return {
+      data: new Uint8Array(traced.data),
+      contentId: traced.contentId,
+      size: fullSize
+    };
+  }
+  /** Read a file as UTF-8 text at `version`. Throws on non-UTF-8 content. */
+  async readText(path3, version) {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+      await this.readFile(path3, version)
+    );
+  }
+  /** List one directory (non-recursive) at `version`. */
+  async listFiles(dirPath = "", version) {
+    const resolvedVersion = version || await this.branch();
+    const traced = await callNative2(
+      () => this.native.listFilesystemTree(this.name, dirPath, resolvedVersion),
+      new FileNotFoundInFilesystemError(this.name, dirPath || "/")
+    );
+    const page = JSON.parse(traced.json);
+    return (page.entries ?? []).map((entry) => fileEntryFromWire(entry, dirPath));
+  }
+  // -- status -------------------------------------------------------------------
+  /** Remote status: identity plus the current native version. */
+  async status() {
+    const metaTraced = await callNative2(
+      () => this.native.filesystemMeta(this.name),
+      new FilesystemNotFoundError(this.name)
+    );
+    const meta = JSON.parse(metaTraced.json);
+    const defaultBranch = String(meta.default_branch || "main");
+    this.defaultBranch = defaultBranch;
+    let versionId = null;
+    let generation = null;
+    try {
+      const refTraced = await callNative2(
+        () => this.native.filesystemRefStatus(this.name, defaultBranch)
+      );
+      const ref = JSON.parse(refTraced.json);
+      versionId = ref.resolved_commit || ref.oid || null;
+      generation = typeof ref.generation === "number" ? ref.generation : null;
+    } catch (error) {
+      if (!(error instanceof FilesystemAPIError) || error.statusCode !== 404) {
+        throw error;
+      }
+    }
+    return {
+      name: this.name,
+      status: String(meta.status ?? ""),
+      versionId,
+      generation
+    };
+  }
+  // -- mounts -------------------------------------------------------------------
+  /**
+   * Mount this filesystem to a local path (requires the `tl` CLI).
+   *
+   * `readonly: true` is not supported for local mounts and throws
+   * {@link ReadOnlyMountNotSupportedError}; use a sandbox read-only mount
+   * (`readOnly: true`) or `tl git mount --ro` instead.
+   */
+  async mount(localPath, readonly = false) {
+    return await this.client.mount(this.name, localPath, readonly);
+  }
+};
+var FilesystemMount = class {
+  client;
+  cli;
+  filesystem;
+  path;
+  readonly;
+  /** @internal — obtain instances via `FilesystemClient.mount()`. */
+  constructor(client, cli, filesystem, path3, readonly) {
+    this.client = client;
+    this.cli = cli;
+    this.filesystem = filesystem;
+    this.path = path3;
+    this.readonly = readonly;
+  }
+  /** Flush pending local changes into a durable snapshot. */
+  async snapshot(message) {
+    await this.cli.snapshot(this.path, message);
+  }
+  /** Local mount status as reported by the mount daemon. */
+  async status() {
+    return await this.client.mountStatus(this.path);
+  }
+  /** Unmount; `discard: true` drops changes not yet uploaded. */
+  async unmount(discard = false) {
+    await this.client.unmount(this.path, discard);
+  }
+};
+
+// src/api-client.ts
+init_errors();
+var APIClient = class {
+  cloudClient;
+  filesystemOptions;
+  constructor(options) {
+    this.cloudClient = new CloudClient(options);
+    this.filesystemOptions = {
+      apiKey: options?.apiKey,
+      apiUrl: options?.apiUrl,
+      organizationId: options?.organizationId,
+      projectId: options?.projectId
+    };
+  }
+  close() {
+    this.cloudClient.close();
+  }
+  async upsertApplication(manifest, codeZip, upgradeRunningRequests = false) {
+    await this.cloudClient.upsertApplication(
+      manifest,
+      codeZip,
+      upgradeRunningRequests
+    );
+  }
+  async deleteApplication(applicationName) {
+    await this.cloudClient.deleteApplication(applicationName);
+  }
+  async deleteSandboxImage(imageName) {
+    await this.cloudClient.deleteSandboxImage(imageName);
+  }
+  async createFileSystem(name, description, options) {
+    const filesystem = await new FilesystemClient(this.filesystemOptions).create(
+      name,
+      { region: options?.region }
+    );
+    return {
+      id: filesystem.name,
+      name: filesystem.name,
+      description,
+      status: "ready"
+    };
+  }
+  async listFileSystems(_options) {
+    const filesystems = await new FilesystemClient(this.filesystemOptions).list();
+    return filesystems.map((filesystem) => ({
+      id: filesystem.name,
+      name: filesystem.name,
+      status: filesystem.status
+    }));
+  }
+  async deleteFileSystem(fileSystemId, _options) {
+    await new FilesystemClient(this.filesystemOptions).delete(fileSystemId);
+  }
+  async applications() {
+    return this.cloudClient.applications();
+  }
+  async application(applicationName) {
+    return this.cloudClient.applicationManifest(applicationName);
+  }
+  async runRequest(applicationName, inputs) {
+    return this.cloudClient.runRequest(applicationName, inputs);
+  }
+  async waitOnRequestCompletion(applicationName, requestId) {
+    await this.cloudClient.waitOnRequestCompletion(applicationName, requestId);
+  }
+  async requestOutput(applicationName, requestId) {
+    const metadata = await this.cloudClient.requestMetadata(
+      applicationName,
+      requestId
+    );
+    if (metadata.outcome == null) {
+      throw new RequestNotFinishedError();
+    }
+    if (typeof metadata.outcome === "object") {
+      if (metadata.requestError?.message) {
+        throw new RequestExecutionError(
+          metadata.requestError.message,
+          metadata.requestError.functionName
+        );
+      }
+      const failure = typeof metadata.outcome.failure === "string" ? metadata.outcome.failure : JSON.stringify(metadata.outcome);
+      throw new RequestFailedError(failure);
+    }
+    return this.cloudClient.requestOutput(applicationName, requestId);
+  }
+};
+
+// src/applications/remote.ts
+init_errors();
+var CLOUD_CLIENT_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "apiUrl",
+  "apiKey",
+  "organizationId",
+  "projectId",
+  "namespace",
+  "maxRetries",
+  "retryBackoffMs"
+]);
+var REMOTE_OPTIONS_BRAND = /* @__PURE__ */ Symbol.for(
+  "tensorlake.applications.remote-options.v1"
+);
+function isCloudClientOptions(value) {
+  if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  return entries.every(([key, option]) => {
+    if (!CLOUD_CLIENT_OPTION_KEYS.has(key)) return false;
+    if (option === void 0) return true;
+    if (key === "maxRetries" || key === "retryBackoffMs") {
+      return typeof option === "number";
+    }
+    return typeof option === "string";
+  });
+}
+function isRemoteOptions(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const candidate = value;
+  return candidate[REMOTE_OPTIONS_BRAND] === true && isCloudClientOptions(candidate.clientOptions);
+}
+function remoteOptions(options = {}) {
+  if (!isCloudClientOptions(options)) {
+    throw new SDKUsageError("remoteOptions requires valid CloudClientOptions");
+  }
+  return Object.freeze({
+    [REMOTE_OPTIONS_BRAND]: true,
+    clientOptions: Object.freeze({ ...options })
+  });
+}
+var RemoteRequest = class {
+  constructor(id, applicationName, client, outputIsFile) {
+    this.id = id;
+    this.applicationName = applicationName;
+    this.client = client;
+    this.outputIsFile = outputIsFile;
+  }
+  async output() {
+    let output;
+    try {
+      await this.client.waitOnRequestCompletion(this.applicationName, this.id);
+      output = await this.client.requestOutput(this.applicationName, this.id);
+    } catch (error) {
+      if (error instanceof RequestExecutionError) {
+        throw new RequestError(error.message, { cause: error });
+      }
+      if (error instanceof RequestFailedError) {
+        throw new FunctionError(error.message, { cause: error });
+      }
+      throw error;
+    }
+    if (this.outputIsFile === true) {
+      return new File(output.serializedValue, output.contentType);
+    }
+    if (this.outputIsFile === false || output.contentType.toLowerCase().startsWith("application/json")) {
+      return deserializeJSON(output.serializedValue);
+    }
+    return new File(output.serializedValue, output.contentType);
+  }
+};
+async function runRemote(application, ...argsAndOptions) {
+  const definition = typeof application === "string" ? void 0 : application.definition;
+  if (definition != null && definition.application == null) {
+    throw new SDKUsageError(`${definition.name} is not a Tensorlake application`);
+  }
+  const applicationName = typeof application === "string" ? application : definition.name;
+  let options;
+  const args = [...argsAndOptions];
+  const candidate = args.at(-1);
+  if (typeof application === "string") {
+    if (isRemoteOptions(candidate)) {
+      options = candidate.clientOptions;
+      args.pop();
+    }
+  } else {
+    const parameters = definition.parameters;
+    const expectedArgs = parameters.length;
+    if (isRemoteOptions(candidate)) {
+      const suppliedApplicationArgs = args.length - 1;
+      const omitted = parameters.slice(suppliedApplicationArgs);
+      if (omitted.some((parameter2) => parameter2.required)) {
+        throw new SDKUsageError(
+          `${definition.name} is missing a required application argument before remoteOptions`
+        );
+      }
+      options = candidate.clientOptions;
+      args.pop();
+    } else if (args.length === expectedArgs + 1) {
+      if (candidate !== void 0 && !isCloudClientOptions(candidate)) {
+        throw new SDKUsageError("The trailing runRemote argument must be CloudClientOptions");
+      }
+      options = args.pop();
+    }
+  }
+  const client = new APIClient(options);
+  const inputs = args.map((value, index) => {
+    const serialized = serializeValue(value);
+    return { name: String(index), data: serialized.data, contentType: serialized.contentType };
+  });
+  const id = await client.runRequest(applicationName, inputs);
+  return new RemoteRequest(id, applicationName, client, definition?.returns._file);
+}
+
+// src/applications/manifest.ts
+init_cjs_shims();
+var import_node_buffer = require("buffer");
+var TYPESCRIPT_DESCRIPTOR_FORMAT = "tensorlake.typescript.json-schema.v1";
+function encodeDescriptor(value) {
+  return import_node_buffer.Buffer.from(JSON.stringify({ format: TYPESCRIPT_DESCRIPTOR_FORMAT, value }), "utf8").toString("base64");
+}
+function decodeDescriptor(encoded) {
+  const envelope = JSON.parse(import_node_buffer.Buffer.from(encoded, "base64").toString("utf8"));
+  if (envelope.format !== TYPESCRIPT_DESCRIPTOR_FORMAT) {
+    throw new SDKUsageError("Application manifest does not contain TypeScript schema descriptors");
+  }
+  return envelope.value;
+}
+function parseGPU(value) {
+  const [model, countText, ...extra] = value.split(":");
+  if (!model || extra.length > 0) throw new SDKUsageError(`Invalid GPU setting '${value}'`);
+  const count = countText == null ? 1 : Number(countText);
+  if (!Number.isInteger(count) || count <= 0) throw new SDKUsageError(`Invalid GPU count in '${value}'`);
+  return { count, model };
+}
+function parameterManifest(parameter2) {
+  return {
+    name: parameter2.name,
+    data_type: parameterJSONSchema(parameter2),
+    description: parameter2.description,
+    required: parameter2.required
+  };
+}
+function functionManifest(application, definition) {
+  const retries2 = definition.options.retries ?? application.application?.retries ?? { maxRetries: 0 };
+  const gpu = definition.options.gpu == null ? [] : (Array.isArray(definition.options.gpu) ? definition.options.gpu : [definition.options.gpu]).map(parseGPU);
+  const result = {
+    name: definition.name,
+    description: definition.options.description,
+    docstring: "",
+    secret_names: [...definition.options.secrets],
+    initialization_timeout_sec: definition.options.timeout,
+    timeout_sec: definition.options.timeout,
+    resources: {
+      cpus: definition.options.cpu,
+      memory_mb: Math.ceil(definition.options.memory * 1024),
+      ephemeral_disk_mb: Math.ceil(definition.options.ephemeralDisk * 1024),
+      gpus: gpu
+    },
+    retry_policy: {
+      max_retries: retries2.maxRetries,
+      initial_delay_sec: 1,
+      max_delay_sec: 60,
+      delay_multiplier: 2
+    },
+    cache_key: null,
+    parameters: definition.application == null ? [] : definition.parameters.map(parameterManifest),
+    return_type: definition.application == null ? null : { ...definition.returns.jsonSchema, title: "Return value" },
+    placement_constraints: {
+      filter_expressions: (definition.options.region ?? application.options.region) == null ? [] : [`region==${definition.options.region ?? application.options.region}`]
+    },
+    max_concurrency: 1
+  };
+  if (definition.options.warmContainers != null) result.warm_containers = definition.options.warmContainers;
+  if (definition.options.minContainers != null) result.min_containers = definition.options.minContainers;
+  if (definition.options.maxContainers != null) result.max_containers = definition.options.maxContainers;
+  if (definition.options.image != null) result.image = definition.options.image.name;
+  return result;
+}
+function createApplicationManifest(application) {
+  if (application.application == null) throw new SDKUsageError(`${application.name} is not an application`);
+  const functions = Object.fromEntries(
+    getFunctions().map((definition) => [definition.name, functionManifest(application, definition)])
+  );
+  return {
+    name: application.name,
+    description: application.options.description,
+    tags: { ...application.application.tags },
+    allow: [...application.application.allow],
+    version: application.application.version,
+    runtime: "typescript",
+    functions,
+    entrypoint: {
+      function_name: application.name,
+      input_serializer: "json",
+      inputs_base64: encodeDescriptor(application.parameters.map((parameter2) => ({
+        name: parameter2.name,
+        schema: parameter2.schema.jsonSchema,
+        required: parameter2.required,
+        hasDefault: parameter2.hasDefault,
+        defaultValue: parameter2.defaultValue
+      }))),
+      output_serializer: "json",
+      output_type_hints_base64: encodeDescriptor(application.returns.jsonSchema)
+    }
+  };
+}
+function createApplicationManifests() {
+  return getApplications().map(createApplicationManifest);
+}
+function createCodeManifest(module2 = "runtime.mjs") {
+  return {
+    format_version: 2,
+    runtime: "typescript",
+    minimum_node_major: 24,
+    module: module2,
+    functions: Object.fromEntries(getFunctions().map((definition) => [definition.name, { name: definition.name }]))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeserializationError,
+  File,
+  FunctionError,
+  Future,
+  Headers,
+  HttpBody,
+  Image,
+  LocalRequest,
+  RemoteRequest,
+  ReplayMismatchError,
+  RequestContext,
+  RequestError,
+  SDKUsageError,
+  SDK_VERSION,
+  SerializationError,
+  TensorlakeApplicationError,
+  TimeoutError,
+  createApplicationManifest,
+  createApplicationManifests,
+  createCodeManifest,
+  decodeDescriptor,
+  getApplications,
+  getFunction,
+  getFunctions,
+  registerApplication,
+  registerFunction,
+  remoteOptions,
+  retries,
+  runLocal,
+  runRemote,
+  schema
+});
+//# sourceMappingURL=index.cjs.map