@ricsam/r5d-worker 0.0.136 → 0.0.138

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>;

package/dist/types/command-launcher.d.ts

@@ -1,104 +0,0 @@
-export type CommandLaunchRequest = {
-    id: string;
-    kind: "exec" | "exec_start" | "pty_open";
-    workspaceEffect?: "none";
-    /** An explicitly classified short coordination command; the launcher keeps a bounded lane for these. */
-    commandClass?: "control";
-    sessionId?: string;
-    assertAdmission: () => void;
-};
-export type CommandLaunchLane = "general" | "utility" | "control";
-export type CommandLaunchCapacity = {
-    generalSlots: number;
-    utilitySlots: number;
-    controlSlots: number;
-    controlRuntimeMs: number;
-    queueTimeoutMs: number;
-};
-export type CommandLaunchLaneReport = {
-    /** Null when no launcher bounds this lane (direct execution). */
-    slots: number | null;
-    active: Array<{
-        id: string;
-        sessionId?: string;
-        since: string;
-    }>;
-    queued: Array<{
-        id: string;
-        sessionId?: string;
-        since: string;
-    }>;
-};
-/** Who holds and who waits for each lane, as the worker sees its own admissions. */
-export type CommandLaunchCapacityReport = {
-    /** False for a direct worker: nothing is bounded and nothing can be starved. */
-    bounded: boolean;
-    controlRuntimeMs: number | null;
-    lanes: Record<CommandLaunchLane, CommandLaunchLaneReport>;
-};
-/** The same lane rule the managed launcher applies; kept here so reports match admissions. */
-export declare function commandLaunchLane(request: Pick<CommandLaunchRequest, "kind" | "workspaceEffect" | "commandClass">): CommandLaunchLane;
-export type CommandLaunchLease = {
-    wrap(argv: string[]): string[];
-    cancel(): Promise<void>;
-    diagnose(): Promise<string | undefined>;
-    release(): Promise<void>;
-};
-export declare class CommandLauncherUnavailableError extends Error {
-    constructor(message: string, cause?: unknown);
-}
-export declare class CommandLaunchCancelledError extends Error {
-    constructor();
-}
-export declare function parseCommandLauncher(configuration: string | undefined): string[] | undefined;
-/** Launcher configuration is operator-owned; do not inherit worker or package credentials. */
-export declare function commandLauncherEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Generic optional JSONL controller; policy and OS-specific launch prefixes live outside the worker. */
-export declare class WorkerCommandLauncher {
-    private readonly options;
-    readonly mode: "direct" | "external";
-    private readonly child?;
-    private readonly pending;
-    private readonly launches;
-    private readonly exited;
-    private failure?;
-    private closing;
-    private initialized;
-    private closePromise?;
-    private sequence;
-    private capacity?;
-    constructor(options?: {
-        argv?: string[];
-        env?: NodeJS.ProcessEnv;
-        onFailure?: (error: Error, ids: string[]) => void;
-        onStderr?: (text: string) => void;
-        requestTimeoutMs?: number;
-        acquisitionTimeoutMs?: number;
-        /** Called after any admission changes lane, phase, or is released. */
-        onCapacityChange?: () => void;
-    });
-    initialize(): Promise<void>;
-    get activeIds(): string[];
-    /** The lane totals the launcher declared at initialization; undefined for a direct worker or an older launcher. */
-    get declaredCapacity(): CommandLaunchCapacity | undefined;
-    get supportsControlLane(): boolean;
-    /** Current admissions per lane, for the worker's capacity report. */
-    capacityReport(): CommandLaunchCapacityReport;
-    private notifyCapacityChange;
-    acquire(request: CommandLaunchRequest): Promise<CommandLaunchLease>;
-    /** Revoke a launch. Returns whether this launcher still held it (queued or acquired, not yet released). */
-    cancel(id: string): Promise<boolean>;
-    cancelSession(sessionId: string): Promise<void>;
-    cancelMatching(matches: (id: string, sessionId?: string) => boolean): Promise<void>;
-    close(): Promise<void>;
-    private waitForExit;
-    private releaseRecord;
-    private assertHealthy;
-    private rpc;
-    private receive;
-    private rejectPending;
-    private fail;
-}
-export declare function createWorkerCommandLauncher(options?: Omit<NonNullable<ConstructorParameters<typeof WorkerCommandLauncher>[0]>, "argv"> & {
-    configuration?: string;
-}): Promise<WorkerCommandLauncher>;

package/dist/types/control-command-policy.d.ts

@@ -1,53 +0,0 @@
-/**
- * Which agent shell invocations may run in the managed launcher's bounded
- * `control` lane: exactly one plain `r5dctl` coordination/diagnosis command.
- *
- * The lane exists so an agent can inspect capacity, message another session,
- * or stop its own runs while every general slot is held by long work
- * (incident 9). It is bounded (small memory, few PIDs, a runtime limit), so
- * only commands that are short HTTP calls to the platform qualify. The
- * classifier fails closed: anything the shell would interpret (operators,
- * substitutions, expansions, quoting the tokenizer cannot prove literal,
- * environment assignments, wrapper programs, paths) is refused and keeps its
- * ordinary general-lane shell semantics. The resulting argv is validated a
- * second time by the worker before it is spawned without a shell.
- */
-export declare const CONTROL_COMMAND_PROGRAM = "r5dctl";
-/** Worker-side runtime bound for a control run; the launcher enforces its own limit as a backstop. */
-export declare const CONTROL_COMMAND_RUNTIME_MS = 120000;
-export declare const CONTROL_COMMAND_MAX_ARGV = 64;
-export declare const CONTROL_COMMAND_MAX_LENGTH = 4096;
-export type ControlCommandClassification = {
-    control: true;
-    argv: string[];
-} | {
-    control: false;
-    reason: string;
-};
-/**
- * Validate an argv as an allowed r5dctl coordination invocation. Used on the
- * server after tokenizing, and again on the worker before spawning.
- */
-export declare function assertControlCommandArgv(argv: readonly string[]): void;
-/**
- * Locate the installed CLI through the worker's own, operator-controlled
- * search path. The command's cwd, its environment, and any checkout-local
- * shim play no part, so a project cannot substitute the executable the
- * reserved lane runs.
- */
-export declare function resolveControlCommandExecutable(trustedPath: string | undefined, which: (program: string, options: {
-    PATH: string;
-}) => string | null, program?: string): string;
-/**
- * The environment a control spawn receives: everything the platform sets for
- * the run (credentials, session identity, declared project values) minus any
- * variable that could load code into the CLI process or redirect which
- * executable runs, with the worker's own PATH restored.
- */
-export declare function controlCommandEnvironment(environment: NodeJS.ProcessEnv, trustedPath: string | undefined): Record<string, string>;
-/**
- * Classify an agent shell command. Only a plain `r5dctl` coordination
- * invocation becomes a control command; the returned argv is spawned without a
- * shell. Everything else keeps its ordinary shell semantics and lane.
- */
-export declare function classifyControlCommand(command: string): ControlCommandClassification;

package/dist/types/git-blob-hash.d.ts

@@ -1,10 +0,0 @@
-export type GitObjectHashAlgorithm = "sha1" | "sha256";
-/** The object format an object id of this length belongs to, or null for anything that is not an object id. */
-export declare function gitObjectHashAlgorithmFor(objectId: string): GitObjectHashAlgorithm | null;
-/**
- * The id `git hash-object` gives `content` as a blob: the hash of the
- * `blob <size>\0` header followed by the bytes, with no filter applied. The
- * sync engine hashes checkout bytes with it to ask whether a file still holds
- * what a commit records without spawning git.
- */
-export declare function gitBlobHash(content: Buffer, algorithm: GitObjectHashAlgorithm): string;

package/dist/types/git-identity.d.ts

@@ -1,9 +0,0 @@
-export type WorkerGitIdentity = {
-    name: string;
-    email: string;
-};
-type RunGit = (args: string[], options?: {
-    cwd?: string;
-}) => string | void;
-export declare function configureVisibleGitIdentity(branchPath: string, identity: WorkerGitIdentity | null | undefined, runGit: RunGit): void;
-export {};

package/dist/types/git-process-environment.d.ts

@@ -1,9 +0,0 @@
-/** Build the complete environment for a worker-owned Git child process. */
-export declare function workerGitProcessEnvironment(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-/** Clear inherited and repository-local HTTP authorization headers for one transport URL. */
-export declare function gitHttpAuthorizationClearArgs(remoteUrl: string): string[];
-/** Select only the app-owned credential store, regardless of repository-local helpers. */
-export declare function gitCredentialHelperConfigArgs(credentialHelper?: string | null): string[];
-export declare function gitCredentialUsernameConfigKey(remoteUrl: string): string;
-/** Non-secret command configuration required for an authenticated HTTP transport. */
-export declare function gitTransportSecurityArgs(remoteUrl: string, credentialHelper?: string | null, credentialUsername?: string | null): string[];

package/dist/types/inline-output.d.ts

@@ -1,3 +0,0 @@
-export declare const WORKER_INLINE_OUTPUT_MAX_BYTES: number;
-/** Bound inline RPC buffers in the worker regardless of child launch policy. */
-export declare function collectWorkerInlineOutput(stream: ReadableStream<Uint8Array> | null, maxBytes?: number, signal?: AbortSignal): Promise<string>;

package/dist/types/managed-paths.d.ts

@@ -1,19 +0,0 @@
-export declare const BRANCH_NAME_MAX_LENGTH = 45;
-export declare const BRANCH_NAME_PATTERN: RegExp;
-export type CheckoutPathSegments = [namespace: string, project: string];
-export type ManagedRoot = {
-    label: string;
-    rootPath: string;
-};
-/**
- * Destructive worker roots must never alias or contain one another. Resolve
- * and materialize every root first so symlinks, bind mounts, casing aliases,
- * and Unicode-normalization aliases cannot disguise an overlap. This runs
- * before any snapshot recovery or other destructive filesystem operation.
- */
-export declare function assertDisjointManagedRoots(roots: readonly ManagedRoot[]): void;
-export declare function validateManagedBranchName(branchName: string): void;
-export declare function validateCheckoutPathSegments(value: unknown): CheckoutPathSegments;
-export declare function assertPathInside(root: string, candidate: string, label: string): void;
-export declare function managedProjectRoot(projectsRoot: string, checkoutPathSegments: unknown): string;
-export declare function managedBranchPath(projectsRoot: string, checkoutPathSegments: unknown, branchName: string): string;

package/dist/types/plan-lint.d.ts

@@ -1,16 +0,0 @@
-export interface PlanLintError {
-    planId: string;
-    message: string;
-    severity: "warning" | "error";
-    line?: number;
-}
-export interface PlanLintResult {
-    type: "plan_lint";
-    errors: PlanLintError[];
-    errorCount: number;
-    warningCount: number;
-    lintedPlanCount: number;
-}
-export declare function lintPlanContent(planId: string, content: string): PlanLintError[];
-export declare function lintPlans(plansDir: string, glob?: string): Promise<PlanLintResult>;
-export declare function formatPlanLintErrors(errors: PlanLintError[]): string;