disk 0.8.17 → 0.8.19

package/dist/index.js

@@ -1,1202 +0,0 @@
-// src/client.ts
-import createClientDefault from "openapi-fetch";
-
-// src/s3xml.ts
-import { XMLParser } from "fast-xml-parser";
-var parser = new XMLParser({
-  isArray: (name) => name === "Contents" || name === "CommonPrefixes",
-  parseTagValue: false,
-  trimValues: true,
-  ignoreAttributes: true
-});
-function parseXml(xml) {
-  if (!xml.trim()) return {};
-  return parser.parse(xml);
-}
-
-// src/errors.ts
-var ArchilError = class extends Error {
-  /** HTTP status code associated with the failure. */
-  status;
-  /** Machine-readable error code (e.g. an S3 code like "NoSuchKey"), if known. */
-  code;
-  constructor(message, status, code) {
-    super(message);
-    this.name = "ArchilError";
-    this.status = status;
-    this.code = code;
-  }
-};
-var ArchilApiError = class extends ArchilError {
-  constructor(message, status, code) {
-    super(message, status, code);
-    this.name = "ArchilApiError";
-  }
-};
-var ArchilS3Error = class extends ArchilError {
-  /** S3 request id, if the gateway returned one. */
-  requestId;
-  /** Raw response body (the XML document), for debugging. */
-  raw;
-  constructor(opts) {
-    const detail = opts.message ?? opts.statusText ?? "";
-    const codePart = opts.code ? ` ${opts.code}` : "";
-    super(
-      `S3 ${opts.operation} failed: ${opts.statusCode}${codePart}${detail ? ` \u2014 ${detail}` : ""}`,
-      opts.statusCode,
-      opts.code
-    );
-    this.name = "ArchilS3Error";
-    this.requestId = opts.requestId;
-    this.raw = opts.raw;
-  }
-};
-function tagString(obj, tag) {
-  const value = obj[tag];
-  return value === void 0 || value === null ? void 0 : String(value);
-}
-function parseS3Error(operation, statusCode, statusText, body) {
-  let err = {};
-  try {
-    err = parseXml(body).Error ?? {};
-  } catch {
-    err = {};
-  }
-  return new ArchilS3Error({
-    operation,
-    statusCode,
-    statusText,
-    code: tagString(err, "Code"),
-    message: tagString(err, "Message"),
-    requestId: tagString(err, "RequestId"),
-    raw: body
-  });
-}
-
-// src/regions.ts
-var REGION_URLS = {
-  "aws-us-east-1": "https://control.green.us-east-1.aws.prod.archil.com",
-  "aws-us-west-2": "https://control.green.us-west-2.aws.prod.archil.com",
-  "aws-eu-west-1": "https://control.green.eu-west-1.aws.prod.archil.com",
-  "gcp-us-central1": "https://control.blue.us-central1.gcp.prod.archil.com"
-};
-function resolveBaseUrl(region) {
-  const url = REGION_URLS[region];
-  if (!url) {
-    throw new Error(
-      `Unknown region "${region}". Valid regions: ${Object.keys(REGION_URLS).join(", ")}`
-    );
-  }
-  return url;
-}
-function deriveS3BaseUrl(controlBaseUrl) {
-  try {
-    const u = new URL(controlBaseUrl);
-    u.hostname = u.hostname.replace(/^control\./, "s3.");
-    return u.toString().replace(/\/$/, "");
-  } catch {
-    return void 0;
-  }
-}
-
-// src/version.ts
-var VERSION = true ? "0.8.17" : "0.0.0-dev";
-var USER_AGENT = `archil-js/${VERSION}`;
-
-// src/client.ts
-var createClient = typeof createClientDefault === "function" ? createClientDefault : createClientDefault.default;
-function createApiClient(opts) {
-  const baseUrl = opts.baseUrl ?? resolveBaseUrl(opts.region);
-  return createClient({
-    baseUrl,
-    headers: {
-      Authorization: `key-${opts.apiKey.replace(/^key-/, "")}`,
-      // Identifies the JS SDK (and its version) to the control plane. Honored
-      // by Node's fetch; browsers treat User-Agent as a forbidden header and
-      // drop it, which is fine — the SDK's primary use is server-side.
-      "User-Agent": USER_AGENT
-    }
-  });
-}
-async function unwrap(promise) {
-  const { data: body, error, response } = await promise;
-  if (error || !body) {
-    const errBody = error;
-    throw new ArchilApiError(
-      errBody?.error ?? `API request failed with status ${response.status}`,
-      response.status
-    );
-  }
-  if (!body.success) {
-    throw new ArchilApiError(
-      body.error ?? "Unknown API error",
-      response.status
-    );
-  }
-  return body.data;
-}
-async function unwrapEmpty(promise) {
-  const { data: body, error, response } = await promise;
-  if (error || !body) {
-    const errBody = error;
-    throw new ArchilApiError(
-      errBody?.error ?? `API request failed with status ${response.status}`,
-      response.status
-    );
-  }
-  if (!body.success) {
-    throw new ArchilApiError(
-      body.error ?? "Unknown API error",
-      response.status
-    );
-  }
-}
-
-// src/disk.ts
-var Disk = class {
-  id;
-  name;
-  organization;
-  status;
-  provider;
-  region;
-  createdAt;
-  fsHandlerStatus;
-  lastAccessed;
-  dataSize;
-  monthlyUsage;
-  mounts;
-  metrics;
-  connectedClients;
-  authorizedUsers;
-  allowedIps;
-  /** @internal */
-  _client;
-  /** @internal */
-  _archilRegion;
-  /** Base URL for the S3-compatible API (port 9000 ingress). Empty if unset. */
-  _s3BaseUrl;
-  /** Lazily-constructed multipart namespace (see {@link multipart}). @internal */
-  _multipart;
-  /** @internal */
-  constructor(data, client, archilRegion, s3BaseUrl) {
-    this.id = data.id;
-    this.name = data.name;
-    this.organization = data.organization;
-    this.status = data.status;
-    this.provider = data.provider;
-    this.region = data.region;
-    this.createdAt = data.createdAt;
-    this.fsHandlerStatus = data.fsHandlerStatus;
-    this.lastAccessed = data.lastAccessed;
-    this.dataSize = data.dataSize;
-    this.monthlyUsage = data.monthlyUsage;
-    this.mounts = data.mounts;
-    this.metrics = data.metrics;
-    this.connectedClients = data.connectedClients;
-    this.authorizedUsers = data.authorizedUsers;
-    this.allowedIps = data.allowedIps;
-    this._client = client;
-    this._archilRegion = archilRegion;
-    this._s3BaseUrl = s3BaseUrl ?? "";
-  }
-  toJSON() {
-    return {
-      id: this.id,
-      name: this.name,
-      organization: this.organization,
-      status: this.status,
-      provider: this.provider,
-      region: this.region,
-      createdAt: this.createdAt,
-      fsHandlerStatus: this.fsHandlerStatus,
-      lastAccessed: this.lastAccessed,
-      dataSize: this.dataSize,
-      monthlyUsage: this.monthlyUsage,
-      mounts: this.mounts,
-      metrics: this.metrics,
-      connectedClients: this.connectedClients,
-      authorizedUsers: this.authorizedUsers,
-      allowedIps: this.allowedIps
-    };
-  }
-  async addUser(user) {
-    return unwrap(
-      this._client.POST("/api/disks/{id}/users", {
-        params: { path: { id: this.id } },
-        body: user
-      })
-    );
-  }
-  async removeUser(userType, identifier) {
-    await unwrapEmpty(
-      this._client.DELETE("/api/disks/{id}/users/{userType}", {
-        params: {
-          path: { id: this.id, userType },
-          query: { identifier }
-        }
-      })
-    );
-  }
-  async createToken(nickname) {
-    const user = await unwrap(
-      this._client.POST("/api/disks/{id}/users", {
-        params: { path: { id: this.id } },
-        body: { type: "token", nickname }
-      })
-    );
-    if (!user.token || !user.identifier) {
-      throw new Error("Server did not return a generated token");
-    }
-    return user;
-  }
-  async removeTokenUser(identifier) {
-    await this.removeUser("token", identifier);
-  }
-  async getAllowedIPs() {
-    const data = await unwrap(
-      this._client.GET("/api/disks/{id}/allowed-ips", {
-        params: { path: { id: this.id } }
-      })
-    );
-    return data.allowedIps;
-  }
-  async setAllowedIPs(allowedIps) {
-    const data = await unwrap(
-      this._client.PUT("/api/disks/{id}/allowed-ips", {
-        params: { path: { id: this.id } },
-        body: { allowedIps }
-      })
-    );
-    return data.allowedIps;
-  }
-  async addAllowedIP(ip) {
-    const current = await this.getAllowedIPs();
-    if (current.includes(ip)) return current;
-    return this.setAllowedIPs([...current, ip]);
-  }
-  async removeAllowedIP(ip) {
-    const current = await this.getAllowedIPs();
-    return this.setAllowedIPs(current.filter((i) => i !== ip));
-  }
-  async delete() {
-    await unwrapEmpty(
-      this._client.DELETE("/api/disks/{id}", {
-        params: { path: { id: this.id } }
-      })
-    );
-  }
-  /**
-   * Execute a command in a container with this disk mounted.
-   * Blocks until the command completes and returns stdout, stderr, and exit code.
-   */
-  async exec(command) {
-    return unwrap(
-      this._client.POST("/api/disks/{id}/exec", {
-        params: { path: { id: this.id } },
-        body: { command }
-      })
-    );
-  }
-  /**
-   * Constant-time parallel grep across files on this disk. Listing and
-   * matching are fanned out across ephemeral exec containers; the request
-   * finishes within the supplied time budget regardless of dataset size.
-   *
-   * The returned `stoppedReason` says whether the search ran to completion
-   * or short-circuited on `maxResults` / `maxDurationSeconds`. When
-   * stopping early, the matches returned are a sample (whichever workers
-   * reported first), not the lexicographically first N.
-   */
-  async grep(opts) {
-    return unwrap(
-      this._client.POST("/api/disks/{id}/grep", {
-        params: { path: { id: this.id } },
-        body: {
-          directory: opts.directory,
-          pattern: opts.pattern,
-          recursive: opts.recursive ?? false,
-          maxDurationSeconds: opts.maxDurationSeconds ?? 30,
-          concurrency: opts.concurrency ?? 50,
-          maxResults: opts.maxResults ?? 1e3
-        }
-      })
-    );
-  }
-  /**
-   * Create a signed, time-limited URL that lets anyone download a single file
-   * from this disk without authentication. The returned URL embeds a
-   * cryptographically signed token carrying the disk, the file's key, and an
-   * expiry — share it directly; no API key is needed to redeem it.
-   *
-   * @param key   Path to the file on the disk (e.g. "reports/2026-01/data.pdf").
-   * @param opts  `expiresIn` sets the URL lifetime in seconds (any positive
-   *              integer, max 604800 = 7 days). Defaults to 24h.
-   */
-  async share(key, opts = {}) {
-    const body = { key };
-    if (opts.expiresIn !== void 0) body.expiresIn = opts.expiresIn;
-    const call = this._client.POST;
-    return unwrap(call(`/api/disks/${this.id}/share`, { body }));
-  }
-  /**
-   * Read an object from the disk via the S3-compatible GetObject API and return
-   * its full contents as bytes. Throws `ArchilS3Error` if the object does not
-   * exist (status 404, code "NoSuchKey") or the request is rejected; use
-   * `headObject`/`objectExists` to check existence without throwing.
-   *
-   * @param key  Path on the disk (e.g. "reports/2026-01/data.json")
-   */
-  async getObject(key) {
-    const resp = await this._s3Request("GET", key);
-    if (!resp.ok) {
-      throw parseS3Error("GetObject", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return resp.body;
-  }
-  /**
-   * Fetch an object's metadata (size, etag, content type, last-modified) without
-   * downloading its contents, via the S3-compatible HeadObject API. Returns
-   * `null` if the object does not exist.
-   *
-   * @param key  Path on the disk (e.g. "reports/2026-01/data.json")
-   */
-  async headObject(key) {
-    const resp = await this._s3Request("HEAD", key);
-    if (resp.status === 404) return null;
-    if (!resp.ok) {
-      throw parseS3Error("HeadObject", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    const lastModified = resp.headers.get("last-modified");
-    return {
-      size: Number(resp.headers.get("content-length") ?? 0),
-      etag: resp.headers.get("etag") ?? void 0,
-      contentType: resp.headers.get("content-type") ?? void 0,
-      lastModified: lastModified ? new Date(lastModified) : void 0
-    };
-  }
-  /** Whether an object exists on the disk (a HeadObject that maps 404 → false). */
-  async objectExists(key) {
-    return await this.headObject(key) !== null;
-  }
-  /**
-   * Write an object to the disk via the S3-compatible API. Handles any size:
-   * bodies at or below `multipartThreshold` (defaults to `partSize`, i.e.
-   * 16 MiB) go through a single PutObject request; larger bodies are uploaded as
-   * a multipart upload — split into `partSize` parts, uploaded with bounded
-   * `concurrency` (default 4), and assembled. A failed part aborts the upload so
-   * nothing is left half-staged. For manual control over the multipart
-   * lifecycle, use the {@link multipart} namespace.
-   *
-   * Faster than exec for large files — no container overhead, no command-length
-   * limits. Returns the entity tag the server assigned (a multipart upload's tag
-   * is S3's `md5(concat(partMd5s))-N` form rather than a plain MD5).
-   *
-   * @param key      Path on the disk (e.g. "reports/2026-01/data.json")
-   * @param body     Contents as a string, Uint8Array/Buffer, or ArrayBuffer
-   * @param options  Either a content-type string, or {@link PutObjectOptions}
-   *                 (`contentType`, `multipartThreshold`, `partSize`,
-   *                 `concurrency`). Content type defaults to
-   *                 "application/octet-stream".
-   */
-  async putObject(key, body, options) {
-    const opts = typeof options === "string" ? { contentType: options } : options ?? {};
-    const contentType = opts.contentType ?? "application/octet-stream";
-    const partSize = Math.max(opts.partSize ?? DEFAULT_PART_SIZE, MIN_PART_SIZE);
-    const threshold = opts.multipartThreshold ?? partSize;
-    const bytes = toBytes(body);
-    if (bytes.length <= threshold) {
-      const resp = await this._s3Request("PUT", key, { body, contentType });
-      if (!resp.ok) {
-        throw parseS3Error("PutObject", resp.status, resp.statusText, decodeText(resp.body));
-      }
-      return { etag: resp.headers.get("etag") ?? void 0 };
-    }
-    return this._putMultipart(
-      key,
-      bytes,
-      contentType,
-      partSize,
-      Math.max(1, opts.concurrency ?? DEFAULT_UPLOAD_CONCURRENCY)
-    );
-  }
-  /**
-   * Upload a large body through the multipart lifecycle: split into `partSize`
-   * parts, upload them with bounded concurrency, then complete — aborting the
-   * upload if any part fails so nothing is left half-staged. @internal
-   */
-  async _putMultipart(key, bytes, contentType, partSize, concurrency) {
-    const effectivePartSize = effectiveUploadPartSize(bytes.length, partSize);
-    const mp = this.multipart;
-    const upload = await mp.create(key, contentType);
-    try {
-      const partCount = Math.ceil(bytes.length / effectivePartSize);
-      const parts = new Array(partCount);
-      let next = 0;
-      const worker = async () => {
-        for (; ; ) {
-          const index = next++;
-          if (index >= partCount) return;
-          const start = index * effectivePartSize;
-          const slice = bytes.subarray(start, Math.min(start + effectivePartSize, bytes.length));
-          parts[index] = await mp.uploadPart(key, upload.uploadId, index + 1, slice);
-        }
-      };
-      await Promise.all(Array.from({ length: Math.min(concurrency, partCount) }, worker));
-      const done = await mp.complete(key, upload.uploadId, parts);
-      return { etag: done.etag };
-    } catch (err) {
-      await mp.abort(key, upload.uploadId).catch(() => {
-      });
-      throw err;
-    }
-  }
-  /**
-   * Append bytes to an object via the S3-compatible PutObject append extension
-   * (`?append=true`). If the object already exists the bytes are appended to it;
-   * if it doesn't, it is created. Returns the entity tag of the full object
-   * after the append.
-   *
-   * Each call may append at most 1 MiB — the server rejects a larger body with
-   * `EntityTooLarge`. To grow an object past that, append in chunks (or use
-   * {@link putObject} for a one-shot large write).
-   *
-   * Unlike most operations this is NOT auto-retried on a transient error:
-   * append isn't idempotent, so retrying a succeeded-but-unacknowledged append
-   * would duplicate the bytes. On a transient failure, re-append yourself only
-   * after confirming the object's size.
-   *
-   * @param key          Path on the disk (e.g. "logs/app.log")
-   * @param body         Bytes to append (string, Uint8Array/Buffer, or ArrayBuffer)
-   * @param contentType  MIME type, applied only when the object is newly created.
-   */
-  async appendObject(key, body, contentType = "application/octet-stream") {
-    const resp = await this._s3Request("PUT", key, {
-      body,
-      contentType,
-      query: { append: "true" },
-      retry: false
-    });
-    if (!resp.ok) {
-      throw parseS3Error("AppendObject", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return { etag: resp.headers.get("etag") ?? void 0 };
-  }
-  /**
-   * Delete an object from the disk via the S3-compatible DeleteObject API.
-   * Idempotent: deleting a key that doesn't exist resolves successfully, per
-   * S3 semantics.
-   *
-   * @param key  Path on the disk (e.g. "project/dist/server.cjs")
-   */
-  async deleteObject(key) {
-    const resp = await this._s3Request("DELETE", key);
-    if (!resp.ok && resp.status !== 404) {
-      throw parseS3Error("DeleteObject", resp.status, resp.statusText, decodeText(resp.body));
-    }
-  }
-  /**
-   * List objects on the disk via the S3-compatible ListObjectsV2 API. By
-   * default this follows continuation tokens until the listing is exhausted and
-   * returns every matching key. Use `limit` to cap the total, `singlePage` for a
-   * single request, or {@link listObjectsPages} to stream pages without loading
-   * everything into memory.
-   *
-   * @param prefix  Only return keys beginning with this prefix (omit for all).
-   * @param opts    Listing and pagination options.
-   */
-  async listObjects(prefix, opts = {}) {
-    if (opts.singlePage) {
-      return this._listObjectsPage(prefix, opts);
-    }
-    const objects = [];
-    const commonPrefixes = [];
-    const seenPrefixes = /* @__PURE__ */ new Set();
-    let echoedPrefix;
-    let truncated = false;
-    outer: for await (const page of this.listObjectsPages(prefix, opts)) {
-      echoedPrefix = page.prefix;
-      for (const cp of page.commonPrefixes) {
-        if (!seenPrefixes.has(cp)) {
-          seenPrefixes.add(cp);
-          commonPrefixes.push(cp);
-        }
-      }
-      for (const obj of page.objects) {
-        if (opts.limit !== void 0 && objects.length >= opts.limit) {
-          truncated = true;
-          break outer;
-        }
-        objects.push(obj);
-      }
-    }
-    return { objects, commonPrefixes, isTruncated: truncated, keyCount: objects.length, prefix: echoedPrefix };
-  }
-  /**
-   * Yield ListObjectsV2 pages lazily, following continuation tokens. A
-   * memory-friendly way to process a large listing without materializing it:
-   *
-   * ```ts
-   * for await (const page of disk.listObjectsPages("logs/")) {
-   *   for (const obj of page.objects) process(obj);
-   * }
-   * ```
-   *
-   * @param prefix  Only return keys beginning with this prefix (omit for all).
-   * @param opts    Listing options (`limit` / `singlePage` are ignored here —
-   *                control your own loop).
-   */
-  async *listObjectsPages(prefix, opts = {}) {
-    const seenTokens = /* @__PURE__ */ new Set();
-    let continuationToken = opts.continuationToken;
-    for (; ; ) {
-      const page = await this._listObjectsPage(prefix, { ...opts, continuationToken });
-      yield page;
-      const next = page.isTruncated ? page.nextContinuationToken : void 0;
-      if (!next || seenTokens.has(next)) break;
-      seenTokens.add(next);
-      continuationToken = next;
-    }
-  }
-  /** Fetch a single ListObjectsV2 page. @internal */
-  async _listObjectsPage(prefix, opts) {
-    const query = { "list-type": 2 };
-    if (prefix !== void 0) query.prefix = prefix;
-    if (!opts.recursive) query.delimiter = "/";
-    if (opts.continuationToken !== void 0) query["continuation-token"] = opts.continuationToken;
-    if (opts.startAfter !== void 0) query["start-after"] = opts.startAfter;
-    const resp = await this._s3Request("GET", "", { query });
-    if (!resp.ok) {
-      throw parseS3Error("ListObjectsV2", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return parseListObjectsResult(decodeText(resp.body));
-  }
-  /**
-   * Delete up to many objects in a single S3-compatible DeleteObjects request.
-   * Unlike {@link deleteObject}, failures are reported per key rather than
-   * thrown: the result's `deleted` lists the keys that were removed and
-   * `errors` lists the ones that weren't (with the server's code/message). A
-   * key that didn't exist still counts as deleted, per S3 semantics.
-   *
-   * The server caps a single request at 1000 keys; this method transparently
-   * splits larger inputs into 1000-key batches and merges the results.
-   *
-   * @param keys  Object keys to delete.
-   * @param opts  `quiet` suppresses the per-key success list server-side.
-   */
-  async deleteObjects(keys, opts = {}) {
-    const deleted = [];
-    const errors = [];
-    for (let i = 0; i < keys.length; i += MAX_DELETE_OBJECTS_PER_REQUEST) {
-      const batch = keys.slice(i, i + MAX_DELETE_OBJECTS_PER_REQUEST);
-      const xml = buildDeleteObjectsXml(batch, opts.quiet ?? false);
-      const resp = await this._s3Request("POST", "", {
-        query: { delete: "" },
-        body: xml,
-        contentType: "application/xml"
-      });
-      if (!resp.ok) {
-        throw parseS3Error("DeleteObjects", resp.status, resp.statusText, decodeText(resp.body));
-      }
-      const parsed = parseDeleteObjectsResult(decodeText(resp.body));
-      deleted.push(...parsed.deleted);
-      errors.push(...parsed.errors);
-    }
-    return { deleted, errors };
-  }
-  /**
-   * The advanced, opt-in multipart-upload API. Drive the raw lifecycle
-   * yourself — `create` → `uploadPart` → `complete` (or `abort`), plus
-   * `listParts` / `listUploads`. Most callers don't need this: {@link putObject}
-   * runs the whole lifecycle automatically for large bodies. Reach for it only
-   * when you need manual control (e.g. uploading parts from separate processes),
-   * and note you then own part-size, memory, and concurrency management.
-   */
-  get multipart() {
-    return this._multipart ??= new DiskMultipart(this.id, this._s3Request.bind(this));
-  }
-  /**
-   * Send a single request to the disk's S3-compatible endpoint. This reuses the
-   * control-plane client purely for its credential and transport — the same
-   * `Authorization` header is sent and verified by the same code server-side —
-   * pointed at the S3 host. Returns the response status and fully-buffered body
-   * so callers can inspect both regardless of the verb used.
-   *
-   * The S3 routes (`/{diskId}/{key}` for objects, `/{diskId}` for the bucket)
-   * are not part of the typed control-plane API, so the path and per-request
-   * options are passed untyped. An empty `key` targets the bucket itself (used
-   * by listObjects).
-   *
-   * @internal
-   */
-  async _s3Request(method, key, opts = {}) {
-    if (!this._s3BaseUrl) {
-      throw new Error(
-        "S3 base URL not configured. Pass s3BaseUrl to new Archil({...}) or set ARCHIL_S3_BASE_URL."
-      );
-    }
-    const call = this._client[method];
-    const trimmedKey = key.replace(/^\//, "");
-    const encodedKey = trimmedKey.split("/").map(encodeURIComponent).join("/");
-    const path = encodedKey ? `/${this.id}/${encodedKey}` : `/${this.id}`;
-    const init = {
-      baseUrl: this._s3BaseUrl,
-      parseAs: "stream",
-      ...opts.query ? { params: { query: opts.query } } : {},
-      // fetch accepts string / Uint8Array / ArrayBuffer bodies directly; pass it
-      // through unchanged (no Node Buffer in the data path). Bodies are fully
-      // buffered (never streams), so re-sending one on a retry is safe.
-      ...opts.body !== void 0 ? { body: opts.body, bodySerializer: (b) => b } : {},
-      ...opts.contentType ? { headers: { "Content-Type": opts.contentType } } : {}
-    };
-    const hasBody = method === "GET" || method === "POST";
-    const maxRetries = opts.retry === false ? 0 : MAX_S3_RETRIES;
-    for (let attempt = 0; ; attempt++) {
-      let error;
-      let response;
-      try {
-        ({ error, response } = await call(path, init));
-      } catch (transportError) {
-        if (attempt < maxRetries) {
-          await sleep(s3RetryDelayMs(attempt));
-          continue;
-        }
-        throw transportError;
-      }
-      if (!response.ok) {
-        if (isTransientS3Status(response.status) && attempt < maxRetries) {
-          await response.body?.cancel().catch(() => {
-          });
-          await sleep(s3RetryDelayMs(attempt));
-          continue;
-        }
-        const message = typeof error === "string" ? error : error ? JSON.stringify(error) : "";
-        return {
-          ok: false,
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers,
-          body: new TextEncoder().encode(message)
-        };
-      }
-      const bytes = hasBody ? new Uint8Array(await response.arrayBuffer()) : new Uint8Array(0);
-      return {
-        ok: true,
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-        body: bytes
-      };
-    }
-  }
-  /**
-   * Connect to this disk's data plane via the native ArchilClient.
-   *
-   * Requires the native module to be available (platform-specific .node binary).
-   */
-  async mount(opts) {
-    let ArchilClient;
-    try {
-      const nativeSpecifier = "@archildata/native";
-      const native = await import(nativeSpecifier);
-      ArchilClient = native.ArchilClient ?? native.default?.ArchilClient;
-      if (!ArchilClient) {
-        throw new Error("@archildata/native did not export ArchilClient");
-      }
-    } catch {
-      throw new Error(
-        "Native client not available. Install @archildata/native (platform-specific binary) or use ArchilClient.connect() directly. mount() is not supported in browsers."
-      );
-    }
-    return ArchilClient.connect({
-      region: this._archilRegion,
-      diskName: `${this.organization}/${this.name}`,
-      authToken: opts?.authToken,
-      logLevel: opts?.logLevel,
-      serverAddress: opts?.serverAddress,
-      insecure: opts?.insecure
-    });
-  }
-};
-var DiskMultipart = class {
-  /** @internal */
-  constructor(diskId, s3Request) {
-    this.diskId = diskId;
-    this.s3Request = s3Request;
-  }
-  diskId;
-  s3Request;
-  /**
-   * Start a multipart upload (CreateMultipartUpload) and return its `uploadId`.
-   *
-   * @param key          Path on the disk the finished object will live at.
-   * @param contentType  MIME type to store the object with.
-   */
-  async create(key, contentType) {
-    const resp = await this.s3Request("POST", key, { query: { uploads: "" }, contentType });
-    if (!resp.ok) {
-      throw parseS3Error("CreateMultipartUpload", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    const root = parseXml(decodeText(resp.body)).InitiateMultipartUploadResult ?? {};
-    const uploadId = optionalString(root.UploadId);
-    if (!uploadId) {
-      throw new ArchilS3Error({
-        operation: "CreateMultipartUpload",
-        statusCode: resp.status,
-        message: "response did not contain an UploadId",
-        raw: decodeText(resp.body)
-      });
-    }
-    return {
-      uploadId,
-      key: optionalString(root.Key) ?? key,
-      bucket: optionalString(root.Bucket) ?? this.diskId
-    };
-  }
-  /**
-   * Upload one part (UploadPart) and return its entity tag, which you must
-   * collect (with its part number) and pass to {@link complete}. Every part
-   * except the last must be at least 5 MiB.
-   *
-   * @param key         The upload's object key.
-   * @param uploadId    The id from {@link create}.
-   * @param partNumber  1-based part number (1..=10000).
-   * @param body        Part contents as a string, Uint8Array/Buffer, or ArrayBuffer.
-   */
-  async uploadPart(key, uploadId, partNumber, body) {
-    const resp = await this.s3Request("PUT", key, { query: { uploadId, partNumber }, body });
-    if (!resp.ok) {
-      throw parseS3Error("UploadPart", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return { partNumber, etag: resp.headers.get("etag") ?? "" };
-  }
-  /**
-   * Finish a multipart upload (CompleteMultipartUpload), assembling the listed
-   * parts into one object. Parts are sorted by part number before submission
-   * (the server requires strictly-increasing order).
-   *
-   * Unlike the other operations this is NOT auto-retried on a transient error:
-   * the gateway isn't idempotent for completion, so a retry after a
-   * successful-but-unacknowledged complete would return a spurious NoSuchUpload.
-   * On a transient failure, re-drive completion yourself only after confirming
-   * the object isn't already present.
-   *
-   * @param key       The upload's object key.
-   * @param uploadId  The id from {@link create}.
-   * @param parts     The `{ partNumber, etag }` pairs from {@link uploadPart}.
-   */
-  async complete(key, uploadId, parts) {
-    const sorted = [...parts].sort((a, b) => a.partNumber - b.partNumber);
-    const xml = buildCompleteMultipartUploadXml(sorted);
-    const resp = await this.s3Request("POST", key, {
-      query: { uploadId },
-      body: xml,
-      contentType: "application/xml",
-      retry: false
-    });
-    if (!resp.ok) {
-      throw parseS3Error("CompleteMultipartUpload", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    const root = parseXml(decodeText(resp.body)).CompleteMultipartUploadResult ?? {};
-    return {
-      etag: optionalString(root.ETag),
-      location: optionalString(root.Location),
-      bucket: optionalString(root.Bucket),
-      key: optionalString(root.Key)
-    };
-  }
-  /**
-   * Abort a multipart upload (AbortMultipartUpload), discarding every staged
-   * part. Idempotent against an upload that's already gone (404 / NoSuchUpload
-   * resolves successfully).
-   *
-   * @param key       The upload's object key.
-   * @param uploadId  The id from {@link create}.
-   */
-  async abort(key, uploadId) {
-    const resp = await this.s3Request("DELETE", key, { query: { uploadId } });
-    if (!resp.ok && resp.status !== 404) {
-      throw parseS3Error("AbortMultipartUpload", resp.status, resp.statusText, decodeText(resp.body));
-    }
-  }
-  /**
-   * List the parts already uploaded for an in-progress upload (ListParts).
-   * Returns a single page; follow `nextPartNumberMarker` (when `isTruncated`)
-   * to page through the rest.
-   *
-   * @param key       The upload's object key.
-   * @param uploadId  The id from {@link create}.
-   * @param opts      `maxParts` / `partNumberMarker` pagination controls.
-   */
-  async listParts(key, uploadId, opts = {}) {
-    const query = { uploadId };
-    if (opts.maxParts !== void 0) query["max-parts"] = opts.maxParts;
-    if (opts.partNumberMarker !== void 0) query["part-number-marker"] = opts.partNumberMarker;
-    const resp = await this.s3Request("GET", key, { query });
-    if (!resp.ok) {
-      throw parseS3Error("ListParts", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return parseListPartsResult(decodeText(resp.body));
-  }
-  /**
-   * List in-progress multipart uploads on the disk (ListMultipartUploads).
-   * Returns a single page; follow `nextKeyMarker` / `nextUploadIdMarker` (when
-   * `isTruncated`) for the rest.
-   *
-   * @param opts  Prefix/delimiter filter and pagination markers.
-   */
-  async listUploads(opts = {}) {
-    const query = { uploads: "" };
-    if (opts.prefix !== void 0) query.prefix = opts.prefix;
-    if (opts.delimiter !== void 0) query.delimiter = opts.delimiter;
-    if (opts.keyMarker !== void 0) query["key-marker"] = opts.keyMarker;
-    if (opts.uploadIdMarker !== void 0) query["upload-id-marker"] = opts.uploadIdMarker;
-    if (opts.maxUploads !== void 0) query["max-uploads"] = opts.maxUploads;
-    const resp = await this.s3Request("GET", "", { query });
-    if (!resp.ok) {
-      throw parseS3Error("ListMultipartUploads", resp.status, resp.statusText, decodeText(resp.body));
-    }
-    return parseListMultipartUploadsResult(decodeText(resp.body));
-  }
-};
-var MAX_DELETE_OBJECTS_PER_REQUEST = 1e3;
-var MAX_S3_RETRIES = 3;
-var S3_RETRY_BASE_MS = 100;
-var S3_RETRY_CAP_MS = 2e3;
-function isTransientS3Status(status) {
-  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
-}
-function s3RetryDelayMs(attempt) {
-  const ceiling = Math.min(S3_RETRY_CAP_MS, S3_RETRY_BASE_MS * 2 ** attempt);
-  return Math.random() * ceiling;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-var MIN_PART_SIZE = 5 * 1024 * 1024;
-var DEFAULT_PART_SIZE = 16 * 1024 * 1024;
-var DEFAULT_UPLOAD_CONCURRENCY = 4;
-var MAX_PARTS_PER_UPLOAD = 1e4;
-function effectiveUploadPartSize(totalBytes, requestedPartSize) {
-  if (Math.ceil(totalBytes / requestedPartSize) <= MAX_PARTS_PER_UPLOAD) {
-    return requestedPartSize;
-  }
-  const MiB = 1024 * 1024;
-  const needed = Math.ceil(totalBytes / MAX_PARTS_PER_UPLOAD);
-  return Math.ceil(needed / MiB) * MiB;
-}
-function toBytes(body) {
-  if (typeof body === "string") return new TextEncoder().encode(body);
-  if (body instanceof Uint8Array) return body;
-  return new Uint8Array(body);
-}
-function escapeXml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function buildDeleteObjectsXml(keys, quiet) {
-  const objects = keys.map((k) => `<Object><Key>${escapeXml(k)}</Key></Object>`).join("");
-  const quietTag = quiet ? "<Quiet>true</Quiet>" : "";
-  return `<?xml version="1.0" encoding="UTF-8"?><Delete>${objects}${quietTag}</Delete>`;
-}
-function buildCompleteMultipartUploadXml(parts) {
-  const body = parts.map(
-    (p) => `<Part><PartNumber>${p.partNumber}</PartNumber><ETag>${escapeXml(p.etag)}</ETag></Part>`
-  ).join("");
-  return `<?xml version="1.0" encoding="UTF-8"?><CompleteMultipartUpload>${body}</CompleteMultipartUpload>`;
-}
-function asArray(value) {
-  if (value === void 0 || value === null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-function optionalNumber(value) {
-  return value === void 0 || value === null ? void 0 : Number(value);
-}
-function optionalString(value) {
-  return value === void 0 || value === null ? void 0 : String(value);
-}
-function optionalDate(value) {
-  return value === void 0 || value === null ? void 0 : new Date(String(value));
-}
-function decodeText(bytes) {
-  return new TextDecoder().decode(bytes);
-}
-function parseListObjectsResult(xml) {
-  const root = parseXml(xml).ListBucketResult ?? {};
-  const contents = root.Contents ?? [];
-  const objects = contents.map((c) => ({
-    key: String(c.Key ?? ""),
-    size: Number(c.Size ?? 0),
-    etag: optionalString(c.ETag),
-    lastModified: optionalDate(c.LastModified)
-  }));
-  const commonPrefixes = (root.CommonPrefixes ?? []).map((cp) => optionalString(cp.Prefix)).filter((p) => p !== void 0);
-  return {
-    objects,
-    commonPrefixes,
-    isTruncated: root.IsTruncated === "true" || root.IsTruncated === true,
-    nextContinuationToken: optionalString(root.NextContinuationToken),
-    keyCount: root.KeyCount !== void 0 ? Number(root.KeyCount) : objects.length,
-    prefix: optionalString(root.Prefix)
-  };
-}
-function xmlIsTruncated(value) {
-  return value === "true" || value === true;
-}
-function parseDeleteObjectsResult(xml) {
-  const root = parseXml(xml).DeleteResult ?? {};
-  const deleted = asArray(root.Deleted).map((d) => optionalString(d.Key)).filter((k) => k !== void 0);
-  const errors = asArray(root.Error).map((e) => ({
-    key: String(e.Key ?? ""),
-    code: optionalString(e.Code),
-    message: optionalString(e.Message)
-  }));
-  return { deleted, errors };
-}
-function parseListPartsResult(xml) {
-  const root = parseXml(xml).ListPartsResult ?? {};
-  const parts = asArray(root.Part).map((p) => ({
-    partNumber: Number(p.PartNumber ?? 0),
-    etag: optionalString(p.ETag),
-    size: Number(p.Size ?? 0),
-    lastModified: optionalDate(p.LastModified)
-  }));
-  return {
-    bucket: optionalString(root.Bucket),
-    key: optionalString(root.Key),
-    uploadId: optionalString(root.UploadId),
-    parts,
-    isTruncated: xmlIsTruncated(root.IsTruncated),
-    partNumberMarker: Number(root.PartNumberMarker ?? 0),
-    nextPartNumberMarker: optionalNumber(root.NextPartNumberMarker),
-    maxParts: Number(root.MaxParts ?? parts.length)
-  };
-}
-function parseListMultipartUploadsResult(xml) {
-  const root = parseXml(xml).ListMultipartUploadsResult ?? {};
-  const uploads = asArray(root.Upload).map((u) => ({
-    key: String(u.Key ?? ""),
-    uploadId: String(u.UploadId ?? ""),
-    initiated: optionalDate(u.Initiated)
-  }));
-  const commonPrefixes = asArray(root.CommonPrefixes).map((cp) => optionalString(cp.Prefix)).filter((p) => p !== void 0);
-  return {
-    bucket: optionalString(root.Bucket),
-    uploads,
-    commonPrefixes,
-    isTruncated: xmlIsTruncated(root.IsTruncated),
-    keyMarker: optionalString(root.KeyMarker),
-    uploadIdMarker: optionalString(root.UploadIdMarker),
-    nextKeyMarker: optionalString(root.NextKeyMarker),
-    nextUploadIdMarker: optionalString(root.NextUploadIdMarker),
-    prefix: optionalString(root.Prefix),
-    delimiter: optionalString(root.Delimiter),
-    maxUploads: optionalNumber(root.MaxUploads)
-  };
-}
-
-// src/disks.ts
-var Disks = class {
-  /** @internal */
-  _client;
-  /** @internal */
-  _region;
-  /** @internal */
-  _s3BaseUrl;
-  /** @internal */
-  constructor(client, region, s3BaseUrl) {
-    this._client = client;
-    this._region = region;
-    this._s3BaseUrl = s3BaseUrl;
-  }
-  async list(opts) {
-    const data = await unwrap(
-      this._client.GET("/api/disks", {
-        params: { query: { limit: opts?.limit, cursor: opts?.cursor, name: opts?.name } }
-      })
-    );
-    return data.map(
-      (d) => new Disk(d, this._client, this._region, this._s3BaseUrl)
-    );
-  }
-  async get(id) {
-    const data = await unwrap(
-      this._client.GET("/api/disks/{id}", {
-        params: { path: { id } }
-      })
-    );
-    return new Disk(data, this._client, this._region, this._s3BaseUrl);
-  }
-  /**
-   * Create a new disk with an auto-generated mount token.
-   *
-   * Returns the Disk, the one-time token (save it — it cannot be retrieved
-   * again), and the token identifier for later management.
-   */
-  async create(req) {
-    const created = await unwrap(
-      this._client.POST("/api/disks", { body: req })
-    );
-    const resp = created;
-    if (!resp.diskId) {
-      throw new Error("API returned success but no diskId");
-    }
-    const authorizedUsers = resp.authorizedUsers ?? [];
-    const tokenUser = authorizedUsers.find((u) => u.token);
-    const disk = await this.get(resp.diskId);
-    return {
-      disk,
-      token: tokenUser?.token ?? null,
-      tokenIdentifier: tokenUser?.identifier ?? null,
-      authorizedUsers
-    };
-  }
-};
-
-// src/tokens.ts
-var Tokens = class {
-  /** @internal */
-  _client;
-  /** @internal */
-  constructor(client) {
-    this._client = client;
-  }
-  async list(opts) {
-    const data = await unwrap(
-      this._client.GET("/api/tokens", {
-        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
-      })
-    );
-    return data.tokens ?? [];
-  }
-  async create(req) {
-    const data = await unwrap(
-      this._client.POST("/api/tokens", { body: req })
-    );
-    return data;
-  }
-  async delete(id) {
-    await unwrapEmpty(
-      this._client.DELETE("/api/tokens/{id}", {
-        params: { path: { id } }
-      })
-    );
-  }
-};
-
-// src/archil.ts
-function envVar(name) {
-  return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
-}
-function isExecMountSpec(m) {
-  return typeof m === "object" && m !== null && "disk" in m;
-}
-function diskIdFromMount(m) {
-  return typeof m === "string" ? m : m.id;
-}
-var Archil = class {
-  disks;
-  tokens;
-  /** @internal */
-  _client;
-  constructor(opts = {}) {
-    const apiKey = opts.apiKey ?? envVar("ARCHIL_API_KEY");
-    const region = opts.region ?? envVar("ARCHIL_REGION");
-    if (!apiKey) {
-      throw new Error("Missing API key: pass apiKey in options or set ARCHIL_API_KEY environment variable");
-    }
-    if (!region) {
-      throw new Error("Missing region: pass region in options or set ARCHIL_REGION environment variable");
-    }
-    const controlBaseUrl = opts.baseUrl ?? resolveBaseUrl(region);
-    const client = createApiClient({
-      apiKey,
-      region,
-      baseUrl: controlBaseUrl
-    });
-    const s3BaseUrl = opts.s3BaseUrl ?? envVar("ARCHIL_S3_BASE_URL") ?? deriveS3BaseUrl(controlBaseUrl);
-    this._client = client;
-    this.disks = new Disks(client, region, s3BaseUrl);
-    this.tokens = new Tokens(client);
-  }
-  /**
-   * Run a command in a container with multiple disks mounted simultaneously,
-   * each at its own relative path under `/mnt/archil`. Blocks until the
-   * command completes and returns its stdout, stderr, exit code, and timing.
-   */
-  async exec(opts) {
-    const disks = {};
-    for (const [relPath, mount] of Object.entries(opts.disks)) {
-      if (isExecMountSpec(mount)) {
-        const entry = {
-          disk: diskIdFromMount(mount.disk),
-          readOnly: mount.readOnly ?? false
-        };
-        if (mount.subdirectory !== void 0) entry.subdirectory = mount.subdirectory;
-        disks[relPath] = entry;
-      } else {
-        disks[relPath] = diskIdFromMount(mount);
-      }
-    }
-    return unwrap(
-      this._client.POST("/api/exec", {
-        body: { disks, command: opts.command }
-      })
-    );
-  }
-};
-
-// src/index.ts
-var _options;
-var _instance;
-function configure(options) {
-  _options = options;
-  _instance = void 0;
-}
-function archil() {
-  if (!_instance) {
-    _instance = new Archil(_options);
-  }
-  return _instance;
-}
-function createDisk(req) {
-  return archil().disks.create(req);
-}
-function listDisks(opts) {
-  return archil().disks.list(opts);
-}
-function getDisk(id) {
-  return archil().disks.get(id);
-}
-function listApiKeys(opts) {
-  return archil().tokens.list(opts);
-}
-function createApiKey(req) {
-  return archil().tokens.create(req);
-}
-function deleteApiKey(id) {
-  return archil().tokens.delete(id);
-}
-function exec(opts) {
-  return archil().exec(opts);
-}
-export {
-  Archil,
-  ArchilApiError,
-  ArchilError,
-  ArchilS3Error,
-  Disk,
-  DiskMultipart,
-  Disks,
-  Tokens,
-  USER_AGENT,
-  VERSION,
-  configure,
-  createApiKey,
-  createDisk,
-  deleteApiKey,
-  effectiveUploadPartSize,
-  exec,
-  getDisk,
-  listApiKeys,
-  listDisks
-};