@storacha/clawracha 0.0.1 → 0.0.2

package/dist/sync.js

@@ -8,25 +8,26 @@
  * 5. Upload all blocks as CAR
  * 6. Apply remote changes to local filesystem
  */
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { CarWriter } from "@ipld/car/writer";
 // UCN Pail imports
-import { Agent, Name, Revision, Value } from "@storacha/ucn/pail";
-import * as Batch from "@storacha/ucn/pail/batch";
+import { Agent, Name, NoValueError, Revision } from "@storacha/ucn/pail";
 import { createWorkspaceBlockstore, } from "./blockstore/index.js";
-import { encodeFiles } from "./encoder.js";
-import { diffRemoteChanges } from "./differ.js";
+import { applyPendingOps } from "./handlers/apply.js";
+import { applyRemoteChanges } from "./handlers/remote.js";
+import { processChanges } from "./handlers/process.js";
+import { diffRemoteChanges } from "./utils/differ.js";
+import { makeTempCar } from "./utils/tempcar.js";
 export class SyncEngine {
     workspace;
     blocks;
     name = null;
     current = null;
     pendingOps = [];
-    allBlocks = []; // Accumulate blocks for CAR upload
+    carFile = null;
     running = false;
     lastSync = null;
-    constructor(workspace) {
+    storachaClient;
+    constructor(storachaClient, workspace) {
+        this.storachaClient = storachaClient;
         this.workspace = workspace;
         this.blocks = createWorkspaceBlockstore(workspace);
     }
@@ -36,10 +37,21 @@ export class SyncEngine {
     async init(config) {
         const agent = Agent.parse(config.agentKey);
         if (config.nameArchive) {
+            // Restore from previously saved archive (has full state)
             const archiveBytes = Buffer.from(config.nameArchive, "base64");
             this.name = await Name.extract(agent, archiveBytes);
         }
+        else if (config.nameDelegation) {
+            // Reconstruct from delegation (granted by another device)
+            const { extract } = await import("@storacha/client/delegation");
+            const nameBytes = Buffer.from(config.nameDelegation, "base64");
+            const { ok: delegation } = await extract(nameBytes);
+            if (!delegation)
+                throw new Error("Failed to extract name delegation");
+            this.name = Name.from(agent, [delegation]);
+        }
         else {
+            // First device — create a new name
             this.name = await Name.create(agent);
         }
         try {
@@ -48,7 +60,7 @@ export class SyncEngine {
             await this.storeBlocks(result.additions);
         }
         catch (err) {
-            if (err.code === "ERR_NO_VALUE") {
+            if (err instanceof NoValueError) {
                 this.current = null;
             }
             else {
@@ -60,34 +72,11 @@ export class SyncEngine {
      * Process a batch of file changes
      */
     async processChanges(changes) {
-        const toEncode = changes
-            .filter((c) => c.type !== "unlink")
-            .map((c) => c.path);
-        const toDelete = changes
-            .filter((c) => c.type === "unlink")
-            .map((c) => c.path);
-        // Encode changed files
-        const encoded = await encodeFiles(this.workspace, toEncode);
-        // Accumulate file blocks for CAR upload only (not persisted to blockstore)
-        // TODO: spill to temporary CAR file if memory becomes an issue
-        for (const file of encoded) {
-            this.allBlocks.push(...file.blocks);
-        }
-        // Check current pail state to skip no-ops
-        const currentEntries = await this.getPailEntries();
-        // Generate puts for changed files (skip if CID unchanged)
-        for (const file of encoded) {
-            const existing = currentEntries.get(file.path);
-            if (!existing || !existing.equals(file.rootCID)) {
-                this.pendingOps.push({ type: 'put', key: file.path, value: file.rootCID });
-            }
-        }
-        // Generate dels for removed files (skip if not in pail)
-        for (const deletePath of toDelete) {
-            if (currentEntries.has(deletePath)) {
-                this.pendingOps.push({ type: 'del', key: deletePath });
-            }
+        if (!this.carFile) {
+            this.carFile = await makeTempCar();
         }
+        const pendingOps = await processChanges(changes, this.workspace, this.current, this.blocks, (block) => this.carFile.put(block), (block) => this.blocks.put(block));
+        this.pendingOps.push(...pendingOps);
     }
     /**
      * Execute sync: generate revision, publish, upload, apply remote changes
@@ -97,78 +86,19 @@ export class SyncEngine {
             throw new Error("Sync engine not initialized");
         }
         const beforeEntries = await this.getPailEntries();
-        const revisionBlocks = [];
-        // Separate puts and dels (batch only supports puts)
-        const puts = this.pendingOps.filter((op) => op.type === "put" && op.value);
-        const dels = this.pendingOps.filter((op) => op.type === "del");
-        // Process puts with batch
-        if (puts.length > 0) {
-            if (this.current) {
-                const batcher = await Batch.create(this.blocks, this.current);
-                for (const op of puts) {
-                    if (op.value)
-                        await batcher.put(op.key, op.value);
-                }
-                const result = await batcher.commit();
-                revisionBlocks.push(...result.additions);
-                await this.storeBlocks(result.additions);
-                const opResult = result.revision.operation;
-                this.current = Value.create(this.name, opResult.root, [
-                    result.revision,
-                ]);
+        if (this.pendingOps.length > 0) {
+            if (!this.carFile) {
+                throw new Error("CAR file not initialized");
             }
-            else {
-                // First revision - v0Put
-                const firstPut = puts[0];
-                if (firstPut.value) {
-                    const result = await Revision.v0Put(this.blocks, firstPut.key, firstPut.value);
-                    revisionBlocks.push(...result.additions);
-                    await this.storeBlocks(result.additions);
-                    const opResult = result.revision.operation;
-                    this.current = Value.create(this.name, opResult.root, [
-                        result.revision,
-                    ]);
-                    // Batch remaining puts
-                    if (puts.length > 1) {
-                        const batcher = await Batch.create(this.blocks, this.current);
-                        for (const op of puts.slice(1)) {
-                            if (op.value)
-                                await batcher.put(op.key, op.value);
-                        }
-                        const batchResult = await batcher.commit();
-                        revisionBlocks.push(...batchResult.additions);
-                        await this.storeBlocks(batchResult.additions);
-                        const batchOpResult = batchResult.revision.operation;
-                        this.current = Value.create(this.name, batchOpResult.root, [
-                            batchResult.revision,
-                        ]);
-                    }
-                }
+            const result = await applyPendingOps(this.blocks, this.name, this.current, this.pendingOps);
+            this.current = result.current;
+            for (const block of result.revisionBlocks) {
+                await this.carFile.put(block);
             }
-        }
-        // Process dels individually (batch doesn't support del)
-        if (dels.length > 0 && this.current) {
-            for (const op of dels) {
-                const result = await Revision.del(this.blocks, this.current, op.key);
-                revisionBlocks.push(...result.additions);
-                await this.storeBlocks(result.additions);
-                const opResult = result.revision.operation;
-                this.current = Value.create(this.name, opResult.root, [
-                    result.revision,
-                ]);
-            }
-        }
-        this.pendingOps = [];
-        // Publish to network
-        if (this.current && this.current.revision.length > 0) {
-            const latestRevision = this.current.revision[this.current.revision.length - 1];
-            const pubResult = await Revision.publish(this.blocks, this.name, latestRevision);
-            revisionBlocks.push(...pubResult.additions);
-            await this.storeBlocks(pubResult.additions);
-            this.current = pubResult.value;
+            await this.storeBlocks(result.revisionBlocks);
         }
         else {
-            // Just pull remote
+            // No pending ops — just pull remote
             try {
                 const result = await Revision.resolve(this.blocks, this.name, {
                     base: this.current ?? undefined,
@@ -177,16 +107,13 @@ export class SyncEngine {
                 this.current = result.value;
             }
             catch (err) {
-                if (err.code !== "ERR_NO_VALUE")
+                if (!(err instanceof NoValueError))
                     throw err;
             }
         }
-        // Combine all blocks and upload as CAR
-        const allUploadBlocks = [...this.allBlocks, ...revisionBlocks];
-        if (allUploadBlocks.length > 0) {
-            await this.uploadCAR(allUploadBlocks);
-            this.allBlocks = []; // Clear accumulated blocks
-        }
+        this.pendingOps = [];
+        // Upload all accumulated blocks as CAR
+        await this.possiblyUploadCAR();
         // Apply remote changes
         const afterEntries = await this.getPailEntries();
         const remoteChanges = diffRemoteChanges(beforeEntries, afterEntries);
@@ -198,35 +125,19 @@ export class SyncEngine {
     /**
      * Create CAR and upload to Storacha
      */
-    async uploadCAR(blocks) {
-        if (blocks.length === 0)
-            return;
-        // Find root CID (last block is typically the root)
-        const rootCID = blocks[blocks.length - 1].cid;
-        // Create CAR
-        const { writer, out } = CarWriter.create([rootCID]);
-        // Collect CAR bytes
-        const chunks = [];
-        const collectPromise = (async () => {
-            for await (const chunk of out) {
-                chunks.push(chunk);
+    async possiblyUploadCAR() {
+        if (this.carFile) {
+            const readableCar = await this.carFile.switchToReadable();
+            this.carFile = null;
+            if (readableCar) {
+                try {
+                    await this.storachaClient.uploadCAR(readableCar.readable);
+                }
+                finally {
+                    await readableCar.cleanup();
+                }
             }
-        })();
-        // Write blocks
-        for (const block of blocks) {
-            await writer.put(block);
-        }
-        await writer.close();
-        await collectPromise;
-        const carBytes = new Uint8Array(chunks.reduce((acc, c) => acc + c.length, 0));
-        let offset = 0;
-        for (const chunk of chunks) {
-            carBytes.set(chunk, offset);
-            offset += chunk.length;
         }
-        // TODO: Upload to Storacha using client.uploadCAR
-        // For now, just log
-        console.log(`[storacha-sync] Would upload CAR: ${blocks.length} blocks, ${carBytes.length} bytes, root: ${rootCID}`);
     }
     /**
      * Get current pail entries as map
@@ -246,25 +157,39 @@ export class SyncEngine {
      * Apply remote changes to local filesystem
      */
     async applyRemoteChanges(changedPaths, entries) {
-        for (const relativePath of changedPaths) {
-            const cid = entries.get(relativePath);
-            if (!cid) {
-                // Deleted remotely
-                const fullPath = path.join(this.workspace, relativePath);
-                try {
-                    await fs.unlink(fullPath);
-                    console.log(`[storacha-sync] Deleted: ${relativePath}`);
-                }
-                catch (err) {
-                    if (err.code !== "ENOENT")
-                        throw err;
-                }
-            }
-            else {
-                // Changed remotely - TODO: fetch and reconstruct
-                console.log(`[storacha-sync] Remote change: ${relativePath} → ${cid}`);
-            }
+        await applyRemoteChanges(changedPaths, entries, this.workspace, {
+            blocks: this.blocks,
+            current: this.current ?? undefined,
+        });
+    }
+    /**
+     * Pull all remote state and write to local filesystem.
+     * Used by /storacha-join to overwrite local with remote before watcher starts.
+     */
+    async pullRemote() {
+        if (!this.name)
+            throw new Error("Sync engine not initialized");
+        try {
+            const result = await Revision.resolve(this.blocks, this.name, {
+                base: this.current ?? undefined,
+            });
+            await this.storeBlocks(result.additions);
+            this.current = result.value;
+        }
+        catch (err) {
+            if (!(err instanceof NoValueError))
+                throw err;
         }
+        const entries = await this.getPailEntries();
+        if (entries.size > 0) {
+            const allPaths = [...entries.keys()];
+            await applyRemoteChanges(allPaths, entries, this.workspace, {
+                blocks: this.blocks,
+                current: this.current ?? undefined,
+            });
+        }
+        this.lastSync = Date.now();
+        return entries.size;
     }
     async status() {
         const entries = await this.getPailEntries();

package/dist/types/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Type definitions for Storacha workspace sync
+ */
+import type { UnknownLink } from "multiformats";
+import type { Block } from "multiformats";
+import type { CID } from "multiformats/cid";
+/** Plugin configuration (from openclaw.plugin.json schema) */
+export interface SyncPluginConfig {
+    enabled: boolean;
+    watchPatterns: string[];
+    ignorePatterns: string[];
+}
+/** Stored in .storacha/config.json — device-specific, not synced */
+export interface DeviceConfig {
+    /** Ed25519 agent private key (base64) */
+    agentKey: string;
+    /** UCN name archive (base64 CAR) */
+    nameArchive?: string;
+    /** Space → agent upload delegation (base64 archive) */
+    uploadDelegation?: string;
+    /** Name → agent delegation for pail sync (base64 archive) */
+    nameDelegation?: string;
+    /** Space DID extracted from upload delegation */
+    spaceDID?: string;
+    /** Whether setup is complete (watcher won't start without this) */
+    setupComplete?: boolean;
+}
+/** Current sync state */
+export interface SyncState {
+    /** Is sync currently running? */
+    running: boolean;
+    /** Last successful sync timestamp */
+    lastSync: number | null;
+    /** Current pail root CID */
+    root: UnknownLink | null;
+    /** Number of tracked entries */
+    entryCount: number;
+    /** Pending local changes not yet pushed */
+    pendingChanges: number;
+}
+/** File change event from watcher */
+export interface FileChange {
+    type: "add" | "change" | "unlink";
+    path: string;
+}
+/** Encoded file result */
+export interface EncodedFile {
+    path: string;
+    blocks: ReadableStream<Block>;
+    size: number;
+}
+/** Diff operation for pail */
+export interface PailOp {
+    type: "put" | "del";
+    key: string;
+    value?: CID;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAE5C,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,yBAAyB;AACzB,MAAM,WAAW,SAAS;IACxB,iCAAiC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,4BAA4B;IAC5B,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,0BAA0B;AAC1B,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,8BAA8B;AAC9B,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,GAAG,CAAC;CACb"}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for Storacha workspace sync
+ */
+export {};

package/dist/utils/client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Create a @storacha/client instance from an agent private key and upload delegation.
+ *
+ * Uses the top-level `create()` factory which accepts principal + store directly,
+ * avoiding internal @storacha/access imports.
+ */
+import type { DeviceConfig } from "../types/index.js";
+import type { Client } from "@storacha/client";
+/**
+ * Build a Storacha Client from device config.
+ * Requires agentKey and uploadDelegation to be present.
+ */
+export declare function createStorachaClient(config: DeviceConfig): Promise<Client>;
+//# sourceMappingURL=client.d.ts.map

package/dist/utils/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/utils/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,MAAM,CAAC,CA8BjB"}

package/dist/utils/client.js

@@ -0,0 +1,38 @@
+/**
+ * Create a @storacha/client instance from an agent private key and upload delegation.
+ *
+ * Uses the top-level `create()` factory which accepts principal + store directly,
+ * avoiding internal @storacha/access imports.
+ */
+import { Agent as PailAgent } from "@storacha/ucn/pail";
+import { create as createClient } from "@storacha/client";
+import { StoreMemory } from "@storacha/client/stores/memory";
+import { extract } from "@storacha/client/delegation";
+/**
+ * Build a Storacha Client from device config.
+ * Requires agentKey and uploadDelegation to be present.
+ */
+export async function createStorachaClient(config) {
+    if (!config.uploadDelegation) {
+        throw new Error("No upload delegation in device config");
+    }
+    const agent = PailAgent.parse(config.agentKey);
+    const client = await createClient({
+        principal: agent,
+        store: new StoreMemory(),
+    });
+    // Import the upload delegation (space → agent)
+    const uploadBytes = Buffer.from(config.uploadDelegation, "base64");
+    const { ok: uploadDelegation, error: uploadErr } = await extract(uploadBytes);
+    if (!uploadDelegation) {
+        throw new Error(`Failed to extract upload delegation: ${uploadErr}`);
+    }
+    // addSpace registers the space and adds the delegation as a proof
+    await client.addSpace(uploadDelegation);
+    // Set the space as current so uploads target it
+    const spaceDID = uploadDelegation.capabilities[0]?.with;
+    if (spaceDID) {
+        await client.setCurrentSpace(spaceDID);
+    }
+    return client;
+}

package/dist/utils/differ.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Differ - compares local directory tree with pail entries
+ *
+ * Generates put/del operations to sync local state to pail.
+ */
+import type { CID } from "multiformats/cid";
+import type { PailOp } from "../types/index.js";
+/** Map of path → CID from pail entries */
+export type PailEntries = Map<string, CID>;
+/** Map of path → CID from local encoded files */
+export type LocalEntries = Map<string, CID>;
+/**
+ * Compute diff between local files and pail entries
+ *
+ * @param local - Encoded local files (path → rootCID)
+ * @param pail - Current pail entries (path → CID)
+ * @returns Operations to apply to pail
+ */
+export declare function diffEntries(local: LocalEntries, pail: PailEntries): PailOp[];
+/**
+ * Diff two pail states to find files that changed remotely
+ * (Used after publish to determine what to download)
+ *
+ * @param before - Pail entries before publish
+ * @param after - Pail entries after publish (may include remote changes)
+ * @returns Paths that changed remotely (need to download)
+ */
+export declare function diffRemoteChanges(before: PailEntries, after: PailEntries): string[];
+//# sourceMappingURL=differ.d.ts.map

package/dist/utils/differ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/utils/differ.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,0CAA0C;AAC1C,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE3C,iDAAiD;AACjD,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE5C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CAmB5E;AAGD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,GACjB,MAAM,EAAE,CAWV"}

package/dist/utils/differ.js

@@ -0,0 +1,47 @@
+/**
+ * Differ - compares local directory tree with pail entries
+ *
+ * Generates put/del operations to sync local state to pail.
+ */
+/**
+ * Compute diff between local files and pail entries
+ *
+ * @param local - Encoded local files (path → rootCID)
+ * @param pail - Current pail entries (path → CID)
+ * @returns Operations to apply to pail
+ */
+export function diffEntries(local, pail) {
+    const ops = [];
+    // Find puts: files in local that are new or changed
+    for (const [path, localCID] of local) {
+        const pailCID = pail.get(path);
+        if (!pailCID || !localCID.equals(pailCID)) {
+            ops.push({ type: "put", key: path, value: localCID });
+        }
+    }
+    // Find deletes: files in pail that aren't in local
+    for (const path of pail.keys()) {
+        if (!local.has(path)) {
+            ops.push({ type: "del", key: path });
+        }
+    }
+    return ops;
+}
+/**
+ * Diff two pail states to find files that changed remotely
+ * (Used after publish to determine what to download)
+ *
+ * @param before - Pail entries before publish
+ * @param after - Pail entries after publish (may include remote changes)
+ * @returns Paths that changed remotely (need to download)
+ */
+export function diffRemoteChanges(before, after) {
+    const changed = [];
+    for (const [path, afterCID] of after) {
+        const beforeCID = before.get(path);
+        if (!beforeCID || !afterCID.equals(beforeCID)) {
+            changed.push(path);
+        }
+    }
+    return changed;
+}

package/dist/utils/encoder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * File encoder - converts files to UnixFS DAG with root CID
+ *
+ * Uses @storacha/upload-client's UnixFS encoding to generate
+ * content-addressed blocks for each file.
+ */
+import type { EncodedFile } from "../types/index.js";
+/**
+ * Encode a single file to UnixFS blocks
+ */
+export declare function encodeWorkspaceFile(workspacePath: string, relativePath: string): Promise<EncodedFile>;
+/**
+ * Encode multiple files, returning all encoded results
+ */
+export declare function encodeFiles(workspacePath: string, relativePaths: string[]): Promise<EncodedFile[]>;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/utils/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/utils/encoder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAkBtB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,WAAW,EAAE,CAAC,CAkBxB"}

package/dist/utils/encoder.js

@@ -0,0 +1,51 @@
+/**
+ * File encoder - converts files to UnixFS DAG with root CID
+ *
+ * Uses @storacha/upload-client's UnixFS encoding to generate
+ * content-addressed blocks for each file.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as stream from "node:stream";
+import { createFileEncoderStream } from "@storacha/upload-client/unixfs";
+/**
+ * Encode a single file to UnixFS blocks
+ */
+export async function encodeWorkspaceFile(workspacePath, relativePath) {
+    const fullPath = path.join(workspacePath, relativePath);
+    const fileHandle = await fs.open(fullPath);
+    const stat = await fs.stat(fullPath);
+    // Encode to UnixFS - returns { cid, blocks }
+    const blocks = createFileEncoderStream({
+        // @ts-expect-error node web stream not type compatible with web stream
+        stream() {
+            return stream.Readable.toWeb(fileHandle.createReadStream());
+        },
+    });
+    return {
+        path: relativePath,
+        size: stat.size,
+        blocks: blocks,
+    };
+}
+/**
+ * Encode multiple files, returning all encoded results
+ */
+export async function encodeFiles(workspacePath, relativePaths) {
+    const results = [];
+    for (const relativePath of relativePaths) {
+        try {
+            const encoded = await encodeWorkspaceFile(workspacePath, relativePath);
+            results.push(encoded);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                // File was deleted between detection and encoding - skip
+                console.warn(`File not found during encoding: ${relativePath}`);
+                continue;
+            }
+            throw err;
+        }
+    }
+    return results;
+}

package/dist/utils/tempcar.d.ts

@@ -0,0 +1,22 @@
+import type { Block } from "multiformats";
+import type { BlobLike } from "@storacha/client/types";
+export interface WritableCar {
+    /**
+     * Write a block to the CAR file.
+     * Must not be called after close/switchToReadable.
+     */
+    put(block: Block): Promise<void>;
+    cleanup(): Promise<void>;
+    /**
+     * Close the writer and return a readable for upload.
+     * Returns null if nothing was written.
+     */
+    switchToReadable(): Promise<ReadableCar | null>;
+}
+interface ReadableCar {
+    readable: BlobLike;
+    cleanup(): Promise<void>;
+}
+export declare const makeTempCar: () => Promise<WritableCar>;
+export {};
+//# sourceMappingURL=tempcar.d.ts.map

package/dist/utils/tempcar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tempcar.d.ts","sourceRoot":"","sources":["../../src/utils/tempcar.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACjD;AAED,UAAU,WAAW;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,WAAW,CAkDvD,CAAC"}