tensorlake 0.5.126 → 0.5.127

package/dist/index.js

@@ -46,7 +46,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_esm_shims();
-    SDK_VERSION = "0.5.126";
+    SDK_VERSION = "0.5.127";
     API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
     API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
     NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
@@ -315,10 +315,10 @@ var init_native_worker_client = __esm({
       call(handle, method, args, emit) {
         const id = this.nextId++;
         let worker;
-        const promise = new Promise((resolve, reject) => {
+        const promise = new Promise((resolve2, reject) => {
           try {
             worker = this.getWorker();
-            this.pending.set(id, { resolve, reject, emit, handle });
+            this.pending.set(id, { resolve: resolve2, reject, emit, handle });
             worker.ref();
             if (handle) this.register(handle, worker);
             this.send(worker, {
@@ -421,7 +421,7 @@ var init_native_worker_client = __esm({
       }
     };
     runtimeKey = /* @__PURE__ */ Symbol.for(
-      `tensorlake.native.worker.${false ? "source" : "0.5.126"}.v1`
+      `tensorlake.native.worker.${false ? "source" : "0.5.127"}.v1`
     );
     runtimes = globalThis;
   }
@@ -489,9 +489,9 @@ async function* nativeEventStream(start, context, signal) {
   let stopped = false;
   let failure;
   const notify = () => {
-    const resolve = wake;
+    const resolve2 = wake;
     wake = void 0;
-    resolve?.();
+    resolve2?.();
   };
   const emit = (value) => {
     if (stopped) return Promise.resolve();
@@ -526,8 +526,8 @@ async function* nativeEventStream(start, context, signal) {
       } else if (finished) {
         break;
       } else {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve2) => {
+          wake = resolve2;
         });
       }
     }
@@ -683,7 +683,7 @@ import WebSocket from "ws";
 async function openTunnelWebSocket(options) {
   const wsUrl = buildTunnelWsUrl(options.baseUrl, options.remotePort);
   const timeoutMs = options.connectTimeoutMs ?? DEFAULT_TUNNEL_CONNECT_TIMEOUT_MS;
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const socket = new WebSocket(wsUrl, {
       headers: options.wsHeaders
     });
@@ -714,7 +714,7 @@ async function openTunnelWebSocket(options) {
       });
     };
     const onOpen = () => {
-      settle(() => resolve(socket));
+      settle(() => resolve2(socket));
     };
     const onError = (error) => {
       fail(new SandboxConnectionError(error.message));
@@ -757,7 +757,7 @@ function normalizeWebSocketData(message) {
   return Buffer.from(message);
 }
 async function relaySocket(localSocket, websocket) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let settled = false;
     const keepAliveInterval = setInterval(() => {
       if (websocket.readyState === WebSocket.OPEN) {
@@ -770,7 +770,7 @@ async function relaySocket(localSocket, websocket) {
       settled = true;
       clearInterval(keepAliveInterval);
       cleanup();
-      resolve();
+      resolve2();
     };
     const cleanup = () => {
       localSocket.removeListener("data", onLocalData);
@@ -848,7 +848,7 @@ async function relaySocket(localSocket, websocket) {
   });
 }
 async function listenServer(server, localPort, localHost) {
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(
@@ -859,7 +859,7 @@ async function listenServer(server, localPort, localHost) {
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve();
+      resolve2();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -885,13 +885,13 @@ function secondsToMillis(seconds) {
   return Math.round(seconds * 1e3);
 }
 async function withTimeout(timeoutMs, operation, timeoutMessage) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       reject(new SandboxError(timeoutMessage));
     }, timeoutMs);
     void operation().then((value) => {
       clearTimeout(timer);
-      resolve(value);
+      resolve2(value);
     }).catch((error) => {
       clearTimeout(timer);
       reject(error);
@@ -965,8 +965,8 @@ var init_tunnel = __esm({
         if (this.closeError) {
           throw this.closeError;
         }
-        return new Promise((resolve, reject) => {
-          this.pendingReads.push({ length, resolve, reject });
+        return new Promise((resolve2, reject) => {
+          this.pendingReads.push({ length, resolve: resolve2, reject });
         });
       }
       async writeAll(data) {
@@ -977,13 +977,13 @@ var init_tunnel = __esm({
           throw new SandboxError("desktop tunnel is not connected");
         }
         const payload = Buffer.from(data);
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           this.socket.send(payload, { binary: true }, (error) => {
             if (error) {
               reject(new SandboxConnectionError(error.message));
               return;
             }
-            resolve();
+            resolve2();
           });
         });
       }
@@ -995,10 +995,10 @@ var init_tunnel = __esm({
           this.closePromise = Promise.resolve();
           return this.closePromise;
         }
-        this.closePromise = new Promise((resolve) => {
+        this.closePromise = new Promise((resolve2) => {
           const onClose = () => {
             this.socket.removeListener("close", onClose);
-            resolve();
+            resolve2();
           };
           this.socket.on("close", onClose);
           this.socket.close();
@@ -1092,13 +1092,13 @@ var init_tunnel = __esm({
           relay.localSocket.destroy();
           relay.websocket?.close();
         }
-        this.closePromise = new Promise((resolve, reject) => {
+        this.closePromise = new Promise((resolve2, reject) => {
           this.server.close((error) => {
             if (error) {
               reject(new SandboxError(`failed to close tunnel listener: ${error.message}`));
               return;
             }
-            resolve();
+            resolve2();
           });
         });
         return this.closePromise;
@@ -1327,14 +1327,14 @@ function isReconnectableDesktopScreenshotError(error) {
 }
 function createDeferredSignal() {
   let resolveCurrent;
-  let promise = new Promise((resolve) => {
-    resolveCurrent = resolve;
+  let promise = new Promise((resolve2) => {
+    resolveCurrent = resolve2;
   });
   return {
     resolve() {
       resolveCurrent();
-      promise = new Promise((resolve) => {
-        resolveCurrent = resolve;
+      promise = new Promise((resolve2) => {
+        resolveCurrent = resolve2;
       });
     },
     wait() {
@@ -1678,7 +1678,7 @@ var init_desktop = __esm({
         validateNonNegativeInteger(delayMs, "double click delay");
         await this.click({ button, x: options?.x, y: options?.y });
         if (delayMs > 0) {
-          await new Promise((resolve) => setTimeout(resolve, delayMs));
+          await new Promise((resolve2) => setTimeout(resolve2, delayMs));
         }
         await this.click({ button });
       }
@@ -3144,7 +3144,7 @@ function processUserPayload(user) {
   return user;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function normalizePtyMessage(message) {
   if (Buffer.isBuffer(message)) return message;
@@ -3165,8 +3165,8 @@ function encodePtyResize(cols, rows) {
   return frame;
 }
 function sendPtyFrame(socket, frame) {
-  return new Promise((resolve, reject) => {
-    socket.send(frame, (error) => error ? reject(error) : resolve());
+  return new Promise((resolve2, reject) => {
+    socket.send(frame, (error) => error ? reject(error) : resolve2());
   });
 }
 function markBindOutcome(sandbox, outcome) {
@@ -3407,8 +3407,8 @@ var init_sandbox = __esm({
         this.wsUrl = options.wsUrl;
         this.wsHeaders = options.wsHeaders;
         this.killSession = options.killSession;
-        this.waitPromise = new Promise((resolve, reject) => {
-          this.resolveWait = resolve;
+        this.waitPromise = new Promise((resolve2, reject) => {
+          this.resolveWait = resolve2;
           this.rejectWait = reject;
         });
       }
@@ -3431,7 +3431,7 @@ var init_sandbox = __esm({
           return this.connectPromise;
         }
         this.intentionalDisconnect = false;
-        this.connectPromise = new Promise((resolve, reject) => {
+        this.connectPromise = new Promise((resolve2, reject) => {
           let opened = false;
           const socket = new WebSocket2(this.wsUrl, {
             headers: this.wsHeaders
@@ -3441,7 +3441,7 @@ var init_sandbox = __esm({
             try {
               await sendPtyFrame(socket, Buffer.from([PTY_OP_READY]));
               opened = true;
-              resolve(this);
+              resolve2(this);
             } catch (error) {
               reject(error);
             }
@@ -4372,7 +4372,7 @@ var init_sandbox = __esm({
           const remainingMs = deadlineMs - Date.now();
           if (remainingMs <= 0) break;
           await new Promise(
-            (resolve) => setTimeout(resolve, Math.min(probeIntervalMs, remainingMs))
+            (resolve2) => setTimeout(resolve2, Math.min(probeIntervalMs, remainingMs))
           );
         }
         const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
@@ -4479,7 +4479,7 @@ function validateTimeoutMs(timeoutMs) {
   }
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function snapshotStatusSatisfiesWaitCondition(status, waitUntil) {
   if (waitUntil === "local_ready") {
@@ -5328,7 +5328,7 @@ function anySignal(signals) {
   return controller.signal;
 }
 function sleep3(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var REQUEST_TIMEOUT_HEADER, HttpClient;
 var init_http = __esm({
@@ -6908,9 +6908,11 @@ init_cloud_client();
 
 // src/filesystem.ts
 init_esm_shims();
-init_defaults();
-import { execFile } from "child_process";
 import { randomBytes } from "crypto";
+
+// src/mount-cli.ts
+init_esm_shims();
+import { execFile } from "child_process";
 import { accessSync, constants } from "fs";
 import { homedir } from "os";
 import { join } from "path";
@@ -6994,60 +6996,25 @@ var ReadOnlyMountNotSupportedError = class extends MountError {
   }
 };
 var CliNotFoundError = class extends MountError {
-  constructor(detail) {
+  constructor(detail, command = "fs") {
     super(
-      `Mount operations require the Tensorlake CLI (\`tl\`) with \`tl fs\` support: ${detail}. Install or upgrade it with: curl -fsSL https://tensorlake.ai/install.sh | sh`
+      `Mount operations require the Tensorlake CLI (\`tl\`) with \`tl ${command}\` support: ${detail}. Install or upgrade it with: curl -fsSL https://tensorlake.ai/install.sh | sh`
     );
     this.name = "CliNotFoundError";
   }
 };
 
-// src/filesystem.ts
-init_native_sandbox();
-init_sandbox_image();
+// src/mount-cli.ts
 var execFileAsync = promisify(execFile);
-var FILESYSTEM_REPO_KIND = "filesystem";
-function translateNativeError2(error, notFound) {
-  const message = error instanceof Error ? error.message : String(error);
-  let payload;
-  try {
-    payload = JSON.parse(message);
-  } catch {
-    return error instanceof Error ? error : new FilesystemError(message);
-  }
-  if (!payload || typeof payload.category !== "string") {
-    return error instanceof Error ? error : new FilesystemError(message);
-  }
-  const detail = typeof payload.message === "string" ? payload.message : message;
-  if (payload.category === "connection") {
-    return new FilesystemError(detail);
-  }
-  if (payload.status === 404 && notFound !== void 0) {
-    return notFound;
-  }
-  if (typeof payload.status === "number") {
-    return new FilesystemAPIError(payload.status, detail);
-  }
-  return new FilesystemError(detail);
-}
-async function callNative2(fn, notFound) {
-  try {
-    return await fn();
-  } catch (error) {
-    throw translateNativeError2(error, notFound);
-  }
-}
-var FsCli = class {
-  binary = null;
-  envOverrides;
-  constructor(envOverrides) {
+var MountCli = class {
+  constructor(command, envOverrides) {
+    this.command = command;
     this.envOverrides = envOverrides;
   }
+  binary = null;
   async findCli() {
     const candidates = [];
-    if (process.env.TENSORLAKE_CLI) {
-      candidates.push(process.env.TENSORLAKE_CLI);
-    }
+    if (process.env.TENSORLAKE_CLI) candidates.push(process.env.TENSORLAKE_CLI);
     candidates.push("tl");
     const installed = join(homedir(), ".tensorlake", "bin", "tl");
     try {
@@ -7055,27 +7022,26 @@ var FsCli = class {
       candidates.push(installed);
     } catch {
     }
+    const support = this.command === "git" ? "git mount" : "fs";
+    const probe = this.command === "git" ? ["git", "mount", "--help"] : ["fs", "--help"];
     let unsupported = null;
     for (const candidate of candidates) {
       try {
-        await execFileAsync(candidate, ["fs", "--help"], { timeout: 15e3 });
+        await execFileAsync(candidate, probe, { timeout: 15e3 });
         return candidate;
       } catch (error) {
-        if (error.code !== "ENOENT") {
-          unsupported = candidate;
-        }
+        if (error.code !== "ENOENT") unsupported = candidate;
       }
     }
     throw new CliNotFoundError(
-      unsupported ? `\`tl\` at ${unsupported} does not support \`tl fs\` (upgrade required)` : "`tl` was not found on PATH"
+      unsupported ? `\`tl\` at ${unsupported} does not support \`tl ${support}\` (upgrade required)` : "`tl` was not found on PATH",
+      support
     );
   }
   async run(args, timeoutMs = 3e5) {
-    if (this.binary === null) {
-      this.binary = await this.findCli();
-    }
+    if (this.binary === null) this.binary = await this.findCli();
     try {
-      const { stdout } = await execFileAsync(this.binary, ["fs", ...args], {
+      const { stdout } = await execFileAsync(this.binary, [this.command, ...args], {
         timeout: timeoutMs,
         env: { ...process.env, ...this.envOverrides },
         maxBuffer: 16 * 1024 * 1024
@@ -7084,12 +7050,53 @@ var FsCli = class {
     } catch (error) {
       const failure = error;
       if (failure.killed) {
-        throw new MountError(`\`tl fs ${args[0]}\` timed out after ${timeoutMs}ms`);
+        throw new MountError(`\`tl ${this.command} ${args[0]}\` timed out after ${timeoutMs}ms`);
       }
       const detail = (failure.stderr || failure.stdout || String(error)).trim();
-      throw new MountError(`\`tl fs ${args.join(" ")}\` failed: ${detail}`);
+      throw new MountError(`\`tl ${this.command} ${args.join(" ")}\` failed: ${detail}`);
     }
   }
+};
+
+// src/filesystem.ts
+init_defaults();
+init_native_sandbox();
+init_sandbox_image();
+var FILESYSTEM_REPO_KIND = "filesystem";
+function translateNativeError2(error, notFound) {
+  const message = error instanceof Error ? error.message : String(error);
+  let payload;
+  try {
+    payload = JSON.parse(message);
+  } catch {
+    return error instanceof Error ? error : new FilesystemError(message);
+  }
+  if (!payload || typeof payload.category !== "string") {
+    return error instanceof Error ? error : new FilesystemError(message);
+  }
+  const detail = typeof payload.message === "string" ? payload.message : message;
+  if (payload.category === "connection") {
+    return new FilesystemError(detail);
+  }
+  if (payload.status === 404 && notFound !== void 0) {
+    return notFound;
+  }
+  if (typeof payload.status === "number") {
+    return new FilesystemAPIError(payload.status, detail);
+  }
+  return new FilesystemError(detail);
+}
+async function callNative2(fn, notFound) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw translateNativeError2(error, notFound);
+  }
+}
+var FsCli = class extends MountCli {
+  constructor(envOverrides) {
+    super("fs", envOverrides);
+  }
   // Flags always precede a `--` end-of-options separator so caller-supplied
   // names/paths can never be parsed as CLI flags (e.g. a path literally
   // named "--discard" must stay a path, not become the destructive flag).
@@ -7703,9 +7710,146 @@ init_errors();
 init_native_sandbox();
 init_models();
 init_sandbox_image();
+
+// src/repository-mount.ts
+init_esm_shims();
+import { resolve } from "path";
+function requireNonEmpty(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${name} must be a non-empty string`);
+  }
+}
+var GitCli = class extends MountCli {
+  constructor(envOverrides) {
+    super("git", envOverrides);
+  }
+  async mount(target, localPath, options = {}) {
+    requireNonEmpty(target, "target");
+    requireNonEmpty(localPath, "localPath");
+    if (options.workspace !== void 0) requireNonEmpty(options.workspace, "workspace");
+    if (options.readOnly && (options.publish || options.workspace !== void 0) || options.publish && options.workspace !== void 0) {
+      throw new TypeError("readOnly, publish, and workspace are mutually exclusive");
+    }
+    const path4 = resolve(localPath);
+    const args = ["mount"];
+    if (options.readOnly) args.push("--ro");
+    if (options.publish) args.push("--publish");
+    if (options.workspace !== void 0) args.push(`--workspace=${options.workspace}`);
+    args.push("--", target, path4);
+    await this.run(args);
+    return new RepositoryMount(this, target, path4, options.readOnly ?? false);
+  }
+  async unmount(localPath, options = {}) {
+    requireNonEmpty(localPath, "localPath");
+    const args = ["unmount"];
+    if (options.deleteWorkspace) args.push("--delete");
+    if (options.discard) args.push("--discard");
+    args.push("--", resolve(localPath));
+    await this.run(args);
+  }
+  async status(localPath) {
+    const args = ["status", "--json"];
+    if (localPath !== void 0) {
+      requireNonEmpty(localPath, "localPath");
+      args.push("--", resolve(localPath));
+    }
+    const output = await this.run(args, 6e4);
+    let raw;
+    try {
+      const payload = JSON.parse(output);
+      if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        throw new Error("expected a JSON object");
+      }
+      raw = payload;
+    } catch {
+      throw new MountError(`\`tl git status --json\` returned invalid JSON: ${output.slice(0, 200)}`);
+    }
+    const stringField = (key) => typeof raw[key] === "string" ? raw[key] : null;
+    return {
+      path: stringField("mountpoint") ?? (localPath === void 0 ? "" : resolve(localPath)),
+      repository: stringField("repository"),
+      reference: stringField("reference"),
+      workspaceId: stringField("workspace"),
+      state: stringField("state"),
+      localChanges: typeof raw.local_changes === "boolean" ? raw.local_changes : null,
+      raw
+    };
+  }
+  async snapshot(path4, message) {
+    const args = ["snapshot"];
+    if (message !== void 0) args.push(`--message=${message}`);
+    args.push("--", path4);
+    await this.run(args);
+  }
+  async sync(path4, target) {
+    const args = ["sync", "--", path4];
+    if (target !== void 0) {
+      requireNonEmpty(target, "target");
+      args.push(target);
+    }
+    await this.run(args);
+  }
+  async rebase(path4, target, failOnConflict) {
+    requireNonEmpty(target, "target");
+    const args = ["rebase"];
+    if (failOnConflict) args.push("--fail-on-conflict");
+    args.push("--", path4, target);
+    await this.run(args);
+  }
+  async promote(path4, branch, merge) {
+    requireNonEmpty(branch, "branch");
+    const args = ["promote"];
+    if (merge) args.push("--merge");
+    args.push("--", path4, branch);
+    await this.run(args);
+  }
+  async prefetch(path4) {
+    await this.run(["prefetch", "--", path4]);
+  }
+};
+var RepositoryMount = class {
+  /** @internal Obtain instances via RepositoryClient.mount(). */
+  constructor(cli, target, path4, readOnly) {
+    this.cli = cli;
+    this.target = target;
+    this.path = path4;
+    this.readOnly = readOnly;
+  }
+  /** Inspect workspace state, pending changes, and daemon diagnostics. */
+  async status() {
+    return this.cli.status(this.path);
+  }
+  /** Materialize autosaved edits as a commit; publish mounts also update their branch. */
+  async snapshot(message) {
+    await this.cli.snapshot(this.path, message);
+  }
+  /** Refresh the current source, or switch an unsnapshotted workspace to a new base. */
+  async sync(target) {
+    await this.cli.sync(this.path, target);
+  }
+  /** Replay snapshots and pending edits onto another base. Conflicts become diff3 markers by default. */
+  async rebase(target, options) {
+    await this.cli.rebase(this.path, target, options?.failOnConflict ?? false);
+  }
+  /** Publish the workspace to a branch; merge allows landing when the branch moved. */
+  async promote(branch, options) {
+    await this.cli.promote(this.path, branch, options?.merge ?? false);
+  }
+  /** Download and verify the mounted working set for network-free reads. */
+  async prefetch() {
+    await this.cli.prefetch(this.path);
+  }
+  /** Detach, retaining the private workspace and unpublished state unless explicitly requested. */
+  async unmount(options) {
+    await this.cli.unmount(this.path, options);
+  }
+};
+
+// src/repositories.ts
 var RepositoryClient = class _RepositoryClient {
   native;
   requestTimeoutMs;
+  cli;
   constructor(options) {
     this.requestTimeoutMs = resolveRequestTimeoutMs2(options);
     const apiKey = options?.apiKey ?? API_KEY;
@@ -7726,9 +7870,20 @@ var RepositoryClient = class _RepositoryClient {
       null,
       this.requestTimeoutMs / 1e3
     );
+    const context = buildContextFromEnv();
+    const envOverrides = {
+      TENSORLAKE_API_KEY: apiKey,
+      TENSORLAKE_API_URL: options?.apiUrl ?? API_URL
+    };
+    const organizationId = options?.organizationId ?? context.organizationId;
+    const projectId = options?.projectId ?? context.projectId;
+    if (organizationId) envOverrides.TENSORLAKE_ORGANIZATION_ID = organizationId;
+    if (projectId) envOverrides.TENSORLAKE_PROJECT_ID = projectId;
+    this.cli = new GitCli(envOverrides);
   }
   static forCloud(options) {
     return new _RepositoryClient({
+      ...options,
       apiUrl: options?.apiUrl ?? "https://api.tensorlake.ai",
       apiKey: options?.apiKey,
       requestTimeout: options?.requestTimeout,
@@ -7747,12 +7902,30 @@ var RepositoryClient = class _RepositoryClient {
     }
     return new _RepositoryClient({
       apiUrl: context.apiUrl,
-      apiKey: context.apiKey
+      apiKey: context.apiKey,
+      organizationId: context.organizationId,
+      projectId: context.projectId
     });
   }
   close() {
     releaseNativeHandle(this.native);
   }
+  /**
+   * Mount `repo[:branch|tag|full-commit][//subtree]` to a local directory.
+   * Requires the separately installed `tl` CLI with mount support. Mounts
+   * live on the machine running Node.js and must be explicitly unmounted.
+   */
+  async mount(target, localPath, options) {
+    return this.cli.mount(target, localPath, options);
+  }
+  /** Detach a local repository mount, optionally deleting its private workspace. */
+  async unmount(localPath, options) {
+    await this.cli.unmount(localPath, options);
+  }
+  /** Inspect a local mount; defaults to the mount containing the current directory. */
+  async mountStatus(localPath) {
+    return this.cli.status(localPath);
+  }
   async url(repo) {
     return callNative(() => this.native.gitRepoUrl(repo));
   }
@@ -8469,16 +8642,16 @@ var FunctionFuture = class _FunctionFuture {
         ))
       );
     } else {
-      wait = new Promise((resolve) => {
+      wait = new Promise((resolve2) => {
         let remaining = pending.length;
         for (const future of pending) {
           void internalDurableThen(
             future.result(),
             () => {
               remaining -= 1;
-              if (remaining === 0) resolve({ kind: "all_completed" });
+              if (remaining === 0) resolve2({ kind: "all_completed" });
             },
-            () => resolve({ kind: "cutoff", future })
+            () => resolve2({ kind: "cutoff", future })
           );
         }
       });
@@ -8514,8 +8687,8 @@ async function waitUntilOrTimeout(promise, timeoutSeconds) {
   try {
     return await internalPromiseRace([
       promise,
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutSeconds * 1e3);
+      new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2({ kind: "timeout" }), timeoutSeconds * 1e3);
       })
     ]);
   } finally {
@@ -9515,8 +9688,8 @@ var LocalRuntime = class {
       let timer;
       try {
         await waitWithAbortSignal(
-          new Promise((resolve) => {
-            timer = setTimeout(resolve, future.delaySeconds * 1e3);
+          new Promise((resolve2) => {
+            timer = setTimeout(resolve2, future.delaySeconds * 1e3);
           }),
           this.requestContext.signal
         );
@@ -9746,6 +9919,7 @@ export {
   ReadOnlyMountNotSupportedError,
   RemoteAPIError,
   RepositoryClient,
+  RepositoryMount,
   RequestContext,
   RequestExecutionError,
   RequestFailedError,