@ricsam/r5d-worker 0.0.80 → 0.0.82

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

@@ -0,0 +1,355 @@
+import fs from "node:fs";
+import path from "node:path";
+import { workerGitProcessEnvironment } from "./git-process-environment.mjs";
+import { inspectWorkingTree } from "./working-tree-mirror.mjs";
+import { assertManagedDirectoryPath } from "./workspace-mount-boundary.mjs";
+const MINIMUM_MERGE_TREE_GIT_VERSION = { major: 2, minor: 40 };
+const NON_RECURSIVE_GIT_CONFIG = [
+  "-c",
+  "submodule.recurse=false",
+  "-c",
+  "fetch.recurseSubmodules=false",
+  "-c",
+  "push.recurseSubmodules=false"
+];
+let cachedWorkspaceMergeProjectionSupport = null;
+function gitCommandArgs(args) {
+  return ["git", ...NON_RECURSIVE_GIT_CONFIG, ...args];
+}
+function gitResult(cwd, args, options = {}) {
+  const result = Bun.spawnSync(gitCommandArgs(args), {
+    cwd,
+    ...options.stdin !== void 0 ? { stdin: options.stdin } : {},
+    stdout: "pipe",
+    stderr: "pipe",
+    env: options.environment ?? workerGitProcessEnvironment()
+  });
+  return { exitCode: result.exitCode, stdout: Buffer.from(result.stdout), stderr: Buffer.from(result.stderr) };
+}
+function git(cwd, args, action, options = {}) {
+  const result = gitResult(cwd, args, options);
+  if (result.exitCode !== 0) {
+    const detail = result.stderr.toString().trim() || result.stdout.toString().trim() || `git exited ${result.exitCode}`;
+    throw new Error(`${action}: ${detail}`);
+  }
+  return result.stdout;
+}
+function gitText(cwd, args, action, options = {}) {
+  return git(cwd, args, action, options).toString().trim();
+}
+function gitVersionIsSupported(version) {
+  const match = /(?:^|\s)(\d+)\.(\d+)(?:\.\d+)?(?:\s|$)/u.exec(version);
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > MINIMUM_MERGE_TREE_GIT_VERSION.major || major === MINIMUM_MERGE_TREE_GIT_VERSION.major && minor >= MINIMUM_MERGE_TREE_GIT_VERSION.minor;
+}
+function workspaceMergeProjectionSupport() {
+  if (cachedWorkspaceMergeProjectionSupport) return cachedWorkspaceMergeProjectionSupport;
+  if (process.env.R5D_WORKSPACE_MERGE_PROJECTION === "0") {
+    cachedWorkspaceMergeProjectionSupport = {
+      supported: false,
+      error: "Workspace merge projection is disabled by R5D_WORKSPACE_MERGE_PROJECTION=0; stale mounts will remain pinned until it is enabled"
+    };
+    return cachedWorkspaceMergeProjectionSupport;
+  }
+  const version = gitResult(void 0, ["--version"]);
+  const versionText = version.stdout.toString().trim();
+  if (version.exitCode !== 0 || !gitVersionIsSupported(versionText)) {
+    const observed = versionText || version.stderr.toString().trim() || `git exited ${version.exitCode}`;
+    cachedWorkspaceMergeProjectionSupport = {
+      supported: false,
+      error: `Workspace merge projection requires Git 2.40 or newer (found ${observed}); upgrade Git before synchronizing stale mounts`
+    };
+    return cachedWorkspaceMergeProjectionSupport;
+  }
+  cachedWorkspaceMergeProjectionSupport = { supported: true };
+  return cachedWorkspaceMergeProjectionSupport;
+}
+function normalizeWorkspaceRelativePath(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === "." || normalized.includes("\0") || normalized.split("/").some((segment) => segment === ".." || segment === ".git")) {
+    throw new Error(`Invalid workspace merge-projection path: ${value}`);
+  }
+  return normalized;
+}
+function requireObjectId(value, label) {
+  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(value)) throw new Error(`${label} is not a Git object id: ${value}`);
+  return value;
+}
+function requireCommit(workspacePath, revision, label) {
+  const head = gitText(workspacePath, ["rev-parse", "--verify", `${revision}^{commit}`], `resolve ${label}`);
+  return requireObjectId(head, label);
+}
+function workspacePrivateStateDirectory(workspacePath) {
+  const gitDirectory = path.join(workspacePath, ".git");
+  const gitStatus = fs.lstatSync(gitDirectory);
+  if (!gitStatus.isDirectory() || gitStatus.isSymbolicLink()) {
+    throw new Error(`Workspace Git directory is not a regular directory: ${gitDirectory}`);
+  }
+  const stateDirectory = path.join(gitDirectory, "r5d");
+  let stateStatus = null;
+  try {
+    stateStatus = fs.lstatSync(stateDirectory);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!stateStatus) fs.mkdirSync(stateDirectory, { mode: 448 });
+  else if (!stateStatus.isDirectory() || stateStatus.isSymbolicLink()) {
+    throw new Error(`Workspace Git private state is not a regular directory: ${stateDirectory}`);
+  }
+  return stateDirectory;
+}
+function temporaryIndexPath(workspacePath) {
+  return path.join(workspacePrivateStateDirectory(workspacePath), `tmp-index-${crypto.randomUUID()}`);
+}
+function temporaryIndexEnvironment(indexPath) {
+  return { ...workerGitProcessEnvironment(), GIT_INDEX_FILE: indexPath };
+}
+function removeTemporaryIndex(indexPath) {
+  fs.rmSync(indexPath, { force: true });
+  fs.rmSync(`${indexPath}.lock`, { force: true });
+}
+function sourceEntryPath(sourceRoot, relativePath) {
+  const candidate = path.resolve(sourceRoot, ...relativePath.split("/"));
+  const relative = path.relative(sourceRoot, candidate);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`Workspace merge-projection source escapes its root: ${relativePath}`);
+  }
+  return candidate;
+}
+function assertSameOpenFile(before, after, sourcePath) {
+  if (!after.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mode !== after.mode || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+}
+function hashRegularFile(workspacePath, sourcePath, entry) {
+  const descriptor = fs.openSync(sourcePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  try {
+    const before = fs.fstatSync(descriptor);
+    if (!before.isFile() || before.size !== entry.size || (before.mode & 511) !== (entry.mode & 511)) {
+      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+    }
+    const objectId = requireObjectId(
+      gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection file ${sourcePath}`, {
+        stdin: descriptor
+      }),
+      `Workspace projection blob for ${sourcePath}`
+    );
+    const after = fs.fstatSync(descriptor);
+    assertSameOpenFile(before, after, sourcePath);
+    const pathStatus = fs.lstatSync(sourcePath);
+    if (pathStatus.dev !== after.dev || pathStatus.ino !== after.ino || !pathStatus.isFile() || pathStatus.isSymbolicLink()) {
+      throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+    }
+    return objectId;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function hashSymlink(workspacePath, sourcePath, entry) {
+  const status = fs.lstatSync(sourcePath);
+  if (!status.isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+  const objectId = requireObjectId(
+    gitText(workspacePath, ["hash-object", "-w", "--stdin"], `hash workspace projection symlink ${sourcePath}`, {
+      stdin: Buffer.from(entry.target)
+    }),
+    `Workspace projection symlink blob for ${sourcePath}`
+  );
+  if (!fs.lstatSync(sourcePath).isSymbolicLink() || fs.readlinkSync(sourcePath) !== entry.target) {
+    throw new Error(`Working-tree source changed while its merge projection was being synthesized: ${sourcePath}`);
+  }
+  return objectId;
+}
+function indexMode(entry) {
+  if (entry.kind === "symlink") return "120000";
+  return (entry.mode & 73) !== 0 ? "100755" : "100644";
+}
+function indexInfoRecord(mode, objectId, relativePath) {
+  return Buffer.concat([Buffer.from(`${mode} ${objectId}	`), Buffer.from(relativePath), Buffer.from([0])]);
+}
+function synthesizeMountTree(input) {
+  const sourceRoot = path.resolve(input.sourcePath);
+  const entries = inspectWorkingTree(sourceRoot, input.sourceMode);
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", "--empty"], "initialize workspace projection index", { environment });
+    const records = [];
+    for (const [relativePath, entry] of [...entries.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+      if (entry.kind === "directory") continue;
+      const sourcePath = sourceEntryPath(sourceRoot, relativePath);
+      const objectId = entry.kind === "file" ? hashRegularFile(input.workspacePath, sourcePath, entry) : hashSymlink(input.workspacePath, sourcePath, entry);
+      records.push(indexInfoRecord(indexMode(entry), objectId, relativePath));
+    }
+    if (records.length > 0) {
+      git(input.workspacePath, ["update-index", "-z", "--index-info"], "populate workspace projection index", {
+        environment,
+        stdin: Buffer.concat(records)
+      });
+    }
+    return requireObjectId(
+      gitText(input.workspacePath, ["write-tree"], "write workspace projection mount tree", { environment }),
+      "Workspace projection mount tree"
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
+  }
+}
+function nulRecords(content) {
+  const records = [];
+  let start = 0;
+  for (let index = 0; index < content.length; index += 1) {
+    if (content[index] !== 0) continue;
+    if (index > start) records.push(content.subarray(start, index));
+    start = index + 1;
+  }
+  if (start < content.length) records.push(content.subarray(start));
+  return records;
+}
+function indexedSubtreePaths(content, workspaceRelativePath) {
+  const prefix = Buffer.from(workspaceRelativePath);
+  const descendantPrefix = Buffer.from(`${workspaceRelativePath}/`);
+  const records = nulRecords(content).filter(
+    (record) => record.equals(prefix) || record.length > descendantPrefix.length && record.subarray(0, descendantPrefix.length).equals(descendantPrefix)
+  );
+  return records.length > 0 ? Buffer.concat(records.flatMap((record) => [record, Buffer.from([0])])) : Buffer.alloc(0);
+}
+function graftMountTree(input) {
+  const indexPath = temporaryIndexPath(input.workspacePath);
+  const environment = temporaryIndexEnvironment(indexPath);
+  try {
+    git(input.workspacePath, ["read-tree", input.basisHead], "read workspace projection basis", { environment });
+    const indexedPaths = git(input.workspacePath, ["ls-files", "-z"], "enumerate workspace projection basis", { environment });
+    const removedPaths = indexedSubtreePaths(indexedPaths, input.workspaceRelativePath);
+    if (removedPaths.length > 0) {
+      git(input.workspacePath, ["update-index", "--force-remove", "-z", "--stdin"], "remove prior workspace projection subtree", {
+        environment,
+        stdin: removedPaths
+      });
+    }
+    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"
+    );
+  } finally {
+    removeTemporaryIndex(indexPath);
+  }
+}
+function synthesizeOursCommit(input) {
+  const mountTree = synthesizeMountTree({
+    workspacePath: input.workspacePath,
+    sourcePath: input.mount.sourcePath,
+    sourceMode: input.mount.sourceMode
+  });
+  const rootTree = graftMountTree({
+    workspacePath: input.workspacePath,
+    workspaceRelativePath: input.workspaceRelativePath,
+    basisHead: input.basisHead,
+    mountTree
+  });
+  const message = JSON.stringify({
+    type: "workspace_projection_basis",
+    mountId: input.mount.id,
+    attemptId: input.attemptId
+  });
+  return requireObjectId(
+    gitText(
+      input.workspacePath,
+      ["commit-tree", rootTree, "-p", input.basisHead, "-m", message],
+      `commit synthesized workspace projection for mount ${input.mount.id}`
+    ),
+    `Synthesized workspace projection commit for mount ${input.mount.id}`
+  );
+}
+function mergeWorkspaceProjectionMount(input) {
+  const support = workspaceMergeProjectionSupport();
+  if (!support.supported) throw new Error(support.error);
+  const workspacePath = path.resolve(input.workspacePath);
+  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.mount.workspaceRelativePath);
+  const basisHead = requireCommit(workspacePath, input.basisHead, `workspace projection basis for mount ${input.mount.id}`);
+  const currentHead = requireCommit(workspacePath, input.currentHead, "current workspace projection head");
+  const oursCommit = synthesizeOursCommit({
+    workspacePath,
+    mount: input.mount,
+    workspaceRelativePath,
+    basisHead,
+    attemptId: input.attemptId
+  });
+  const merged = gitResult(workspacePath, [
+    "merge-tree",
+    "--write-tree",
+    `--merge-base=${basisHead}`,
+    "--name-only",
+    "-z",
+    "--no-messages",
+    oursCommit,
+    currentHead
+  ]);
+  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 };
+  const conflictPaths = records.map((record) => record.toString()).sort();
+  return {
+    kind: "conflict",
+    oursCommit,
+    conflictPaths,
+    error: `Workspace projection for mount ${input.mount.id} conflicted with the current workspace head`
+  };
+}
+function materializeWorkspaceProjectionTree(input) {
+  const workspacePath = path.resolve(input.workspacePath);
+  const workspaceRelativePath = normalizeWorkspaceRelativePath(input.workspaceRelativePath);
+  const resultTree = requireObjectId(input.resultTree, "Workspace projection result tree");
+  const targetPath = path.join(workspacePath, ...workspaceRelativePath.split("/"));
+  assertManagedDirectoryPath({
+    trustedRoot: workspacePath,
+    candidate: targetPath,
+    label: "Workspace merge-projection target"
+  });
+  git(workspacePath, ["cat-file", "-e", `${resultTree}^{tree}`], "resolve workspace merge-projection result tree");
+  const subtree = gitResult(workspacePath, ["cat-file", "-e", `${resultTree}:${workspaceRelativePath}`]);
+  if (subtree.exitCode !== 0) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    return;
+  }
+  const subtreeType = gitText(
+    workspacePath,
+    ["cat-file", "-t", `${resultTree}:${workspaceRelativePath}`],
+    "inspect workspace merge-projection result subtree"
+  );
+  if (subtreeType !== "tree") {
+    throw new Error(`Workspace merge-projection result is not a directory at ${workspaceRelativePath}`);
+  }
+  fs.rmSync(targetPath, { recursive: true, force: true });
+  git(
+    workspacePath,
+    ["checkout", "--no-recurse-submodules", resultTree, "--", `:(literal)${workspaceRelativePath}`],
+    "materialize merged workspace projection subtree"
+  );
+}
+const workspaceMergeProjectionTestHarness = {
+  gitVersionIsSupported,
+  resetSupportProbe() {
+    cachedWorkspaceMergeProjectionSupport = null;
+  }
+};
+export {
+  materializeWorkspaceProjectionTree,
+  mergeWorkspaceProjectionMount,
+  workspaceMergeProjectionSupport,
+  workspaceMergeProjectionTestHarness
+};

package/dist/types/main.d.ts

@@ -114,6 +114,46 @@ declare function assertWorkerChildAdmission(input: {
     workspaceConfigured: boolean;
     runtimeHealthy: boolean;
 }): void;
+type WorkerPty = {
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    terminate(): Promise<void>;
+};
+type ActiveWorkerPty = WorkerPty & {
+    target: WorkerSessionTarget;
+    foregroundBusy: boolean;
+    lastInputAt: number;
+    releaseWorkspaceMutation?: () => void;
+};
+type StagedPtyEnvFiles = {
+    paths: string[];
+    resolvedByRequestedPath: Map<string, string>;
+};
+declare function resolvePtyEnvFilePath(requestedPath: string, temporaryRoot?: string): string;
+declare function removePtyEnvFiles(paths: readonly string[]): void;
+declare function stagePtyEnvFiles(envFiles: readonly {
+    path: string;
+    content: string;
+    mode?: number;
+}[] | undefined, temporaryRoot?: string): StagedPtyEnvFiles;
+declare function resolvePtyEnvFileReferences(env: Record<string, string>, staged: StagedPtyEnvFiles): Record<string, string>;
+declare function workerCommandHasWorkspaceEffect(message: {
+    workspaceEffect?: "none";
+}): boolean;
+declare function workerPtyIsWorkspaceBusy(pty: Pick<ActiveWorkerPty, "foregroundBusy" | "lastInputAt">, now?: number, foregroundIdleEnabled?: boolean): boolean;
+declare function parseLinuxPtyForegroundBusy(stat: string): boolean | null;
+export declare const workerPtyTestHarness: {
+    temporaryPathPrefix: string;
+    inputBusyGraceMs: number;
+    resolveEnvFilePath: typeof resolvePtyEnvFilePath;
+    stageEnvFiles: typeof stagePtyEnvFiles;
+    removeEnvFiles: typeof removePtyEnvFiles;
+    resolveEnvFileReferences: typeof resolvePtyEnvFileReferences;
+    commandHasWorkspaceEffect: typeof workerCommandHasWorkspaceEffect;
+    ptyIsWorkspaceBusy: typeof workerPtyIsWorkspaceBusy;
+    parseLinuxForegroundBusy: typeof parseLinuxPtyForegroundBusy;
+};
 export type WorkerBuiltInToolPaths = {
     artifactsDir?: string;
     plansDir?: string;
@@ -375,6 +415,29 @@ export declare function prepareShellEnvForTarget(input: {
     artifactRoot: string;
     planRoot: string;
 }): Promise<Record<string, string>>;
+declare function createNodePtyBridge(options: {
+    file: string;
+    args: string[];
+    ptyOptions: {
+        name: string;
+        cols: number;
+        rows: number;
+        cwd: string;
+        env: Record<string, string | undefined>;
+    };
+    onOpened: (pid: number) => void;
+    onForeground: (busy: boolean) => void;
+    onOutput: (data: string) => void;
+    onExit: (event: {
+        exitCode: number;
+        signal?: number | string;
+    }) => void;
+    onError: (error: Error) => void;
+    onTerminationError: (error: Error) => void;
+}): WorkerPty;
+export declare const workerPtyBridgeTestHarness: {
+    create: typeof createNodePtyBridge;
+};
 export declare function resolveHostShell(command?: string, platform?: NodeJS.Platform): {
     file: string;
     args: string[];

package/dist/types/working-tree-mirror.d.ts

@@ -1,7 +1,7 @@
 export type WorkingTreeSourceMode = "all" | "git";
 export type WorkingTreeDeletionMode = "all" | "git";
 export type WorkingTreeMirrorDurability = "per_entry" | "deferred_private_staging";
-type TreeEntry = {
+export type TreeEntry = {
     kind: "directory";
     mode: number;
 } | {
@@ -35,4 +35,3 @@ export declare function mirrorWorkingTree(input: {
 }): {
     paths: string[];
 };
-export {};

package/dist/types/workspace-command-sync-policy.d.ts

@@ -12,9 +12,10 @@ type WorkspaceSyncCompletionBarrier = {
     afterCurrent(): Promise<void>;
 };
 /**
- * A visible command must not become active halfway through an outer sync. Wait
- * for the current cycle, then register the target without another await so a
- * later cycle observes the reservation and defers before integration.
+ * A project command may reserve immediately: per-mount hydration rechecks its
+ * busy predicate immediately before touching visible bytes. A visible-projects
+ * workspace command spans every project, so it keeps the whole-cycle barrier.
+ * Canonical remediation is serialized separately by the mutation gate.
  */
 export declare function reserveWorkspaceCommandAfterCurrentSync(target: WorkspaceCommandTarget, coordinator: WorkspaceSyncCompletionBarrier, reserve: () => void): Promise<void>;
 /**

package/dist/types/workspace-git-sync.d.ts

@@ -29,6 +29,8 @@ export type WorkspaceGitMount = {
     /** Remove the outer-workspace subtree when the mounted source was intentionally deleted. */
     deleteWhenSourceMissing?: boolean;
     busy?: () => boolean;
+    /** Monotonic/opaque visible-mutation token used to catch short writes that begin and end between busy checks. */
+    mutationToken?: () => string;
     /** Activity-only fence used before checkout readiness is established on reconnect. */
     busyForRecovery?: () => boolean;
 };
@@ -50,6 +52,7 @@ export type WorkspaceGitSyncResult = {
         local: string;
         remote: string;
     };
+    conflictKind?: "integration_rebase" | "projection_merge";
     error?: string;
 };
 declare function gitCommandArgs(args: string[]): string[];
@@ -74,6 +77,7 @@ export declare function ensureWorkspaceGitClone(input: {
         name: string;
         email: string;
     };
+    preserveResolutionInProgress?: boolean;
 }): {
     localHead: string | null;
     remoteHead: string | null;
@@ -88,6 +92,8 @@ export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts:
 export declare function recoverWorkspaceGitHydration(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
     ignoreBusy?: boolean;
     deferMountIds?: ReadonlySet<string>;
+    preserveResolutionInProgress?: boolean;
+    preserveStaleBases?: boolean;
 }): void;
 export declare function resetWorkspaceGit(input: {
     workspacePath: string;

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

@@ -0,0 +1,42 @@
+import { type WorkingTreeSourceMode } from "./working-tree-mirror";
+export type WorkspaceMergeProjectionSupport = {
+    supported: true;
+} | {
+    supported: false;
+    error: string;
+};
+export type WorkspaceMergeProjectionMount = {
+    id: string;
+    sourcePath: string;
+    workspaceRelativePath: string;
+    sourceMode: WorkingTreeSourceMode;
+};
+export type WorkspaceMergeProjectionResult = {
+    kind: "clean";
+    resultTree: string;
+    oursCommit: string;
+} | {
+    kind: "conflict";
+    oursCommit: string;
+    conflictPaths: string[];
+    error: string;
+};
+declare function gitVersionIsSupported(version: string): boolean;
+export declare function workspaceMergeProjectionSupport(): WorkspaceMergeProjectionSupport;
+export declare function mergeWorkspaceProjectionMount(input: {
+    workspacePath: string;
+    mount: WorkspaceMergeProjectionMount;
+    basisHead: string;
+    currentHead: string;
+    attemptId: string;
+}): WorkspaceMergeProjectionResult;
+export declare function materializeWorkspaceProjectionTree(input: {
+    workspacePath: string;
+    workspaceRelativePath: string;
+    resultTree: string;
+}): void;
+export declare const workspaceMergeProjectionTestHarness: {
+    gitVersionIsSupported: typeof gitVersionIsSupported;
+    resetSupportProbe(): void;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",