@ricsam/r5d-worker 0.0.136 → 0.0.138

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

@@ -1,495 +0,0 @@
-import { type PreparedWorkingTreeMirror, type ProjectedWorkingTreeEntry, type WorkingTreeGitlink, type WorkingTreeMirrorPlan, type WorkingTreeMirrorScope, type WorkingTreeSourceMode } from "./working-tree-mirror";
-import { type WorkspaceHydrationMergeBasis, type WorkspaceHydrationMergeDecision, type WorkspaceHydrationMountSkip as WorkspaceHydrationMountSkipBase } from "./workspace-hydration-merge";
-import { WorkspaceHydrationPreBlobLedger } from "./workspace-hydration-ledger";
-export declare const WORKSPACE_GIT_BRANCH = "main";
-export declare const MAX_WORKSPACE_GIT_DIFF_BYTES: number;
-export declare const WORKSPACE_GIT_CONFIRMED_LARGE_DIFF_PUSH_OPTION = "r5d-confirm-large-diff-v1";
-export declare const WORKSPACE_GIT_HYDRATED_RECEIPT = "r5d/workspace-hydrated-head";
-export declare const WORKSPACE_GIT_HYDRATION_TRANSACTION = "r5d/workspace-hydration-transaction";
-export declare const WORKSPACE_GIT_HYDRATION_RECOVERIES = "r5d/workspace-hydration-recoveries";
-export declare const WORKSPACE_GIT_CHECKOUT_DURABILITY = "r5d/workspace-checkout-durability";
-/** `R5D_MERGE_HYDRATION=0` restores the plain byte mirror for post-publication hydration (docs/merge-hydration-design.md §4). */
-export declare const WORKSPACE_MERGE_HYDRATION_SWITCH = "R5D_MERGE_HYDRATION";
-declare function hydrationPreBlobLedger(workspacePath: string): WorkspaceHydrationPreBlobLedger;
-export type WorkspaceHydrationMountSkip = WorkspaceHydrationMountSkipBase & {
-    retainedPaths?: string[];
-};
-export type WorkspaceMountSkipReason = WorkspaceHydrationMountSkip["reason"] | "stale_rewrite_detected";
-/** Why a mount was left at its recorded basis this cycle, with the paths involved; a diagnostic beside `skippedMountIds`. */
-export type WorkspaceMountSkipReasons = Record<string, {
-    reason: WorkspaceMountSkipReason;
-    paths: string[];
-    retainedPaths?: string[];
-}>;
-type WorkspaceHydrationMountBasis = {
-    id: string;
-    incarnationKey: string;
-    sourcePath: string;
-    durabilityRootPath: string;
-    workspaceRelativePath: string;
-    sourceMode: WorkingTreeSourceMode;
-    hydrateDeletionMode: "all" | "git";
-    preserveLocalOnInitialOuterAbsence: boolean;
-    preserveLocalOnHydrationBasisChange: boolean;
-    deleteWhenSourceMissing: boolean;
-};
-type WorkspaceHydrationMountReceipt = WorkspaceHydrationMountBasis & {
-    head: string;
-};
-export type WorkspaceHydrationReceipt = {
-    version: 3;
-    mounts: WorkspaceHydrationMountReceipt[];
-    /** Non-enumerable read-compat marker used only to finish a v1/v2 crash transition. */
-    legacyHead?: string;
-};
-type WorkspaceHydrationTransactionManifest = {
-    /** Version 5 makes guarded recovery explicit before any visible mutation. */
-    version: 3 | 4 | 5;
-    transactionId?: string;
-    targetReceipt: WorkspaceHydrationReceipt | null;
-    receiptBefore: WorkspaceHydrationReceipt | null;
-    mounts: Array<{
-        id: string;
-        incarnationKey: string;
-        sourcePath: string;
-        durabilityRootPath: string;
-        workspaceRelativePath: string;
-        existed: boolean;
-        snapshotName: string;
-        /**
-         * Present when the snapshot holds only the entries hydration replaces or
-         * removes, with the paths it creates listed. Without it the snapshot is a
-         * complete copy of the mount.
-         */
-        scope?: WorkingTreeMirrorScope;
-        /** Required in v5: guarded mounts never enter unguarded snapshot restore. */
-        recovery?: "snapshot" | "guarded";
-    }>;
-    /** Settled rollback scopes remain evidence; they are never restored again. */
-    preservedMounts?: WorkspaceHydrationTransactionManifest["mounts"];
-};
-export type WorkspaceHydrationRecoveryRequired = {
-    transactionId: string;
-    transactionPath: string;
-    mounts: Array<Pick<WorkspaceHydrationTransactionManifest["mounts"][number], "id" | "incarnationKey" | "sourcePath" | "durabilityRootPath" | "workspaceRelativePath"> & {
-        retainedPaths?: string[];
-    }>;
-    receiptBefore: WorkspaceHydrationReceipt | null;
-};
-export declare class WorkspaceHydrationRecoveryRequiredError extends Error {
-    readonly hydrationRecovery: WorkspaceHydrationRecoveryRequired;
-    readonly code = "hydration_recovery_required";
-    constructor(hydrationRecovery: WorkspaceHydrationRecoveryRequired, options?: ErrorOptions);
-}
-export type WorkspaceHydrationPreservationResult = {
-    transactionId: string;
-    archivePath: string;
-    receiptBefore: WorkspaceHydrationReceipt | null;
-    preservedMountIds: string[];
-    alreadyPreserved: boolean;
-    retainedEntries?: Array<{
-        mountId: string;
-        sourcePath: string;
-        archivePath: string;
-    }>;
-};
-export type WorkspaceGitMount = {
-    id: string;
-    /** Durable logical incarnation (for example the project-branch row id). */
-    hydrationIncarnationKey: string;
-    sourcePath: string;
-    /** Existing managed root through which hydrated source directory entries are durably published. */
-    durabilityRootPath: string;
-    workspaceRelativePath: string;
-    sourceMode: WorkingTreeSourceMode;
-    hydrateDeletionMode: "all" | "git";
-    /**
-     * Only an exact creator-local unpublished mount may treat an absent outer
-     * subtree as bootstrap authority before this clone has a hydration receipt.
-     * Published/active mounts treat absence as a canonical deletion.
-     */
-    preserveLocalOnInitialOuterAbsence?: boolean;
-    /**
-     * Preserve a durably copied local tree across an exact checkout-path move.
-     * This is transient and must clear after that move is published.
-     */
-    preserveLocalOnHydrationBasisChange?: boolean;
-    /**
-     * Workspace-relative path of the subtree this creator-local mount was copied
-     * from (its source branch checkout). While the mount's own outer subtree is
-     * still unpublished, the automatic diff-size guard measures it against that
-     * source subtree instead of counting the whole copied tree as new content.
-     */
-    initialPublicationSourceRelativePath?: string;
-    /** Remove the outer-workspace subtree when the mounted source was intentionally deleted. */
-    deleteWhenSourceMissing?: boolean;
-    busy?: () => boolean;
-    /** Control-thread diagnostics only; never sent to a filesystem job. */
-    describeHolders?: () => string;
-    /** Monotonic/opaque visible-mutation token used to catch short writes that begin and end between busy checks. */
-    mutationToken?: () => string;
-    /**
-     * The token a completed cycle observed when it last projected this mount.
-     * While the current token still equals it and the mount's hydration basis
-     * is the outer HEAD being projected, the outer subtree already carries the
-     * visible bytes and the mirror copy is skipped. This is a cross-cycle skip
-     * only; the per-cycle busy and token re-checks are unchanged.
-     */
-    lastProjectedMutationToken?: string;
-    /** Activity-only fence used before checkout readiness is established on reconnect. */
-    busyForRecovery?: () => boolean;
-};
-/**
- * The data of a mount, without its control-thread predicates. This is what a
- * workspace filesystem job receives: a job never evaluates `busy()` or
- * `mutationToken()`; the control thread evaluated them before dispatch and
- * holds the mount (see WorkspaceHydrationTransactionHooks.holdMounts) until
- * the job ends.
- */
-export type WorkspaceGitMountData = Pick<WorkspaceGitMount, "id" | "hydrationIncarnationKey" | "sourcePath" | "durabilityRootPath" | "workspaceRelativePath" | "sourceMode" | "hydrateDeletionMode" | "preserveLocalOnInitialOuterAbsence" | "preserveLocalOnHydrationBasisChange" | "initialPublicationSourceRelativePath" | "deleteWhenSourceMissing" | "lastProjectedMutationToken">;
-export declare function workspaceGitMountData(mount: WorkspaceGitMount): WorkspaceGitMountData;
-/**
- * Incident-bound configuration keeps project checkouts unready while the
- * canonical remediation owns the workspace. The guarded remediation sync is
- * nevertheless allowed to hydrate an existing checkout when its activity-only
- * fence is clear; the ordinary `busy` predicate would mistake that deliberate
- * unready state for concurrent visible work.
- */
-export declare function workspaceGitMountsForRemediation(mounts: readonly WorkspaceGitMount[]): WorkspaceGitMount[];
-export type WorkspaceHydrationTransactionContext = {
-    /** Unique per transaction; pairs the begin and end observations. */
-    transactionId: string;
-    workspacePath: string;
-    /** Mounts the transaction may hydrate or carry across the durability barrier. */
-    mountIds: string[];
-};
-/**
- * Observes a hydration transaction (snapshot, hydration pass, durability
- * barrier, receipt) and fences the mounts any workspace filesystem job reads
- * or writes. The body runs on the executor thread and on a stalled disk it
- * can run for a long time. `beforeTransaction` is awaited after the last
- * asynchronous precheck and before the final busy observation, so it may
- * announce the operation and yield once; `afterTransaction` runs after the
- * body committed or rolled back. `holdMounts` is called synchronously right
- * after the busy observation that selected the mounts, before the job is
- * dispatched, and its release is called when the job's result or failure
- * arrived: while held, command admission for those mounts waits (see
- * WorkspaceMountHoldFence), which replaces the guarantee the un-yielding body
- * used to give.
- */
-export type WorkspaceHydrationTransactionHooks = {
-    beforeTransaction: (context: WorkspaceHydrationTransactionContext) => Promise<void> | void;
-    afterTransaction: (context: WorkspaceHydrationTransactionContext) => void;
-    holdMounts: (mountIds: readonly string[], description: string) => () => void;
-};
-export type WorkspaceGitSyncOutcome = "no_change" | "updated" | "pushed" | "large_diff_blocked" | "conflict_blocked";
-export type WorkspaceGitSyncResult = {
-    outcome: WorkspaceGitSyncOutcome;
-    startingHead: string | null;
-    /** The worker-local commit, including an unpublished blocked commit. */
-    localHead: string | null;
-    remoteHead: string | null;
-    publishedHead: string | null;
-    rebaseCount: number;
-    /**
-     * Bytes the automatic publication guard evaluated. A creator-local branch's
-     * first publication counts only its divergence from the source subtree.
-     */
-    diffSizeBytes: number;
-    affectedPaths: string[];
-    activeMountIds: string[];
-    skippedMountIds: string[];
-    /**
-     * Mounts merge hydration pinned this cycle (a conflict between a write
-     * that landed after the projection read and the inbound change, or a write
-     * racing the hydration) and mounts the stale-rewrite detector refused to
-     * project, each with the paths involved. Worker-internal until the server
-     * contract carries it.
-     */
-    mountSkipReasons?: WorkspaceMountSkipReasons;
-    /** Token each active mount carried when this cycle projected it; recorded by the caller to skip unchanged mounts later. */
-    projectedMutationTokens?: Record<string, string>;
-    /** Creator-local mounts whose first outer publication was measured against their source subtree. */
-    initialPublicationMountIds?: string[];
-    /** Network fetches of the outer workspace head this cycle ran; zero when the advertised head proved them unnecessary. */
-    remoteHeadFetches?: number;
-    conflictPaths?: string[];
-    conflictSnapshotRefs?: {
-        local: string;
-        remote: string;
-    };
-    conflictKind?: "integration_rebase" | "projection_merge";
-    verifiedAncestorHeads?: string[];
-    error?: string;
-};
-/** A guarded remediation was rejected before it was allowed to hydrate or publish. */
-export declare class WorkspaceRemediationAncestryError extends Error {
-    constructor(message: string);
-}
-declare function gitCommandArgs(args: string[]): string[];
-declare function workspaceCloneCommandArgs(args: string[], remoteUrl: string, credentialHelper?: string | null, credentialUsername?: string | null): string[];
-export declare function workspaceGitHydrationIsCurrent(workspacePath: string, mounts?: readonly WorkspaceGitMount[]): boolean;
-/**
- * Failure-time variant of the currency check. A mount pinned at a valid
- * recorded basis is convergent whether or not it is busy right now: the next
- * cycle merges it forward from that exact basis and a genuine collision
- * surfaces as a projection_merge conflict, never a silent overwrite. Live
- * busy-ness must not decide safety here because the same disconnect that
- * aborts a sync also clears the process/PTY maps busy-ness is computed from.
- * Configuration-time recovery keeps the strict predicate.
- */
-export declare function workspaceGitHydrationIsRecoverable(workspacePath: string, mounts?: readonly WorkspaceGitMount[]): boolean;
-/** Executor job body: recover the durable boundary, then record the transition that follows. */
-export declare function runCheckoutTransitionBeginJob(input: {
-    workspacePath: string;
-}): null;
-/** Executor job body: make the outer checkout durable and record its head as the durable boundary. */
-export declare function runCheckoutTransitionCompleteJob(input: {
-    workspacePath: string;
-}): null;
-/** Executor job body: `recoverWorkspaceCheckoutDurability`. */
-export declare function runCheckoutDurabilityRecoveryJob(input: {
-    workspacePath: string;
-    preserveResolutionInProgress: boolean;
-}): null;
-/** Executor job body: the outer-tree durability barrier alone. */
-export declare function runOuterCheckoutFsyncJob(input: {
-    workspacePath: string;
-}): null;
-/** Read-only admission inspection, including before incident configuration fast paths. */
-export declare function runHydrationRecoveryInspectJob(input: {
-    workspacePath: string;
-}): WorkspaceHydrationRecoveryRequired | null;
-/**
- * Explicitly preserve an interrupted guarded transaction. The caller owns
- * workspace admission/exclusion. No visible file is restored or deleted and
- * no mount is receipted at the partially applied target head. The entire
- * transaction directory is archived atomically, including snapshots and any
- * interrupted manifest writes, before ordinary merge projection may resume.
- */
-export declare function runHydrationPreserveInterruptedJob(input: {
-    workspacePath: string;
-    expectedTransactionId: string;
-}): WorkspaceHydrationPreservationResult;
-/** Everything the apply phase needs for a merge-hydrated mount, decided before the manifest was written. */
-type WorkspaceHydrationMergePlan = {
-    prepared: PreparedWorkingTreeMirror;
-    decision: Extract<WorkspaceHydrationMergeDecision, {
-        kind: "apply";
-    }>;
-    plan: WorkingTreeMirrorPlan;
-    /** The mount's snapshot directory once the transaction directory is published. */
-    snapshotPath: string;
-    basis: WorkspaceHydrationMergeBasis;
-};
-declare function beginHydrationTransaction(workspacePath: string, mounts: readonly WorkspaceGitMount[], targetReceipt: WorkspaceHydrationReceipt | null, mergeBases?: Readonly<Record<string, WorkspaceHydrationMergeBasis>>): {
-    manifest: WorkspaceHydrationTransactionManifest;
-    durabilityScopes: Map<string, readonly string[]>;
-    mergePlans: Map<string, WorkspaceHydrationMergePlan>;
-    /** Mounts merge hydration decided not to touch; they have no snapshot, no manifest entry and keep their receipt entry. */
-    skippedMounts: WorkspaceHydrationMountSkip[];
-    targetReceipt: WorkspaceHydrationReceipt | null;
-};
-declare function configureWorkspaceRepository(input: {
-    workspacePath: string;
-    remoteUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    gitIdentity: {
-        name: string;
-        email: string;
-    };
-}): Promise<void>;
-/**
- * Rebind only the existing canonical checkout's local Git configuration while
- * an incident owns its HEAD. In particular, this deliberately does not fetch,
- * recover durability, move refs, reset the index/worktree, or inspect/abort an
- * in-progress merge or rebase.
- */
-export declare function configureExistingWorkspaceGitForRemediation(input: {
-    workspacePath: string;
-    remoteUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    gitIdentity: {
-        name: string;
-        email: string;
-    };
-}): Promise<void>;
-export declare function ensureWorkspaceGitClone(input: {
-    workspacePath: string;
-    remoteUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    gitIdentity: {
-        name: string;
-        email: string;
-    };
-    preserveResolutionInProgress?: boolean;
-    /** Server-advertised head of the workspace remote; see resolveWorkspaceRemoteHead. */
-    advertisedRemoteHead?: string | null;
-}): Promise<{
-    localHead: string | null;
-    remoteHead: string | null;
-    remoteHeadFetched: boolean;
-}>;
-type ProjectedMountGitlinks = {
-    mount: WorkspaceGitMount;
-    gitlinks: WorkingTreeGitlink[];
-};
-/**
- * Mirror each mount's visible tree into the outer worktree. A submodule
- * arrives as an empty directory plus a gitlink the caller must stage with
- * `stageWorkspaceGitlinks` before `git add -A`, which can never create one.
- */
-declare function mirrorMountsToWorkspace(workspacePath: string, mounts: readonly WorkspaceGitMount[], projectedFiles?: Map<string, ProjectedWorkingTreeEntry>): ProjectedMountGitlinks[];
-/**
- * Executor job body: the complete hydration transaction. Snapshot exactly
- * what hydration replaces, hydrate, cross the durability barrier, write the
- * commit marker, publish the receipt, remove the transaction; on failure
- * restore the snapshot unless the visible tree is already durable. The write
- * and fsync ordering is the one the control thread used to run inline.
- */
-export declare function runHydrationTransactionJob(input: {
-    workspacePath: string;
-    hydrationMounts: readonly WorkspaceGitMountData[];
-    advancedDurabilityMounts: readonly WorkspaceGitMountData[];
-    targetReceipt: WorkspaceHydrationReceipt | null;
-    mergeBases?: Readonly<Record<string, WorkspaceHydrationMergeBasis>>;
-}): {
-    hydratedMountIds: string[];
-    skippedMounts: WorkspaceHydrationMountSkip[];
-    hydratedPreBlobs: Record<string, Record<string, string>>;
-};
-/** Executor job body: hydrate visible mounts before an outer clone exists (no transaction to record). */
-export declare function runHydrationRawJob(input: {
-    workspacePath: string;
-    mounts: readonly WorkspaceGitMountData[];
-}): {
-    hydratedMountIds: string[];
-};
-/**
- * Executor job body: checkout durability recovery, pending hydration
- * transaction restore or completion, and basis-ref repair, in that order.
- */
-export declare function runHydrationRecoveryJob(input: {
-    workspacePath: string;
-    preserveResolutionInProgress: boolean;
-}): null;
-export declare function hydrateWorkspaceGitMounts(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
-    ignoreBusy?: boolean;
-    hydrationHooks?: WorkspaceHydrationTransactionHooks;
-}): Promise<{
-    hydratedMountIds: string[];
-    skippedMountIds: string[];
-}>;
-export declare function recoverWorkspaceGitHydration(workspacePath: string, mounts: readonly WorkspaceGitMount[], options?: {
-    ignoreBusy?: boolean;
-    deferMountIds?: ReadonlySet<string>;
-    preserveResolutionInProgress?: boolean;
-    preserveStaleBases?: boolean;
-    hydrationHooks?: WorkspaceHydrationTransactionHooks;
-}): Promise<void>;
-export declare function resetWorkspaceGit(input: {
-    workspacePath: string;
-    remoteUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    gitIdentity: {
-        name: string;
-        email: string;
-    };
-    mounts: readonly WorkspaceGitMount[];
-    hydrationHooks?: WorkspaceHydrationTransactionHooks;
-}): Promise<{
-    startingHead: string | null;
-    localHead: string | null;
-    remoteHead: string | null;
-    discardedPaths: string[];
-    activeMountIds: string[];
-    skippedMountIds: string[];
-}>;
-/**
- * Bytes of the raw `git diff --binary` between two revisions, capped at
- * `limit + 1`. `pathspecs` narrows what is measured; callers pass
- * `:(exclude,literal)<path>` for paths whose text is not publication content,
- * such as a subtree a gitlink replaces (see `pathsReplacedByGitlinks`).
- */
-declare function diffSizeBytes(workspacePath: string, baseRevision: string | null, headRevision: string, limit: number, pathspecs?: readonly string[]): Promise<number>;
-export type SynchronizeWorkspaceGitInput = {
-    attemptId?: string;
-    workerLabel: string;
-    workspacePath: string;
-    remoteUrl: string;
-    credentialHelper?: string | null;
-    credentialUsername?: string | null;
-    gitIdentity: {
-        name: string;
-        email: string;
-    };
-    mounts: readonly WorkspaceGitMount[];
-    commitDetail?: string;
-    allowLargeDiff?: boolean;
-    maxDiffBytes?: number;
-    maxPushAttempts?: number;
-    /** Publish edits already made in the outer clone without first projecting visible mounts over them. */
-    skipMountMirror?: boolean;
-    /** Positive ancestry proof required before a remediation may integrate, publish, or hydrate. */
-    requiredAncestorHeads?: readonly string[];
-    /**
-     * Head of the workspace remote as the server last read it from disk. Equal
-     * to the local remote-tracking ref, it lets the cycle skip its workspace
-     * head fetches; see resolveWorkspaceRemoteHead. Omit to always fetch.
-     */
-    advertisedRemoteHead?: string | null;
-    /** Revalidate the worker/config/incident generation after every async boundary. */
-    assertStillAdmitted?: () => void;
-    /** Test seam for exercising an incident transition during asynchronous diff measurement. */
-    measureDiffSize?: typeof diffSizeBytes;
-    afterWorkspacePublished?: (context: {
-        publishedHead: string;
-        activeMountIds: string[];
-    }) => void | Promise<void>;
-    /** Announces each synchronous hydration transaction of this cycle; see WorkspaceHydrationTransactionHooks. */
-    hydrationHooks?: WorkspaceHydrationTransactionHooks;
-};
-export declare function synchronizeWorkspaceGit(input: SynchronizeWorkspaceGitInput): Promise<WorkspaceGitSyncResult>;
-/** Executor job body: byte-mirror one visible mount into the outer checkout, recording what it read. */
-export declare function runProjectionMirrorJob(input: {
-    workspacePath: string;
-    mount: WorkspaceGitMountData;
-    staleRewriteBlobs?: Record<string, string>;
-}): {
-    gitlinks: WorkingTreeGitlink[];
-    projectedFiles: Record<string, ProjectedWorkingTreeEntry>;
-    readAtMs: number;
-    staleRewritePaths: string[];
-    staleRewriteCleared: string[];
-};
-/** Executor job body: outer-tree edits that follow the mirrors, in the cycle's order. */
-export declare function runProjectionOuterApplyJob(input: {
-    workspacePath: string;
-    removeMounts: readonly WorkspaceGitMountData[];
-    materialize: ReadonlyArray<{
-        workspaceRelativePath: string;
-        resultTree: string;
-    }>;
-    restoreFromHead: readonly WorkspaceGitMountData[];
-}): null;
-/** Executor job body: persist projected visible mounts, then publish the projection receipt. */
-export declare function runProjectionReceiptJob(input: {
-    workspacePath: string;
-    fsyncMounts: readonly WorkspaceGitMountData[];
-    receipt: WorkspaceHydrationReceipt;
-}): null;
-export declare const workspaceGitSyncTestHarness: {
-    beginHydrationTransaction: typeof beginHydrationTransaction;
-    commandArgs: typeof gitCommandArgs;
-    workspaceCloneCommandArgs: typeof workspaceCloneCommandArgs;
-    configureWorkspaceRepository: typeof configureWorkspaceRepository;
-    mirrorMountsToWorkspace: typeof mirrorMountsToWorkspace;
-    hydrateMountsFromWorkspace: typeof hydrateWorkspaceGitMounts;
-    hydrationPreBlobLedger: typeof hydrationPreBlobLedger;
-    resetHydrationPreBlobLedgers(): void;
-};
-export {};

package/dist/types/workspace-hydration-ledger.d.ts

@@ -1,43 +0,0 @@
-/**
- * Blob ids of the bytes merge hydration replaced in a checkout, kept in
- * memory per mount incarnation until a later hydration of the same path
- * replaces them or the mount is hydrated outside a cycle (recovery, reset,
- * configuration), which rewrites the checkout without recording anything.
- *
- * The projection reads it as the stale-rewrite detector
- * (docs/merge-hydration-design.md §3.3): a process that read a file before a
- * hydration and re-emits the same bytes afterwards would otherwise publish a
- * revert of the inbound change as an ordinary local edit. A changed file whose
- * content hashes to the blob hydration replaced is exactly that, so the mount
- * is pinned instead of published, loudly.
- *
- * Deliberately not persisted: a restart loses the entries and the detector is
- * best effort. Phase 2 of the design turns this into a durable ledger if
- * telemetry warrants it.
- */
-export declare class WorkspaceHydrationPreBlobLedger {
-    private readonly mounts;
-    private static key;
-    /** Blob ids by mount-relative path for the mount, or an empty map. */
-    preBlobs(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }): ReadonlyMap<string, string>;
-    /** Record the pre-hydration blob of every path a merge hydration replaced; earlier entries for other paths are kept. */
-    record(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }, preBlobs: ReadonlyMap<string, string> | Readonly<Record<string, string>>): void;
-    /** Forget the mount: its checkout was rewritten by something this ledger did not observe. */
-    clearMount(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }): void;
-    /** Forget paths whose checkout content moved on from the hydrated bytes: a later return to the old bytes is a deliberate edit. */
-    forget(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }, paths: readonly string[]): void;
-    clear(): void;
-    get size(): number;
-}

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

@@ -1,95 +0,0 @@
-import fs from "node:fs";
-import { type PreparedWorkingTreeMirror, type ProjectedWorkingTreeEntry, type WorkingTreeMirrorOverride, type WorkingTreeMirrorSelection } from "./working-tree-mirror";
-/**
- * Where a mount's bytes were read this cycle (docs/merge-hydration-design.md
- * §2.1). `projectedCommit` is the commit whose subtree at the mount path is
- * exactly what projection read: the projected head for a mirrored mount, the
- * synthesized ours commit for a merge-projected one. `projectedFiles` is
- * what the mirror or synthesis saw for each entry, or null when the mount was
- * not read this cycle (its token was unchanged), in which case a changed
- * file is recognized by hashing it against the projected blob.
- */
-export type WorkspaceHydrationMergeBasis = {
-    projectedCommit: string;
-    projectedFiles: Record<string, ProjectedWorkingTreeEntry> | null;
-    /**
-     * Wall-clock time the projection finished reading. A projected stat whose
-     * timestamps fall within `RACY_PROJECTION_WINDOW_MS` of it is not trusted
-     * to prove the file unchanged (git's racy-clean rule: a rewrite of the
-     * same size in the same coarse timestamp tick leaves the stat intact), so
-     * such a file is hashed against the projected blob instead.
-     */
-    readAtMs?: number;
-};
-export declare const RACY_PROJECTION_WINDOW_MS = 2000;
-export type WorkspaceHydrationSkipReason = "hydration_merge_conflict" | "hydration_target_changed";
-/** A mount merge hydration left at its previous receipt entry, and why. */
-export type WorkspaceHydrationMountSkip = {
-    mountId: string;
-    reason: WorkspaceHydrationSkipReason;
-    paths: string[];
-};
-/** One path whose blob differs between the projected subtree (base) and the hydration head's subtree (theirs). */
-export type WorkspaceSubtreeChange = {
-    base: {
-        mode: string;
-        objectId: string;
-    } | null;
-    theirs: {
-        mode: string;
-        objectId: string;
-    } | null;
-};
-export type WorkspaceHydrationMergeDecision = {
-    kind: "conflict";
-    paths: string[];
-} | {
-    kind: "target_changed";
-    paths: string[];
-} | {
-    kind: "apply";
-    selection: WorkingTreeMirrorSelection;
-    overrides: Map<string, WorkingTreeMirrorOverride>;
-    /** The target `lstat` (or absence) every mutated path must still show when it is mutated. */
-    expectations: Map<string, fs.Stats | null>;
-    /** Blob of the bytes each written or removed path held before hydration; the stale-rewrite detector's input. */
-    preBlobs: Map<string, string>;
-    /** Paths whose content was three-way merged. */
-    mergedPaths: string[];
-    /** Paths the checkout changed since projection that hydration leaves as they are. */
-    keptPaths: string[];
-};
-/**
- * Decide, per path the hydration head changed relative to what projection
- * read, whether hydration writes theirs (the checkout is unchanged there),
- * leaves the checkout alone (theirs did not change there), writes a
- * three-way merge, or cannot proceed (docs/merge-hydration-design.md §2.2,
- * §2.6). Every path the checkout changed since projection that the head did
- * not change survives untouched, including files created since. Nothing is
- * written here; the result drives `applyWorkingTreeMirror` under guards that
- * re-check each path's `lstat` immediately before mutating it.
- */
-export declare function decideWorkspaceHydrationMerge(input: {
-    prepared: PreparedWorkingTreeMirror;
-    changes: ReadonlyMap<string, WorkspaceSubtreeChange>;
-    projectedFiles: Readonly<Record<string, ProjectedWorkingTreeEntry>> | null;
-    readAtMs?: number;
-    /** Blob contents by object id, in one batch. */
-    readBaseBlobs: (objectIds: readonly string[]) => Map<string, Buffer>;
-    /** Paths marked -diff on either side must never enter the text merger. */
-    readBinaryPaths?: (relativePaths: readonly string[]) => ReadonlySet<string>;
-}): WorkspaceHydrationMergeDecision;
-/** Batch attribute reads, with NUL delimiters so arbitrary Git filenames stay intact. */
-export declare function readHydrationBinaryPaths(input: {
-    checkoutRoot: string;
-    outerRoot: string;
-    relativePaths: readonly string[];
-}): Set<string>;
-/**
- * Parse `git diff-tree -r -z --no-renames --raw <base tree> <theirs tree>`
- * output into per-path changes. Records come in pairs: the status line
- * (`:<base mode> <theirs mode> <base id> <theirs id> <status>`) and the path.
- */
-export declare function parseWorkspaceSubtreeChanges(raw: Buffer): Map<string, WorkspaceSubtreeChange>;
-/** The mount-relative path of a checkout entry as its absolute path, for diagnostics. */
-export declare function describeHydrationSkipPaths(mountSourcePath: string, paths: readonly string[]): string;

package/dist/types/workspace-hydration-recovery-state.d.ts

@@ -1,10 +0,0 @@
-/** Wire evidence owned by the standalone worker package; no API runtime dependency. */
-export type WorkerHydrationRecovery = {
-    transactionId: string;
-    transactionPath: string;
-    mountIds: string[];
-    previousHeads: Record<string, string>;
-    retainedPaths?: string[];
-};
-/** Extract durable recovery evidence even through executor/AggregateError wrapping. */
-export declare function findHydrationRecovery(error: unknown): WorkerHydrationRecovery | undefined;

package/dist/types/workspace-incident-state.d.ts

@@ -1,19 +0,0 @@
-export type WorkspaceIncidentUpdate = {
-    incidentId: string | null;
-    status: "remediating" | "waiting_for_worker" | "resolved" | "confirmed" | "reset" | null;
-};
-export declare function applyWorkspaceIncidentUpdate(currentIncidentId: string | null, update: WorkspaceIncidentUpdate): string | null;
-/**
- * Whether an incoming `workspace_config` is the full configuration a terminal
- * incident update promised: the worker still holds an incident-deferred
- * configuration, no incident is active any more, and the server did not ask
- * for another deferral. Arrival of that configuration disarms the refresh
- * watchdog; from then on the configuration's own generation checks and its
- * failure close govern, so a legitimately long full configuration is never
- * cut off mid-flight by the arrival timer.
- */
-export declare function workspaceConfigurationRefreshesDeferredConfiguration(input: {
-    deferredIncidentId: string | null;
-    activeIncidentId: string | null;
-    requestedDeferredIncidentId: string | undefined;
-}): boolean;