@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/types/project-worktrees.d.ts

@@ -1,397 +0,0 @@
-import { type ProjectMirrorMount, type ProjectMirrorRefsTokens } from "./project-mirror-refs-token";
-import type { WorkspaceFilesystemJobContext } from "./workspace-filesystem-job-types";
-export declare const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
-declare const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION: 1;
-/**
- * Distinguishes this control thread's live snapshots from stale ones left by
- * an earlier process that reused the PID. The control thread passes it to
- * every snapshot job, so the executor thread never invents its own.
- */
-export declare const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID: `${string}-${string}-${string}-${string}-${string}`;
-/**
- * `project` snapshots cover every configured branch and restore by replacing
- * the whole project root. `branches` snapshots cover only the checkouts one
- * reconciliation rewrites and restore those paths individually, so a rollback
- * never touches a checkout the transaction did not.
- */
-export type ProjectWorktreeSnapshotScope = "project" | "branches";
-export type ProjectWorktreeSnapshotManifest = {
-    version: typeof PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION;
-    state: "building" | "prepared" | "restoring" | "consumed";
-    scope: ProjectWorktreeSnapshotScope;
-    ownerProcessId: number;
-    ownerSessionId: string;
-    projectRoot: string;
-    branches: Array<{
-        branchName: string;
-        snapshotPresent: boolean;
-    }>;
-    createdAt: string;
-};
-export type ProjectWorktreeSnapshot = {
-    root: string;
-    manifest: ProjectWorktreeSnapshotManifest;
-    paths: Map<string, string>;
-};
-export type ProjectWorktreeSnapshotProgress = {
-    operation: "snapshot" | "restore";
-    phase: "scanning" | "copying" | "moving" | "syncing" | "cleaning";
-    projectRoot: string;
-    branchName?: string;
-    completedBranches: number;
-    totalBranches: number;
-    completedBytes: number;
-    totalBytes?: number;
-};
-export type ProjectWorktreeBranch = {
-    branchId?: string;
-    branchName: string;
-    baseCommitHash: string;
-    sourceBranchName?: string | null;
-};
-export type ProjectWorktreeState = {
-    branchName: string;
-    branchPath: string;
-    head: string;
-    mirrorHead: string | null;
-    ahead: number | null;
-    behind: number | null;
-};
-/**
- * Creation failed after its branch ref may have been written, and rollback
- * could not prove that every local artifact was removed. Callers must retain
- * their durable creation intent so a later cleanup can recover it.
- */
-export declare class ProjectBranchCreationRollbackIncompleteError extends Error {
-    readonly branchMayExist: true;
-    readonly cleanupFailures: readonly string[];
-    constructor(branchName: string, cleanupFailures: readonly string[], cause: unknown);
-}
-export declare function projectBranchMayExistAfterCreateFailure(error: unknown): boolean;
-export declare function projectWorktreeConfigurationFingerprint(input: {
-    checkoutPathSegments: readonly string[];
-    projectPath: string;
-    repoHttpUrl: string | null;
-    repoAuthHeader: string | null;
-    defaultBranch: string;
-    repositoryTransitionId?: string | null;
-    executionDisabled?: boolean;
-    mirrorWritesDisabled?: boolean;
-    preserveOnlyBranches?: readonly {
-        branchId?: string;
-        branchName: string;
-    }[];
-    branches: readonly ProjectWorktreeBranch[];
-    gitIdentity: {
-        name: string;
-        email: string;
-    } | null;
-}): string;
-declare function gitCommandArgs(args: string[]): string[];
-export declare function hasLinkedProjectWorktreeLayout(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    branches: readonly Pick<ProjectWorktreeBranch, "branchName">[];
-}): boolean;
-export declare function recoverStaleProjectWorktreeSnapshots(input: {
-    projectsRoot: string;
-    temporaryRoot?: string;
-    processAlive?: (processId: number) => boolean;
-    currentProcessId?: number;
-    currentOwnerSessionId?: string;
-    onProgress?: (progress: ProjectWorktreeSnapshotProgress) => void;
-}): {
-    restored: string[];
-    removed: string[];
-    failed: Array<{
-        path: string;
-        error: string;
-    }>;
-};
-export declare function projectOriginBranchName(input: {
-    branchName: string;
-    primaryBranchName: string;
-    defaultBranch: string;
-}): string;
-declare function configureRepository(input: {
-    primaryPath: string;
-    originUrl: string;
-    primaryBranchName?: string;
-    defaultBranch?: string;
-    branches?: readonly Pick<ProjectWorktreeBranch, "branchName">[];
-    credentialHelper?: string | null;
-    originCredentialUsername?: string | null;
-    gitIdentity?: {
-        name: string;
-        email: string;
-    } | null;
-}): Promise<void>;
-export declare function ensureProjectWorktrees(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    defaultBranch?: string;
-    branches: readonly ProjectWorktreeBranch[];
-    originUrl: string;
-    mirrorUrl: string;
-    credentialHelper?: string | null;
-    originCredentialUsername?: string | null;
-    mirrorCredentialUsername?: string | null;
-    gitIdentity?: {
-        name: string;
-        email: string;
-    } | null;
-    exactMirrorBranches?: ReadonlySet<string>;
-    snapshotRoot?: string;
-    onSnapshotProgress?: (progress: ProjectWorktreeSnapshotProgress) => void;
-}): Promise<ProjectWorktreeState[]>;
-export declare function projectWorktreeOperationInProgress(checkoutPath: string): boolean;
-/**
- * How a new linked worktree's working tree starts. `carry` materializes the
- * source checkout's Git-visible working state, uncommitted changes included;
- * `clean` checks out the source branch's current commit and nothing else.
- */
-export type ProjectWorktreeWorkingTreeMode = "carry" | "clean";
-export declare function createLinkedProjectBranch(input: {
-    projectRoot: string;
-    sourceBranchName: string;
-    branchName: string;
-    workingTree: ProjectWorktreeWorkingTreeMode;
-}): {
-    branchPath: string;
-    baseCommitHash: string;
-};
-/**
- * A retained pending intent is ownership proof for artifacts left by an
- * interrupted earlier attempt. Remove those artifacts idempotently before
- * recreating; if cleanup still fails, the caller keeps the same intent and can
- * retry again later.
- */
-export declare function createOrRetryLinkedProjectBranch(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    sourceBranchName: string;
-    branchName: string;
-    workingTree: ProjectWorktreeWorkingTreeMode;
-    pendingRetry: boolean;
-}): Promise<{
-    branchPath: string;
-    baseCommitHash: string;
-}>;
-export type ProjectCheckoutState = "linked" | "missing" | "not_a_worktree";
-export type ProjectCheckoutInventory = {
-    /** Branches whose checkout is this project's primary clone or one of its linked worktrees. */
-    linkedBranchNames: string[];
-    missingCheckouts: Array<{
-        branchName: string;
-        checkoutPath: string;
-        reason: Exclude<ProjectCheckoutState, "linked">;
-    }>;
-};
-/**
- * Classify one configured branch checkout without spawning git, cheap enough
- * to run for every configured branch on every sync cycle. The primary
- * checkout is `linked` when its `.git` is a directory; another branch is
- * `linked` when its `.git` pointer file resolves into that primary clone's
- * `.git/worktrees` registry and the registered directory still exists.
- * `missing` means the checkout path is absent. Everything else (a hydrated
- * directory that never became a checkout, a foreign clone, a pointer to a
- * pruned registration) is `not_a_worktree`.
- */
-export declare function classifyProjectCheckout(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    branchName: string;
-}): ProjectCheckoutState;
-/**
- * Partition a ready project's configured branches into checkouts a sync cycle
- * may use and checkouts it must skip. A primary clone that is not linked takes
- * every branch with it: nothing can be observed or published through it.
- */
-export declare function inventoryProjectCheckouts(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    branchNames: readonly string[];
-}): ProjectCheckoutInventory;
-export declare const PROJECT_REMOVED_CHECKOUTS_DIRECTORY = ".r5d-removed";
-export declare function deleteLinkedProjectBranch(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    branchName: string;
-}): {
-    branchName: string;
-    /** Where a path that was not this project's linked worktree was set aside instead of being deleted. */
-    movedAsidePath?: string;
-    /**
-     * Where the linked worktree's tree now waits for garbage collection. The
-     * branch is already gone from Git; the caller hands this path to the
-     * collector so the recursive removal runs outside every workspace lease.
-     */
-    stagedForCollectionPath?: string;
-};
-/**
- * Retire a whole project: one rename into the namespace garbage directory
- * (the tree, primary Git objects included, is removed by the collector
- * outside every lease), or nothing when the root is already gone.
- */
-export declare function removeProjectWorktrees(input: {
-    projectsRoot: string;
-    projectRoot: string;
-    branchNames: readonly string[];
-}): {
-    stagedForCollectionPath?: string;
-};
-export declare function deleteProjectMirrorBranch(input: {
-    gitDirectory: string;
-    branchName: string;
-    mirrorUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-}): Promise<void>;
-export declare function pushProjectMirrorHeads(input: {
-    projectRoot: string;
-    branchNames: readonly string[];
-    mirrorUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    onlyBranches?: ReadonlySet<string>;
-    /** Exact pre-projection commits to publish after the outer tree is reachable. */
-    publicationHeads?: ReadonlyMap<string, string>;
-    /** Hidden-mirror tips observed before the corresponding outer projection. */
-    expectedMirrorHeads: ReadonlyMap<string, string | null>;
-    /** Durable branch incarnations used to scope server-authored handoff refs. */
-    branchIds: ReadonlyMap<string, string>;
-}): Promise<Array<{
-    branchName: string;
-    head: string;
-    pushed: boolean;
-    reason?: string;
-}>>;
-export declare function assertProjectMirrorHeadsPushed(results: readonly {
-    branchName: string;
-    pushed: boolean;
-    reason?: string;
-}[]): void;
-type ProjectMirrorHeadUpdateInput = {
-    projectRoot: string;
-    primaryBranchName: string;
-    branchNames: readonly string[];
-    mirrorUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    /** Rechecked after fetch and ancestry inspection, immediately before refs or the index move. */
-    branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
-};
-export type ProjectMirrorHeadObservation = {
-    branchName: string;
-    previousHead: string;
-    mirrorHead: string | null;
-    mode: "fast_forward" | "reseed" | "server_synced";
-    serverSyncedWorkspaceHeads: string[];
-    shouldMove: boolean;
-};
-/**
- * Fetch and pin the exact hidden-mirror tips that may be applied after a
- * causally later outer-workspace fetch and hydration. Observation deliberately
- * does not mutate a live branch or its index.
- *
- * With `refreshRemote: false` the network fetch is skipped and the tips come
- * from the locally cached `refs/r5d/mirror/*` / `refs/r5d/server-synced/*`
- * refs of an earlier fetch. That is safe in the stale direction (a newer
- * mirror tip waits for a later cycle, exactly like a tip that lands mid-cycle
- * today) and in the fresh direction (hidden-mirror publication is tree-first,
- * so any locally cached tip's covering outer tree was published before the
- * fetch that cached it, hence before this cycle's outer fetch).
- */
-export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
-    allowNonFastForward: boolean;
-    branchIds?: ReadonlyMap<string, string>;
-    refreshRemote?: boolean;
-    /**
-     * Fetch only these mounts' branch heads and handoff refs, because
-     * per-mount token gating found every other mount current. Undefined
-     * fetches the whole mirror; an empty set fetches nothing, exactly like
-     * `refreshRemote: false`.
-     */
-    fetchOnlyBranches?: ReadonlySet<string>;
-}): Promise<ProjectMirrorHeadObservation[]>;
-/**
- * Compute the tokens the locally cached mirror state covers — the project
- * token and one token per mount — from one listing of `refs/r5d/mirror/*` and
- * `refs/r5d/server-synced/*`, with the formula shared with the server. After a
- * fetch these name exactly the canonical state the fetch transferred; after a
- * successful lease push (which updates `refs/r5d/mirror/*` above) they predict
- * the server's next advertisement unless something else also moved the
- * canonical repository, in which case the mismatch fails open into a fetch.
- */
-export declare function computeLocalProjectMirrorRefsTokens(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    mounts: readonly ProjectMirrorMount[];
-}): Promise<ProjectMirrorRefsTokens>;
-/** Apply only previously observed object ids; this function never refetches. */
-export declare function applyObservedProjectMirrorHeads(input: {
-    projectRoot: string;
-    primaryBranchName: string;
-    observations: readonly ProjectMirrorHeadObservation[];
-    /** Rechecked immediately before refs or the index move. */
-    branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
-    /** Proves the visible outer workspace has hydrated the server commit's exact source generation. */
-    serverSyncedWorkspaceCovered?: (observation: ProjectMirrorHeadObservation) => Promise<boolean>;
-}): Promise<Array<{
-    branchName: string;
-    previousHead: string;
-    mirrorHead: string | null;
-    moved: boolean;
-}>>;
-export declare function fastForwardProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Promise<Array<{
-    branchName: string;
-    previousHead: string;
-    mirrorHead: string | null;
-    fastForwarded: boolean;
-}>>;
-export declare function reseedProjectHeadsFromMirror(input: ProjectMirrorHeadUpdateInput): Promise<Array<{
-    branchName: string;
-    previousHead: string;
-    mirrorHead: string | null;
-    reseeded: boolean;
-}>>;
-/** Executor job body: `snapshotBranchTrees` with progress relayed to the control thread. */
-export declare function runProjectSnapshotCreateJob(input: {
-    projectRoot: string;
-    branches: ProjectWorktreeBranch[];
-    temporaryRoot: string;
-    scope: ProjectWorktreeSnapshotScope;
-    ownerSessionId: string;
-}, context: WorkspaceFilesystemJobContext): ProjectWorktreeSnapshot;
-/** Executor job body: mirror captured checkouts back over reconciled worktrees. */
-export declare function runProjectSnapshotApplyJob(input: {
-    mirrors: Array<{
-        snapshotPath: string;
-        targetPath: string;
-    }>;
-}): null;
-/** Executor job body: `persistReconciledProjectAndConsumeSnapshot`. */
-export declare function runProjectSnapshotPersistJob(input: {
-    snapshot: ProjectWorktreeSnapshot;
-    durabilityPaths: string[] | null;
-}): null;
-/** Executor job body: `rollbackProjectWorktreeSnapshot`. */
-export declare function runProjectSnapshotRollbackJob(input: {
-    snapshot: ProjectWorktreeSnapshot;
-}): null;
-export declare const projectWorktreesTestHarness: {
-    commandArgs: typeof gitCommandArgs;
-    configureRepository: typeof configureRepository;
-    createPreparedSnapshot(input: {
-        projectRoot: string;
-        branches: readonly ProjectWorktreeBranch[];
-        temporaryRoot: string;
-        scope?: ProjectWorktreeSnapshotScope;
-    }): {
-        root: string;
-    };
-    consumeSnapshot(snapshotRoot: string): void;
-    persistProjectAndConsumeSnapshot(snapshotRoot: string, afterProjectTreeFsync?: () => void): void;
-    snapshotState(snapshotRoot: string): ProjectWorktreeSnapshotManifest["state"];
-};
-export {};

package/dist/types/pty-output-coalescer.d.ts

@@ -1,20 +0,0 @@
-export interface PtyOutputCoalescerOptions {
-    send: (data: string) => void;
-    flushIntervalMs?: number;
-    maxBufferBytes?: number;
-    now?: () => number;
-    schedule?: (callback: () => void, delayMs: number) => () => void;
-}
-export interface PtyOutputCoalescer {
-    push(data: string): void;
-    flush(): void;
-}
-export declare const DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS = 8;
-export declare const DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES: number;
-/**
- * Batches PTY output into fewer, larger relay messages. An isolated chunk
- * (an interactive keystroke echo) is sent immediately so coalescing adds no
- * input latency; only sustained bursts (build logs, `cat` of a large file)
- * are buffered, bounded by the flush interval and the buffer byte cap.
- */
-export declare function createPtyOutputCoalescer(options: PtyOutputCoalescerOptions): PtyOutputCoalescer;

package/dist/types/recovery-journal-protocol.d.ts

@@ -1,35 +0,0 @@
-/** Messages between the control thread and the recovery journal thread. */
-export declare const WORKER_RECOVERY_JOURNAL_OPS: readonly ["admit", "readmitUnknownBranchDeletion", "record", "unknown", "unknownRun", "acknowledgeResult", "acknowledgeOutput", "acknowledgeTerminal", "cancelSession", "isRequestCancelled", "operations", "recoveryState", "terminals", "outputReplayBegin", "outputReplayNext", "outputReplayEnd"];
-export type WorkerRecoveryJournalOp = (typeof WORKER_RECOVERY_JOURNAL_OPS)[number];
-export declare function isWorkerRecoveryJournalOp(value: unknown): value is WorkerRecoveryJournalOp;
-export type WorkerRecoveryJournalEntry = {
-    seq: number;
-    op: WorkerRecoveryJournalOp;
-    args: unknown[];
-};
-export type WorkerRecoveryJournalBatchRequest = {
-    type: "batch";
-    id: number;
-    entries: WorkerRecoveryJournalEntry[];
-};
-export type WorkerRecoveryJournalSerializedError = {
-    name: string;
-    message: string;
-    stack?: string;
-};
-export type WorkerRecoveryJournalThreadReply = {
-    type: "ready";
-    ledgerId: string;
-} | {
-    type: "batch_result";
-    id: number;
-    results: Array<{
-        seq: number;
-        value: unknown;
-    }>;
-} | {
-    type: "batch_failure";
-    id: number;
-    error: WorkerRecoveryJournalSerializedError;
-};
-export declare function serializeWorkerRecoveryJournalError(error: unknown): WorkerRecoveryJournalSerializedError;

package/dist/types/recovery-journal-runtime.d.ts

@@ -1,12 +0,0 @@
-import type { MessagePort } from "node:worker_threads";
-/**
- * The recovery journal thread's loop. It owns the one WorkerRecoveryStore
- * handle of the process and applies the control thread's entries strictly in
- * sequence, one durable commit per batch. Everything the store guarantees
- * (acceptance before effects, offsets, terminal lengths, unknown gating,
- * acknowledgement retention, cancel snapshots) is unchanged; only the thread
- * running it moved. `beforeBatch` exists for the stall fixture used by tests.
- */
-export declare function serveRecoveryJournal(port: MessagePort, filename: string, hooks?: {
-    beforeBatch?: () => void;
-}): void;

package/dist/types/recovery-journal-thread.d.ts

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