@ricsam/r5d-worker 0.0.137 → 0.0.139

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

@@ -1,514 +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 { WorkspaceHydrationLedger, type WorkspaceHydrationLedgerEntry } 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";
-/** `R5D_PROCESS_BUSY_FENCE=1` makes a live process or PTY skip its mount again, as every cycle did before merge hydration. */
-export declare const WORKSPACE_PROCESS_BUSY_FENCE_SWITCH = "R5D_PROCESS_BUSY_FENCE";
-declare function hydrationPreBlobLedger(workspacePath: string): WorkspaceHydrationLedger;
-export type WorkspaceHydrationMountSkip = WorkspaceHydrationMountSkipBase & {
-    retainedPaths?: string[];
-};
-export type WorkspaceMountSkipReason = WorkspaceHydrationMountSkip["reason"] | "stale_rewrite_detected" | "projection_conflict_deferred";
-/** 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;
-    /**
-     * True while a worker-tracked process or PTY targets this mount. Not a
-     * fence (a busy checkout is still projected and hydrated; merge hydration
-     * folds the inbound change into it): a conflict found on a mount with a
-     * live process is deferred instead of reported, and the hydration ledger
-     * records the liveness so a stale-read rewrite by that process is merged
-     * at the next projection. `R5D_PROCESS_BUSY_FENCE=1` folds it back into
-     * `busy` (see `mountBusy`).
-     */
-    processLive?: () => 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[];
-    hydratedEntries: Record<string, Record<string, Omit<WorkspaceHydrationLedgerEntry, "processLiveAcrossHydration">>>;
-};
-/** 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. With `checkOnly` it stops after the ledger pass:
- * the cycle decides the mount's route (mirror, merge, or a stale-rewrite
- * refusal) before any outer write.
- */
-export declare function runProjectionMirrorJob(input: {
-    workspacePath: string;
-    mount: WorkspaceGitMountData;
-    hydrationLedger?: Record<string, WorkspaceHydrationLedgerEntry>;
-    checkOnly?: boolean;
-}): {
-    gitlinks: WorkingTreeGitlink[];
-    projectedFiles: Record<string, ProjectedWorkingTreeEntry>;
-    readAtMs: number;
-    staleRewritePaths: string[];
-    ledgerMergePaths: 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,76 +0,0 @@
-import type { ProjectedWorkingTreeEntry } from "./working-tree-mirror";
-/**
- * What a merge hydration replaced at one checkout path
- * (docs/merge-hydration-design.md §3.1): the blob that was there before
- * (`preBlob`), the blob hydration wrote (`postBlob`, null when it removed the
- * path), the `lstat` it left behind (`stat`, null when removed), and whether
- * a worker-tracked process or PTY was alive across that hydration.
- *
- * At the next projection a path whose stat moved is treated by that flag: a
- * process alive across the hydration may have read the file before it and
- * written it afterwards, so its bytes are merged against `preBlob` (what it
- * read) with `postBlob` as the other side, which turns a stale-read revert
- * into the inbound change plus the process's own delta, or a visible
- * conflict. Without a live process the change is a plain edit on top of
- * `postBlob`; the exact re-emission of `preBlob` is still refused as a stale
- * rewrite (§3.3).
- */
-export type WorkspaceHydrationLedgerEntry = {
-    preBlob: string;
-    postBlob: string | null;
-    stat: Extract<ProjectedWorkingTreeEntry, {
-        kind: "file";
-    }> | null;
-    processLiveAcrossHydration: boolean;
-};
-/**
- * In memory, per mount incarnation and clone. Not persisted: every process
- * and PTY the flag refers to is a child of the worker, so a restart ends
- * them all and no entry could still merge; the detector half is best effort.
- */
-export declare class WorkspaceHydrationLedger {
-    private readonly mounts;
-    private static key;
-    /** Entries by mount-relative path for the mount, or an empty map. */
-    entries(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }): ReadonlyMap<string, WorkspaceHydrationLedgerEntry>;
-    /** Blob ids by mount-relative path for the mount (the §3.3 detector's input), or an empty map. */
-    preBlobs(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }): ReadonlyMap<string, string>;
-    /**
-     * Record what a merge hydration replaced; earlier entries for other paths
-     * are kept. A path that already carries a live entry keeps its `preBlob`
-     * while the new hydration also ran across a live process: the process's
-     * read predates both hydrations, so what it read is still the first blob.
-     */
-    record(mount: {
-        id: string;
-        hydrationIncarnationKey: string;
-    }, entries: ReadonlyMap<string, WorkspaceHydrationLedgerEntry> | Readonly<Record<string, WorkspaceHydrationLedgerEntry>>, options?: {
-        /**
-         * Paths whose new `preBlob` is taken even over a live entry: the
-         * hydration followed a projection that merged the process's own write
-         * at that path, so the bytes it wrote (not what it originally read)
-         * are the base its next write derives from.
-         */
-        replacePreBlobFor?: readonly 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;
-}
-/** The name the first version of this module exported; kept for callers that still use it. */
-export declare const WorkspaceHydrationPreBlobLedger: typeof WorkspaceHydrationLedger;