@ricsam/r5d-worker 0.0.136 → 0.0.137

package/dist/types/workspace-hydration-ledger.d.ts

@@ -1,33 +1,64 @@
+import type { ProjectedWorkingTreeEntry } from "./working-tree-mirror";
 /**
- * Blob ids of the bytes merge hydration replaced in a checkout, kept in
- * memory per mount incarnation until a later hydration of the same path
- * replaces them or the mount is hydrated outside a cycle (recovery, reset,
- * configuration), which rewrites the checkout without recording anything.
+ * What a merge hydration replaced at one checkout path
+ * (docs/merge-hydration-design.md §3.1): the blob that was there before
+ * (`preBlob`), the blob hydration wrote (`postBlob`, null when it removed the
+ * path), the `lstat` it left behind (`stat`, null when removed), and whether
+ * a worker-tracked process or PTY was alive across that hydration.
  *
- * The projection reads it as the stale-rewrite detector
- * (docs/merge-hydration-design.md §3.3): a process that read a file before a
- * hydration and re-emits the same bytes afterwards would otherwise publish a
- * revert of the inbound change as an ordinary local edit. A changed file whose
- * content hashes to the blob hydration replaced is exactly that, so the mount
- * is pinned instead of published, loudly.
- *
- * Deliberately not persisted: a restart loses the entries and the detector is
- * best effort. Phase 2 of the design turns this into a durable ledger if
- * telemetry warrants it.
+ * At the next projection a path whose stat moved is treated by that flag: a
+ * process alive across the hydration may have read the file before it and
+ * written it afterwards, so its bytes are merged against `preBlob` (what it
+ * read) with `postBlob` as the other side, which turns a stale-read revert
+ * into the inbound change plus the process's own delta, or a visible
+ * conflict. Without a live process the change is a plain edit on top of
+ * `postBlob`; the exact re-emission of `preBlob` is still refused as a stale
+ * rewrite (§3.3).
+ */
+export type WorkspaceHydrationLedgerEntry = {
+    preBlob: string;
+    postBlob: string | null;
+    stat: Extract<ProjectedWorkingTreeEntry, {
+        kind: "file";
+    }> | null;
+    processLiveAcrossHydration: boolean;
+};
+/**
+ * In memory, per mount incarnation and clone. Not persisted: every process
+ * and PTY the flag refers to is a child of the worker, so a restart ends
+ * them all and no entry could still merge; the detector half is best effort.
  */
-export declare class WorkspaceHydrationPreBlobLedger {
+export declare class WorkspaceHydrationLedger {
     private readonly mounts;
     private static key;
-    /** Blob ids by mount-relative path for the mount, or an empty map. */
+    /** Entries by mount-relative path for the mount, or an empty map. */
+    entries(mount: {
+        id: string;
+        hydrationIncarnationKey: string;
+    }): ReadonlyMap<string, WorkspaceHydrationLedgerEntry>;
+    /** Blob ids by mount-relative path for the mount (the §3.3 detector's input), or an empty map. */
     preBlobs(mount: {
         id: string;
         hydrationIncarnationKey: string;
     }): ReadonlyMap<string, string>;
-    /** Record the pre-hydration blob of every path a merge hydration replaced; earlier entries for other paths are kept. */
+    /**
+     * Record what a merge hydration replaced; earlier entries for other paths
+     * are kept. A path that already carries a live entry keeps its `preBlob`
+     * while the new hydration also ran across a live process: the process's
+     * read predates both hydrations, so what it read is still the first blob.
+     */
     record(mount: {
         id: string;
         hydrationIncarnationKey: string;
-    }, preBlobs: ReadonlyMap<string, string> | Readonly<Record<string, string>>): void;
+    }, entries: ReadonlyMap<string, WorkspaceHydrationLedgerEntry> | Readonly<Record<string, WorkspaceHydrationLedgerEntry>>, options?: {
+        /**
+         * Paths whose new `preBlob` is taken even over a live entry: the
+         * hydration followed a projection that merged the process's own write
+         * at that path, so the bytes it wrote (not what it originally read)
+         * are the base its next write derives from.
+         */
+        replacePreBlobFor?: readonly string[];
+    }): void;
     /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
     clearMount(mount: {
         id: string;
@@ -41,3 +72,5 @@ export declare class WorkspaceHydrationPreBlobLedger {
     clear(): void;
     get size(): number;
 }
+/** The name the first version of this module exported; kept for callers that still use it. */
+export declare const WorkspaceHydrationPreBlobLedger: typeof WorkspaceHydrationLedger;

package/dist/types/workspace-hydration-merge.d.ts

@@ -54,6 +54,14 @@ export type WorkspaceHydrationMergeDecision = {
     expectations: Map<string, fs.Stats | null>;
     /** Blob of the bytes each written or removed path held before hydration; the stale-rewrite detector's input. */
     preBlobs: Map<string, string>;
+    /** Blob each path in `preBlobs` holds after hydration (null: removed); with `preBlobs`, the hydration ledger's record. */
+    postBlobs: Map<string, string | null>;
+    /**
+     * Bytes the ledger names that no commit holds (a merged file's previous
+     * and merged content), keyed by blob id, for the job to write into the
+     * clone's object store so a later projection can read them back.
+     */
+    blobsToStore: Map<string, Buffer>;
     /** Paths whose content was three-way merged. */
     mergedPaths: string[];
     /** Paths the checkout changed since projection that hydration leaves as they are. */

package/dist/types/workspace-merge-projection.d.ts

@@ -1,4 +1,5 @@
 import { type ProjectedWorkingTreeEntry, type WorkingTreeSourceMode } from "./working-tree-mirror";
+import type { WorkspaceHydrationLedgerEntry } from "./workspace-hydration-ledger";
 export type WorkspaceMergeProjectionSupport = {
     supported: true;
 } | {
@@ -25,6 +26,13 @@ export type WorkspaceMergeProjectionResult = {
     readAtMs: number;
     /** Ledger paths whose checkout content moved on from both the replaced and the basis bytes (or that are gone). */
     staleRewriteCleared: string[];
+    /**
+     * Ledger paths a process alive across their hydration rewrote, merged
+     * here against what that process read (docs/merge-hydration-design.md
+     * §3.1): the checkout still holds the process's bytes, so the mount must
+     * be hydrated from the merged result even where its receipt is current.
+     */
+    ledgerMergedPaths: string[];
 } | {
     kind: "conflict";
     oursCommit: string;
@@ -33,6 +41,7 @@ export type WorkspaceMergeProjectionResult = {
     projectedFiles: Record<string, ProjectedWorkingTreeEntry>;
     readAtMs: number;
     staleRewriteCleared: string[];
+    ledgerMergedPaths: string[];
 } | {
     kind: "stale_rewrite";
     paths: string[];
@@ -46,7 +55,7 @@ export declare function mergeWorkspaceProjectionMount(input: {
     basisHead: string;
     currentHead: string;
     attemptId: string;
-    staleRewriteBlobs?: Readonly<Record<string, string>>;
+    hydrationLedger?: Readonly<Record<string, WorkspaceHydrationLedgerEntry>>;
 }): WorkspaceMergeProjectionResult;
 export declare function materializeWorkspaceProjectionTree(input: {
     workspacePath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.136",
+  "version": "0.0.137",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/cjs/main.cjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.136",
+    "@ricsam/r5d-api": "^0.0.137",
     "node-pty": "^1.1.0",
     "picomatch": "^4.0.3"
   },