tensorlake 0.5.143 → 0.5.148

package/dist/sandbox-image.js

@@ -1,1987 +0,0 @@
-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
-));
-
-// node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-  }
-});
-
-// 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_esm_shims();
-    SDK_VERSION = "0.5.143";
-    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_esm_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;
-var init_errors = __esm({
-  "src/errors.ts"() {
-    "use strict";
-    init_esm_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;
-      }
-    };
-  }
-});
-
-// src/native-worker-protocol.ts
-var cancelNativeCall, closeNativeHandle;
-var init_native_worker_protocol = __esm({
-  "src/native-worker-protocol.ts"() {
-    "use strict";
-    init_esm_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_esm_shims();
-    init_defaults();
-  }
-});
-
-// src/native-worker-client.ts
-import { createRequire } from "module";
-import { Worker } from "worker_threads";
-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 NativeWorkerClient, runtimeKey, runtimes;
-var init_native_worker_client = __esm({
-  "src/native-worker-client.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_native_worker_protocol();
-    init_url();
-    NativeWorkerClient = class {
-      constructor(workerPath = () => createRequire(import.meta.url).resolve(
-        "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 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.143"}.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_esm_shims();
-    init_models();
-    init_errors();
-    init_native_worker_client();
-    init_native_worker_protocol();
-  }
-});
-
-// src/native-cloud.ts
-async function serializeRequest(method, path4, 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: path4,
-    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_esm_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, path4, options) {
-        const request = await serializeRequest(method, path4, 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, path4) {
-        const response = await this.requestResponse(method, path4);
-        const text = await response.text();
-        const value = text ? JSON.parse(text) : null;
-        return Object.assign(value ?? {}, { traceId: response.traceId });
-      }
-      async *stream(method, path4, signal) {
-        if (signal?.aborted) return;
-        const request = await serializeRequest(method, path4, { headers: { Accept: "text/event-stream" } });
-        yield* nativeEventStream((emit) => this.client().stream(request, emit), void 0, signal);
-      }
-    };
-  }
-});
-
-// src/cloud-client.ts
-import { nanoid } from "nanoid";
-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_${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 CloudClient, UNAUTHENTICATED_REQUESTS;
-var init_cloud_client = __esm({
-  "src/cloud-client.ts"() {
-    "use strict";
-    init_esm_shims();
-    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 path4 = `${base}?pageSize=100`;
-        const templates = [];
-        while (path4 !== null) {
-          const page = await this.transport.requestJson(
-            "GET",
-            path4
-          );
-          for (const item of page.items ?? []) {
-            templates.push(fromSnakeKeys(item));
-          }
-          const next = page.pagination?.next;
-          path4 = 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 path4 = this.namespacePath(
-          `applications/${encodeURIComponent(applicationName)}`
-        );
-        const response = inputs.length === 0 ? await this.transport.requestResponse("POST", path4, {
-          body: new Uint8Array(),
-          headers: { Accept: "application/json" }
-        }) : inputs.length === 1 && inputs[0].name === "0" ? await this.transport.requestResponse("POST", path4, {
-          body: toRequestBody(inputs[0].data),
-          headers: {
-            Accept: "application/json",
-            "Content-Type": inputs[0].contentType
-          }
-        }) : await this.runMultipartRequest(path4, 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": 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": 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(path4, 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", path4, {
-          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";
-  }
-});
-
-// src/image.ts
-import { randomUUID } from "crypto";
-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 DEFAULT_IMAGE_NAME, ImageBuildOperationType, Image;
-var init_image = __esm({
-  "src/image.ts"() {
-    "use strict";
-    init_esm_shims();
-    DEFAULT_IMAGE_NAME = "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 = randomUUID();
-        this._buildOperations = [];
-        if (typeof nameOrOptions === "string") {
-          this._name = nameOrOptions;
-          this._tag = tag;
-          this._baseImage = baseImage;
-          return;
-        }
-        this._name = nameOrOptions.name ?? DEFAULT_IMAGE_NAME;
-        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;
-      }
-    };
-  }
-});
-
-// lib/libc.cjs
-var require_libc = __commonJS({
-  "lib/libc.cjs"(exports, module) {
-    "use strict";
-    init_esm_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);
-      }
-    }
-    module.exports = { detectLinuxLibc: detectLinuxLibc2 };
-  }
-});
-
-// src/native-binding.ts
-import * as fs from "fs";
-import { createRequire as createRequire2 } from "module";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function packageRoot() {
-  const parent = fileURLToPath2(new URL("../", import.meta.url));
-  if (fs.existsSync(path2.join(parent, "package.json"))) return parent;
-  const grandparent = fileURLToPath2(new URL("../../", import.meta.url));
-  if (fs.existsSync(path2.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 path2.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 = createRequire2(import.meta.url);
-  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 tensorlake without omitting optional dependencies, and install dependencies on the machine where they will run.`,
-      { cause }
-    );
-  }
-  return require2(packageEntry);
-}
-var import_libc, NATIVE_PACKAGES, cachedLinuxLibc;
-var init_native_binding = __esm({
-  "src/native-binding.ts"() {
-    "use strict";
-    init_esm_shims();
-    import_libc = __toESM(require_libc(), 1);
-    NATIVE_PACKAGES = {
-      "darwin-arm64": "tensorlake-native-darwin-arm64",
-      "linux-arm64": "tensorlake-native-linux-arm64-gnu",
-      "linux-arm64-musl": "tensorlake-native-linux-arm64-musl",
-      "linux-x64": "tensorlake-native-linux-x64-gnu",
-      "linux-x64-musl": "tensorlake-native-linux-x64-musl",
-      "win32-x64": "tensorlake-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
-});
-import path3 from "path";
-import os from "os";
-import { existsSync as existsSync2, mkdtempSync, rmSync } from "fs";
-import { parseArgs } from "util";
-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 = path3.parse(dockerfilePath);
-  if (parsed.name.toLowerCase() === "dockerfile") {
-    const parentName = path3.basename(path3.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 = path3.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 = mkdtempSync(path3.join(os.tmpdir(), "tl-build-context-"));
-      resolvedContext = tempContextDir;
-    }
-    dockerfilePath = path3.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 = path3.resolve(source);
-    if (!existsSync2(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_NAME2) {
-      console.warn(
-        `Building sandbox image with the default name "${DEFAULT_IMAGE_NAME2}". 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) {
-      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_NAME2) {
-    console.warn(
-      `Importing sandbox image with the default name "${DEFAULT_IMAGE_NAME2}". 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 = 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 = 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 cachedNativeBinding, cachedNativeBindingError, DEFAULT_IMAGE_NAME2;
-var init_sandbox_image = __esm({
-  "src/sandbox-image.ts"() {
-    init_esm_shims();
-    init_cloud_client();
-    init_image();
-    init_native_binding();
-    DEFAULT_IMAGE_NAME2 = "default";
-  }
-});
-init_sandbox_image();
-export {
-  __setNativeBindingForTest,
-  buildContextFromEnv,
-  createSandboxImage,
-  deleteSandboxImage,
-  findSandboxImageByName,
-  importSandboxImage,
-  listSandboxImages,
-  runCreateSandboxImageCli,
-  runImportSandboxImageCli
-};
-//# sourceMappingURL=sandbox-image.js.map