tensorlake 0.5.126 → 0.5.127

package/dist/index.cjs

@@ -49,7 +49,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_cjs_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";
@@ -318,10 +318,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, {
@@ -424,7 +424,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;
   }
@@ -492,9 +492,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();
@@ -529,8 +529,8 @@ async function* nativeEventStream(start, context, signal) {
       } else if (finished) {
         break;
       } else {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve2) => {
+          wake = resolve2;
         });
       }
     }
@@ -684,7 +684,7 @@ var init_models = __esm({
 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 import_ws.default(wsUrl, {
       headers: options.wsHeaders
     });
@@ -715,7 +715,7 @@ async function openTunnelWebSocket(options) {
       });
     };
     const onOpen = () => {
-      settle(() => resolve(socket));
+      settle(() => resolve2(socket));
     };
     const onError = (error) => {
       fail(new SandboxConnectionError(error.message));
@@ -758,7 +758,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 === import_ws.default.OPEN) {
@@ -771,7 +771,7 @@ async function relaySocket(localSocket, websocket) {
       settled = true;
       clearInterval(keepAliveInterval);
       cleanup();
-      resolve();
+      resolve2();
     };
     const cleanup = () => {
       localSocket.removeListener("data", onLocalData);
@@ -849,7 +849,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(
@@ -860,7 +860,7 @@ async function listenServer(server, localPort, localHost) {
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve();
+      resolve2();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -886,13 +886,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);
@@ -968,8 +968,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) {
@@ -980,13 +980,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();
           });
         });
       }
@@ -998,10 +998,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();
@@ -1095,13 +1095,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;
@@ -1329,14 +1329,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() {
@@ -1681,7 +1681,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 });
       }
@@ -3146,7 +3146,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;
@@ -3167,8 +3167,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) {
@@ -3410,8 +3410,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;
         });
       }
@@ -3434,7 +3434,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 import_ws2.default(this.wsUrl, {
             headers: this.wsHeaders
@@ -3444,7 +3444,7 @@ var init_sandbox = __esm({
             try {
               await sendPtyFrame(socket, Buffer.from([PTY_OP_READY]));
               opened = true;
-              resolve(this);
+              resolve2(this);
             } catch (error) {
               reject(error);
             }
@@ -4375,7 +4375,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}` : "";
@@ -4482,7 +4482,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") {
@@ -5326,7 +5326,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 import_undici, REQUEST_TIMEOUT_HEADER, HttpClient;
 var init_http = __esm({
@@ -6314,9 +6314,9 @@ var require_libc = __commonJS({
 // src/native-binding.ts
 function packageRoot() {
   const parent = (0, import_node_url.fileURLToPath)(new URL("../", importMetaUrl));
-  if (fs.existsSync(import_node_path.default.join(parent, "package.json"))) return parent;
+  if (fs.existsSync(import_node_path2.default.join(parent, "package.json"))) return parent;
   const grandparent = (0, import_node_url.fileURLToPath)(new URL("../../", importMetaUrl));
-  if (fs.existsSync(import_node_path.default.join(grandparent, "package.json"))) return grandparent;
+  if (fs.existsSync(import_node_path2.default.join(grandparent, "package.json"))) return grandparent;
   return parent;
 }
 function linuxLibcFamily(options) {
@@ -6339,7 +6339,7 @@ function nativeTargetId(platform = process.platform, arch = process.arch, option
 function nativeBindingPath(options = {}) {
   const platform = options.platform ?? process.platform;
   const arch = options.arch ?? process.arch;
-  return import_node_path.default.join(
+  return import_node_path2.default.join(
     options.packageRoot ?? packageRoot(),
     "dist",
     "native",
@@ -6372,7 +6372,7 @@ function loadNative() {
   }
   return require2(packageEntry);
 }
-var import_libc, fs, import_node_module2, import_node_path, import_node_url, NATIVE_PACKAGES, cachedLinuxLibc;
+var import_libc, fs, import_node_module2, import_node_path2, import_node_url, NATIVE_PACKAGES, cachedLinuxLibc;
 var init_native_binding = __esm({
   "src/native-binding.ts"() {
     "use strict";
@@ -6380,7 +6380,7 @@ var init_native_binding = __esm({
     import_libc = __toESM(require_libc(), 1);
     fs = __toESM(require("fs"), 1);
     import_node_module2 = require("module");
-    import_node_path = __toESM(require("path"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
     import_node_url = require("url");
     NATIVE_PACKAGES = {
       "darwin-arm64": "tensorlake-native-darwin-arm64",
@@ -6438,9 +6438,9 @@ function buildContextFromEnv() {
   };
 }
 function defaultRegisteredName(dockerfilePath) {
-  const parsed = import_node_path2.default.parse(dockerfilePath);
+  const parsed = import_node_path3.default.parse(dockerfilePath);
   if (parsed.name.toLowerCase() === "dockerfile") {
-    const parentName = import_node_path2.default.basename(import_node_path2.default.dirname(dockerfilePath)).trim();
+    const parentName = import_node_path3.default.basename(import_node_path3.default.dirname(dockerfilePath)).trim();
     return parentName || "sandbox-image";
   }
   return parsed.name || "sandbox-image";
@@ -6530,24 +6530,24 @@ async function createSandboxImage(source, options = {}, deps = {}) {
     }
     let resolvedContext;
     if (options.contextDir != null) {
-      resolvedContext = import_node_path2.default.resolve(options.contextDir);
+      resolvedContext = import_node_path3.default.resolve(options.contextDir);
     } else if (imageRequiresContext(source)) {
       throw new Error(
         "This image reads files from the host (via COPY/ADD or a RUN bind mount), so it needs a build context. Pass `contextDir` pointing at the directory that contains those sources; they resolve relative to it, like `docker build <contextDir>`."
       );
     } else {
-      tempContextDir = (0, import_node_fs.mkdtempSync)(import_node_path2.default.join(import_node_os.default.tmpdir(), "tl-build-context-"));
+      tempContextDir = (0, import_node_fs2.mkdtempSync)(import_node_path3.default.join(import_node_os2.default.tmpdir(), "tl-build-context-"));
       resolvedContext = tempContextDir;
     }
-    dockerfilePath = import_node_path2.default.join(resolvedContext, "Dockerfile");
+    dockerfilePath = import_node_path3.default.join(resolvedContext, "Dockerfile");
     let text = dockerfileContent(source);
     if (!text.endsWith("\n")) text += "\n";
     dockerfileText = text;
     nativeContextDir = resolvedContext;
     effectiveName = options.registeredName ?? source.name;
   } else if (typeof source === "string") {
-    const resolvedPath = import_node_path2.default.resolve(source);
-    if (!(0, import_node_fs.existsSync)(resolvedPath)) {
+    const resolvedPath = import_node_path3.default.resolve(source);
+    if (!(0, import_node_fs2.existsSync)(resolvedPath)) {
       throw new Error(`Dockerfile not found: ${source}`);
     }
     dockerfilePath = resolvedPath;
@@ -6624,7 +6624,7 @@ async function createSandboxImage(source, options = {}, deps = {}) {
     return result;
   } finally {
     if (tempContextDir != null) {
-      (0, import_node_fs.rmSync)(tempContextDir, { recursive: true, force: true });
+      (0, import_node_fs2.rmSync)(tempContextDir, { recursive: true, force: true });
     }
   }
 }
@@ -6773,7 +6773,7 @@ async function listSandboxImages() {
   }
 }
 async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
-  const parsed = (0, import_node_util.parseArgs)({
+  const parsed = (0, import_node_util2.parseArgs)({
     args: argv,
     allowPositionals: true,
     options: {
@@ -6825,7 +6825,7 @@ async function runCreateSandboxImageCli(argv = process.argv.slice(2)) {
   );
 }
 async function runImportSandboxImageCli(argv = process.argv.slice(2)) {
-  const parsed = (0, import_node_util.parseArgs)({
+  const parsed = (0, import_node_util2.parseArgs)({
     args: argv,
     allowPositionals: true,
     options: {
@@ -6876,15 +6876,15 @@ async function runImportSandboxImageCli(argv = process.argv.slice(2)) {
     { emit: ndjsonStdoutEmit, _allowPat: true }
   );
 }
-var import_node_path2, import_node_os, import_node_fs, import_node_util, cachedNativeBinding, cachedNativeBindingError, DEFAULT_IMAGE_NAME2;
+var import_node_path3, import_node_os2, import_node_fs2, import_node_util2, cachedNativeBinding, cachedNativeBindingError, DEFAULT_IMAGE_NAME2;
 var init_sandbox_image = __esm({
   "src/sandbox-image.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path2 = __toESM(require("path"), 1);
-    import_node_os = __toESM(require("os"), 1);
-    import_node_fs = require("fs");
-    import_node_util = require("util");
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_os2 = __toESM(require("os"), 1);
+    import_node_fs2 = require("fs");
+    import_node_util2 = require("util");
     init_cloud_client();
     init_image();
     init_native_binding();
@@ -6922,6 +6922,7 @@ __export(index_exports, {
   ReadOnlyMountNotSupportedError: () => ReadOnlyMountNotSupportedError,
   RemoteAPIError: () => RemoteAPIError,
   RepositoryClient: () => RepositoryClient,
+  RepositoryMount: () => RepositoryMount,
   RequestContext: () => RequestContext,
   RequestExecutionError: () => RequestExecutionError,
   RequestFailedError: () => RequestFailedError,
@@ -6969,13 +6970,15 @@ init_cloud_client();
 
 // src/filesystem.ts
 init_cjs_shims();
-var import_node_child_process = require("child_process");
 var import_node_crypto2 = require("crypto");
-var import_node_fs2 = require("fs");
-var import_node_os2 = require("os");
-var import_node_path3 = require("path");
-var import_node_util2 = require("util");
-init_defaults();
+
+// src/mount-cli.ts
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_util = require("util");
 
 // src/filesystem-models.ts
 init_cjs_shims();
@@ -7055,18 +7058,72 @@ 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/mount-cli.ts
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var MountCli = class {
+  constructor(command, envOverrides) {
+    this.command = command;
+    this.envOverrides = envOverrides;
+  }
+  binary = null;
+  async findCli() {
+    const candidates = [];
+    if (process.env.TENSORLAKE_CLI) candidates.push(process.env.TENSORLAKE_CLI);
+    candidates.push("tl");
+    const installed = (0, import_node_path.join)((0, import_node_os.homedir)(), ".tensorlake", "bin", "tl");
+    try {
+      (0, import_node_fs.accessSync)(installed, import_node_fs.constants.F_OK);
+      candidates.push(installed);
+    } catch {
+    }
+    const support = this.command === "git" ? "git mount" : "fs";
+    const probe = this.command === "git" ? ["git", "mount", "--help"] : ["fs", "--help"];
+    let unsupported = null;
+    for (const candidate of candidates) {
+      try {
+        await execFileAsync(candidate, probe, { timeout: 15e3 });
+        return candidate;
+      } catch (error) {
+        if (error.code !== "ENOENT") unsupported = candidate;
+      }
+    }
+    throw new CliNotFoundError(
+      unsupported ? `\`tl\` at ${unsupported} does not support \`tl ${support}\` (upgrade required)` : "`tl` was not found on PATH",
+      support
+    );
+  }
+  async run(args, timeoutMs = 3e5) {
+    if (this.binary === null) this.binary = await this.findCli();
+    try {
+      const { stdout } = await execFileAsync(this.binary, [this.command, ...args], {
+        timeout: timeoutMs,
+        env: { ...process.env, ...this.envOverrides },
+        maxBuffer: 16 * 1024 * 1024
+      });
+      return stdout;
+    } catch (error) {
+      const failure = error;
+      if (failure.killed) {
+        throw new MountError(`\`tl ${this.command} ${args[0]}\` timed out after ${timeoutMs}ms`);
+      }
+      const detail = (failure.stderr || failure.stdout || String(error)).trim();
+      throw new MountError(`\`tl ${this.command} ${args.join(" ")}\` failed: ${detail}`);
+    }
+  }
+};
+
 // src/filesystem.ts
+init_defaults();
 init_native_sandbox();
 init_sandbox_image();
-var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process.execFile);
 var FILESYSTEM_REPO_KIND = "filesystem";
 function translateNativeError2(error, notFound) {
   const message = error instanceof Error ? error.message : String(error);
@@ -7098,58 +7155,9 @@ async function callNative2(fn, notFound) {
     throw translateNativeError2(error, notFound);
   }
 }
-var FsCli = class {
-  binary = null;
-  envOverrides;
+var FsCli = class extends MountCli {
   constructor(envOverrides) {
-    this.envOverrides = envOverrides;
-  }
-  async findCli() {
-    const candidates = [];
-    if (process.env.TENSORLAKE_CLI) {
-      candidates.push(process.env.TENSORLAKE_CLI);
-    }
-    candidates.push("tl");
-    const installed = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".tensorlake", "bin", "tl");
-    try {
-      (0, import_node_fs2.accessSync)(installed, import_node_fs2.constants.F_OK);
-      candidates.push(installed);
-    } catch {
-    }
-    let unsupported = null;
-    for (const candidate of candidates) {
-      try {
-        await execFileAsync(candidate, ["fs", "--help"], { timeout: 15e3 });
-        return candidate;
-      } catch (error) {
-        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"
-    );
-  }
-  async run(args, timeoutMs = 3e5) {
-    if (this.binary === null) {
-      this.binary = await this.findCli();
-    }
-    try {
-      const { stdout } = await execFileAsync(this.binary, ["fs", ...args], {
-        timeout: timeoutMs,
-        env: { ...process.env, ...this.envOverrides },
-        maxBuffer: 16 * 1024 * 1024
-      });
-      return stdout;
-    } catch (error) {
-      const failure = error;
-      if (failure.killed) {
-        throw new MountError(`\`tl fs ${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}`);
-    }
+    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
@@ -7764,9 +7772,146 @@ init_errors();
 init_native_sandbox();
 init_models();
 init_sandbox_image();
+
+// src/repository-mount.ts
+init_cjs_shims();
+var import_node_path4 = require("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 path3 = (0, import_node_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, path3);
+    await this.run(args);
+    return new RepositoryMount(this, target, path3, 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("--", (0, import_node_path4.resolve)(localPath));
+    await this.run(args);
+  }
+  async status(localPath) {
+    const args = ["status", "--json"];
+    if (localPath !== void 0) {
+      requireNonEmpty(localPath, "localPath");
+      args.push("--", (0, import_node_path4.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 ? "" : (0, import_node_path4.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(path3, message) {
+    const args = ["snapshot"];
+    if (message !== void 0) args.push(`--message=${message}`);
+    args.push("--", path3);
+    await this.run(args);
+  }
+  async sync(path3, target) {
+    const args = ["sync", "--", path3];
+    if (target !== void 0) {
+      requireNonEmpty(target, "target");
+      args.push(target);
+    }
+    await this.run(args);
+  }
+  async rebase(path3, target, failOnConflict) {
+    requireNonEmpty(target, "target");
+    const args = ["rebase"];
+    if (failOnConflict) args.push("--fail-on-conflict");
+    args.push("--", path3, target);
+    await this.run(args);
+  }
+  async promote(path3, branch, merge) {
+    requireNonEmpty(branch, "branch");
+    const args = ["promote"];
+    if (merge) args.push("--merge");
+    args.push("--", path3, branch);
+    await this.run(args);
+  }
+  async prefetch(path3) {
+    await this.run(["prefetch", "--", path3]);
+  }
+};
+var RepositoryMount = class {
+  /** @internal Obtain instances via RepositoryClient.mount(). */
+  constructor(cli, target, path3, readOnly) {
+    this.cli = cli;
+    this.target = target;
+    this.path = path3;
+    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;
@@ -7787,9 +7932,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,
@@ -7808,12 +7964,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));
   }
@@ -8530,16 +8704,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 })
           );
         }
       });
@@ -8575,8 +8749,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 {
@@ -9576,8 +9750,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
         );
@@ -9808,6 +9982,7 @@ init_models();
   ReadOnlyMountNotSupportedError,
   RemoteAPIError,
   RepositoryClient,
+  RepositoryMount,
   RequestContext,
   RequestExecutionError,
   RequestFailedError,