@ricsam/r5d-worker 0.0.135 → 0.0.137

package/dist/mjs/workspace-hydration-ledger.mjs

@@ -1,28 +1,42 @@
-class WorkspaceHydrationPreBlobLedger {
+class WorkspaceHydrationLedger {
   mounts = /* @__PURE__ */ new Map();
   static key(mount) {
     return `${mount.hydrationIncarnationKey}\0${mount.id}`;
   }
-  /** 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) {
+    return this.mounts.get(WorkspaceHydrationLedger.key(mount)) ?? /* @__PURE__ */ new Map();
+  }
+  /** Blob ids by mount-relative path for the mount (the §3.3 detector's input), or an empty map. */
   preBlobs(mount) {
-    return this.mounts.get(WorkspaceHydrationPreBlobLedger.key(mount)) ?? /* @__PURE__ */ new Map();
+    return new Map([...this.entries(mount)].map(([relativePath, entry]) => [relativePath, entry.preBlob]));
   }
-  /** Record the pre-hydration blob of every path a merge hydration replaced; earlier entries for other paths are kept. */
-  record(mount, preBlobs) {
-    const entries = preBlobs instanceof Map ? [...preBlobs] : Object.entries(preBlobs);
-    if (entries.length === 0) return;
-    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+  /**
+   * 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, entries, options = {}) {
+    const incoming = entries instanceof Map ? [...entries] : Object.entries(entries);
+    if (incoming.length === 0) return;
+    const replace = new Set(options.replacePreBlobFor ?? []);
+    const key = WorkspaceHydrationLedger.key(mount);
     const current = this.mounts.get(key) ?? /* @__PURE__ */ new Map();
-    for (const [relativePath, blob] of entries) current.set(relativePath, blob);
+    for (const [relativePath, entry] of incoming) {
+      const previous = current.get(relativePath);
+      const preBlob = previous && previous.processLiveAcrossHydration && entry.processLiveAcrossHydration && !replace.has(relativePath) ? previous.preBlob : entry.preBlob;
+      current.set(relativePath, { ...entry, preBlob });
+    }
     this.mounts.set(key, current);
   }
   /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
   clearMount(mount) {
-    this.mounts.delete(WorkspaceHydrationPreBlobLedger.key(mount));
+    this.mounts.delete(WorkspaceHydrationLedger.key(mount));
   }
   /** Forget paths whose checkout content moved on from the hydrated bytes: a later return to the old bytes is a deliberate edit. */
   forget(mount, paths) {
-    const key = WorkspaceHydrationPreBlobLedger.key(mount);
+    const key = WorkspaceHydrationLedger.key(mount);
     const current = this.mounts.get(key);
     if (!current) return;
     for (const relativePath of paths) current.delete(relativePath);
@@ -37,6 +51,8 @@ class WorkspaceHydrationPreBlobLedger {
     return total;
   }
 }
+const WorkspaceHydrationPreBlobLedger = WorkspaceHydrationLedger;
 export {
+  WorkspaceHydrationLedger,
   WorkspaceHydrationPreBlobLedger
 };

package/dist/mjs/workspace-hydration-merge.mjs

@@ -87,6 +87,8 @@ function decideWorkspaceHydrationMerge(input) {
   const overrides = /* @__PURE__ */ new Map();
   const expectations = /* @__PURE__ */ new Map();
   const preBlobs = /* @__PURE__ */ new Map();
+  const postBlobs = /* @__PURE__ */ new Map();
+  const blobsToStore = /* @__PURE__ */ new Map();
   const mergedPaths = [];
   const keptPaths = /* @__PURE__ */ new Set();
   const desiredForIndex = new Map(desired);
@@ -139,13 +141,17 @@ function decideWorkspaceHydrationMerge(input) {
             remove.add(relativePath);
             expectations.set(relativePath, oursStat);
           }
-          if (change.base && isBlobMode(change.base.mode)) preBlobs.set(relativePath, change.base.objectId);
+          if (change.base && isBlobMode(change.base.mode)) {
+            preBlobs.set(relativePath, change.base.objectId);
+            postBlobs.set(relativePath, null);
+          }
           continue;
         }
         write.add(relativePath);
         expectations.set(relativePath, oursStat ?? currentTargetStat(targetRoot, relativePath));
         if (change.base && isBlobMode(change.base.mode) && change.base.objectId !== change.theirs.objectId) {
           preBlobs.set(relativePath, change.base.objectId);
+          postBlobs.set(relativePath, isBlobMode(change.theirs.mode) ? change.theirs.objectId : null);
         }
         continue;
       }
@@ -259,7 +265,14 @@ function decideWorkspaceHydrationMerge(input) {
         overrides.set(relativePath, { content: merged.content, mode });
         write.add(relativePath);
         expectations.set(relativePath, candidate.oursStat);
-        if (!contentUnchanged) preBlobs.set(relativePath, hashOf(oursBytes));
+        if (!contentUnchanged) {
+          const preBlob = hashOf(oursBytes);
+          const postBlob = hashOf(merged.content);
+          preBlobs.set(relativePath, preBlob);
+          postBlobs.set(relativePath, postBlob);
+          blobsToStore.set(preBlob, oursBytes);
+          blobsToStore.set(postBlob, merged.content);
+        }
         mergedPaths.push(relativePath);
       }
     }
@@ -333,6 +346,8 @@ function decideWorkspaceHydrationMerge(input) {
     overrides,
     expectations,
     preBlobs,
+    postBlobs,
+    blobsToStore,
     mergedPaths: mergedPaths.sort(),
     keptPaths: [...keptPaths].sort()
   };

package/dist/mjs/workspace-merge-projection.mjs

@@ -218,9 +218,12 @@ function synthesizeMountTree(input) {
     removeTemporaryIndex(indexPath);
   }
 }
-function staleRewritePaths(input) {
-  const entries = Object.entries(input.staleRewriteBlobs ?? {});
-  if (entries.length === 0) return { stale: [], cleared: [] };
+function ledgerStatMatches(recorded, projected) {
+  return recorded !== null && projected?.kind === "file" && projected.ino === recorded.ino && projected.size === recorded.size && projected.mode === recorded.mode && projected.mtimeMs === recorded.mtimeMs && projected.ctimeMs === recorded.ctimeMs;
+}
+function classifyHydrationLedger(input) {
+  const entries = Object.entries(input.hydrationLedger ?? {});
+  if (entries.length === 0) return { stale: [], merge: [], cleared: [] };
   const probed = gitText(input.workspacePath, ["cat-file", "--batch-check"], "resolve workspace projection basis subtree", {
     stdin: Buffer.from(`${input.basisHead}:${input.workspaceRelativePath}
 `)
@@ -241,21 +244,116 @@ function staleRewritePaths(input) {
     for (let index = 0; index + 1 < records.length; index += 2) changed.add(records[index + 1].toString());
   }
   const stale = [];
+  const merge = [];
   const cleared = [];
-  for (const [relativePath, blob] of entries) {
+  for (const [relativePath, entry] of entries) {
     const synthesized = input.blobs.get(relativePath);
     if (synthesized === void 0) {
+      if (entry.postBlob === null) continue;
+      cleared.push(relativePath);
+      continue;
+    }
+    if (ledgerStatMatches(entry.stat, input.projectedFiles[relativePath]) || synthesized === entry.postBlob) continue;
+    if (!changed.has(relativePath)) {
       cleared.push(relativePath);
       continue;
     }
-    if (synthesized === blob) {
-      if (changed.has(relativePath)) stale.push(relativePath);
-      else cleared.push(relativePath);
+    if (entry.processLiveAcrossHydration) {
+      merge.push({ relativePath, preBlob: entry.preBlob, postBlob: entry.postBlob });
       continue;
     }
-    if (changed.has(relativePath)) cleared.push(relativePath);
+    if (synthesized === entry.preBlob) {
+      stale.push(relativePath);
+      continue;
+    }
+    cleared.push(relativePath);
+  }
+  if (merge.length > 0) {
+    const ids = [...new Set(merge.flatMap(({ preBlob, postBlob }) => postBlob ? [preBlob, postBlob] : [preBlob]))];
+    const checked = gitText(input.workspacePath, ["cat-file", "--batch-check"], "verify hydration ledger blobs", {
+      stdin: Buffer.from(`${ids.join("\n")}
+`)
+    });
+    const missing = new Set(
+      checked.split("\n").filter((line) => / missing$/u.test(line)).map((line) => line.split(" ")[0])
+    );
+    if (missing.size > 0) {
+      for (let index = merge.length - 1; index >= 0; index -= 1) {
+        const { relativePath, preBlob, postBlob } = merge[index];
+        if (missing.has(preBlob) || postBlob !== null && missing.has(postBlob)) {
+          merge.splice(index, 1);
+          cleared.push(relativePath);
+        }
+      }
+    }
+  }
+  return { stale: stale.sort(), merge: merge.sort((left, right) => left.relativePath.localeCompare(right.relativePath)), cleared: cleared.sort() };
+}
+function hydrationLedgerMergeBase(input) {
+  if (input.merges.length === 0) return input.basisHead;
+  return commitWithLedgerPaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    parent: input.basisHead,
+    paths: input.merges.map(({ relativePath, preBlob }) => ({ relativePath, blob: preBlob })),
+    message: JSON.stringify({
+      type: "workspace_hydration_ledger_basis",
+      mountId: input.mountId,
+      attemptId: input.attemptId,
+      paths: input.merges.map(({ relativePath }) => relativePath)
+    }),
+    action: "hydration ledger merge base"
+  });
+}
+function hydrationLedgerTheirs(input) {
+  const paths = input.merges.flatMap(({ relativePath, postBlob }) => postBlob ? [{ relativePath, blob: postBlob }] : []);
+  if (paths.length === 0) return input.currentHead;
+  return commitWithLedgerPaths({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    parent: input.currentHead,
+    paths,
+    message: JSON.stringify({
+      type: "workspace_hydration_ledger_theirs",
+      mountId: input.mountId,
+      attemptId: input.attemptId,
+      paths: paths.map(({ relativePath }) => relativePath)
+    }),
+    action: "hydration ledger theirs"
+  });
+}
+function commitWithLedgerPaths(input) {
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", input.parent], `read workspace tree for the ${input.action}`, { environment });
+    const paths = input.paths.map(({ relativePath }) => `${input.workspaceRelativePath}/${relativePath}`);
+    const listed = git(
+      input.workspacePath,
+      ["ls-files", "-z", "--stage", "--", ...paths.map((entry) => `:(literal)${entry}`)],
+      `inspect modes for the ${input.action}`,
+      { environment }
+    );
+    const modes = /* @__PURE__ */ new Map();
+    for (const record of nulRecords(listed)) {
+      const match = /^([0-7]{6}) [0-9a-f]{40,64} [0-3]\t(.+)$/su.exec(record.toString());
+      if (match) modes.set(match[2], match[1]);
+    }
+    const records = input.paths.map(
+      ({ relativePath, blob }, index) => indexInfoRecord(modes.get(paths[index]) ?? "100644", requireObjectId(blob, `hydration ledger blob for ${relativePath}`), paths[index])
+    );
+    git(input.workspacePath, ["update-index", "-z", "--index-info"], `rewrite paths for the ${input.action}`, {
+      environment,
+      stdin: Buffer.concat(records)
+    });
+    const tree = requireObjectId(gitText(input.workspacePath, ["write-tree"], `write the ${input.action}`, { environment }), `${input.action} tree`);
+    return requireObjectId(
+      gitText(input.workspacePath, ["commit-tree", tree, "-p", input.parent, "-m", input.message], `commit the ${input.action}`),
+      `${input.action} commit`
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
   }
-  return { stale: stale.sort(), cleared: cleared.sort() };
 }
 function nulRecords(content) {
   const records = [];
@@ -289,12 +387,14 @@ function graftMountTree(input) {
         stdin: removedPaths
       });
     }
-    git(
-      input.workspacePath,
-      ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
-      "graft workspace projection mount tree",
-      { environment }
-    );
+    if (input.mountTree !== null) {
+      git(
+        input.workspacePath,
+        ["read-tree", "-i", `--prefix=${input.workspaceRelativePath}/`, input.mountTree],
+        "graft workspace projection mount tree",
+        { environment }
+      );
+    }
     return requireObjectId(
       gitText(input.workspacePath, ["write-tree"], "write grafted workspace projection tree", { environment }),
       "Grafted workspace projection tree"
@@ -303,25 +403,41 @@ function graftMountTree(input) {
     removeTemporaryIndex(indexPath);
   }
 }
+function mountSubtreeObjectId(workspacePath, revision, workspaceRelativePath, label) {
+  const spec = `${revision}:${workspaceRelativePath}`;
+  if (gitResult(workspacePath, ["cat-file", "-e", spec]).exitCode !== 0) return null;
+  const type = gitText(workspacePath, ["cat-file", "-t", spec], `inspect ${label}`);
+  if (type !== "tree") throw new Error(`${label} is not a directory at ${workspaceRelativePath}`);
+  return requireObjectId(gitText(workspacePath, ["rev-parse", spec], `resolve ${label}`), label);
+}
 function synthesizeOursCommit(input) {
   const synthesized = synthesizeMountTree({
     workspacePath: input.workspacePath,
     sourcePath: input.mount.sourcePath,
     sourceMode: input.mount.sourceMode
   });
-  const detected = staleRewritePaths({
+  const classified = classifyHydrationLedger({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
     mountTree: synthesized.tree,
     blobs: synthesized.blobs,
-    staleRewriteBlobs: input.staleRewriteBlobs
+    projectedFiles: synthesized.projectedFiles,
+    hydrationLedger: input.hydrationLedger
   });
-  if (detected.stale.length > 0) return { staleRewritePaths: detected.stale, staleRewriteCleared: detected.cleared };
-  const rootTree = graftMountTree({
+  if (classified.stale.length > 0) return { staleRewritePaths: classified.stale, staleRewriteCleared: classified.cleared };
+  const mergeBase = hydrationLedgerMergeBase({
     workspacePath: input.workspacePath,
     workspaceRelativePath: input.workspaceRelativePath,
     basisHead: input.basisHead,
+    merges: classified.merge,
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
+  const rootTree = graftMountTree({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: mergeBase,
     mountTree: synthesized.tree
   });
   const message = JSON.stringify({
@@ -332,12 +448,18 @@ function synthesizeOursCommit(input) {
   const oursCommit = requireObjectId(
     gitText(
       input.workspacePath,
-      ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
+      ["commit-tree", rootTree, "-p", mergeBase, "-m", message],
       `commit synthesized workspace projection for mount ${input.mount.id}`
     ),
     `Synthesized workspace projection commit for mount ${input.mount.id}`
   );
-  return { oursCommit, projectedFiles: synthesized.projectedFiles, staleRewriteCleared: detected.cleared };
+  return {
+    oursCommit,
+    mergeBase,
+    projectedFiles: synthesized.projectedFiles,
+    staleRewriteCleared: classified.cleared,
+    ledgerMerges: classified.merge
+  };
 }
 function mergeWorkspaceProjectionMount(input) {
   const support = workspaceMergeProjectionSupport();
@@ -352,31 +474,69 @@ function mergeWorkspaceProjectionMount(input) {
     workspaceRelativePath,
     basisHead,
     attemptId: input.attemptId,
-    ...input.staleRewriteBlobs ? { staleRewriteBlobs: input.staleRewriteBlobs } : {}
+    ...input.hydrationLedger ? { hydrationLedger: input.hydrationLedger } : {}
   });
   if ("staleRewritePaths" in synthesized) {
     return { kind: "stale_rewrite", paths: synthesized.staleRewritePaths, staleRewriteCleared: synthesized.staleRewriteCleared };
   }
-  const { oursCommit, projectedFiles, staleRewriteCleared } = synthesized;
+  const { oursCommit, mergeBase, projectedFiles, staleRewriteCleared, ledgerMerges } = synthesized;
+  const ledgerMergedPaths = ledgerMerges.map(({ relativePath }) => relativePath);
+  const theirsHead = hydrationLedgerTheirs({
+    workspacePath,
+    workspaceRelativePath,
+    currentHead,
+    merges: ledgerMerges,
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
   const readAtMs = Date.now();
+  const inboundMountTree = mountSubtreeObjectId(
+    workspacePath,
+    theirsHead,
+    workspaceRelativePath,
+    `current workspace head subtree for mount ${input.mount.id}`
+  );
+  const inboundCommit = requireObjectId(
+    gitText(
+      workspacePath,
+      [
+        "commit-tree",
+        graftMountTree({ workspacePath, workspaceRelativePath, basisHead: mergeBase, mountTree: inboundMountTree }),
+        "-p",
+        mergeBase,
+        "-m",
+        JSON.stringify({ type: "workspace_projection_inbound", mountId: input.mount.id, attemptId: input.attemptId })
+      ],
+      `commit inbound workspace projection for mount ${input.mount.id}`
+    ),
+    `Inbound workspace projection commit for mount ${input.mount.id}`
+  );
   const merged = gitResult(workspacePath, [
     "merge-tree",
     "--write-tree",
-    `--merge-base=${basisHead}`,
+    `--merge-base=${mergeBase}`,
     "--name-only",
     "-z",
     "--no-messages",
     oursCommit,
-    currentHead
+    inboundCommit
   ]);
   if (merged.exitCode !== 0 && merged.exitCode !== 1) {
     const detail = merged.stderr.toString().trim() || merged.stdout.toString().trim() || `git exited ${merged.exitCode}`;
     throw new Error(`Merge workspace projection for mount ${input.mount.id}: ${detail}`);
   }
   const records = nulRecords(merged.stdout);
-  const resultTree = records.shift()?.toString() ?? "";
-  requireObjectId(resultTree, `Merged workspace projection tree for mount ${input.mount.id}`);
-  if (merged.exitCode === 0) return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared };
+  const mergedTree = records.shift()?.toString() ?? "";
+  requireObjectId(mergedTree, `Merged workspace projection tree for mount ${input.mount.id}`);
+  if (merged.exitCode === 0) {
+    const resultTree = graftMountTree({
+      workspacePath,
+      workspaceRelativePath,
+      basisHead: currentHead,
+      mountTree: mountSubtreeObjectId(workspacePath, mergedTree, workspaceRelativePath, `merged subtree for mount ${input.mount.id}`)
+    });
+    return { kind: "clean", resultTree, oursCommit, projectedFiles, readAtMs, staleRewriteCleared, ledgerMergedPaths };
+  }
   const conflictPaths = records.map((record) => record.toString()).sort();
   return {
     kind: "conflict",
@@ -385,7 +545,8 @@ function mergeWorkspaceProjectionMount(input) {
     error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`,
     projectedFiles,
     readAtMs,
-    staleRewriteCleared
+    staleRewriteCleared,
+    ledgerMergedPaths
   };
 }
 function materializeWorkspaceProjectionTree(input) {

package/dist/types/runtime/adapter.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/runtime/client.d.ts

@@ -0,0 +1,15 @@
+import type { OperationEnvelope, OwnershipFence } from "@ricsam/r5d-api/runtime-protocol";
+import { AdapterConfig, type ActionReceipt, type ExecutorCommand, type PollResult, type RunIdentity, type RunReceipt } from "./protocol";
+/** Stateless one-request connections: disconnect/timeout never implies the operation did not happen. */
+export declare class HostExecutorClient {
+    readonly config: ReturnType<typeof AdapterConfig.parse>;
+    constructor(config: AdapterConfig);
+    request<T = unknown>(command: ExecutorCommand): Promise<T>;
+    status(): Promise<unknown>;
+    setAuthority(fence: OwnershipFence, validUntil: number): Promise<unknown>;
+    start(operation: OperationEnvelope): Promise<RunReceipt>;
+    poll(run: RunIdentity, stdoutOffset?: number, stderrOffset?: number, maxBytes?: number): Promise<PollResult>;
+    write(run: RunIdentity, actionId: string, data: string, eof?: boolean): Promise<ActionReceipt>;
+    resize(run: RunIdentity, actionId: string, cols: number, rows: number): Promise<ActionReceipt>;
+    cancel(run: RunIdentity, actionId: string): Promise<ActionReceipt>;
+}

package/dist/types/runtime/daemon.d.ts

@@ -0,0 +1,8 @@
+import { HostExecutor } from "./executor";
+import { type ExecutorConfig as Config } from "./protocol";
+/** Start only from an independently supervised daemon entrypoint, never an adapter. */
+export declare function startHostExecutor(input: Config): Promise<{
+    executor: HostExecutor;
+    socketPath: string;
+    close(): Promise<void>;
+}>;

package/dist/types/runtime/executor.d.ts

@@ -0,0 +1,30 @@
+import { type RuntimeHello } from "@ricsam/r5d-api/runtime-protocol";
+import { ExecutorConfig, type ResolvedConfig } from "./protocol";
+import { ExecutorStore } from "./storage";
+type PtyModule = typeof import("node-pty");
+export declare const tokenHash: (token: string) => string;
+/** Resource owner, never instantiated in a replaceable adapter. No legacy worker singleton imports. */
+export declare class HostExecutor {
+    private readonly nativePty?;
+    readonly config: ResolvedConfig;
+    readonly store: ExecutorStore;
+    readonly hello: RuntimeHello;
+    private readonly active;
+    private readonly leaseTimer;
+    private closing;
+    private poisoned;
+    private serial;
+    constructor(config: ExecutorConfig, nativePty?: PtyModule | undefined);
+    /** Single serialized command boundary, including controller promotions and dedupe checks. */
+    handle(input: unknown): Promise<unknown>;
+    private authenticate;
+    private authority;
+    private workerFence;
+    private authorize;
+    private receipt;
+    private dispatch;
+    private output;
+    private finish;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,5 @@
+export { startHostExecutor } from "./daemon";
+export { HostExecutorClient } from "./client";
+export { tokenHash } from "./executor";
+export { AdapterConfig, ExecutorConfig, ExecutorCommand, ExecutorError, EXECUTOR_CAPABILITY, ShellPayload } from "./protocol";
+export type { ActionReceipt, PollResult, RunIdentity, RunReceipt } from "./protocol";