taphound 0.2.0-dev.1 → 0.2.0-dev.11

package/dist/application/generation/generation-app-preparer.js

@@ -0,0 +1,28 @@
+import { normalizeActivity } from "../../domain/activity.js";
+import { withRuntimeSession } from "../../ports/runtime-backend.js";
+import { coldLaunchApp } from "../runtime/cold-launch.js";
+export class GenerationAppPreparer {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    prepare(input) {
+        return withRuntimeSession(this.dependencies.sessions, input.deviceSerial, input.signal, (session) => this.coldLaunch(this.dependencies.sessionPorts(session).adb, input));
+    }
+    async coldLaunch(adb, input) {
+        const launched = await coldLaunchApp(adb, this.dependencies.clock, {
+            packageName: input.config.run.packageName,
+            activity: normalizeActivity(input.config.run.packageName, input.config.run.activity),
+            deviceSerial: input.deviceSerial,
+            pollIntervalMs: input.config.idle.pollIntervalMs,
+            timeoutMs: input.config.idle.timeoutMs,
+            signal: input.signal
+        });
+        if (launched.status === "cancelled") {
+            throw new Error("App launch was cancelled");
+        }
+        if (launched.status === "failed") {
+            throw new Error(launched.message);
+        }
+    }
+}

package/dist/application/generation/generation-config-service.d.ts

@@ -0,0 +1,21 @@
+import { type GenerationSession } from "../../domain/generation.js";
+import { type TapHoundConfig } from "../../domain/config.js";
+import type { GenerationSessionStore } from "../../ports/generation-session-store.js";
+export interface GenerationIdlePolicyPatch {
+    strategy?: TapHoundConfig["idle"]["strategy"] | undefined;
+    pollIntervalMs?: number | undefined;
+    stablePolls?: number | undefined;
+    timeoutMs?: number | undefined;
+}
+export interface GenerationConfigServiceDependencies {
+    store: Pick<GenerationSessionStore, "read" | "update">;
+}
+export declare class GenerationConfigService {
+    private readonly dependencies;
+    constructor(dependencies: GenerationConfigServiceDependencies);
+    readonly updateIdlePolicy: (input: {
+        generationId: string;
+        config: TapHoundConfig;
+        patch: GenerationIdlePolicyPatch;
+    }) => Promise<GenerationSession>;
+}

package/dist/application/generation/generation-config-service.js

@@ -0,0 +1,53 @@
+import { GenerationSessionSchema } from "../../domain/generation.js";
+import { IdlePolicySchema } from "../../domain/config.js";
+import { GenerationOperationError } from "./generation-starter.js";
+function hasPatch(patch) {
+    return patch.strategy !== undefined
+        || patch.pollIntervalMs !== undefined
+        || patch.stablePolls !== undefined
+        || patch.timeoutMs !== undefined;
+}
+function assertUpdatable(session) {
+    if (session.state !== "active") {
+        throw new GenerationOperationError("CONFIG_INVALID", `Generation idle policy can only be updated on an active session (state: ${session.state})`);
+    }
+    if (session.inFlight !== null) {
+        throw new GenerationOperationError("CONFIG_INVALID", "Generation idle policy cannot change while a step is in flight");
+    }
+    if (session.pendingConfirmation !== null) {
+        throw new GenerationOperationError("CONFIG_INVALID", "Generation idle policy cannot change while a confirmation is pending");
+    }
+    if (session.verification.status !== "notRun") {
+        throw new GenerationOperationError("CONFIG_INVALID", "Generation idle policy cannot change once verification has started");
+    }
+    if (session.publication.status !== "notRun") {
+        throw new GenerationOperationError("CONFIG_INVALID", "Generation idle policy cannot change after publication");
+    }
+}
+export class GenerationConfigService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    updateIdlePolicy = async (input) => {
+        if (!hasPatch(input.patch)) {
+            throw new GenerationOperationError("CONFIG_INVALID", "Generation idle policy update requires at least one setting");
+        }
+        const session = GenerationSessionSchema.parse(await this.dependencies.store.read(input.generationId));
+        assertUpdatable(session);
+        const base = session.idlePolicy ?? input.config.idle;
+        const idlePolicy = IdlePolicySchema.parse({
+            strategy: input.patch.strategy ?? base.strategy,
+            pollIntervalMs: input.patch.pollIntervalMs ?? base.pollIntervalMs,
+            stablePolls: input.patch.stablePolls ?? base.stablePolls,
+            timeoutMs: input.patch.timeoutMs ?? base.timeoutMs
+        });
+        const next = {
+            ...session,
+            revision: session.revision + 1,
+            idlePolicy
+        };
+        await this.dependencies.store.update(input.generationId, session.revision, next);
+        return next;
+    };
+}

package/dist/application/generation/generation-confirmation-service.d.ts

@@ -13,18 +13,22 @@ export interface GenerationConfirmationDependencies {
 export interface ConfirmationRequestInput {
     generationId: string;
     proposal: ProposedStep;
-    snapshot: RuntimeSnapshot;
+    snapshot?: RuntimeSnapshot | undefined;
+    snapshotRef?: string | undefined;
     source?: "planner" | "manualOverride" | undefined;
 }
 export interface ConfirmationApproveInput extends ConfirmationRequestInput {
     challengeId: string;
+    decision?: ConfirmationDecision | undefined;
     signal?: AbortSignal | undefined;
 }
 export interface StoredConfirmationApproveInput {
     generationId: string;
     challengeId: string;
+    decision?: ConfirmationDecision | undefined;
     signal?: AbortSignal | undefined;
 }
+export type ConfirmationDecision = "approve" | "decline";
 export interface ManualConfirmationRequestInput {
     generationId: string;
     snapshot: RuntimeSnapshot;
@@ -37,18 +41,22 @@ export interface PendingManualConfirmationInput {
 }
 export interface ConfirmationRequiredResult {
     status: "confirmationRequired";
+    revision: number;
     challenge: PendingConfirmation;
 }
 export type ConfirmationRequestResult = {
     status: "approved";
     proposal: ProposedStep;
+    snapshot: RuntimeSnapshot;
 } | ConfirmationRequiredResult;
-export interface StoredConfirmationApproveResult {
+export type StoredConfirmationApproveResult = {
     status: "approved";
     proposal: ProposedStep;
     snapshot: RuntimeSnapshot;
     source: "planner" | "manualOverride";
-}
+} | {
+    status: "declined";
+};
 export declare function summarizeProposedStep(step: ProposedStep): string;
 export declare function confirmationEvidencePath(challengeId: string): string;
 export declare class GenerationConfirmationService {
@@ -63,6 +71,8 @@ export declare class GenerationConfirmationService {
     readonly confirm: (input: ConfirmationApproveInput) => Promise<{
         status: "approved";
         proposal: ProposedStep;
+    } | {
+        status: "declined";
     }>;
     readonly clearApproved: (input: {
         generationId: string;
@@ -73,4 +83,5 @@ export declare class GenerationConfirmationService {
     private requireExactPendingChallenge;
     private updateConfirmationReconciled;
     private readStoredEvidence;
+    private resolveSnapshot;
 }

package/dist/application/generation/generation-confirmation-service.js

@@ -1,7 +1,8 @@
-import { GenerationConfirmationEvidenceSchema, GenerationSessionIdSchema, GenerationSessionSchema, hashGenerationConfirmationEvidence } from "../../domain/generation.js";
+import { GenerationConfirmationEvidenceSchema, GenerationSessionIdSchema, GenerationSessionSchema, hashGenerationConfirmationEvidence, isGenerationConfirmationExpired } from "../../domain/generation.js";
 import { ProposedStepSchema, hashProposedStep } from "../../domain/proposed-step.js";
 import { RuntimeSnapshotSchema, hashRuntimeSnapshot } from "../../domain/runtime-snapshot.js";
 import { GenerationPromptCancelledError } from "../../ports/generation-prompt.js";
+import { parseSnapshotEvidenceReference } from "../../domain/workspace.js";
 import { GenerationOperationError } from "./generation-starter.js";
 import { ProposedStepValidator } from "./proposed-step-validator.js";
 import { RiskEvaluator } from "./risk-evaluator.js";
@@ -11,6 +12,9 @@ function locatorSummary(step) {
         || step.action === "wait") {
         return "";
     }
+    if (step.action === "bridge") {
+        return JSON.stringify(step.triggerLocator);
+    }
     return JSON.stringify(step.locator);
 }
 export function summarizeProposedStep(step) {
@@ -27,6 +31,9 @@ export function summarizeProposedStep(step) {
     if (step.action === "scrollTo") {
         return `Scroll ${step.direction} in ${JSON.stringify(step.container)} to ${locatorSummary(step)} on ${before}`;
     }
+    if (step.action === "bridge") {
+        return `Bridge ${step.scenario} via ${locatorSummary(step)} on ${before}`;
+    }
     return `${step.action} ${locatorSummary(step)} on ${before}`;
 }
 function bindingFailure(message) {
@@ -47,15 +54,23 @@ export class GenerationConfirmationService {
         }
     }
     request = async (input) => {
+        const inputSnapshot = await this.resolveSnapshot(input);
         const session = GenerationSessionSchema.parse(await this.dependencies.store.read(input.generationId));
         const submittedEvidence = GenerationConfirmationEvidenceSchema.parse({
             version: 1,
             proposal: input.proposal,
-            snapshot: input.snapshot,
+            snapshot: inputSnapshot,
             source: input.source ?? "planner"
         });
         if (session.pendingConfirmation !== null
             && session.pendingConfirmation.status === "pending") {
+            if (isGenerationConfirmationExpired(session.pendingConfirmation, this.dependencies.now())) {
+                await this.clearExactChallenge(session.id, {
+                    expectedRevision: session.revision,
+                    expectedChallenge: session.pendingConfirmation
+                });
+                throw bindingFailure("Generation confirmation challenge expired and was cleared; observe again before proposing a step");
+            }
             const storedEvidence = await this.readStoredEvidence({
                 generationId: session.id,
                 challengeId: session.pendingConfirmation.challengeId
@@ -64,19 +79,27 @@ export class GenerationConfirmationService {
                 throw bindingFailure("Pending generation confirmation does not match submitted evidence");
             }
             const challenge = this.requireExactPendingChallenge(session, storedEvidence);
-            return { status: "confirmationRequired", challenge };
+            return {
+                status: "confirmationRequired",
+                revision: session.revision,
+                challenge
+            };
         }
         const proposal = this.validator.validate({
             session,
             snapshot: submittedEvidence.snapshot,
             proposal: submittedEvidence.proposal
         });
-        const risk = this.riskEvaluator.evaluate(proposal.action, session.target.interactionPolicy);
+        const risk = this.riskEvaluator.evaluate(proposal, session.target.interactionPolicy, submittedEvidence.snapshot);
         if (risk.effectiveRisk === "forbidden") {
             throw new GenerationOperationError("ACTION_FORBIDDEN", `${proposal.action} is forbidden by the Core interaction policy`);
         }
         if (risk.effectiveRisk === "safe") {
-            return { status: "approved", proposal };
+            return {
+                status: "approved",
+                proposal,
+                snapshot: submittedEvidence.snapshot
+            };
         }
         if (session.revision === Number.MAX_SAFE_INTEGER) {
             throw bindingFailure("Generation revision cannot create a challenge");
@@ -94,6 +117,7 @@ export class GenerationConfirmationService {
             snapshotHash: proposal.binding.snapshotHash,
             evidenceHash: hashGenerationConfirmationEvidence(evidence),
             actionSummary: summarizeProposedStep(proposal),
+            ...(risk.reason === undefined ? {} : { reason: risk.reason }),
             expiresAt: new Date(this.dependencies.now().getTime()
                 + this.dependencies.confirmationTtlMs).toISOString(),
             status: "pending"
@@ -105,7 +129,11 @@ export class GenerationConfirmationService {
         });
         await this.dependencies.store.writeEvidence(session.id, confirmationEvidencePath(challenge.challengeId), evidence);
         await this.updateConfirmationReconciled(session.id, session.revision, next);
-        return { status: "confirmationRequired", challenge };
+        return {
+            status: "confirmationRequired",
+            revision: next.revision,
+            challenge
+        };
     };
     requestManual = async (input) => {
         const proposal = await this.dependencies.prompt.buildManualProposal(input.manual, input.signal);
@@ -125,6 +153,13 @@ export class GenerationConfirmationService {
         if (pending === null || pending.status !== "pending") {
             return null;
         }
+        if (isGenerationConfirmationExpired(pending, this.dependencies.now())) {
+            await this.clearExactChallenge(session.id, {
+                expectedRevision: session.revision,
+                expectedChallenge: pending
+            });
+            throw bindingFailure("Generation confirmation challenge expired and was cleared; observe again before manual takeover");
+        }
         const evidence = await this.readStoredEvidence({
             generationId: session.id,
             challengeId: pending.challengeId
@@ -134,18 +169,28 @@ export class GenerationConfirmationService {
             throw bindingFailure("Pending manual confirmation does not match the requested action");
         }
         const challenge = this.requireExactPendingChallenge(session, evidence);
-        return { status: "confirmationRequired", challenge };
+        return {
+            status: "confirmationRequired",
+            revision: session.revision,
+            challenge
+        };
     };
     confirmStored = async (input) => {
         const evidence = await this.readStoredEvidence(input);
-        await this.confirm({
+        const result = await this.confirm({
             generationId: input.generationId,
             challengeId: input.challengeId,
             proposal: evidence.proposal,
             snapshot: evidence.snapshot,
             source: evidence.source,
+            ...(input.decision === undefined
+                ? {}
+                : { decision: input.decision }),
             signal: input.signal
         });
+        if (result.status === "declined") {
+            return result;
+        }
         return {
             status: "approved",
             proposal: evidence.proposal,
@@ -174,9 +219,14 @@ export class GenerationConfirmationService {
             expectedRevision,
             expectedChallenge: challenge
         };
-        const expired = this.dependencies.now().getTime()
-            >= new Date(challenge.expiresAt).getTime();
+        const expired = isGenerationConfirmationExpired(challenge, this.dependencies.now());
         const challengeMatches = challenge.challengeId === input.challengeId;
+        if (input.decision === "decline") {
+            if (!challengeMatches || !await this.clearExactChallenge(session.id, cleanupToken)) {
+                throw bindingFailure("Generation confirmation binding is no longer authoritative");
+            }
+            return { status: "declined" };
+        }
         const proposalMatches = challenge.proposalHash
             === hashProposedStep(proposal);
         const evidenceMatches = challenge.evidenceHash === evidenceHash;
@@ -227,13 +277,15 @@ export class GenerationConfirmationService {
         if (challenge.status === "approved") {
             return { status: "approved", proposal };
         }
-        let confirmed;
-        try {
-            confirmed = await this.dependencies.prompt.confirm(challenge, input.signal);
-        }
-        catch (error) {
-            await this.clearExactChallenge(session.id, cleanupToken);
-            throw error;
+        let confirmed = input.decision === "approve";
+        if (input.decision === undefined) {
+            try {
+                confirmed = await this.dependencies.prompt.confirm(challenge, input.signal);
+            }
+            catch (error) {
+                await this.clearExactChallenge(session.id, cleanupToken);
+                throw error;
+            }
         }
         if (input.signal?.aborted === true) {
             await this.cancelPrompt(session.id, cleanupToken);
@@ -249,8 +301,7 @@ export class GenerationConfirmationService {
         const stillAuthoritative = latest.revision === session.revision
             && JSON.stringify(latest.pendingConfirmation)
                 === JSON.stringify(challenge)
-            && this.dependencies.now().getTime()
-                < new Date(challenge.expiresAt).getTime();
+            && !isGenerationConfirmationExpired(challenge, this.dependencies.now());
         if (!stillAuthoritative) {
             await this.clearExactChallenge(session.id, cleanupToken);
             throw bindingFailure("Generation confirmation state changed while prompting");
@@ -267,7 +318,10 @@ export class GenerationConfirmationService {
             revision: latest.revision + 1,
             pendingConfirmation: {
                 ...challenge,
-                status: "approved"
+                status: "approved",
+                approvalMode: input.decision === "approve"
+                    ? "delegated"
+                    : "localTty"
             }
         });
         await this.dependencies.store.updateConfirmation(latest.id, latest.revision, approved);
@@ -292,7 +346,7 @@ export class GenerationConfirmationService {
         if (latest.revision !== token.expectedRevision
             || pending === null
             || JSON.stringify(pending) !== JSON.stringify(token.expectedChallenge)) {
-            return;
+            return false;
         }
         if (latest.revision === Number.MAX_SAFE_INTEGER) {
             throw bindingFailure("Generation revision cannot clear challenge");
@@ -303,6 +357,7 @@ export class GenerationConfirmationService {
             pendingConfirmation: null
         });
         await this.updateConfirmationReconciled(latest.id, latest.revision, cleared);
+        return true;
     }
     async cancelPrompt(generationId, token) {
         await this.clearExactChallenge(generationId, token);
@@ -332,7 +387,7 @@ export class GenerationConfirmationService {
         catch {
             throw bindingFailure("Pending generation confirmation is no longer authoritative");
         }
-        const risk = this.riskEvaluator.evaluate(proposal.action, session.target.interactionPolicy);
+        const risk = this.riskEvaluator.evaluate(proposal, session.target.interactionPolicy, snapshot);
         if (risk.effectiveRisk !== "confirmationRequired"
             || challenge.stepIndex !== session.candidateSteps.length
             || challenge.proposalHash !== hashProposedStep(proposal)
@@ -340,8 +395,7 @@ export class GenerationConfirmationService {
             || challenge.snapshotHash !== proposal.binding.snapshotHash
             || challenge.evidenceHash !== hashGenerationConfirmationEvidence(evidence)
             || challenge.actionSummary !== summarizeProposedStep(proposal)
-            || this.dependencies.now().getTime()
-                >= new Date(challenge.expiresAt).getTime()) {
+            || isGenerationConfirmationExpired(challenge, this.dependencies.now())) {
             throw bindingFailure("Pending generation confirmation does not match stored evidence");
         }
         return challenge;
@@ -380,4 +434,35 @@ export class GenerationConfirmationService {
                 : "Generation confirmation evidence is unavailable");
         }
     }
+    async resolveSnapshot(input) {
+        if ((input.snapshot !== undefined) === (input.snapshotRef !== undefined)) {
+            throw new GenerationOperationError("SNAPSHOT_STALE", "Provide exactly one of snapshot or snapshotRef");
+        }
+        if (input.snapshot !== undefined) {
+            return input.snapshot;
+        }
+        const reference = input.snapshotRef ?? "";
+        const evidencePath = parseSnapshotEvidenceReference(reference, input.generationId);
+        if (evidencePath === null) {
+            throw new GenerationOperationError("SNAPSHOT_STALE", `Snapshot reference is not a valid evidence binding for generation ${input.generationId}: ${reference}`);
+        }
+        let bytes;
+        try {
+            bytes = await this.dependencies.store.readEvidence(input.generationId, evidencePath);
+        }
+        catch (error) {
+            throw new GenerationOperationError("SNAPSHOT_STALE", `Referenced snapshot evidence is unavailable: ${reference} (${error instanceof Error ? error.message : "read failed"})`);
+        }
+        let snapshot;
+        try {
+            snapshot = RuntimeSnapshotSchema.parse(JSON.parse(bytes.toString("utf8")));
+        }
+        catch {
+            throw new GenerationOperationError("SNAPSHOT_STALE", `Referenced snapshot evidence is not a valid RuntimeSnapshot: ${reference}`);
+        }
+        if (snapshot.generationId !== input.generationId) {
+            throw new GenerationOperationError("SNAPSHOT_STALE", `Referenced snapshot belongs to another generation: ${reference}`);
+        }
+        return snapshot;
+    }
 }

package/dist/application/generation/generation-context-snapshot.d.ts

@@ -0,0 +1,6 @@
+import { type ResolvedProjectContext } from "../../domain/project-context.js";
+import { type GenerationSessionStore } from "../../ports/generation-session-store.js";
+export interface GenerationContextSnapshotDependencies {
+    store: Pick<GenerationSessionStore, "read" | "readEvidence">;
+}
+export declare const readGenerationContextSnapshot: (dependencies: GenerationContextSnapshotDependencies, sessionId: string) => Promise<ResolvedProjectContext>;

package/dist/application/generation/generation-context-snapshot.js

@@ -0,0 +1,29 @@
+import { ResolvedProjectContextSchema } from "../../domain/project-context.js";
+import { GENERATION_CONTEXT_SNAPSHOT_PATH } from "../../domain/workspace.js";
+import { GenerationSessionStoreError } from "../../ports/generation-session-store.js";
+import { GenerationOperationError, hashGenerationBinding } from "./generation-starter.js";
+export const readGenerationContextSnapshot = async (dependencies, sessionId) => {
+    let bytes;
+    try {
+        bytes = await dependencies.store.readEvidence(sessionId, GENERATION_CONTEXT_SNAPSHOT_PATH);
+    }
+    catch (error) {
+        if (error instanceof GenerationSessionStoreError
+            && error.code === "EVIDENCE_NOT_FOUND") {
+            throw new GenerationOperationError("CONTEXT_INVALID", "Generation session has no stored context snapshot; start a new session");
+        }
+        throw error;
+    }
+    let context;
+    try {
+        context = ResolvedProjectContextSchema.parse(JSON.parse(bytes.toString("utf8")));
+    }
+    catch {
+        throw new GenerationOperationError("CONTEXT_INVALID", "Stored context snapshot is unreadable");
+    }
+    const session = await dependencies.store.read(sessionId);
+    if (hashGenerationBinding(context) !== session.bindings.contextHash) {
+        throw new GenerationOperationError("CONTEXT_INVALID", "Stored context snapshot does not match the session context binding");
+    }
+    return context;
+};

package/dist/application/generation/generation-finalizer.d.ts

@@ -1,11 +1,9 @@
 import { z } from "zod";
-import { type GenerationErrorCode, type GenerationMeta } from "../../domain/generation.js";
+import { type GenerationErrorCode, type GenerationMeta, type VerificationPhase } from "../../domain/generation.js";
 import { type Journey } from "../../domain/journey.js";
-import { type ProjectContext } from "../../domain/project-context.js";
+import { type ResolvedProjectContext } from "../../domain/project-context.js";
 import { type TapHoundConfig } from "../../domain/config.js";
-import type { AdbPort } from "../../ports/adb.js";
 import { type GenerationSessionStore } from "../../ports/generation-session-store.js";
-import type { ContextValidator } from "../context/context-validator.js";
 import type { ProjectDescription } from "../project/project-describer.js";
 import type { VerifyRuntime } from "../runtime/verify-runtime.js";
 import { GenerationPublisher } from "./generation-publisher.js";
@@ -15,28 +13,34 @@ export declare class GenerationFinalizationError extends Error {
     readonly code: GenerationErrorCode;
     readonly stage: GenerationFinalizationStage;
     readonly recoverable: boolean;
+    readonly details?: unknown | undefined;
     readonly name = "GenerationFinalizationError";
-    constructor(code: GenerationErrorCode, stage: GenerationFinalizationStage, recoverable: boolean, message: string, options?: ErrorOptions);
+    constructor(code: GenerationErrorCode, stage: GenerationFinalizationStage, recoverable: boolean, message: string, options?: ErrorOptions, details?: unknown | undefined);
 }
 export interface GenerationFinalizeInput {
     generationId: string;
     projectRoot: string;
     config: TapHoundConfig;
-    context: ProjectContext;
+    context: ResolvedProjectContext;
     project: ProjectDescription;
     outputPath: string;
     name?: string | undefined;
     deviceSerial: string;
+    manualReplay?: boolean | undefined;
     toolVersions: Record<string, string>;
     signal?: AbortSignal | undefined;
 }
 export interface GenerationFinalizerDependencies {
-    store: Pick<GenerationSessionStore, "read" | "beginVerification" | "completeVerification" | "failVerification" | "markBundlePublishable" | "writeTextEvidence" | "readEvidence">;
-    contextValidator: Pick<ContextValidator, "validate">;
-    adb: Pick<AdbPort, "forceStop">;
+    store: Pick<GenerationSessionStore, "read" | "beginVerification" | "updateVerificationPhase" | "abortVerification" | "completeVerification" | "failVerification" | "markBundlePublishable" | "writeTextEvidence" | "readEvidence">;
     verifyRuntime: Pick<VerifyRuntime, "verify">;
     publisher: GenerationPublisher;
     generateAttemptId: () => string;
+    owner?: {
+        pid: number;
+        now: () => Date;
+    } | undefined;
+    progress?: ((stage: GenerationFinalizationStage) => void) | undefined;
+    replayProgress?: ((phase: VerificationPhase) => void) | undefined;
 }
 export interface GenerationFinalizeResult {
     status: "verified";
@@ -51,6 +55,7 @@ export declare class GenerationFinalizer {
     private readonly dependencies;
     constructor(dependencies: GenerationFinalizerDependencies);
     readonly finalize: (input: GenerationFinalizeInput) => Promise<GenerationFinalizeResult>;
+    private bridgeReplayProgress;
     private assertBindings;
     private revalidate;
     private beginVerification;
@@ -60,6 +65,7 @@ export declare class GenerationFinalizer {
     private receiptMatches;
     private persistPassedVerification;
     private reconcilePassedVerification;
+    private tryAbortVerification;
     private persistFailedVerification;
     private readVerifiedReport;
     private buildMeta;