tensorlake 0.5.85 → 0.5.89

package/dist/index.js

@@ -19,7 +19,7 @@ var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TI
 var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
-    SDK_VERSION = "0.5.85";
+    SDK_VERSION = "0.5.89";
     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";
@@ -6513,8 +6513,9 @@ function fileEntryFromWire(entry, dirPath) {
   return {
     name: entry.name,
     path: prefix ? `${prefix}/${entry.name}` : entry.name,
-    oid: entry.oid ?? "",
-    mode,
+    contentId: entry.oid ?? "",
+    kind: mode === GIT_MODE_DIR ? "directory" : mode === GIT_MODE_SYMLINK ? "symlink" : "file",
+    executable: mode === 33261,
     size: entry.size ?? null,
     isDir: mode === GIT_MODE_DIR,
     isSymlink: mode === GIT_MODE_SYMLINK
@@ -6768,6 +6769,26 @@ var FilesystemClient = class {
       created.default_branch || "main"
     );
   }
+  /**
+   * Fork a filesystem at its live head or an explicit retained snapshot.
+   * The server shares immutable content and publishes only metadata.
+   */
+  async fork(name, baseFilesystem, snapshot) {
+    if (!name || !baseFilesystem) {
+      throw new FilesystemError(
+        "fork and base filesystem names must not be empty"
+      );
+    }
+    await callNative2(
+      () => this.native.forkFilesystem(
+        name,
+        baseFilesystem,
+        snapshot ?? null
+      ),
+      new FilesystemNotFoundError(baseFilesystem)
+    );
+    return new Filesystem(this, this.native, this.cli, name, "main");
+  }
   /** Return a handle to an existing filesystem (verifies it exists). */
   async get(name) {
     const traced = await callNative2(
@@ -6793,7 +6814,6 @@ var FilesystemClient = class {
     return (page.repos ?? []).map((repo) => ({
       name: String(repo.name ?? ""),
       fullName: String(repo.full_name ?? ""),
-      defaultBranch: String(repo.default_branch ?? "main"),
       status: String(repo.status ?? ""),
       kind: String(repo.kind ?? FILESYSTEM_REPO_KIND)
     }));
@@ -6873,13 +6893,92 @@ var Filesystem = class {
       content: toBuffer(data)
     }));
     const resolvedMessage = message || `write ${writes.length} file(s) via SDK`;
+    return await this.publishChanges(
+      writes,
+      deletes,
+      [],
+      [],
+      resolvedMessage
+    );
+  }
+  /**
+   * Stream one local file directly to object storage in bounded parts.
+   * This is the memory-bounded API for multi-GiB files.
+   */
+  async writeFileFromPath(path2, localPath, message) {
+    return await this.writeFilesFromPaths(
+      /* @__PURE__ */ new Map([[path2, localPath]]),
+      message
+    );
+  }
+  /**
+   * Atomically publish local files without loading their complete payloads
+   * into JavaScript or Rust memory.
+   */
+  async writeFilesFromPaths(files, message) {
+    const entries = files instanceof Map ? [...files.entries()] : Object.entries(files);
+    if (entries.length === 0) {
+      throw new FilesystemError("nothing to write: no local files given");
+    }
+    const writes = entries.map(([path2, localPath]) => ({ path: path2, localPath }));
+    const resolvedMessage = message || `write ${writes.length} local file(s) via SDK`;
+    const branch = await this.branch();
+    const traced = await callNative2(
+      () => this.native.pushFilesystemPaths(
+        this.name,
+        writes,
+        resolvedMessage,
+        branch,
+        randomBytes(16).toString("hex")
+      ),
+      new FilesystemNotFoundError(this.name)
+    );
+    const report = JSON.parse(traced.json);
+    const versionId = String(report.version_id ?? "");
+    const previousVersionId = report.previous_version_id == null ? null : String(report.previous_version_id);
+    return {
+      versionId,
+      previousVersionId,
+      created: previousVersionId !== versionId,
+      message: resolvedMessage
+    };
+  }
+  /**
+   * Move a file or directory without downloading or re-uploading its bytes.
+   * The source removal and destination creation publish as one atomic snapshot.
+   */
+  async moveFile(from, to, message) {
+    return await this.publishChanges(
+      [],
+      [],
+      [{ from, to }],
+      [],
+      message || `move ${from} to ${to} via SDK`
+    );
+  }
+  /**
+   * Copy a file or directory by reusing immutable content references. No
+   * payload bytes traverse the client, API server, or object store.
+   */
+  async copyFile(from, to, message) {
+    return await this.publishChanges(
+      [],
+      [],
+      [],
+      [{ from, to }],
+      message || `copy ${from} to ${to} via SDK`
+    );
+  }
+  async publishChanges(writes, deletes, moves, copies, message) {
     const branch = await this.branch();
     const traced = await callNative2(
       () => this.native.pushFilesystemFiles(
         this.name,
         writes,
         deletes,
-        resolvedMessage,
+        moves,
+        copies,
+        message,
         branch,
         // One key per logical write: a retried submit reattaches to the
         // same durable commit job instead of double-committing.
@@ -6888,16 +6987,16 @@ var Filesystem = class {
       new FilesystemNotFoundError(this.name)
     );
     const report = JSON.parse(traced.json);
+    const versionId = String(report.version_id ?? "");
+    const previousVersionId = report.previous_version_id == null ? null : String(report.previous_version_id);
     return {
-      commit: String(report.commit ?? ""),
-      tree: String(report.tree ?? ""),
-      refName: String(report.ref_name ?? ""),
-      parent: null,
-      created: report.created === void 0 ? true : Boolean(report.created),
-      message: resolvedMessage
+      versionId,
+      previousVersionId,
+      created: previousVersionId !== versionId,
+      message
     };
   }
-  /** Delete one file. Returns the snapshot the deletion produced. */
+  /** Delete one file. Returns the durable version the deletion produced. */
   async deleteFile(path2, message) {
     return await this.writeFiles(
       /* @__PURE__ */ new Map(),
@@ -6908,40 +7007,90 @@ var Filesystem = class {
   /**
    * Return the filesystem's current version as a snapshot.
    *
-   * Writes already create snapshots implicitly; this pins the current head
-   * without changing any content.
+   * Writes publish durable live versions. This retains the current head
+   * permanently in one metadata-only server operation without changing or
+   * copying any content.
    */
-  async snapshot(message = "") {
-    const status = await this.status();
-    if (!status.headCommit) {
-      throw new FilesystemError(
-        `filesystem ${this.name} is empty: write files first`
-      );
-    }
+  async snapshot(message = "snapshot via SDK") {
+    const resolvedMessage = message || "snapshot via SDK";
+    const traced = await callNative2(
+      () => this.native.retainFilesystemSnapshot(
+        this.name,
+        resolvedMessage,
+        randomBytes(16).toString("hex")
+      ),
+      new FilesystemNotFoundError(this.name)
+    );
+    const retained = JSON.parse(traced.json);
     return {
-      commit: status.headCommit,
-      tree: "",
-      refName: `refs/heads/${status.defaultBranch}`,
-      parent: null,
-      created: false,
-      message
+      id: String(retained.snapshot_id ?? ""),
+      message: retained.message || resolvedMessage
     };
   }
+  /** List explicitly retained snapshots without reading filesystem contents. */
+  async listSnapshots() {
+    const traced = await callNative2(
+      () => this.native.listFilesystemSnapshots(this.name),
+      new FilesystemNotFoundError(this.name)
+    );
+    const payload = JSON.parse(traced.json);
+    return (payload.snapshots ?? []).map((snapshot) => ({
+      id: String(snapshot.snapshot_id ?? ""),
+      createdAt: new Date(Number(snapshot.created_at_ms ?? 0)),
+      message: String(snapshot.message ?? "")
+    }));
+  }
+  /** Delete one permanent retention point; shared/head-reachable bytes remain. */
+  async deleteSnapshot(snapshot) {
+    await callNative2(
+      () => this.native.deleteFilesystemSnapshot(this.name, snapshot),
+      new FilesystemNotFoundError(this.name)
+    );
+  }
   // -- reads --------------------------------------------------------------------
   /**
-   * Read a file's bytes at `version` (branch, ref, or snapshot commit;
-   * defaults to the filesystem's default branch).
+   * Read a file's bytes at `version` (the current `main` head or a retained
+   * snapshot id; defaults to the filesystem's current head).
    */
   async readFile(path2, version) {
+    return (await this.readFileWithMetadata(path2, { version })).data;
+  }
+  /**
+   * Read bytes and immutable metadata in one request. A range is executed by
+   * Artifact Storage, so callers never download the unrequested remainder.
+   */
+  async readFileWithMetadata(path2, options = {}) {
     if (trimSlashes(path2) === "") {
       throw new FilesystemError("file path must not be empty");
     }
-    const resolvedVersion = version || await this.branch();
+    const range = options.range;
+    if (range !== void 0 && (!Number.isSafeInteger(range.offset) || range.offset < 0 || !Number.isSafeInteger(range.length) || range.length <= 0)) {
+      throw new FilesystemError(
+        "range requires a non-negative integer offset and positive integer length"
+      );
+    }
+    const resolvedVersion = options.version || await this.branch();
     const traced = await callNative2(
-      () => this.native.readFilesystemFile(this.name, path2, resolvedVersion),
+      () => this.native.readFilesystemFile(
+        this.name,
+        path2,
+        resolvedVersion,
+        range?.offset,
+        range?.length
+      ),
       new FileNotFoundInFilesystemError(this.name, path2)
     );
-    return new Uint8Array(traced.data);
+    const fullSize = traced.fullSize;
+    if (!traced.contentId || fullSize === void 0 || !Number.isSafeInteger(fullSize) || fullSize < 0 || traced.data.byteLength > fullSize) {
+      throw new FilesystemError(
+        "filesystem read response omitted content identity or total size"
+      );
+    }
+    return {
+      data: new Uint8Array(traced.data),
+      contentId: traced.contentId,
+      size: fullSize
+    };
   }
   /** Read a file as UTF-8 text at `version`. Throws on non-UTF-8 content. */
   async readText(path2, version) {
@@ -6960,7 +7109,7 @@ var Filesystem = class {
     return (page.entries ?? []).map((entry) => fileEntryFromWire(entry, dirPath));
   }
   // -- status -------------------------------------------------------------------
-  /** Remote status: identity plus the current head snapshot. */
+  /** Remote status: identity plus the current native version. */
   async status() {
     const metaTraced = await callNative2(
       () => this.native.filesystemMeta(this.name),
@@ -6969,14 +7118,14 @@ var Filesystem = class {
     const meta = JSON.parse(metaTraced.json);
     const defaultBranch = String(meta.default_branch || "main");
     this.defaultBranch = defaultBranch;
-    let headCommit = null;
+    let versionId = null;
     let generation = null;
     try {
       const refTraced = await callNative2(
         () => this.native.filesystemRefStatus(this.name, defaultBranch)
       );
       const ref = JSON.parse(refTraced.json);
-      headCommit = ref.resolved_commit || ref.oid || null;
+      versionId = ref.resolved_commit || ref.oid || null;
       generation = typeof ref.generation === "number" ? ref.generation : null;
     } catch (error) {
       if (!(error instanceof FilesystemAPIError) || error.statusCode !== 404) {
@@ -6986,8 +7135,7 @@ var Filesystem = class {
     return {
       name: this.name,
       status: String(meta.status ?? ""),
-      defaultBranch,
-      headCommit,
+      versionId,
       generation
     };
   }