@arker-ai/sdk 0.5.2 → 0.6.2

package/dist/modal.cjs

@@ -0,0 +1,1356 @@
+"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 __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);
+
+// src/modal.ts
+var modal_exports = {};
+__export(modal_exports, {
+  ModalClient: () => ModalClient,
+  Sandbox: () => Sandbox
+});
+module.exports = __toCommonJS(modal_exports);
+var import_modal = require("@computesdk/modal");
+
+// src/compat/common.ts
+function shouldGuardNested(value) {
+  return !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+function guardUnsupported(instance, shimName) {
+  const passthrough = /* @__PURE__ */ new Set([
+    "then",
+    "catch",
+    "finally",
+    "constructor",
+    "toJSON",
+    "toString",
+    "valueOf",
+    Symbol.toStringTag
+  ]);
+  const supported = /* @__PURE__ */ new Set();
+  for (let current = instance; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+    for (const key of Reflect.ownKeys(current)) supported.add(key);
+  }
+  return new Proxy(instance, {
+    get(target, prop) {
+      if (typeof prop === "symbol" || passthrough.has(prop) || supported.has(prop)) {
+        const value = Reflect.get(target, prop, target);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return shouldGuardNested(value) ? guardUnsupported(value, shimName) : value;
+      }
+      throw new Error(
+        `'${String(prop)}' is not supported by the Arker compatibility layer for ${shimName}. The compatibility layer covers create/connect/get, command execution, and core filesystem operations. Use the native ${shimName} SDK directly for the full API.`
+      );
+    }
+  });
+}
+function isPlainRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function formatKeys(keys) {
+  return keys.map((key) => `'${key}'`).join(", ");
+}
+function assertNoUnsupportedArgs(args, shimName, methodName) {
+  if (args.length === 0) return;
+  throw new Error(
+    `${methodName} received unsupported positional argument(s) in the Arker compatibility layer for ${shimName}. Those values would be ignored, so this layer fails fast. Use the native ${shimName} SDK for app/image/provider-specific options.`
+  );
+}
+function assertSupportedObjectKeys(value, supportedKeys, shimName, methodName) {
+  if (value === void 0) return;
+  if (!isPlainRecord(value)) {
+    throw new Error(
+      `${methodName} only accepts an options object in the Arker compatibility layer for ${shimName}. Use the native ${shimName} SDK for unsupported call signatures.`
+    );
+  }
+  const supported = new Set(supportedKeys);
+  const unsupported = Object.keys(value).filter((key) => !supported.has(key));
+  if (unsupported.length > 0) {
+    throw new Error(
+      `${methodName} received unsupported option(s) ${formatKeys(unsupported)} in the Arker compatibility layer for ${shimName}. Those options would be ignored, so this layer fails fast. Supported option(s): ${supportedKeys.length > 0 ? formatKeys([...supportedKeys]) : "(none)"}.`
+    );
+  }
+}
+function isStringRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function shellQuote(value) {
+  if (value === "") return "''";
+  if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function commandName(command) {
+  return command.split("/").pop() || command;
+}
+function argvToCommand(cmd) {
+  if (typeof cmd === "string") return cmd;
+  const executable = commandName(cmd[0] ?? "");
+  if ((executable === "sh" || executable === "bash") && cmd.length >= 3 && (cmd[1] === "-c" || cmd[1] === "-lc")) {
+    return cmd[2];
+  }
+  return cmd.map(shellQuote).join(" ");
+}
+function emitFinalOutput(result, options) {
+  if (result.stdout && options?.onStdout) options.onStdout(result.stdout);
+  if (result.stderr && options?.onStderr) options.onStderr(result.stderr);
+}
+
+// src/compat/runtime.ts
+var import_computesdk = require("computesdk");
+
+// src/index.ts
+var CHUNK_SIZE = 4 * 1024 * 1024;
+var ARKER_ORG_ID = "ArkerHQ";
+var GOLDEN_NAMES = /* @__PURE__ */ new Set([
+  "arkuntu",
+  "ubuntu",
+  "ubuntu-small",
+  "ubuntu-nodisk",
+  "ubuntu-nonet-nodisk",
+  "ubuntu-full",
+  "ubuntu-full-32",
+  "ubuntu-py-repl",
+  "ubuntu-js-repl",
+  "ubuntu-docker",
+  "ubuntu-chromium",
+  "ubuntu-servo",
+  "ubuntu-servo-js-repl",
+  "ubuntu-chromium-js-repl"
+]);
+var DEFAULT_RETRY_ATTEMPTS = 4;
+var DEFAULT_RETRY_BASE_DELAY_MS = 200;
+var DEFAULT_RETRY_MAX_DELAY_MS = 2e3;
+var DEFAULT_RETRY_JITTER_MS = 50;
+var PRESIGNED_PUT_TIMEOUT_MS = 6e5;
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["routing_unavailable", "unavailable", "temporarily_unavailable"]);
+var TRANSIENT_HINTS = ["503", "Service Unavailable", "throttle", "SlowDown", "ThrottlingException"];
+var ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var DEFAULT_REGION_ENV = "ARKER_REGION";
+var DEFAULT_PROVIDER_ENV = "ARKER_PROVIDER";
+var DEFAULT_PROVIDER = "aws";
+var DEFAULT_CONTROL_BASE_URL = "https://arker.ai/api";
+var BURST_SOURCE_REFS = /* @__PURE__ */ new Set(["arkuntu"]);
+var BURST_VM_ID = /^[0-9A-HJKMNP-TV-Z]{26}_[A-Za-z0-9]+$/;
+var ArkerError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(`${code}: ${message}`);
+    this.name = "ArkerError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var Arker = class {
+  /** Compute base URL for `provider` + `region` — used for fork/run/
+   * per-VM ops. SDK calls go straight to this host, skipping the CF
+   * Worker control plane. */
+  baseUrl;
+  /** Compute base URL for the burst provider in this region. */
+  burstBaseUrl;
+  /** CF Worker control-plane URL — used for cross-cutting admin calls
+   * like list-VMs and filesystems. */
+  controlBaseUrl;
+  region;
+  provider;
+  apiKey;
+  fetchImpl;
+  retry;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? env("ARKER_API_KEY") ?? env("AUTH_KEY");
+    const explicitBaseUrl = opts.baseUrl ?? env("ARKER_BASE_URL");
+    const rawRegion = opts.region ?? (explicitBaseUrl ? void 0 : env(DEFAULT_REGION_ENV));
+    const rawProvider = opts.provider ?? env(DEFAULT_PROVIDER_ENV) ?? DEFAULT_PROVIDER;
+    const provider = parseProvider(rawProvider);
+    const { region, providerFromRegion } = splitRegion(rawRegion);
+    const effectiveProvider = providerFromRegion ?? provider;
+    const baseUrl = explicitBaseUrl ?? (region ? computeBaseUrl(effectiveProvider, region) : void 0);
+    const burstBaseUrl = opts.burstBaseUrl ?? env("ARKER_BURST_BASE_URL") ?? (region ? computeBaseUrl("aws-burst", region) : void 0);
+    const controlBaseUrl = opts.controlBaseUrl ?? env("ARKER_CONTROL_BASE_URL") ?? DEFAULT_CONTROL_BASE_URL;
+    if (!apiKey) throw new Error("apiKey is required; pass apiKey or set ARKER_API_KEY");
+    if (!baseUrl) throw new Error("region or baseUrl is required; pass region, baseUrl, ARKER_REGION, or ARKER_BASE_URL");
+    this.apiKey = apiKey;
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+    this.burstBaseUrl = burstBaseUrl ? normalizeBaseUrl(burstBaseUrl) : void 0;
+    this.controlBaseUrl = normalizeBaseUrl(controlBaseUrl);
+    this.region = region ? normalizeRegion(region) : void 0;
+    this.provider = effectiveProvider;
+    this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    this.retry = normalizeRetry(opts.retry);
+    if (!this.fetchImpl) throw new Error("fetch is required in this runtime");
+  }
+  /**
+   * Address an existing VM. Doesn't make any network calls; returns a
+   * lightweight handle.
+   */
+  vm(vmId) {
+    return new VM(this, vmId, this._baseUrlFor(vmId));
+  }
+  /**
+   * Create a new VM by forking from a source.
+   *
+   *     fork("ubuntu-full")                       // public golden by name
+   *     fork("base")                              // a VM by name in your org
+   *     fork(vm)                                  // an existing VM (uses its id)
+   *     fork({ sourceVmId: "vm_abc..." })
+   *     fork({ sourceVmName: "base", sourceOrgId: "org_..." })
+   *
+   * The source can be a name string, a `VM` handle, or a `ForkSource`
+   * object. `sourceOrgId` defaults to the Arker org when `sourceVmName`
+   * is a known public golden, otherwise to your own org; an explicit
+   * value always wins, and it's irrelevant when forking by id. Forking a
+   * VM in another org requires that VM to be `public: true`. The new VM's
+   * name (in your org) is passed as `name`. When the source is a name or
+   * `VM`, extra fork options go in the second `opts` argument.
+   */
+  async fork(source, opts = {}) {
+    const src = typeof source === "string" ? { sourceVmName: source, ...opts } : source instanceof VM ? { sourceVmId: source.id, ...opts } : source;
+    if (!src.sourceVmId && !src.sourceVmName) {
+      throw new ArkerError(
+        "bad_request",
+        "fork requires a source (a name, a VM, sourceVmName, or sourceVmId)",
+        400
+      );
+    }
+    if (src.sourceVmId && src.sourceVmName) {
+      throw new ArkerError(
+        "bad_request",
+        "fork: pass only one of sourceVmId or sourceVmName",
+        400
+      );
+    }
+    const sourceOrgId = src.sourceOrgId ?? (src.sourceVmName !== void 0 && GOLDEN_NAMES.has(src.sourceVmName) ? ARKER_ORG_ID : void 0);
+    const legacy = src;
+    const resources = src.resources ?? (legacy.vcpu_count != null || legacy.memory_mib != null || legacy.disk_mib != null ? {
+      vcpu: legacy.vcpu_count ?? null,
+      memory_mib: legacy.memory_mib ?? null,
+      disk_mib: legacy.disk_mib ?? null
+    } : null);
+    const body = {
+      source_vm_id: src.sourceVmId ?? null,
+      source_vm_name: src.sourceVmName ?? null,
+      source_org_id: sourceOrgId ?? null,
+      name: src.name ?? null,
+      public: src.public ?? null,
+      network: src.network ?? null,
+      egress: src.egress ?? null,
+      disk: src.disk ?? true,
+      durable: src.durable ?? null,
+      resources
+    };
+    const useBurst = sourceOrgId === ARKER_ORG_ID && src.sourceVmName !== void 0 && isBurstRef(src.sourceVmName);
+    const baseUrl = useBurst && this.burstBaseUrl ? this.burstBaseUrl : this.baseUrl;
+    const vm = await this._request("POST", "/v1/fork", body, baseUrl);
+    const vmId = vm.vm_id ?? vm.id ?? "";
+    return new VM(this, vmId, baseUrl, vm);
+  }
+  /**
+   * List VMs visible to the authenticated caller. **Admin call** —
+   * goes through the control plane (`controlBaseUrl`) so it can
+   * aggregate across providers and regions. Pass `?provider=` /
+   * `?region=` to narrow.
+   */
+  async listVms(opts = {}) {
+    const resp = await this._request("GET", buildQuery("/v1/vms", {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      region: opts.region,
+      provider: opts.provider,
+      state: opts.state,
+      source_org_id: opts.sourceOrgId,
+      started_after: opts.startedAfter,
+      started_before: opts.startedBefore
+    }), void 0, this.controlBaseUrl);
+    const vms = (resp.vms ?? []).map((v) => {
+      const id = v.vm_id ?? v.id ?? "";
+      return new VM(this, id, this._baseUrlFor(id), v);
+    });
+    return { vms, nextCursor: resp.next_cursor ?? null };
+  }
+  /**
+   * List run activity visible to the authenticated caller across VMs,
+   * providers, and regions. Admin call — routed through the control plane.
+   */
+  async listRuns(opts = {}) {
+    return this._request("GET", buildQuery("/v1/runs", {
+      since: opts.since,
+      until: opts.until,
+      vm: opts.vm,
+      vms: opts.vmIds && opts.vmIds.length > 0 ? opts.vmIds.join(",") : void 0,
+      region: opts.region,
+      provider: opts.provider,
+      source: opts.source,
+      search: opts.search,
+      limit: opts.limit,
+      offset: opts.offset,
+      lite: opts.lite === void 0 ? void 0 : opts.lite,
+      runtime: opts.runtime,
+      endpoint: opts.endpoint,
+      actions: opts.actions && opts.actions.length > 0 ? opts.actions.join(",") : void 0,
+      status: opts.status && opts.status.length > 0 ? opts.status.join(",") : void 0,
+      status_min: opts.statusMin,
+      status_max: opts.statusMax,
+      sort: opts.sort,
+      dir: opts.dir
+    }), void 0, this.controlBaseUrl);
+  }
+  /** Compute call — goes direct to the backend hosting this VM (no
+   * control-plane hop). Returns a fully-populated VM handle. */
+  async getVm(vmId) {
+    const data = await this._request("GET", vmPath(vmId), void 0, this._baseUrlFor(vmId));
+    return new VM(this, vmId, this._baseUrlFor(vmId), data);
+  }
+  // ── Filesystems (region-scoped, served by arkerd directly) ──────────
+  // Route to the regional endpoint (baseUrl), not the control plane: the
+  // control-plane path (arker.ai → api_proxy_bash) does not route
+  // /v1/filesystems, while the regional NLB → arkerd serves the full CRUD.
+  async listFilesystems(opts = {}) {
+    return this._request("GET", buildQuery("/v1/filesystems", {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      name_prefix: opts.namePrefix
+    }), void 0, this.baseUrl);
+  }
+  async createFilesystem(request) {
+    return this._request("POST", "/v1/filesystems", { name: request.name }, this.baseUrl);
+  }
+  async getFilesystem(filesystemId) {
+    return this._request("GET", `/v1/filesystems/${pathSegment(filesystemId)}`, void 0, this.baseUrl);
+  }
+  async deleteFilesystem(filesystemId) {
+    return this._request("DELETE", `/v1/filesystems/${pathSegment(filesystemId)}`, void 0, this.baseUrl);
+  }
+  /** @internal */
+  async _request(method, path, body, baseUrl = this.baseUrl, extraHeaders) {
+    const url = `${baseUrl}${path}`;
+    const headers = {
+      authorization: `Bearer ${this.apiKey}`
+    };
+    if (extraHeaders) {
+      for (const [key, value] of Object.entries(extraHeaders)) {
+        if (value !== void 0) headers[key] = value;
+      }
+    }
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(withoutUndefined(body));
+    }
+    let lastStatus = 0;
+    let lastText = "";
+    let lastError;
+    for (let attempt = 0; attempt < this.retry.attempts; attempt++) {
+      try {
+        const response = await this.fetchImpl(url, init);
+        const text = await response.text();
+        const payload = parseJson(text);
+        const parsedError = extractError(payload);
+        lastStatus = response.status;
+        lastText = text;
+        lastError = parsedError;
+        if (isRetryable(response.status, parsedError) && attempt < this.retry.attempts - 1) {
+          await sleep(retryDelay(this.retry, attempt));
+          continue;
+        }
+        if (parsedError) throw new ArkerError(parsedError.code, parsedError.message, response.status);
+        if (!response.ok) {
+          throw new ArkerError("internal", lastText.slice(0, 300) || `HTTP ${response.status}`, response.status);
+        }
+        return payload;
+      } catch (error) {
+        if (error instanceof ArkerError) throw error;
+        if (attempt < this.retry.attempts - 1) {
+          await sleep(retryDelay(this.retry, attempt));
+          continue;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ArkerError("network_error", message, 0);
+      }
+    }
+    if (lastError) throw new ArkerError(lastError.code, lastError.message, lastStatus);
+    throw new ArkerError("internal", lastText.slice(0, 300) || `HTTP ${lastStatus}`, lastStatus);
+  }
+  /** @internal */
+  async _fetch(input, init) {
+    return this.fetchImpl(input, init);
+  }
+  /** @internal */
+  _retryAttempts() {
+    return this.retry.attempts;
+  }
+  /** @internal */
+  _retryDelay(attempt) {
+    return retryDelay(this.retry, attempt);
+  }
+  /** @internal */
+  _authHeaders() {
+    return { authorization: `Bearer ${this.apiKey}` };
+  }
+  /** @internal */
+  _baseUrlFor(ref) {
+    if (isBurstRef(ref) && this.burstBaseUrl) return this.burstBaseUrl;
+    return this.baseUrl;
+  }
+};
+var VM = class _VM {
+  id;
+  baseUrl;
+  /** @internal */
+  _client;
+  // ── Data fields ──────────────────────────────────────────────────
+  // Populated from fork/get/list/refresh; `undefined` on a bare handle
+  // from `arker.vm(id)` until you call `refresh()`. Names mirror the
+  // contract (`Vm`).
+  vm_id;
+  name;
+  state;
+  owner_org_id;
+  created_at;
+  public;
+  region;
+  provider;
+  vcpu_count;
+  memory_mib;
+  disk_mib;
+  network;
+  max_vcpus;
+  max_memory_mib;
+  min_memory_mib;
+  started_at;
+  root_source_vm_id;
+  root_source_vm_name;
+  worker_id;
+  sessions;
+  constructor(client, vmId, baseUrl = client._baseUrlFor(vmId), data) {
+    this._client = client;
+    this.id = vmId;
+    this.baseUrl = baseUrl;
+    if (data) Object.assign(this, data);
+    Object.defineProperty(this, "_client", { enumerable: false });
+  }
+  /** Re-fetch this VM and return a fresh, fully-populated handle. */
+  async refresh() {
+    const data = await this._client._request("GET", vmPath(this.id), void 0, this.baseUrl);
+    return new _VM(this._client, this.id, this.baseUrl, data);
+  }
+  /**
+   * @deprecated Use `Arker.fork({ sourceVmId: this.id, ... })`.
+   * Kept for back-compat with older user code that called `.fork()` on
+   * a VM instance.
+   */
+  async fork(request = {}) {
+    const merged = {
+      ...request,
+      source_vm_id: request.source_vm_id ?? this.id,
+      disk: request.disk ?? true
+    };
+    const vm = await this._client._request("POST", "/v1/fork", merged, this.baseUrl);
+    const vmId = vm.vm_id ?? vm.id ?? "";
+    return new _VM(this._client, vmId, this.baseUrl, vm);
+  }
+  async run(command, options = {}) {
+    const { idempotencyKey, ...body } = options;
+    const headers = idempotencyKey ? { "Idempotency-Key": idempotencyKey } : void 0;
+    const response = await this._client._request(
+      "POST",
+      `${vmPath(this.id)}/runs`,
+      { ...body, command },
+      this.baseUrl,
+      headers
+    );
+    return parseRunResponse(response);
+  }
+  async sync(path, data) {
+    if (data === void 0) return this.syncRead(path);
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (bytes.length <= CHUNK_SIZE) await this.syncWriteInline(path, bytes);
+    else await this.syncWritePresigned(path, bytes);
+  }
+  async syncRead(path) {
+    const response = await this._client._request(
+      "POST",
+      `${vmPath(this.id)}/sync`,
+      { op: "read", path },
+      this.baseUrl
+    );
+    if ("content" in response) return decodeBytes(response.content, response.encoding);
+    const signed = await this._client._fetch(response.presigned_url);
+    if (!signed.ok) throw new ArkerError("internal", `signed GET failed: ${signed.status}`, signed.status);
+    return new Uint8Array(await signed.arrayBuffer());
+  }
+  async syncWriteInline(path, data) {
+    const result = await this.sendOneWrite({
+      path,
+      size: data.length,
+      upload_id: ulid(),
+      content: bytesToBase64(data),
+      start: 0,
+      end: data.length
+    });
+    assertWriteComplete(result, "inline write");
+  }
+  async syncWritePresigned(path, data) {
+    const request = await this.sendOneWrite({ path, size: data.length, presigned: true });
+    if (!("presigned_url" in request) || !request.presigned_url || !request.upload_id) {
+      throw new ArkerError("internal", "write response missing presigned upload fields", 200);
+    }
+    await this.putPresigned(request.presigned_url, data);
+    const commit = await this.sendOneWrite({ path, size: data.length, upload_id: request.upload_id });
+    assertWriteComplete(commit, "presigned write commit");
+  }
+  async putPresigned(url, data) {
+    const attempts = this._client._retryAttempts();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), PRESIGNED_PUT_TIMEOUT_MS);
+      try {
+        const response = await this._client._fetch(url, {
+          method: "PUT",
+          body: data,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) return;
+        if (!RETRYABLE_HTTP.has(response.status) || attempt === attempts - 1) {
+          throw new ArkerError("internal", `upload PUT failed: ${response.status}`, response.status);
+        }
+      } catch (error) {
+        clearTimeout(timeout);
+        if (error instanceof ArkerError) throw error;
+        if (attempt === attempts - 1) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new ArkerError("network_error", `upload PUT failed: ${message}`, 0);
+        }
+      }
+      await sleep(this._client._retryDelay(attempt));
+    }
+  }
+  async sendOneWrite(entry) {
+    let lastError;
+    const attempts = this._client._retryAttempts();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const response = await this._client._request("POST", `${vmPath(this.id)}/sync`, {
+        op: "write",
+        writes: [entry]
+      }, this.baseUrl);
+      const result = response.results[0];
+      if (!result) throw new ArkerError("internal", "write response missing results[0]", 200);
+      const error = result.error ?? void 0;
+      if (!error) return result;
+      lastError = error;
+      if (!isRetryable(200, { code: error.code, message: error.message }) || attempt === attempts - 1) break;
+      await sleep(this._client._retryDelay(attempt));
+    }
+    throw new ArkerError(lastError?.code ?? "internal", lastError?.message ?? "write failed", 200);
+  }
+  /**
+   * Update this VM's resource allocation and/or network settings via
+   * `PATCH /v1/vms/{id}`. Returns the updated `Vm`.
+   *
+   * Accepts either a `PatchVmRequest` (`{ resources, network }`) or, for
+   * convenience, flat resource fields (`{ vcpu, memory_mib, disk_mib }`)
+   * which are folded into `resources`.
+   */
+  async resize(request) {
+    const r = request;
+    const body = r.resources !== void 0 || r.vcpu === void 0 && r.memory_mib === void 0 && r.disk_mib === void 0 ? { resources: r.resources ?? null, network: r.network ?? null } : {
+      resources: {
+        vcpu: r.vcpu ?? null,
+        memory_mib: r.memory_mib ?? null,
+        disk_mib: r.disk_mib ?? null
+      },
+      network: r.network ?? null
+    };
+    return this._client._request("PATCH", vmPath(this.id), body, this.baseUrl);
+  }
+  async delete() {
+    return this._client._request("DELETE", vmPath(this.id), void 0, this.baseUrl);
+  }
+  // ── Syncs: bindings of a filesystem into this VM at a path ────────
+  async listSyncs(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/syncs`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      filesystem_id: opts.filesystemId
+    }), void 0, this.baseUrl);
+  }
+  async createSync(request) {
+    return this._client._request("POST", `${vmPath(this.id)}/syncs`, {
+      filesystem_id: request.filesystemId,
+      path: request.path
+    }, this.baseUrl);
+  }
+  async deleteSync(syncId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/syncs/${pathSegment(syncId)}`, void 0, this.baseUrl);
+  }
+  // ── Runs ──────────────────────────────────────────────────────────
+  async listRuns(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/runs`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      state: opts.state,
+      started_after: opts.startedAfter,
+      started_before: opts.startedBefore,
+      completed_after: opts.completedAfter
+    }), void 0, this.baseUrl);
+  }
+  async getRun(runId) {
+    return this._client._request("GET", `${vmPath(this.id)}/runs/${pathSegment(runId)}`, void 0, this.baseUrl);
+  }
+  async cancelRun(runId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/runs/${pathSegment(runId)}`, void 0, this.baseUrl);
+  }
+  // ── Sessions ──────────────────────────────────────────────────────
+  async listSessions(opts = {}) {
+    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/sessions`, {
+      cursor: opts.cursor,
+      limit: opts.limit,
+      state: opts.state
+    }), void 0, this.baseUrl);
+  }
+  async createSession(request = {}) {
+    return this._client._request("POST", `${vmPath(this.id)}/sessions`, request, this.baseUrl);
+  }
+  async getSession(sessionId) {
+    return this._client._request("GET", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
+  }
+  async deleteSession(sessionId) {
+    return this._client._request("DELETE", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
+  }
+  async connectPty(options = {}) {
+    const sessionId = options.sessionId ?? sessionIdFrom(await this.createSession());
+    const useTicket = options.useTicket ?? !isNodeRuntime();
+    const params = {
+      cols: options.cols,
+      rows: options.rows,
+      command: options.command,
+      persist: options.persist,
+      cancel_ttl_secs: options.cancelTtlSecs && options.cancelTtlSecs > 0 ? Math.floor(options.cancelTtlSecs) : void 0
+    };
+    let ticket;
+    if (useTicket) {
+      const response = await this._client._request(
+        "POST",
+        `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}/pty-ticket`,
+        {},
+        this.baseUrl
+      );
+      ticket = response.ticket;
+    }
+    const url = buildPtyWebSocketUrl(this.baseUrl, this.id, sessionId, { ...params, ticket });
+    const factory = options.webSocketFactory ?? (useTicket ? browserPtyWebSocketFactory : nodePtyWebSocketFactory);
+    const socket = await factory(url, useTicket ? {} : { headers: this._client._authHeaders() });
+    return new PtyConnectionImpl(sessionId, socket);
+  }
+};
+function buildQuery(path, params) {
+  const usp = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    usp.append(key, String(value));
+  }
+  const qs = usp.toString();
+  return qs ? `${path}?${qs}` : path;
+}
+function buildPtyWebSocketUrl(baseUrl, vmId, sessionId, params) {
+  const url = new URL(`${normalizeBaseUrl(baseUrl)}${vmPath(vmId)}/sessions/${pathSegment(sessionId)}/pty`);
+  if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol === "http:") url.protocol = "ws:";
+  else throw new Error(`unsupported PTY WebSocket protocol: ${url.protocol}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function sessionIdFrom(session) {
+  const id = session.session_id ?? session.id;
+  if (!id) throw new ArkerError("internal", "createSession response missing session_id", 200);
+  return id;
+}
+function isNodeRuntime() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+async function nodePtyWebSocketFactory(url, init) {
+  const ws = await import("ws");
+  return new ws.default(url, { headers: init.headers });
+}
+function browserPtyWebSocketFactory(url) {
+  if (typeof globalThis.WebSocket !== "function") {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  return new globalThis.WebSocket(url);
+}
+var PtyConnectionImpl = class {
+  constructor(sessionId, socket) {
+    this.sessionId = sessionId;
+    this.socket = socket;
+    try {
+      socket.binaryType = "arraybuffer";
+    } catch {
+    }
+    this.ready = waitForSocketOpen(socket);
+    addSocketListener(socket, "message", (event) => {
+      const data = messageData(event);
+      if (data !== void 0) this.emitData(bytesFromMessageData(data));
+    });
+    addSocketListener(socket, "close", (event) => this.emitClose(closeEvent(event)));
+    addSocketListener(socket, "error", (event) => this.emitError(event));
+  }
+  sessionId;
+  socket;
+  ready;
+  dataListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  onData(listener) {
+    this.dataListeners.add(listener);
+    return () => this.dataListeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  send(data) {
+    this.socket.send(ptyInputBytes(data));
+  }
+  resize(cols, rows) {
+    this.socket.send(JSON.stringify({ type: "resize", cols: clampPtyDimension(cols), rows: clampPtyDimension(rows) }));
+  }
+  kill() {
+    this.socket.send(JSON.stringify({ type: "kill" }));
+  }
+  close(code, reason) {
+    this.socket.close(code, reason);
+  }
+  emitData(data) {
+    for (const listener of this.dataListeners) listener(data);
+  }
+  emitClose(event) {
+    for (const listener of this.closeListeners) listener(event);
+  }
+  emitError(error) {
+    for (const listener of this.errorListeners) listener(error);
+  }
+};
+function waitForSocketOpen(socket) {
+  if (socket.readyState === 1) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let removeOpen;
+    let removeError;
+    let removeClose;
+    const cleanup = () => {
+      removeOpen?.();
+      removeError?.();
+      removeClose?.();
+    };
+    removeOpen = addSocketListener(socket, "open", () => {
+      cleanup();
+      resolve();
+    });
+    removeError = addSocketListener(socket, "error", (event) => {
+      cleanup();
+      reject(event instanceof Error ? event : new Error("PTY WebSocket failed to open"));
+    });
+    removeClose = addSocketListener(socket, "close", (event) => {
+      cleanup();
+      const ev = closeEvent(event);
+      reject(new Error(`PTY WebSocket closed before opening${ev.code ? ` (${ev.code})` : ""}`));
+    });
+  });
+}
+function addSocketListener(socket, type, listener) {
+  if (socket.addEventListener) {
+    socket.addEventListener(type, listener);
+    return () => socket.removeEventListener?.(type, listener);
+  }
+  if (socket.on) {
+    const nodeListener = (...args) => {
+      if (type === "message") listener({ data: args[0] });
+      else if (type === "close") listener({ code: args[0], reason: args[1] });
+      else listener(args[0]);
+    };
+    socket.on(type, nodeListener);
+    return () => socket.off?.(type, nodeListener);
+  }
+  return () => {
+  };
+}
+function messageData(event) {
+  if (event && typeof event === "object" && "data" in event) {
+    return event.data;
+  }
+  return void 0;
+}
+function closeEvent(event) {
+  if (!event || typeof event !== "object") return {};
+  const raw = event;
+  return {
+    code: typeof raw.code === "number" ? raw.code : void 0,
+    reason: typeof raw.reason === "string" ? raw.reason : void 0
+  };
+}
+function bytesFromMessageData(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (Array.isArray(data)) {
+    const chunks = data.map(bytesFromMessageData);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return out;
+  }
+  return new Uint8Array();
+}
+function ptyInputBytes(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  return data;
+}
+function clampPtyDimension(value) {
+  if (!Number.isFinite(value)) return 1;
+  return Math.max(1, Math.min(1e3, Math.trunc(value)));
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (!trimmed) throw new Error("baseUrl must not be empty");
+  return trimmed;
+}
+function normalizeRegion(region) {
+  const trimmed = region.trim().toLowerCase();
+  if (!trimmed) throw new Error("region must not be empty");
+  return trimmed;
+}
+function computeBaseUrl(provider, region) {
+  const normalized = normalizeRegion(region);
+  return `https://${provider}-${normalized}.arker.ai/api`;
+}
+function parseProvider(value) {
+  if (!value) return DEFAULT_PROVIDER;
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "aws-burst" || trimmed === "burst") return "aws-burst";
+  return "aws";
+}
+function splitRegion(value) {
+  if (!value) return {};
+  const normalized = value.trim().toLowerCase();
+  if (normalized.startsWith("aws-burst-")) {
+    return { region: normalized.slice("aws-burst-".length), providerFromRegion: "aws-burst" };
+  }
+  if (normalized.startsWith("aws-")) {
+    return { region: normalized.slice("aws-".length), providerFromRegion: "aws" };
+  }
+  return { region: normalized };
+}
+function isBurstRef(ref) {
+  const trimmed = ref.trim();
+  return BURST_SOURCE_REFS.has(trimmed.toLowerCase()) || BURST_VM_ID.test(trimmed);
+}
+function normalizeRetry(retry) {
+  if (retry === false) {
+    return { attempts: 1, baseDelayMs: 0, maxDelayMs: 0, jitterMs: 0 };
+  }
+  return {
+    attempts: Math.max(1, Math.floor(retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS)),
+    baseDelayMs: Math.max(0, retry?.baseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS),
+    maxDelayMs: Math.max(0, retry?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS),
+    jitterMs: Math.max(0, retry?.jitterMs ?? DEFAULT_RETRY_JITTER_MS)
+  };
+}
+function env(name) {
+  const value = globalThis.process?.env?.[name];
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function vmPath(vmId) {
+  return `/v1/vms/${pathSegment(vmId)}`;
+}
+function pathSegment(value) {
+  return encodeURIComponent(value);
+}
+function withoutUndefined(value) {
+  if (Array.isArray(value)) return value.map(withoutUndefined);
+  if (!value || typeof value !== "object") return value;
+  const output = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0) output[key] = withoutUndefined(entry);
+  }
+  return output;
+}
+function parseRunResponse(payload) {
+  const body = objectPayload(payload, "run response");
+  if (typeof body.stdout === "string") {
+    const stdout = stringValue(body.stdout, "run response.stdout");
+    const stdoutEncoding = stringField(body.stdout_encoding, "run response.stdout_encoding");
+    const stderr = stringValue(body.stderr, "run response.stderr");
+    const stderrEncoding = stringField(body.stderr_encoding, "run response.stderr_encoding");
+    return {
+      type: "completed",
+      runId: typeof body.run_id === "string" ? body.run_id : void 0,
+      state: typeof body.state === "string" ? body.state : "completed",
+      stdout: decodeBytes(stdout, stdoutEncoding),
+      stdoutEncoding,
+      stderr: decodeBytes(stderr, stderrEncoding),
+      stderrEncoding,
+      exitCode: numberField(body.exit_code, "run response.exit_code"),
+      failReason: typeof body.fail_reason === "string" ? body.fail_reason : null,
+      memoryRequestedMib: optionalNumberOrNull(body.memory_requested_mib),
+      memoryAchievedMib: optionalNumberOrNull(body.memory_achieved_mib),
+      memoryPartial: typeof body.memory_partial === "boolean" ? body.memory_partial : void 0
+    };
+  }
+  if (typeof body.run_id === "string") {
+    return {
+      type: "background",
+      runId: body.run_id,
+      state: typeof body.state === "string" ? body.state : "running"
+    };
+  }
+  throw new ArkerError("internal", "unrecognized run response shape", 200);
+}
+function parseJson(text) {
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function extractError(payload) {
+  if (!isObject(payload)) return void 0;
+  if (typeof payload.code === "string" && typeof payload.message === "string") {
+    return { code: payload.code, message: payload.message };
+  }
+  if (isObject(payload.error)) {
+    return {
+      code: typeof payload.error.code === "string" ? payload.error.code : "internal",
+      message: typeof payload.error.message === "string" ? payload.error.message : ""
+    };
+  }
+  return void 0;
+}
+function isRetryable(status, error) {
+  if (RETRYABLE_HTTP.has(status)) return true;
+  if (!error) return false;
+  if (RETRYABLE_CODES.has(error.code)) return true;
+  if (error.code !== "internal") return false;
+  return TRANSIENT_HINTS.some((hint) => error.message.includes(hint));
+}
+function retryDelay(retry, attempt) {
+  const base = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** attempt);
+  return base + jitter(retry.jitterMs);
+}
+function jitter(maxMs) {
+  return Math.floor(Math.random() * (maxMs + 1));
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function objectPayload(value, context) {
+  if (!isObject(value)) throw new ArkerError("internal", `${context} must be an object`, 200);
+  return value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(value, context) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ArkerError("internal", `${context} must be a non-empty string`, 200);
+  }
+  return value;
+}
+function stringValue(value, context) {
+  if (typeof value !== "string") throw new ArkerError("internal", `${context} must be a string`, 200);
+  return value;
+}
+function numberField(value, context) {
+  if (typeof value !== "number") throw new ArkerError("internal", `${context} must be a number`, 200);
+  return value;
+}
+function optionalNumberOrNull(value) {
+  if (value === null || typeof value === "number") return value;
+  return void 0;
+}
+function assertWriteComplete(result, context) {
+  if (result.complete && result.written) return;
+  throw new ArkerError("internal", `${context} did not complete`, 200);
+}
+function ulid() {
+  const crypto = globalThis.crypto;
+  if (!crypto?.getRandomValues) throw new Error("crypto.getRandomValues is required in this runtime");
+  const time = BigInt(Date.now()) & (1n << 48n) - 1n;
+  const rand = new Uint8Array(10);
+  crypto.getRandomValues(rand);
+  let raw = time << 80n | rand.reduce((acc, byte) => acc << 8n | BigInt(byte), 0n);
+  const out = [];
+  for (let i = 0; i < 26; i++) {
+    out.push(ULID_ALPHABET[Number(raw & 31n)]);
+    raw >>= 5n;
+  }
+  return out.reverse().join("");
+}
+function decodeBytes(text, encoding) {
+  if (encoding === "base64") return base64ToBytes(text);
+  return new TextEncoder().encode(text);
+}
+function bytesToBase64(data) {
+  const buffer = bufferConstructor();
+  if (buffer) return buffer.from(data).toString("base64");
+  let binary = "";
+  for (let offset = 0; offset < data.length; offset += 32768) {
+    const chunk = data.subarray(offset, offset + 32768);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+}
+function base64ToBytes(text) {
+  const buffer = bufferConstructor();
+  if (buffer) {
+    const decoded = buffer.from(text, "base64");
+    return new Uint8Array(decoded.buffer, decoded.byteOffset, decoded.byteLength);
+  }
+  const binary = atob(text);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function bufferConstructor() {
+  return globalThis.Buffer;
+}
+
+// src/compat/arker-provider.ts
+var DEFAULT_REGION = "aws-us-east-1";
+var DEFAULT_SOURCE = "ubuntu-full";
+function env2(key) {
+  const value = globalThis.process?.env?.[key];
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function makeClient(config = {}) {
+  const endpointConfigured = config.baseUrl || config.region || env2("ARKER_BASE_URL") || env2("ARKER_REGION");
+  return new Arker({
+    ...config,
+    region: config.region ?? (endpointConfigured ? void 0 : DEFAULT_REGION)
+  });
+}
+function decode(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function toFileEntries(stdout) {
+  const entries = [];
+  for (const line of stdout.split("\n")) {
+    if (!line) continue;
+    const parts = line.split("	");
+    if (parts.length < 4) continue;
+    const [type, size, mtime, ...nameParts] = parts;
+    entries.push({
+      name: nameParts.join("	"),
+      type: type === "d" ? "directory" : "file",
+      size: Number(size) || 0,
+      modified: new Date((Number(mtime) || 0) * 1e3)
+    });
+  }
+  return entries;
+}
+var ArkerComputeSandbox = class {
+  constructor(vm, destroyVm) {
+    this.vm = vm;
+    this.destroyVm = destroyVm;
+    this.sandboxId = vm.id;
+    this.filesystem = {
+      readFile: async (path) => decode(await this.vm.sync(path)),
+      writeFile: async (path, content) => {
+        await this.vm.sync(path, content);
+      },
+      mkdir: async (path) => {
+        const result = await this.runCommand(`mkdir -p ${shellQuote(path)}`);
+        if (result.exitCode !== 0) throw new Error(`Arker mkdir failed for ${path}: ${result.stderr || `exit ${result.exitCode}`}`);
+      },
+      readdir: async (path) => {
+        const p = shellQuote(path);
+        const script = `cd ${p} 2>/dev/null || exit 3; for e in * .*; do [ "$e" = "." ] && continue; [ "$e" = ".." ] && continue; [ -e "$e" ] || continue; if [ -d "$e" ]; then t=d; else t=f; fi; s=$(stat -c %s "$e" 2>/dev/null || echo 0); m=$(stat -c %Y "$e" 2>/dev/null || echo 0); printf '%s\\t%s\\t%s\\t%s\\n' "$t" "$s" "$m" "$e"; done`;
+        const result = await this.runCommand(script);
+        if (result.exitCode !== 0) throw new Error(`Arker readdir failed for ${path}: ${result.stderr || `exit ${result.exitCode}`}`);
+        return toFileEntries(result.stdout);
+      },
+      exists: async (path) => {
+        const result = await this.runCommand(`test -e ${shellQuote(path)}`);
+        return result.exitCode === 0;
+      },
+      remove: async (path) => {
+        const result = await this.runCommand(`rm -rf ${shellQuote(path)}`);
+        if (result.exitCode !== 0) throw new Error(`Arker remove failed for ${path}: ${result.stderr || `exit ${result.exitCode}`}`);
+      }
+    };
+  }
+  vm;
+  destroyVm;
+  sandboxId;
+  provider = "arker";
+  filesystem;
+  getInstance() {
+    return this.vm;
+  }
+  async runCommand(command, options) {
+    const startTime = Date.now();
+    let fullCommand = command;
+    if (options?.env && Object.keys(options.env).length > 0) {
+      const envPrefix = Object.entries(options.env).map(([key, value]) => `${key}=${shellQuote(String(value))}`).join(" ");
+      fullCommand = `${envPrefix} ${fullCommand}`;
+    }
+    if (options?.cwd) fullCommand = `cd ${shellQuote(options.cwd)} && ${fullCommand}`;
+    if (options?.background) fullCommand = `nohup sh -lc ${shellQuote(fullCommand)} > /dev/null 2>&1 &`;
+    const runOptions = {};
+    if (options?.timeout) runOptions.timeout = options.timeout;
+    const result = await this.vm.run(fullCommand, runOptions);
+    if (result.type !== "completed") {
+      throw new Error(`Arker run did not complete synchronously (type=${result.type}). runCommand requires a foreground command.`);
+    }
+    const commandResult = {
+      stdout: decode(result.stdout),
+      stderr: decode(result.stderr),
+      exitCode: result.exitCode,
+      durationMs: Date.now() - startTime
+    };
+    emitFinalOutput(commandResult, options);
+    return commandResult;
+  }
+  async getInfo() {
+    return {
+      id: this.sandboxId,
+      provider: "arker",
+      status: "running",
+      createdAt: this.vm.created_at ? new Date(this.vm.created_at) : /* @__PURE__ */ new Date(),
+      timeout: 0,
+      metadata: {
+        name: this.vm.name,
+        region: this.vm.region,
+        provider: this.vm.provider
+      }
+    };
+  }
+  async getUrl(_options) {
+    throw new ArkerError(
+      "unsupported_operation",
+      "getUrl is not supported: the Arker VM API does not expose tunnel URLs",
+      422
+    );
+  }
+  async destroy() {
+    await this.destroyVm(this.sandboxId);
+  }
+};
+function createArkerComputeProvider(config = {}) {
+  async function destroy(sandboxId) {
+    const client = makeClient(config);
+    try {
+      await client.vm(sandboxId).delete();
+    } catch (error) {
+      if (error instanceof ArkerError && error.status === 404) return;
+      throw error;
+    }
+  }
+  function wrap(vm) {
+    return new ArkerComputeSandbox(vm, destroy);
+  }
+  return {
+    name: "arker",
+    sandbox: {
+      create: async (options) => {
+        const client = makeClient(config);
+        const source = options?.templateId || options?.snapshotId || config.source || env2("ARKER_SOURCE") || DEFAULT_SOURCE;
+        const forkRequest = {};
+        if (options?.name) forkRequest.name = options.name;
+        const vm = await client.fork(source, forkRequest);
+        return wrap(vm);
+      },
+      getById: async (sandboxId) => {
+        const client = makeClient(config);
+        try {
+          return wrap(await client.getVm(sandboxId));
+        } catch (error) {
+          if (error instanceof ArkerError && error.status === 404) return null;
+          throw error;
+        }
+      },
+      list: async () => {
+        const client = makeClient(config);
+        const { vms } = await client.listVms();
+        return (vms ?? []).map(wrap);
+      },
+      destroy
+    }
+  };
+}
+
+// src/compat/runtime.ts
+var computeFactory = import_computesdk.compute;
+function createCompatSdk(options) {
+  return computeFactory({
+    providers: [
+      createArkerComputeProvider(options.arker),
+      options.fallbackProvider
+    ],
+    providerStrategy: "priority",
+    fallbackOnError: true
+  });
+}
+
+// src/modal.ts
+var MODAL_CONFIG_KEYS = ["tokenId", "tokenSecret", "arker"];
+var MODAL_EXEC_OPTION_KEYS = ["workdir", "env", "timeoutMs", "stdout", "stderr", "mode"];
+function lazyModalProvider(config) {
+  let provider = null;
+  const getProvider = () => {
+    provider ??= (0, import_modal.modal)({
+      tokenId: config?.tokenId,
+      tokenSecret: config?.tokenSecret
+    });
+    return provider;
+  };
+  return {
+    name: "modal",
+    sandbox: {
+      create: (options) => getProvider().sandbox.create(options),
+      getById: (sandboxId) => getProvider().sandbox.getById(sandboxId),
+      destroy: (sandboxId) => getProvider().sandbox.destroy(sandboxId),
+      list: () => getProvider().sandbox.list()
+    }
+  };
+}
+function assertOptionValue(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function toRunCommandOptions(opts) {
+  assertSupportedObjectKeys(opts, MODAL_EXEC_OPTION_KEYS, "modal", "Sandbox.exec");
+  if (opts === void 0) return void 0;
+  const modalOpts = opts;
+  assertOptionValue(
+    modalOpts.workdir === void 0 || typeof modalOpts.workdir === "string",
+    "Sandbox.exec option 'workdir' must be a string in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.timeoutMs === void 0 || typeof modalOpts.timeoutMs === "number",
+    "Sandbox.exec option 'timeoutMs' must be a number in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.env === void 0 || isStringRecord(modalOpts.env),
+    "Sandbox.exec option 'env' must be an object in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.stdout === void 0 || modalOpts.stdout === "pipe",
+    "Sandbox.exec only supports stdout: 'pipe' in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.stderr === void 0 || modalOpts.stderr === "pipe",
+    "Sandbox.exec only supports stderr: 'pipe' in the Arker compatibility layer for modal."
+  );
+  assertOptionValue(
+    modalOpts.mode === void 0 || modalOpts.mode === "text",
+    "Sandbox.exec only supports mode: 'text' in the Arker compatibility layer for modal."
+  );
+  const runOptions = {};
+  if (modalOpts.workdir !== void 0) runOptions.cwd = modalOpts.workdir;
+  if (modalOpts.env !== void 0) runOptions.env = modalOpts.env;
+  if (modalOpts.timeoutMs !== void 0) runOptions.timeout = modalOpts.timeoutMs;
+  return Object.keys(runOptions).length > 0 ? runOptions : void 0;
+}
+var ModalProcess = class {
+  stdout;
+  stderr;
+  #exitCode;
+  constructor(out, err, exitCode) {
+    this.#exitCode = exitCode;
+    this.stdout = { readText: async () => out };
+    this.stderr = { readText: async () => err };
+  }
+  async wait() {
+    return this.#exitCode;
+  }
+};
+var Sandbox = class {
+  sandboxId;
+  #box;
+  constructor(box) {
+    this.#box = box;
+    this.sandboxId = box.sandboxId;
+  }
+  async exec(cmd, opts) {
+    const command = argvToCommand(cmd);
+    const runOptions = toRunCommandOptions(opts);
+    const result = runOptions ? await this.#box.runCommand(command, runOptions) : await this.#box.runCommand(command);
+    return new ModalProcess(result.stdout, result.stderr, result.exitCode);
+  }
+  async terminate() {
+    await this.#box.destroy();
+  }
+};
+var ModalClient = class {
+  #sdk;
+  constructor(config) {
+    assertSupportedObjectKeys(config, MODAL_CONFIG_KEYS, "modal", "new ModalClient");
+    this.#sdk = createCompatSdk({
+      arker: config?.arker,
+      fallbackProvider: lazyModalProvider({
+        tokenId: config?.tokenId,
+        tokenSecret: config?.tokenSecret
+      })
+    });
+    return guardUnsupported(this, "modal");
+  }
+  sandboxes = {
+    create: async (...args) => {
+      assertNoUnsupportedArgs(args, "modal", "ModalClient.sandboxes.create");
+      const box = await this.#sdk.sandbox.create({});
+      return guardUnsupported(new Sandbox(box), "modal");
+    },
+    fromId: async (sandboxId) => {
+      const box = await this.#sdk.sandbox.getById(sandboxId);
+      if (!box) throw new Error(`Sandbox ${sandboxId} not found`);
+      return guardUnsupported(new Sandbox(box), "modal");
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModalClient,
+  Sandbox
+});