@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/workspace-mount-hold-fence.mjs

@@ -1,95 +0,0 @@
-class WorkspaceMountHoldAbortedError extends Error {
-  constructor(reason) {
-    super(reason);
-    this.name = "WorkspaceMountHoldAbortedError";
-  }
-}
-class WorkspaceMountHoldFence {
-  holds = /* @__PURE__ */ new Map();
-  waiters = /* @__PURE__ */ new Set();
-  now;
-  constructor(options = {}) {
-    this.now = options.now ?? (() => Date.now());
-  }
-  /** Take one hold on every listed mount; the returned release is idempotent. */
-  hold(mountIds, description) {
-    const ids = [...new Set(mountIds)];
-    for (const id of ids) {
-      const existing = this.holds.get(id);
-      if (existing) {
-        existing.count += 1;
-        continue;
-      }
-      this.holds.set(id, { count: 1, description, sinceMs: this.now() });
-    }
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      for (const id of ids) {
-        const existing = this.holds.get(id);
-        if (!existing) continue;
-        existing.count -= 1;
-        if (existing.count === 0) this.holds.delete(id);
-      }
-      this.wake();
-    };
-  }
-  isHeld(mountIds) {
-    return mountIds.some((id) => this.holds.has(id));
-  }
-  /** Human-readable holder of the first held mount among `mountIds`, for diagnostics. */
-  describeHold(mountIds) {
-    for (const id of mountIds) {
-      const hold = this.holds.get(id);
-      if (hold) return `${hold.description} (held for ${Math.round((this.now() - hold.sinceMs) / 1e3)}s)`;
-    }
-    return null;
-  }
-  /** Every held mount id, sorted, for status reporting. */
-  heldMountIds() {
-    return [...this.holds.keys()].sort();
-  }
-  /**
-   * Resolves in the same turn as the release that leaves none of `mountIds`
-   * held, so the caller can re-check and reserve without an interleaving
-   * hold. Resolves immediately when nothing is held. Rejects with
-   * WorkspaceMountHoldAbortedError when `signal` aborts first.
-   */
-  waitForRelease(mountIds, options = {}) {
-    if (options.signal?.aborted) {
-      return Promise.reject(new WorkspaceMountHoldAbortedError(abortReason(options.signal)));
-    }
-    if (!this.isHeld(mountIds)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const waiter = { mountIds, resolve, reject, signal: options.signal };
-      if (options.signal) {
-        const signal = options.signal;
-        waiter.onAbort = () => {
-          this.waiters.delete(waiter);
-          reject(new WorkspaceMountHoldAbortedError(abortReason(signal)));
-        };
-        signal.addEventListener("abort", waiter.onAbort, { once: true });
-      }
-      this.waiters.add(waiter);
-    });
-  }
-  wake() {
-    for (const waiter of [...this.waiters]) {
-      if (this.isHeld(waiter.mountIds)) continue;
-      this.waiters.delete(waiter);
-      if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
-      waiter.resolve();
-    }
-  }
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error) return reason.message;
-  if (typeof reason === "string" && reason) return reason;
-  return "Workspace mount reservation was aborted";
-}
-export {
-  WorkspaceMountHoldAbortedError,
-  WorkspaceMountHoldFence
-};

package/dist/mjs/workspace-mutation-gate.mjs

@@ -1,103 +0,0 @@
-class WorkspaceMutationGate {
-  activeMutations = 0;
-  syncActive = false;
-  waiters = [];
-  acquireMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "mutation", resolve });
-      this.drain();
-    });
-  }
-  async runMutation(operation) {
-    const release = await this.acquireMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  async runSync(operation) {
-    const release = await new Promise((resolve) => {
-      this.waiters.push({ kind: "sync", resolve });
-      this.drain();
-    });
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /** A worktree create/delete lease; see the branch lane in the class comment. */
-  acquireBranchMutation() {
-    return new Promise((resolve) => {
-      this.waiters.push({ kind: "branch", resolve });
-      this.drain();
-    });
-  }
-  async runBranchMutation(operation) {
-    const release = await this.acquireBranchMutation();
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  /**
-   * Operations a branch mutation requested now would wait for: the running
-   * sync, if any, plus branch mutations queued behind it. Zero means it runs
-   * at once. Ordinary waiters are not counted because the branch lane admits
-   * ahead of them.
-   */
-  branchMutationQueuePosition() {
-    if (!this.syncActive) return 0;
-    return 1 + this.waiters.filter((waiter) => waiter.kind === "branch").length;
-  }
-  drain() {
-    if (this.syncActive || this.waiters.length === 0) return;
-    for (let index = 0; index < this.waiters.length; ) {
-      const waiter = this.waiters[index];
-      if (waiter?.kind !== "branch") {
-        index += 1;
-        continue;
-      }
-      this.waiters.splice(index, 1);
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-    const first = this.waiters[0];
-    if (first?.kind === "sync") {
-      if (this.activeMutations > 0) return;
-      this.waiters.shift();
-      this.syncActive = true;
-      first.resolve(this.releaseSync());
-      return;
-    }
-    while (this.waiters[0]?.kind === "mutation") {
-      const waiter = this.waiters.shift();
-      if (!waiter || waiter.kind !== "mutation") break;
-      this.activeMutations += 1;
-      waiter.resolve(this.releaseMutation());
-    }
-  }
-  releaseMutation() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.activeMutations -= 1;
-      this.drain();
-    };
-  }
-  releaseSync() {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      this.syncActive = false;
-      this.drain();
-    };
-  }
-}
-export {
-  WorkspaceMutationGate
-};

package/dist/mjs/workspace-path-move.mjs

@@ -1,160 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { projectWorktreeOperationInProgress } from "./project-worktrees.mjs";
-import { validateManagedBranchName } from "./managed-paths.mjs";
-import { assertWorkingTreeHasNoPortableGitMetadataAliases, mirrorWorkingTree } from "./working-tree-mirror.mjs";
-import { assertManagedDirectoryPath } from "./workspace-mount-boundary.mjs";
-function checkoutPathMovePublicationComplete(requiredMountIds, activeMountIds) {
-  return requiredMountIds.length > 0 && requiredMountIds.every((mountId) => activeMountIds.has(mountId));
-}
-function pathIsInside(root, candidate) {
-  const relative = path.relative(path.resolve(root), path.resolve(candidate));
-  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
-function fsyncTree(targetPath) {
-  const stat = fs.lstatSync(targetPath);
-  if (stat.isSymbolicLink()) return;
-  if (stat.isDirectory()) {
-    for (const entry of fs.readdirSync(targetPath).sort()) fsyncTree(path.join(targetPath, entry));
-  }
-  if (!stat.isDirectory() && !stat.isFile()) return;
-  const descriptor = fs.openSync(targetPath, "r");
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function fsyncDirectory(directoryPath) {
-  const descriptor = fs.openSync(directoryPath, "r");
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function fsyncAncestorsToRoot(targetPath, durabilityRoot) {
-  const root = path.resolve(durabilityRoot);
-  let current = path.dirname(path.resolve(targetPath));
-  while (true) {
-    if (fs.existsSync(current)) {
-      const status = fs.lstatSync(current);
-      if (!status.isDirectory() || status.isSymbolicLink()) {
-        throw new Error(`Project checkout path move durability boundary is not a regular directory: ${current}`);
-      }
-      fsyncDirectory(current);
-    }
-    if (current === root) return;
-    const parent = path.dirname(current);
-    if (parent === current) throw new Error(`Project checkout path move escapes durability root ${root}`);
-    current = parent;
-  }
-}
-function stableTree(targetPath, durabilityRoot) {
-  fsyncTree(targetPath);
-  fsyncAncestorsToRoot(targetPath, durabilityRoot);
-}
-function directoryEntryExists(targetPath) {
-  try {
-    fs.lstatSync(targetPath);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-}
-function retiredCheckoutPath(projectsDurabilityRoot, oldProjectRoot) {
-  const storageRoot = path.join(projectsDurabilityRoot, ".r5d-retired-checkouts");
-  const digest = createHash("sha256").update(oldProjectRoot).digest("hex");
-  return { storageRoot, retiredRoot: path.join(storageRoot, digest) };
-}
-function removeRetiredCheckout(retiredRoot, storageRoot) {
-  if (!directoryEntryExists(retiredRoot)) return;
-  fs.rmSync(retiredRoot, { recursive: true, force: true });
-  fsyncDirectory(storageRoot);
-}
-function preserveProjectCheckoutPathMove(input) {
-  const oldProjectRoot = path.resolve(input.oldProjectRoot);
-  const newProjectRoot = path.resolve(input.newProjectRoot);
-  const projectsDurabilityRoot = path.resolve(input.projectsDurabilityRoot);
-  const outerWorkspaceRoot = path.resolve(input.outerWorkspaceRoot);
-  if (oldProjectRoot === newProjectRoot || pathIsInside(oldProjectRoot, newProjectRoot) || pathIsInside(newProjectRoot, oldProjectRoot)) {
-    throw new Error("Project checkout path move roots overlap");
-  }
-  const branchNames = input.branches.map(({ branchName }) => branchName);
-  if (branchNames.length === 0 || new Set(branchNames).size !== branchNames.length) {
-    throw new Error("Project checkout path move requires unique branches");
-  }
-  assertManagedDirectoryPath({
-    trustedRoot: projectsDurabilityRoot,
-    candidate: oldProjectRoot,
-    label: "Old project checkout root"
-  });
-  assertManagedDirectoryPath({
-    trustedRoot: projectsDurabilityRoot,
-    candidate: newProjectRoot,
-    label: "New project checkout root"
-  });
-  for (const branchName of branchNames) validateManagedBranchName(branchName);
-  if (directoryEntryExists(oldProjectRoot)) {
-    assertWorkingTreeHasNoPortableGitMetadataAliases(oldProjectRoot);
-  }
-  const { storageRoot: retirementStorageRoot, retiredRoot } = retiredCheckoutPath(projectsDurabilityRoot, oldProjectRoot);
-  assertManagedDirectoryPath({
-    trustedRoot: projectsDurabilityRoot,
-    candidate: retirementStorageRoot,
-    label: "Retired project checkout storage"
-  });
-  fs.mkdirSync(retirementStorageRoot, { recursive: true, mode: 448 });
-  assertManagedDirectoryPath({
-    trustedRoot: projectsDurabilityRoot,
-    candidate: retirementStorageRoot,
-    label: "Retired project checkout storage"
-  });
-  fsyncDirectory(retirementStorageRoot);
-  fsyncDirectory(projectsDurabilityRoot);
-  assertManagedDirectoryPath({
-    trustedRoot: projectsDurabilityRoot,
-    candidate: retiredRoot,
-    label: "Retired project checkout"
-  });
-  removeRetiredCheckout(retiredRoot, retirementStorageRoot);
-  if (!directoryEntryExists(oldProjectRoot)) return { preservedBranchNames: [] };
-  const preservedBranchNames = [];
-  for (const branch of input.branches) {
-    validateManagedBranchName(branch.branchName);
-    const oldBranchPath = path.join(oldProjectRoot, ...branch.branchName.split("/"));
-    if (!fs.existsSync(oldBranchPath)) continue;
-    const newBranchPath = path.join(newProjectRoot, ...branch.branchName.split("/"));
-    const outerBranchPath = path.resolve(outerWorkspaceRoot, ...branch.outerWorkspaceRelativePath.replace(/\\/g, "/").split("/"));
-    if (!pathIsInside(outerWorkspaceRoot, outerBranchPath)) {
-      throw new Error(`Project checkout path move escapes the outer workspace: ${branch.outerWorkspaceRelativePath}`);
-    }
-    assertManagedDirectoryPath({ trustedRoot: projectsDurabilityRoot, candidate: oldBranchPath, label: "Old project checkout branch" });
-    assertManagedDirectoryPath({ trustedRoot: projectsDurabilityRoot, candidate: newBranchPath, label: "New project checkout branch" });
-    assertManagedDirectoryPath({ trustedRoot: outerWorkspaceRoot, candidate: outerBranchPath, label: "Outer workspace branch" });
-    mirrorWorkingTree({ sourceRoot: oldBranchPath, targetRoot: outerBranchPath, sourceMode: "git", deletionMode: "all" });
-    mirrorWorkingTree({ sourceRoot: oldBranchPath, targetRoot: newBranchPath, sourceMode: "all", deletionMode: "all" });
-    assertManagedDirectoryPath({ trustedRoot: projectsDurabilityRoot, candidate: newBranchPath, label: "New project checkout branch" });
-    assertManagedDirectoryPath({ trustedRoot: outerWorkspaceRoot, candidate: outerBranchPath, label: "Outer workspace branch" });
-    stableTree(outerBranchPath, outerWorkspaceRoot);
-    stableTree(newBranchPath, projectsDurabilityRoot);
-    preservedBranchNames.push(branch.branchName);
-  }
-  for (const branchName of branchNames) {
-    const checkoutPath = path.join(oldProjectRoot, ...branchName.split("/"));
-    if (fs.existsSync(checkoutPath) && projectWorktreeOperationInProgress(checkoutPath)) {
-      throw new Error(`Project branch ${branchName} has an in-progress Git operation`);
-    }
-  }
-  fs.renameSync(oldProjectRoot, retiredRoot);
-  fsyncAncestorsToRoot(oldProjectRoot, projectsDurabilityRoot);
-  fsyncDirectory(retirementStorageRoot);
-  removeRetiredCheckout(retiredRoot, retirementStorageRoot);
-  return { preservedBranchNames: preservedBranchNames.sort() };
-}
-export {
-  checkoutPathMovePublicationComplete,
-  preserveProjectCheckoutPathMove
-};

package/dist/mjs/workspace-preserve-only-policy.mjs

@@ -1,11 +0,0 @@
-function creatorLocalProjectBranchIsAuthorized(input) {
-  return Boolean(input.pendingBranchId && (!input.preserveOnlyBranchId || input.pendingBranchId === input.preserveOnlyBranchId));
-}
-function workerProjectBranchDisposition(input) {
-  if (input.activeConfigured) return "active";
-  return input.locallyPendingCreated ? "creator_local" : "preserve_only";
-}
-export {
-  creatorLocalProjectBranchIsAuthorized,
-  workerProjectBranchDisposition
-};

package/dist/mjs/workspace-project-config-policy.mjs

@@ -1,27 +0,0 @@
-function deferredProjectConfigurationPendingBranches(projects) {
-  return projects.filter((project) => !project.executionDisabled).flatMap((project) => project.branches.map(({ branchName }) => ({ projectId: project.projectId, branchName }))).sort((left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName));
-}
-function busyProjectConfigurationChanges(input) {
-  const currentById = new Map(input.currentProjects.map((project) => [project.projectId, project]));
-  const incomingById = new Map(input.incomingProjects.map((project) => [project.projectId, project]));
-  const targets = [...input.activeTargets];
-  const busyProjectIds = targets.some((target) => target.type === "workspace" && target.rootProfile === "visible_projects") ? /* @__PURE__ */ new Set([...currentById.keys(), ...incomingById.keys()]) : new Set(targets.flatMap((target) => target.type === "project" ? [target.projectId] : []));
-  return [...busyProjectIds].flatMap((projectId) => {
-    const current = currentById.get(projectId);
-    const incoming = incomingById.get(projectId);
-    if (!current && !incoming) return [];
-    if (!current) return [{ projectId, reason: "added" }];
-    if (!incoming) return [{ projectId, reason: "removed" }];
-    if (!input.currentProjectReady(current)) return [{ projectId, reason: "initializing" }];
-    if (input.currentFingerprint(current) !== input.incomingFingerprint(incoming)) return [{ projectId, reason: "changed" }];
-    return [];
-  }).sort((left, right) => left.projectId.localeCompare(right.projectId));
-}
-function describeBusyProjectConfigurationChanges(changes) {
-  return changes.map(({ projectId, reason }) => `${projectId} (${reason})`).join(", ");
-}
-export {
-  busyProjectConfigurationChanges,
-  deferredProjectConfigurationPendingBranches,
-  describeBusyProjectConfigurationChanges
-};

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

@@ -1,57 +0,0 @@
-const RETAINED_OUTCOMES = /* @__PURE__ */ new Set(["no_change", "updated", "published", "large_diff_blocked"]);
-class WorkspaceProjectionLedger {
-  projectedTokens = /* @__PURE__ */ new Map();
-  lastCycle = null;
-  static recordKey(mount) {
-    return `${mount.hydrationIncarnationKey}\0${mount.id}`;
-  }
-  get lastCycleResult() {
-    return this.lastCycle;
-  }
-  lastProjectedToken(mount) {
-    return this.projectedTokens.get(WorkspaceProjectionLedger.recordKey(mount));
-  }
-  /**
-   * Record a completed cycle. `projectedMutationTokens` names the token each
-   * active mount carried when the cycle projected it; a mount absent from it
-   * keeps its earlier record. Any outcome that leaves the outer clone without
-   * a trustworthy projection clears the ledger.
-   */
-  recordCycle(input) {
-    if (!RETAINED_OUTCOMES.has(input.result.outcome)) {
-      this.reset();
-      return;
-    }
-    const mountsById = new Map(input.mounts.map((mount) => [mount.id, mount]));
-    for (const [mountId, token] of Object.entries(input.projectedMutationTokens ?? {})) {
-      const mount = mountsById.get(mountId);
-      if (mount) this.projectedTokens.set(WorkspaceProjectionLedger.recordKey(mount), token);
-    }
-    this.lastCycle = input.result;
-  }
-  reset() {
-    this.projectedTokens.clear();
-    this.lastCycle = null;
-  }
-  /**
-   * The previous cycle's result when every request targets a configured
-   * mount and no mount's token moved since its recorded projection. A request
-   * without a target (a workspace-rooted command may touch any checkout), a
-   * mount without a token (a pending deletion), or pending deletion work all
-   * require a real cycle.
-   */
-  answerFromLastCycle(input) {
-    if (!this.lastCycle || input.pendingDeletions || input.targetMountIds.length === 0) return null;
-    const mountIds = new Set(input.mounts.map(({ id }) => id));
-    if (!input.targetMountIds.every((mountId) => mountId !== null && mountIds.has(mountId))) return null;
-    for (const mount of input.mounts) {
-      if (!mount.mutationToken) return null;
-      const recorded = this.projectedTokens.get(WorkspaceProjectionLedger.recordKey(mount));
-      if (recorded === void 0 || recorded !== mount.mutationToken()) return null;
-    }
-    return this.lastCycle;
-  }
-}
-export {
-  WorkspaceProjectionLedger
-};

package/dist/mjs/workspace-publication-evidence.mjs

@@ -1,21 +0,0 @@
-function projectBranchMountId(projectId, branchName) {
-  return `project:${projectId}:${encodeURIComponent(branchName)}`;
-}
-function activeProjectBranchNames(projectId, branchNames, activeMountIds) {
-  const active = new Set(activeMountIds);
-  return [...branchNames].filter((branchName) => active.has(projectBranchMountId(projectId, branchName))).sort((left, right) => left.localeCompare(right));
-}
-function activeProjectBranchPublicationEvidence(projects, activeMountIds) {
-  const active = new Set(activeMountIds);
-  return projects.flatMap(
-    (project) => project.executionDisabled || project.mirrorWritesDisabled ? [] : project.branches.flatMap(
-      (branch) => active.has(projectBranchMountId(project.projectId, branch.branchName)) ? [{ branchId: branch.branchId, projectId: project.projectId, branchName: branch.branchName }] : []
-    )
-  ).sort(
-    (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName) || left.branchId.localeCompare(right.branchId)
-  );
-}
-export {
-  activeProjectBranchNames,
-  activeProjectBranchPublicationEvidence
-};

package/dist/mjs/workspace-sync-coalescer.mjs

@@ -1,34 +0,0 @@
-class WorkspaceSyncCoalescer {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  pendingBatch = null;
-  batchesStarted = 0;
-  /** Requests attached to the batch that has not started yet. */
-  get queuedRequestCount() {
-    return this.pendingBatch?.requests.length ?? 0;
-  }
-  /** Batches whose body has been entered, whether or not they ran a cycle. */
-  get startedBatchCount() {
-    return this.batchesStarted;
-  }
-  request(request) {
-    const queued = this.pendingBatch;
-    if (queued) {
-      queued.requests.push(request);
-      return queued.settlement;
-    }
-    const batch = { requests: [request], settlement: Promise.resolve() };
-    this.pendingBatch = batch;
-    batch.settlement = this.options.runExclusive(async () => {
-      if (this.pendingBatch === batch) this.pendingBatch = null;
-      this.batchesStarted += 1;
-      return await this.options.runBatch(batch.requests);
-    });
-    return batch.settlement;
-  }
-}
-export {
-  WorkspaceSyncCoalescer
-};

package/dist/types/atomic-rename.d.ts

@@ -1,78 +0,0 @@
-/**
- * Atomic directory-entry primitives the working-tree mirror needs beyond
- * `rename(2)`:
- *
- * - exchange: swap two existing entries in one step
- *   (`renameat2(RENAME_EXCHANGE)` on Linux, `renamex_np(RENAME_SWAP)` on
- *   macOS). After the swap the first path names what the second held and
- *   vice versa, so a replacement can inspect exactly the entry it displaced
- *   instead of guessing from a stat taken before the rename.
- * - no-replace rename: move an entry only while nothing is at the
- *   destination (`RENAME_NOREPLACE` / `RENAME_EXCL`, or `link(2)` plus
- *   `unlink(2)` for a regular file where the flag is unavailable).
- *
- * Both are reached through `bun:ffi` against the C library already loaded in
- * the process; nothing is spawned and nothing is compiled. Availability is
- * never assumed: a filesystem can reject a flag (`EINVAL` on NFS), a runtime
- * can lack FFI, and some filesystems accept the exchange flag and then
- * perform a plain replacing rename (observed on a Docker Desktop virtiofs
- * bind mount), which would lose the displaced entry. `atomicRenamePrimitivesFor`
- * therefore probes each filesystem once with two scratch files and hands out
- * primitives whose flags were seen to work there; the caller falls back to a
- * protocol built from plain POSIX calls for anything that was not.
- */
-export type AtomicExchangeBackend = "renameat2" | "renamex_np" | "syscall" | "unavailable";
-export type AtomicNoReplaceBackend = "renameat2" | "renamex_np" | "syscall" | "link";
-export type AtomicRenameSupport = {
-    platform: NodeJS.Platform;
-    exchange: AtomicExchangeBackend;
-    noReplace: AtomicNoReplaceBackend;
-    /** Why a native primitive is not used, when it is not. */
-    detail?: string;
-};
-/** Failure of one primitive, carrying the POSIX error name the way `fs` errors do. */
-export declare class AtomicRenameError extends Error {
-    readonly syscall: string;
-    readonly code: string;
-    readonly errno: number;
-    readonly path: string;
-    readonly dest: string;
-    constructor(syscall: string, code: string, errno: number, path: string, dest: string);
-}
-export declare function isAtomicRenameUnsupported(error: unknown): boolean;
-/** What this process can do natively, before any filesystem probe. */
-export declare function atomicRenameSupport(): AtomicRenameSupport;
-/**
- * Test seam: pretend a primitive is unavailable so the portable fallback
- * protocols run on a platform that has the native ones. Pass null to clear.
- */
-export declare function overrideAtomicRenameSupportForTests(value: Partial<Pick<AtomicRenameSupport, "exchange" | "noReplace">> | null): void;
-/** Test seam: forget probe results so the next `atomicRenamePrimitivesFor` probes again. */
-export declare function resetAtomicRenameProbesForTests(): void;
-/**
- * Atomically exchange the directory entries `a` and `b` (any kinds, same
- * filesystem) with the process-level primitive, unprobed. Throws
- * AtomicRenameError `ENOENT` when either is missing and an unsupported code
- * (see `isAtomicRenameUnsupported`) when the kernel or filesystem cannot
- * exchange. Prefer `atomicRenamePrimitivesFor` for anything that matters.
- */
-export declare function exchangePaths(a: string, b: string): void;
-/** Move `from` to `to` only if nothing is at `to` (`EEXIST` otherwise), with the process-level primitive, unprobed. */
-export declare function renameNoReplace(from: string, to: string): void;
-/** Primitives bound to what a probe of one filesystem showed to work there. */
-export type AtomicRenamePrimitives = {
-    support: AtomicRenameSupport;
-    exchange: (a: string, b: string) => void;
-    renameNoReplace: (from: string, to: string) => void;
-};
-/**
- * Probe the filesystem holding `directory` (which must be writable) once per
- * device: the exchange flag must actually swap two scratch files (inode
- * numbers exchanged, both still present), and the native no-replace flag
- * must actually refuse an existing destination. A flag that fails, or that
- * succeeds without doing what it promises, is reported as unavailable and
- * the returned primitives use the fallbacks instead.
- */
-export declare function probeAtomicRenameSupport(directory: string): AtomicRenameSupport;
-/** Primitives for the filesystem holding `directory`, probed on first use per device (see `probeAtomicRenameSupport`). */
-export declare function atomicRenamePrimitivesFor(directory: string): AtomicRenamePrimitives;

package/dist/types/browser-upload.d.ts

@@ -1,7 +0,0 @@
-import { type BrowserUploadChunk, type BrowserUploadReadInput } from "@ricsam/r5d-api/browser-upload";
-/** Unlike code-view paths, uploads may read any regular file accessible to this worker. */
-export declare function readBrowserUploadChunk(input: BrowserUploadReadInput, context: {
-    cwd: string;
-    rootDir: string;
-    sessionId: string;
-}): Promise<BrowserUploadChunk>;