@storacha/clawracha 0.0.1

package/README.md

@@ -0,0 +1,134 @@
+# @storacha/clawracha
+
+OpenClaw plugin for Storacha workspace sync via UCN Pail.
+
+## Overview
+
+Clawracha syncs OpenClaw agent workspaces to Storacha using UCN (User Controlled Names) with Pail — a CRDT-based KV store backed by merkle clocks.
+
+**Features:**
+
+- 🔄 Live sync of workspace files (`.md` by default)
+- 🌐 Multi-device, multi-user via UCAN delegation
+- 🔀 CRDT-based conflict resolution (merkle clock)
+- 📦 Local-first with network sync
+
+## Installation
+
+```bash
+openclaw plugins install @storacha/clawracha
+```
+
+## Setup
+
+```bash
+# Initialize sync for this workspace
+openclaw storacha init
+
+# Import a delegation from a space owner
+openclaw storacha delegate <base64-delegation>
+
+# Restart gateway to start syncing
+openclaw gateway restart
+```
+
+## How It Works
+
+```
+Workspace Files                 UCN Pail KV Store
+================                ================
+/AGENTS.md          ────►       "AGENTS.md" → bafk...xyz
+/SOUL.md            ────►       "SOUL.md" → bafk...abc
+/memory/2026-02-10.md ────►     "memory/2026-02-10.md" → bafk...123
+```
+
+The sync loop:
+
+1. **Watch** - File watcher detects changes
+2. **Encode** - Files → UnixFS DAG → root CID
+3. **Diff** - Compare local vs pail entries
+4. **Batch** - Generate UCN revision with all changes
+5. **Upload** - All blocks → CAR → Storacha
+6. **Apply** - Remote changes → local filesystem
+
+## Configuration
+
+In your OpenClaw config:
+
+```yaml
+plugins:
+  entries:
+    storacha-sync:
+      enabled: true
+      config:
+        watchPatterns:
+          - "**/*.md"
+        ignorePatterns:
+          - ".git"
+          - "node_modules"
+          - ".storacha"
+```
+
+## Agent Tools
+
+The plugin provides tools for manual sync control:
+
+- `storacha_sync_status` - Get current sync status
+- `storacha_sync_now` - Trigger immediate sync
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  OpenClaw Agent Workspace                               │
+│  ┌─────────────────┐     ┌─────────────────┐            │
+│  │  Workspace      │◄───►│  File Watcher   │            │
+│  │  *.md files     │     │  (chokidar)     │            │
+│  └─────────────────┘     └────────┬────────┘            │
+│           │                       │                     │
+│           ▼                       ▼                     │
+│  ┌─────────────────┐     ┌─────────────────┐            │
+│  │  .storacha/     │     │  Sync Engine    │            │
+│  │  ├─ config.json │◄───►│  (UCN Pail)     │            │
+│  │  └─ blocks/     │     └────────┬────────┘            │
+│  └─────────────────┘              │                     │
+└───────────────────────────────────┼─────────────────────┘
+                                    │
+                                    ▼ publish/resolve
+┌───────────────────────────────────────────────────────┐
+│  Storacha Network                                     │
+│  ┌───────────────────┐  ┌───────────────────────────┐ │
+│  │  UCN Rendezvous   │  │  Storage Nodes            │ │
+│  │  (clock/head)     │  │  (blob storage)           │ │
+│  └───────────────────┘  └───────────────────────────┘ │
+└───────────────────────────────────────────────────────┘
+```
+
+## Local Data
+
+The plugin stores data in `.storacha/` within the workspace:
+
+- `config.json` - Agent key, delegation, name archive (NOT synced)
+- `blocks/` - Local block cache (NOT synced)
+
+Add `.storacha/` to your `.gitignore`.
+
+## Status
+
+🚧 **Work in Progress**
+
+- [x] Plugin scaffold
+- [x] Tiered blockstore (memory → disk → gateway)
+- [x] File encoder (UnixFS)
+- [x] Differ (local ↔ pail)
+- [x] Sync engine (UCN Pail batch)
+- [x] File watcher
+- [x] OpenClaw plugin integration
+- [ ] CAR upload to Storacha
+- [ ] Remote file download/apply
+- [ ] Encryption (encrypt-upload-client)
+- [ ] Full test coverage
+
+## License
+
+Apache-2.0 OR MIT

package/dist/blockstore/disk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Filesystem-backed blockstore — the one thing UCN doesn't ship.
+ * Persists blocks to .storacha/blocks/ in workspace.
+ */
+import type { Link, Block, Version } from "multiformats";
+export declare class DiskBlockstore {
+    private dir;
+    private initialized;
+    constructor(workspacePath: string);
+    private ensureDir;
+    private cidPath;
+    get<T = unknown, C extends number = number, A extends number = number, V extends Version = 1>(link: Link<T, C, A, V>): Promise<Block<T, C, A, V> | undefined>;
+    put(block: Block): Promise<void>;
+}
+//# sourceMappingURL=disk.d.ts.map

package/dist/blockstore/disk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk.d.ts","sourceRoot":"","sources":["../../src/blockstore/disk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKzD,qBAAa,cAAc;IACzB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,WAAW,CAAS;gBAEhB,aAAa,EAAE,MAAM;YAInB,SAAS;IAOvB,OAAO,CAAC,OAAO;IAIT,GAAG,CACP,CAAC,GAAG,OAAO,EACX,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,CAAC,SAAS,OAAO,GAAG,CAAC,EACrB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;IAgB3D,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CAIvC"}

package/dist/blockstore/disk.js

@@ -0,0 +1,38 @@
+/**
+ * Filesystem-backed blockstore — the one thing UCN doesn't ship.
+ * Persists blocks to .storacha/blocks/ in workspace.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export class DiskBlockstore {
+    dir;
+    initialized = false;
+    constructor(workspacePath) {
+        this.dir = path.join(workspacePath, ".storacha", "blocks");
+    }
+    async ensureDir() {
+        if (!this.initialized) {
+            await fs.mkdir(this.dir, { recursive: true });
+            this.initialized = true;
+        }
+    }
+    cidPath(cid) {
+        return path.join(this.dir, cid.toString());
+    }
+    async get(link) {
+        try {
+            const bytes = new Uint8Array(await fs.readFile(this.cidPath(link)));
+            // Return a minimal block — decoder doesn't matter for storage, the CID is the truth
+            return { cid: link, bytes, links: () => [] };
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return undefined;
+            throw err;
+        }
+    }
+    async put(block) {
+        await this.ensureDir();
+        await fs.writeFile(this.cidPath(block.cid), block.bytes);
+    }
+}

package/dist/blockstore/gateway.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gateway block fetcher
+ * Fetches blocks from Storacha gateway as last resort
+ */
+import type { CID } from "multiformats/cid";
+import type { BlockFetcher } from "../types.js";
+export declare class GatewayBlockFetcher implements BlockFetcher {
+  private gateway;
+  constructor(gateway?: string);
+  get(cid: CID): Promise<Uint8Array | undefined>;
+}
+//# sourceMappingURL=gateway.d.ts.map

package/dist/blockstore/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../src/blockstore/gateway.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,qBAAa,mBAAoB,YAAW,YAAY;IACtD,OAAO,CAAC,OAAO,CAAQ;gBAEX,OAAO,GAAE,MAAwB;IAIvC,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;CAmBrD"}

package/dist/blockstore/gateway.js

@@ -0,0 +1,28 @@
+/**
+ * Gateway block fetcher
+ * Fetches blocks from Storacha gateway as last resort
+ */
+const DEFAULT_GATEWAY = "https://w3s.link";
+export class GatewayBlockFetcher {
+  gateway;
+  constructor(gateway = DEFAULT_GATEWAY) {
+    this.gateway = gateway;
+  }
+  async get(cid) {
+    try {
+      const url = `${this.gateway}/ipfs/${cid.toString()}?format=raw`;
+      const response = await fetch(url, {
+        headers: { Accept: "application/vnd.ipld.raw" },
+      });
+      if (!response.ok) {
+        if (response.status === 404) return undefined;
+        throw new Error(`Gateway error: ${response.status}`);
+      }
+      return new Uint8Array(await response.arrayBuffer());
+    } catch (err) {
+      // Network errors → treat as not found
+      console.warn(`Gateway fetch failed for ${cid}:`, err);
+      return undefined;
+    }
+  }
+}

package/dist/blockstore/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Blockstore layer — thin wrapper around @storacha/ucn/block
+ *
+ * UCN provides: MemoryBlockstore, LRUBlockstore, GatewayBlockFetcher,
+ * TieredBlockFetcher, withCache.
+ *
+ * We add: DiskBlockstore (filesystem persistence) and a pre-configured
+ * tiered setup for workspace sync.
+ */
+export { MemoryBlockstore, LRUBlockstore, GatewayBlockFetcher, TieredBlockFetcher, withCache, } from "@storacha/ucn/block";
+export { DiskBlockstore } from "./disk.js";
+export { createWorkspaceBlockstore, type WorkspaceBlockstore, } from "./workspace.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/blockstore/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,GACV,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,yBAAyB,EACzB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC"}

package/dist/blockstore/index.js

@@ -0,0 +1,12 @@
+/**
+ * Blockstore layer — thin wrapper around @storacha/ucn/block
+ *
+ * UCN provides: MemoryBlockstore, LRUBlockstore, GatewayBlockFetcher,
+ * TieredBlockFetcher, withCache.
+ *
+ * We add: DiskBlockstore (filesystem persistence) and a pre-configured
+ * tiered setup for workspace sync.
+ */
+export { MemoryBlockstore, LRUBlockstore, GatewayBlockFetcher, TieredBlockFetcher, withCache, } from "@storacha/ucn/block";
+export { DiskBlockstore } from "./disk.js";
+export { createWorkspaceBlockstore, } from "./workspace.js";

package/dist/blockstore/memory.d.ts

@@ -0,0 +1,16 @@
+/**
+ * In-memory block cache
+ */
+import type { CID } from "multiformats/cid";
+import type { Block, BlockStore } from "../types.js";
+export declare class MemoryBlockstore implements BlockStore {
+  private blocks;
+  get(cid: CID): Promise<Uint8Array | undefined>;
+  put(block: Block): Promise<void>;
+  has(cid: CID): Promise<boolean>;
+  /** Clear all blocks */
+  clear(): void;
+  /** Get number of blocks */
+  get size(): number;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/blockstore/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/blockstore/memory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEpD,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,MAAM,CAAgC;IAExC,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IAI9C,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhC,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrC,uBAAuB;IACvB,KAAK,IAAI,IAAI;IAIb,2BAA2B;IAC3B,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/blockstore/memory.js

@@ -0,0 +1,23 @@
+/**
+ * In-memory block cache
+ */
+export class MemoryBlockstore {
+  blocks = new Map();
+  async get(cid) {
+    return this.blocks.get(cid.toString());
+  }
+  async put(block) {
+    this.blocks.set(block.cid.toString(), block.bytes);
+  }
+  async has(cid) {
+    return this.blocks.has(cid.toString());
+  }
+  /** Clear all blocks */
+  clear() {
+    this.blocks.clear();
+  }
+  /** Get number of blocks */
+  get size() {
+    return this.blocks.size;
+  }
+}

package/dist/blockstore/tiered.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tiered blockstore: memory → disk → gateway
+ *
+ * Reads check each tier in order.
+ * Writes go to memory (and optionally disk).
+ */
+import type { CID } from "multiformats/cid";
+import type { Block, BlockStore } from "../types.js";
+export declare class TieredBlockstore implements BlockStore {
+  private memory;
+  private disk;
+  private gateway;
+  private persistToDisk;
+  constructor(
+    workspacePath: string,
+    options?: {
+      persistToDisk?: boolean;
+      gateway?: string;
+    }
+  );
+  get(cid: CID): Promise<Uint8Array | undefined>;
+  put(block: Block): Promise<void>;
+  has(cid: CID): Promise<boolean>;
+  /** Flush memory blocks to disk */
+  flush(): Promise<void>;
+  /** Clear memory cache */
+  clearMemory(): void;
+}
+//# sourceMappingURL=tiered.d.ts.map

package/dist/blockstore/tiered.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiered.d.ts","sourceRoot":"","sources":["../../src/blockstore/tiered.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAKpD,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,IAAI,CAAgB;IAC5B,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,aAAa,CAAS;gBAElB,aAAa,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;IAOpF,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IA4B9C,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAUhC,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrC,kCAAkC;IAC5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,yBAAyB;IACzB,WAAW,IAAI,IAAI;CAGpB"}

package/dist/blockstore/tiered.js

@@ -0,0 +1,65 @@
+/**
+ * Tiered blockstore: memory → disk → gateway
+ *
+ * Reads check each tier in order.
+ * Writes go to memory (and optionally disk).
+ */
+import { MemoryBlockstore } from "./memory.js";
+import { DiskBlockstore } from "./disk.js";
+import { GatewayBlockFetcher } from "./gateway.js";
+export class TieredBlockstore {
+  memory;
+  disk;
+  gateway;
+  persistToDisk;
+  constructor(workspacePath, options) {
+    this.memory = new MemoryBlockstore();
+    this.disk = new DiskBlockstore(workspacePath);
+    this.gateway = new GatewayBlockFetcher(options?.gateway);
+    this.persistToDisk = options?.persistToDisk ?? true;
+  }
+  async get(cid) {
+    // Check memory first
+    let bytes = await this.memory.get(cid);
+    if (bytes) return bytes;
+    // Check disk
+    bytes = await this.disk.get(cid);
+    if (bytes) {
+      // Promote to memory cache
+      await this.memory.put({ cid, bytes });
+      return bytes;
+    }
+    // Fetch from gateway
+    bytes = await this.gateway.get(cid);
+    if (bytes) {
+      // Cache in memory and disk
+      const block = { cid, bytes };
+      await this.memory.put(block);
+      if (this.persistToDisk) {
+        await this.disk.put(block);
+      }
+      return bytes;
+    }
+    return undefined;
+  }
+  async put(block) {
+    // Always write to memory
+    await this.memory.put(block);
+    // Optionally persist to disk
+    if (this.persistToDisk) {
+      await this.disk.put(block);
+    }
+  }
+  async has(cid) {
+    return (await this.memory.has(cid)) || (await this.disk.has(cid));
+  }
+  /** Flush memory blocks to disk */
+  async flush() {
+    // Memory store doesn't expose iteration, so this is a no-op for now
+    // In practice, we persist on put anyway
+  }
+  /** Clear memory cache */
+  clearMemory() {
+    this.memory.clear();
+  }
+}

package/dist/blockstore/workspace.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pre-configured blockstore for workspace sync:
+ * Memory (LRU) → Disk → Gateway, with cache promotion.
+ */
+import { TieredBlockFetcher } from "@storacha/ucn/block";
+import type { Block } from "multiformats";
+export interface WorkspaceBlockstore {
+    get: TieredBlockFetcher["get"];
+    put: (block: Block) => Promise<void>;
+}
+export declare function createWorkspaceBlockstore(workspacePath: string, options?: {
+    gateway?: string;
+    lruMax?: number;
+}): WorkspaceBlockstore;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/blockstore/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/blockstore/workspace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC/B,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,mBAAmB,CAkBrB"}

package/dist/blockstore/workspace.js

@@ -0,0 +1,20 @@
+/**
+ * Pre-configured blockstore for workspace sync:
+ * Memory (LRU) → Disk → Gateway, with cache promotion.
+ */
+import { LRUBlockstore, GatewayBlockFetcher, TieredBlockFetcher, withCache, } from "@storacha/ucn/block";
+import { DiskBlockstore } from "./disk.js";
+export function createWorkspaceBlockstore(workspacePath, options) {
+    const memory = new LRUBlockstore(options?.lruMax ?? 1024);
+    const disk = new DiskBlockstore(workspacePath);
+    const gateway = new GatewayBlockFetcher(options?.gateway);
+    // Reads: memory → disk → gateway, with cache promotion to memory
+    const fetcher = withCache(new TieredBlockFetcher(memory, disk, gateway), memory);
+    return {
+        get: fetcher.get.bind(fetcher),
+        async put(block) {
+            await memory.put(block);
+            await disk.put(block);
+        },
+    };
+}

package/dist/differ.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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, EncodedFile } from "./types.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[];
+/**
+ * Convert encoded files to local entries map
+ */
+export declare function encodedToEntries(encoded: EncodedFile[]): LocalEntries;
+/**
+ * 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/differ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../src/differ.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,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;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,YAAY,CAMrE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,GACjB,MAAM,EAAE,CAWV"}

package/dist/differ.js

@@ -0,0 +1,57 @@
+/**
+ * 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;
+}
+/**
+ * Convert encoded files to local entries map
+ */
+export function encodedToEntries(encoded) {
+    const entries = new Map();
+    for (const file of encoded) {
+        entries.set(file.path, file.rootCID);
+    }
+    return entries;
+}
+/**
+ * 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/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.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/encoder.d.ts.map

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

package/dist/encoder.js

@@ -0,0 +1,52 @@
+/**
+ * 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 { encodeFile } 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 result = await encodeFile({
+        // @ts-expect-error node web stream not type compatible with web stream
+        stream() {
+            return stream.Readable.toWeb(fileHandle.createReadStream());
+        },
+    });
+    return {
+        path: relativePath,
+        rootCID: result.cid,
+        blocks: result.blocks, // Type mismatch between @storacha/upload-client and @ipld/unixfs - treat as unknown
+        size: stat.size,
+    };
+}
+/**
+ * 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/fs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Graceful filesystem — drop-in replacement for node:fs/promises.
+ * Handles EMFILE/ENFILE by queuing and retrying on platforms with low fd limits.
+ */
+import * as rawFs from "node:fs";
+declare const fs: typeof rawFs.promises;
+export default fs;
+export declare const readFile: typeof rawFs.promises.readFile,
+  writeFile: typeof rawFs.promises.writeFile,
+  mkdir: typeof rawFs.promises.mkdir,
+  readdir: typeof rawFs.promises.readdir,
+  stat: typeof rawFs.promises.stat,
+  unlink: typeof rawFs.promises.unlink,
+  access: typeof rawFs.promises.access,
+  rm: typeof rawFs.promises.rm,
+  mkdtemp: typeof rawFs.promises.mkdtemp;
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAYhC,QAAA,MAAM,EAAE,uBAAiB,CAAA;AACzB,eAAe,EAAE,CAAA;AACjB,eAAO,MACL,QAAQ,kCACR,SAAS,mCACT,KAAK,+BACL,OAAO,iCACP,IAAI,8BACJ,MAAM,gCACN,MAAM,gCACN,EAAE,4BACF,OAAO,+BACH,CAAA"}