@storyshelf/core 0.6.2 → 0.8.0

package/dist/capture/pipeline.d.mts

@@ -6,14 +6,14 @@ import { DatabaseAdapter } from "../adapter/database.mjs";
 import { StorageAdapter } from "../adapter/storage.mjs";
 import { SecretInput } from "../utils/encrypt.mjs";
 import { Build } from "../schema/build.mjs";
+import { Project } from "../schema/project.mjs";
 import { BuildTables } from "../models/build.mjs";
 import { AttemptLogRecorder } from "../models/capture-attempt.mjs";
-import { Project } from "../schema/project.mjs";
 import { BaselineTables } from "../models/baseline.mjs";
 import { SnapshotTables } from "../models/snapshot.mjs";
 import { InheritedStory } from "./affected.mjs";
+import { CaptureProgress } from "./progress.mjs";
 import { Logger } from "pino";
-//#region src/capture/pipeline.d.ts
 /**
  * Persist a completed capture run: write screenshots, diff against the branch
  * baseline, create snapshots, and finalize the build.
@@ -27,7 +27,7 @@ import { Logger } from "pino";
  * @param flakyFailedStoryIds - Story ids that failed but are marked flaky
  * (non-blocking). They are logged as warnings and do not block the build.
  */
-declare function persistCapture(ctx: CaptureContext, renderFailedStoryIds?: ReadonlySet<string>, flakyFailedStoryIds?: ReadonlySet<string>, a11yFailedStoryIds?: ReadonlySet<string>): Promise<void>;
+declare function persistCapture(input: CaptureContext, renderFailedStoryIds?: ReadonlySet<string>, flakyFailedStoryIds?: ReadonlySet<string>, a11yFailedStoryIds?: ReadonlySet<string>): Promise<void>;
 /** Table handles required by the capture pipeline. */
 type PipelineTables = BuildTables & BaselineTables & SnapshotTables;
 /** Persistence inputs for a completed capture run. */
@@ -44,6 +44,10 @@ interface CaptureContext {
   build: Build;
   /** Viewports at which stories were captured. */
   viewports: Viewport[];
+  /** Engines captured this run, primary first (default: chromium only). */
+  browsers?: string[];
+  /** Secondary engines with no baselines yet; worked out by `persistCapture`, or fixed up front by a shard plan. */
+  freshBrowsers?: ReadonlySet<string>;
   /** Screenshot buffers produced by the capture renderer. */
   captures: RenderedSnapshot[];
   /** Stories inheriting their baseline without rendering (affected capture). */
@@ -52,9 +56,10 @@ interface CaptureContext {
   logger?: Logger;
   /** Optional per-attempt log recorder (mirrors logger lines into the DB). */
   recordLog?: AttemptLogRecorder;
+  /** Called per snapshot persisted, so the job's lease sees a long diff phase making progress. */
+  progress?: CaptureProgress | undefined;
   /** Server secret for decrypting webhook secrets at send time. */
   secret?: SecretInput;
 }
-//#endregion
 export { CaptureContext, PipelineTables, persistCapture };
 //# sourceMappingURL=pipeline.d.mts.map

package/dist/capture/pipeline.mjs

@@ -1,16 +1,21 @@
 import "node:path";
 import "node:url";
 import.meta.url;
-import { BuildModel } from "../models/build.mjs";
+import { ReferenceGenerationConflict } from "../adapter/database.mjs";
+import { DEFAULT_BROWSER } from "../adapters/capture-target.mjs";
 import { emitAttemptLog } from "../models/capture-attempt.mjs";
-import { diffPath, screenshotPath } from "../paths.mjs";
-import { BaselineModel } from "../models/baseline.mjs";
+import { BuildModel } from "../models/build.mjs";
+import { diffPath } from "../paths.mjs";
+import { storeScreenshot } from "../utils/screenshot-store.mjs";
+import { BaselineWriteConflict } from "../models/baseline-conflict.mjs";
 import { NO_BASELINE } from "../models/baseline-status.mjs";
+import { BaselineModel } from "../models/baseline.mjs";
+import { assertScreenshotBuffer } from "./guards.mjs";
 import { SnapshotModel } from "../models/snapshot.mjs";
+import { mapLimit } from "../utils/map-limit.mjs";
+import { freezeComparison, sourceSnapshotId } from "./comparison-reference.mjs";
 import { diffStoredScreenshots, writeDiffOverlay } from "./diff-record.mjs";
-import { assertScreenshotBuffer } from "./guards.mjs";
-import { SIZING_DEFAULTS, infraHashFor } from "./sizing.mjs";
-//#region src/capture/pipeline.ts
+import { buildFingerprint, changedFields, fingerprintHash, mergeFingerprint, parseFingerprint } from "./fingerprint.mjs";
 /**
 * Persist a completed capture run: write screenshots, diff against the branch
 * baseline, create snapshots, and finalize the build.
@@ -24,13 +29,24 @@ import { SIZING_DEFAULTS, infraHashFor } from "./sizing.mjs";
 * @param flakyFailedStoryIds - Story ids that failed but are marked flaky
 * (non-blocking). They are logged as warnings and do not block the build.
 */
-async function persistCapture(ctx, renderFailedStoryIds = /* @__PURE__ */ new Set(), flakyFailedStoryIds = /* @__PURE__ */ new Set(), a11yFailedStoryIds = /* @__PURE__ */ new Set()) {
+async function persistCapture(input, renderFailedStoryIds = /* @__PURE__ */ new Set(), flakyFailedStoryIds = /* @__PURE__ */ new Set(), a11yFailedStoryIds = /* @__PURE__ */ new Set()) {
+	const sets = await persistRendered(input, renderFailedStoryIds, flakyFailedStoryIds, a11yFailedStoryIds);
+	for (const id of await persistInherited(input)) sets.failed.add(id);
+	await finalizeBuild(input, allStoryIds(input), sets.failed, sets.flaky, sets.a11y);
+}
+/**
+* Persist the rendered captures only: screenshots, diffs and snapshot rows, without the
+* inherited snapshots or the build finalize. A sharded capture runs this once per shard.
+*/
+async function persistRendered(input, renderFailedStoryIds = /* @__PURE__ */ new Set(), flakyFailedStoryIds = /* @__PURE__ */ new Set(), a11yFailedStoryIds = /* @__PURE__ */ new Set()) {
+	const ctx = await withFreshBrowsers(input);
 	const failedStoryIds = new Set(renderFailedStoryIds);
 	const flakyIds = new Set(flakyFailedStoryIds);
 	const a11yIds = new Set(a11yFailedStoryIds);
-	await Promise.all(ctx.captures.map(async (capture) => {
+	for (const group of capturesByPhase(ctx)) await mapLimit(group, 4, async (capture) => {
 		try {
 			await persistSnapshot(ctx, capture);
+			ctx.progress?.();
 		} catch (error) {
 			if (flakyIds.has(capture.story.id) || a11yIds.has(capture.story.id)) {
 				if (flakyIds.has(capture.story.id)) flakyIds.add(capture.story.id);
@@ -55,7 +71,7 @@ async function persistCapture(ctx, renderFailedStoryIds = /* @__PURE__ */ new Se
 				viewport: capture.viewportName
 			});
 		}
-	}));
+	});
 	for (const id of flakyIds) if (!failedStoryIds.has(id)) {
 		ctx.logger?.warn({ storyId: id }, "flaky story failed (non-blocking)");
 		await emitAttemptLog(ctx.recordLog, ctx.logger, "warn", "flaky story failed (non-blocking)", { storyId: id });
@@ -64,8 +80,62 @@ async function persistCapture(ctx, renderFailedStoryIds = /* @__PURE__ */ new Se
 		ctx.logger?.warn({ storyId: id }, "a11y violations found (non-blocking)");
 		await emitAttemptLog(ctx.recordLog, ctx.logger, "warn", "a11y violations found (non-blocking)", { storyId: id });
 	}
-	for (const id of await persistInherited(ctx)) failedStoryIds.add(id);
-	await finalize(ctx, allStoryIds(ctx), failedStoryIds, flakyIds, a11yIds);
+	return {
+		failed: failedStoryIds,
+		flaky: flakyIds,
+		a11y: a11yIds
+	};
+}
+/** Engines of this run, primary (first) first. */
+function runBrowsers(ctx) {
+	const listed = ctx.browsers && ctx.browsers.length > 0 ? ctx.browsers : [DEFAULT_BROWSER];
+	return [...new Set(listed)];
+}
+function primaryBrowser(ctx) {
+	return runBrowsers(ctx)[0] ?? "chromium";
+}
+/** The capture's axe violation texts as the JSON stored on the snapshot; null when there are none. */
+function a11yJsonOf(capture) {
+	return capture.a11y && capture.a11y.length > 0 ? JSON.stringify(capture.a11y) : null;
+}
+function browserOf(capture) {
+	return capture.browser ?? "chromium";
+}
+/** Captures split into the primary engine's, then everyone else's. */
+function capturesByPhase(ctx) {
+	const primary = primaryBrowser(ctx);
+	const first = ctx.captures.filter((capture) => browserOf(capture) === primary);
+	const rest = ctx.captures.filter((capture) => browserOf(capture) !== primary);
+	return rest.length > 0 ? [first, rest] : [first];
+}
+/** Secondary engines with no baseline yet (their first snapshots bootstrap from the primary). */
+async function freshBrowsersOf(ctx) {
+	const primary = primaryBrowser(ctx);
+	const baselines = new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret);
+	const secondary = runBrowsers(ctx).filter((browser) => browser !== primary);
+	const checks = await Promise.all(secondary.map(async (browser) => ({
+		browser,
+		fresh: !await baselines.hasAny(ctx.project.id, browser)
+	})));
+	return new Set(checks.filter((check) => check.fresh).map((check) => check.browser));
+}
+/** Mark secondary engines with no baseline yet: their first snapshots bootstrap. */
+async function withFreshBrowsers(ctx) {
+	return ctx.freshBrowsers ? ctx : {
+		...ctx,
+		freshBrowsers: await freshBrowsersOf(ctx)
+	};
+}
+/**
+* A newly enabled engine accepts a story/mode's first snapshot when the
+* primary engine's snapshot of it is clean (Chromatic's "auto-accepted where
+* the primary browser was accepted"); anything else goes to review as `new`.
+*/
+async function bootstrapAccepts(ctx, capture) {
+	const browser = browserOf(capture);
+	if (!ctx.freshBrowsers?.has(browser)) return false;
+	const primary = primaryBrowser(ctx);
+	return (await new SnapshotModel(ctx.db, ctx.tables).listByBuild(ctx.build.id)).some((snapshot) => snapshot.storyId === capture.story.id && snapshot.viewportName === capture.viewportName && (snapshot.browser ?? "chromium") === primary && (snapshot.status === "approved" || snapshot.status === "unchanged"));
 }
 /** Persist one inherited snapshot; returns the story id on failure. */
 async function tryPersistInherited(ctx, inherited) {
@@ -86,25 +156,45 @@ async function tryPersistInherited(ctx, inherited) {
 	}
 }
 /** Persist inherited snapshots; a failure marks the story failed. */
+/** Persist the inherited snapshots (stories reusing their baseline); returns the story ids that failed. */
 async function persistInherited(ctx) {
-	const outcomes = await Promise.all((ctx.inherited ?? []).map(async (inherited) => await tryPersistInherited(ctx, inherited)));
+	const outcomes = await mapLimit(ctx.inherited ?? [], 4, async (inherited) => {
+		const failed = await tryPersistInherited(ctx, inherited);
+		ctx.progress?.();
+		return failed;
+	});
 	return new Set(outcomes.filter((id) => id !== null));
 }
 /** Create an unchanged snapshot reusing the baseline screenshot. */
 async function persistInheritedSnapshot(ctx, inherited) {
-	const infraHash = infraHashFor(ctx.project.browser ?? "chromium", ctx.viewports, SIZING_DEFAULTS);
+	const browser = browserOf(inherited);
+	const infraHash = inherited.baseline.infraHash;
 	const snapshots = new SnapshotModel(ctx.db, ctx.tables);
+	const comparison = await freezeComparison(ctx.storage, ctx.project.id, ctx.build.id, inherited.baseline, {
+		defaultBranch: ctx.project.gitDefaultBranch,
+		mode: modeJsonOf(inherited.viewport),
+		target: browser,
+		width: inherited.viewport.width,
+		height: inherited.viewport.height,
+		captureFingerprint: inherited.baseline.fingerprint ?? null,
+		sourceSnapshotId: await sourceSnapshotId(ctx.db, inherited.baseline)
+	});
 	const snapshot = await snapshots.create(ctx.project.id, ctx.build.id, {
+		...comparison,
+		browser,
 		storyId: inherited.story.id,
 		storyName: inherited.story.name,
 		storyTitle: inherited.story.title,
 		storyImportPath: inherited.story.importPath ?? "",
+		designUrl: inherited.story.designUrl ?? null,
 		viewportName: inherited.viewport.name,
 		viewportWidth: inherited.viewport.width,
 		viewportHeight: inherited.viewport.height,
 		screenshotPath: inherited.baseline.screenshotPath,
 		infraHash,
+		mode: modeJsonOf(inherited.viewport),
 		inherited: true,
+		sourceBuildId: inherited.baseline.sourceBuildId ?? null,
 		baselineId: inherited.baseline.id,
 		baselineVersion: inherited.baseline.updatedAt
 	});
@@ -123,6 +213,10 @@ function allStoryIds(ctx) {
 	for (const inherited of ctx.inherited ?? []) ids.add(inherited.story.id);
 	return ids;
 }
+/** JSON for the snapshot `mode` column: the globals a mode applied (null for plain viewports). */
+function modeJsonOf(viewport) {
+	return viewport?.globals ? JSON.stringify(viewport.globals) : null;
+}
 function viewportByName(ctx, name) {
 	return ctx.viewports.find((v) => v.name === name) ?? {
 		name,
@@ -130,77 +224,212 @@ function viewportByName(ctx, name) {
 		height: 0
 	};
 }
-async function persistSnapshot(ctx, capture) {
+/** Where the capture's screenshot lives: already stored by the orchestrator, or stored now. */
+async function screenshotLocation(ctx, capture) {
+	if (capture.storedPath) return capture.storedPath;
 	assertScreenshotBuffer(capture.screenshot);
+	return await storeScreenshot(ctx.storage, ctx.project.id, capture.screenshot);
+}
+async function persistSnapshot(ctx, capture) {
 	const viewport = capture.viewport ?? viewportByName(ctx, capture.viewportName);
-	const screenshot = screenshotPath(ctx.project.id, ctx.build.id, capture.story.id, capture.viewportName);
-	await ctx.storage.write(screenshot, capture.screenshot);
-	const baseline = await resolveBaseline(ctx, capture.story.id, capture.viewportName);
+	const browser = browserOf(capture);
+	const screenshot = await screenshotLocation(ctx, capture);
+	const baseline = await resolveBaseline(ctx, capture.story.id, capture.viewportName, browser);
 	if (!baseline) {
 		await createWithoutBaseline(ctx, capture, viewport, screenshot);
 		return;
 	}
 	await createWithBaseline(ctx, capture, viewport, screenshot, baseline);
 }
-async function resolveBaseline(ctx, storyId, viewport) {
-	return await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).resolve(ctx.project.id, storyId, viewport, ctx.build.gitBranch, ctx.project.gitDefaultBranch);
+async function resolveBaseline(ctx, storyId, viewport, browser) {
+	return await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).resolve(ctx.project.id, storyId, viewport, ctx.build.gitBranch, ctx.project.gitDefaultBranch, browser);
 }
 async function createWithoutBaseline(ctx, capture, viewport, screenshot) {
 	const snapshots = new SnapshotModel(ctx.db, ctx.tables);
-	const status = ctx.build.isDefault ? "approved" : "new";
-	const infraHash = infraHashFor(ctx.project.browser ?? "chromium", ctx.viewports, SIZING_DEFAULTS);
+	const browser = browserOf(capture);
+	const accepted = ctx.build.isDefault || await bootstrapAccepts(ctx, capture);
+	const status = accepted ? "approved" : "new";
+	const now = fingerprintOf(capture, viewport);
 	const snapshot = await snapshots.create(ctx.project.id, ctx.build.id, {
+		browser,
+		durationMs: capture.durationMs ?? null,
+		a11yViolations: a11yJsonOf(capture),
 		storyId: capture.story.id,
 		storyName: capture.story.name,
 		storyTitle: capture.story.title,
 		storyImportPath: capture.story.importPath ?? "",
+		designUrl: capture.story.designUrl ?? null,
 		viewportName: capture.viewportName,
 		viewportWidth: viewport.width,
 		viewportHeight: viewport.height,
 		screenshotPath: screenshot,
-		infraHash,
+		infraHash: now.infraHash,
+		mode: modeJsonOf(viewport),
 		baselineVersion: NO_BASELINE
 	});
 	await snapshots.setStatus(snapshot.id, status);
-	if (ctx.build.isDefault) await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).upsert(ctx.project.id, capture.story.id, capture.viewportName, ctx.build.gitBranch, snapshot.id, screenshot, infraHash);
+	if (accepted) await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).upsert(ctx.project.id, capture.story.id, capture.viewportName, ctx.build.gitBranch, snapshot.id, screenshot, now.infraHash, {
+		mode: modeJsonOf(viewport),
+		browser,
+		fingerprint: now.json
+	});
+}
+function fingerprintOf(capture, viewport) {
+	return captureFingerprintOf(buildFingerprint(browserOf(capture), viewport, capture.environment));
+}
+/** A fingerprint as stored: its hash (the `infraHash`) and JSON. */
+function captureFingerprintOf(fingerprint) {
+	return {
+		fingerprint,
+		infraHash: fingerprintHash(fingerprint),
+		json: JSON.stringify(fingerprint)
+	};
 }
+/**
+* What changed in the capture environment since the baseline was recorded, or null when nothing
+* did. Compared component by component, only where both sides report a value: a capture with no
+* environment (spooled before a browser crash) is unknown, not a change. A baseline from before
+* fingerprints cannot be compared, so it is never reported as changed; it is backfilled instead.
+*/
+function environmentChange(baseline, now) {
+	const from = parseFingerprint(baseline.fingerprint);
+	if (!from) return null;
+	const changed = changedFields(from, now.fingerprint);
+	return changed.length > 0 ? {
+		changed,
+		from,
+		to: now.fingerprint
+	} : null;
+}
+/**
+* A changed environment migrates the baseline without a diff only on the default branch, which is
+* authoritative and auto-approves its own changes anyway. A feature branch still diffs: a real
+* change is reported as `changed` with the environment change attached, never auto-accepted.
+*/
 async function createWithBaseline(ctx, capture, viewport, screenshot, baseline) {
-	const result = await diffStoredScreenshots(ctx.storage, ctx.project, baseline.screenshotPath, screenshot, capture.story.parameters?.diffThreshold);
-	const infraHash = infraHashFor(ctx.project.browser ?? "chromium", ctx.viewports, SIZING_DEFAULTS);
-	const snapshots = new SnapshotModel(ctx.db, ctx.tables);
-	const snapshot = await snapshots.create(ctx.project.id, ctx.build.id, {
+	const now = fingerprintOf(capture, viewport);
+	const change = environmentChange(baseline, now);
+	const input = {
+		ctx,
+		capture,
+		viewport,
+		screenshot,
+		baseline,
+		now,
+		change,
+		comparison: await freezeComparison(ctx.storage, ctx.project.id, ctx.build.id, baseline, {
+			defaultBranch: ctx.project.gitDefaultBranch,
+			mode: modeJsonOf(viewport),
+			target: browserOf(capture),
+			width: viewport.width,
+			height: viewport.height,
+			captureFingerprint: now.json,
+			sourceSnapshotId: await sourceSnapshotId(ctx.db, baseline)
+		})
+	};
+	if (change && ctx.build.isDefault) await persistMigration(input, change);
+	else await persistDiff(input);
+}
+/** The fingerprint to write on the baseline: the capture's, keeping components it did not report. */
+function baselineFingerprintOf(input) {
+	const earlier = parseFingerprint(input.baseline.fingerprint);
+	return captureFingerprintOf(mergeFingerprint(earlier, input.now.fingerprint));
+}
+function snapshotInput(input) {
+	const { capture, viewport, screenshot, baseline, now } = input;
+	return {
+		browser: browserOf(capture),
+		durationMs: capture.durationMs ?? null,
+		a11yViolations: a11yJsonOf(capture),
 		storyId: capture.story.id,
 		storyName: capture.story.name,
 		storyTitle: capture.story.title,
 		storyImportPath: capture.story.importPath ?? "",
+		designUrl: capture.story.designUrl ?? null,
 		viewportName: capture.viewportName,
 		viewportWidth: viewport.width,
 		viewportHeight: viewport.height,
 		screenshotPath: screenshot,
-		infraHash,
+		infraHash: now.infraHash,
+		mode: modeJsonOf(viewport),
 		baselineId: baseline.id,
-		baselineVersion: baseline.updatedAt
+		baselineVersion: baseline.updatedAt,
+		...input.comparison
+	};
+}
+/**
+* The default branch's capture environment changed (browser build, fonts, platform, scale): pixels
+* would differ with no code change, so no diff is computed. The snapshot is accepted, records what
+* changed, and the new screenshot becomes the baseline.
+*/
+async function persistMigration(input, change) {
+	const { ctx, capture, viewport, screenshot, now } = input;
+	const snapshots = new SnapshotModel(ctx.db, ctx.tables);
+	const snapshot = await snapshots.create(ctx.project.id, ctx.build.id, {
+		...snapshotInput(input),
+		envChange: JSON.stringify(change)
+	});
+	await snapshots.update(snapshot.id, {
+		status: "unchanged",
+		diffPath: null,
+		diffPixels: 0,
+		diffRatio: 0,
+		diffPassed: true,
+		infraHash: now.infraHash
 	});
-	const shouldAutomigrate = result.sizeChanged && !result.passed && ctx.project.automigrate && baseline.infraHash !== null && baseline.infraHash !== infraHash;
-	const status = shouldAutomigrate ? "unchanged" : diffStatus(result.passed, ctx.build.isDefault);
-	const diff = diffPath(ctx.project.id, ctx.build.id, capture.story.id, capture.viewportName);
-	const passed = shouldAutomigrate ? true : result.passed;
-	const pixels = shouldAutomigrate ? 0 : result.diffPixels;
-	const ratio = shouldAutomigrate ? 0 : result.diffRatio;
-	const overlay = await writeDiffOverlay(ctx.storage, diff, result, passed);
+	await upsertDefaultBaseline(ctx, snapshot.id, capture, screenshot, baselineFingerprintOf(input));
+	ctx.logger?.debug({
+		storyId: capture.story.id,
+		viewport: viewport.name,
+		changed: change.changed
+	}, "capture environment changed; accepted without a diff");
+}
+/** Diff against the baseline; a feature-branch environment change rides along as `envChange`. */
+async function persistDiff(input) {
+	const { ctx, capture, screenshot, baseline, now, change } = input;
+	const result = await diffStoredScreenshots(ctx.storage, ctx.project, baseline.screenshotPath === screenshot ? screenshot : input.comparison.comparisonImagePath, screenshot, capture.story.parameters?.diffThreshold);
+	const snapshots = new SnapshotModel(ctx.db, ctx.tables);
+	const snapshot = await snapshots.create(ctx.project.id, ctx.build.id, {
+		...snapshotInput(input),
+		...change ? { envChange: JSON.stringify(change) } : {}
+	});
+	const diff = diffPath(ctx.project.id, ctx.build.id, capture.story.id, capture.viewportName, browserOf(capture));
+	const overlay = await writeDiffOverlay(ctx.storage, diff, result, result.passed);
 	await snapshots.update(snapshot.id, {
-		status,
+		status: diffStatus(result.passed, ctx.build.isDefault),
 		diffPath: overlay,
-		diffPixels: pixels,
-		diffRatio: ratio,
-		diffPassed: passed,
-		infraHash
+		diffPixels: result.diffPixels,
+		diffRatio: result.diffRatio,
+		diffPassed: result.passed,
+		infraHash: now.infraHash
 	});
-	if (ctx.build.isDefault && (shouldAutomigrate || !passed)) await upsertDefaultBaseline(ctx, snapshot.id, capture, screenshot, infraHash);
+	if (ctx.build.isDefault) await refreshDefaultBaseline(input, snapshot.id, result.passed);
+}
+/**
+* After a default-branch diff: a failed diff moves the baseline to the new screenshot; a passing
+* one backfills the fingerprint when it was missing or had components the capture now reports.
+*/
+async function refreshDefaultBaseline(input, snapshotId, passed) {
+	const { ctx, capture, screenshot, baseline } = input;
+	const target = baselineFingerprintOf(input);
+	if (!passed) await upsertDefaultBaseline(ctx, snapshotId, capture, screenshot, target);
+	else if (!baseline.fingerprint || baseline.infraHash !== target.infraHash) try {
+		await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).backfillFingerprint(baseline, target.infraHash, target.json);
+	} catch (error) {
+		if (!(error instanceof BaselineWriteConflict || error instanceof ReferenceGenerationConflict)) throw error;
+		ctx.logger?.debug({
+			err: error,
+			baselineId: baseline.id
+		}, "skipped baseline fingerprint backfill after concurrent write");
+	}
 }
 /** Default-branch builds are authoritative: the captured screenshot becomes the baseline. */
-async function upsertDefaultBaseline(ctx, snapshotId, capture, screenshot, infraHash) {
-	await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).upsert(ctx.project.id, capture.story.id, capture.viewportName, ctx.build.gitBranch, snapshotId, screenshot, infraHash);
+async function upsertDefaultBaseline(ctx, snapshotId, capture, screenshot, now) {
+	await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).upsert(ctx.project.id, capture.story.id, capture.viewportName, ctx.build.gitBranch, snapshotId, screenshot, now.infraHash, {
+		mode: modeJsonOf(capture.viewport),
+		browser: browserOf(capture),
+		fingerprint: now.json
+	});
 }
 /** Snapshot status after diffing: default-branch changes are auto-approved, not queued for review. */
 function diffStatus(passed, isDefault) {
@@ -213,8 +442,16 @@ function finalBuildStatus(isDefault, failedCount, hasCaptures, build) {
 	if (isDefault || hasCaptures && build.changedCount === 0) return "approved";
 	return "reviewing";
 }
-async function finalize(ctx, storyIds, failedStoryIds, flakyFailedStoryIds = /* @__PURE__ */ new Set(), a11yFailedStoryIds = /* @__PURE__ */ new Set()) {
-	const builds = new BuildModel(ctx.db, ctx.tables);
+/**
+* Close out a capture: roll the snapshot counts up, set the build's final status from the failed
+* story ids, and (on the default branch) drop baselines of stories that no longer exist.
+*/
+async function finalizeBuild(ctx, storyIds, failedStoryIds, flakyFailedStoryIds = /* @__PURE__ */ new Set(), a11yFailedStoryIds = /* @__PURE__ */ new Set()) {
+	const builds = new BuildModel(ctx.db, ctx.tables, ctx.logger);
+	if ((await builds.get(ctx.build.id))?.status === "cancelled") {
+		ctx.logger?.debug({ buildId: ctx.build.id }, "build is cancelled; finalize skipped");
+		return;
+	}
 	const build = await builds.updateCounts(ctx.build.id);
 	const hasCaptures = storyIds.size > 0;
 	const status = finalBuildStatus(ctx.build.isDefault, failedStoryIds.size, hasCaptures, build);
@@ -229,7 +466,6 @@ async function finalize(ctx, storyIds, failedStoryIds, flakyFailedStoryIds = /*
 	await builds.setStatus(ctx.build.id, status);
 	if (ctx.build.isDefault && hasCaptures) await new BaselineModel(ctx.db, ctx.tables, ctx.storage, ctx.secret).removeOrphans(ctx.project.id, new Set(storyIds));
 }
-//#endregion
-export { diffStatus, persistCapture };
+export { diffStatus, finalizeBuild, freshBrowsersOf, persistCapture, persistInherited, persistRendered };
 
 //# sourceMappingURL=pipeline.mjs.map