@storyshelf/core 0.6.1 → 0.7.0

package/dist/capture/shards/execute.mjs

@@ -0,0 +1,174 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { classifyFailures } from "../failure-sets.mjs";
+import { renderWork } from "../matrix.mjs";
+import { SnapshotModel } from "../../models/snapshot.mjs";
+import { persistRendered } from "../pipeline.mjs";
+import { removeShardScratch } from "../scratch.mjs";
+import { CaptureShardModel } from "../../models/capture-shard.mjs";
+import { contextOf, matrixInputOf } from "./context.mjs";
+import { extractStorybookToScratch } from "../statics.mjs";
+import { loadTarget } from "../target.mjs";
+import { reduceBuild } from "./reduce.mjs";
+//#region src/capture/shards/execute.ts
+/** The render stage: one shard of a sharded capture, run by whichever worker picked up its job. */
+/**
+* Render and persist one shard, record its outcome, and, if it was the last one, finalize the build.
+*
+* Safe to run twice: a shard already done is not rendered again, and a rerun of an interrupted one
+* starts from a clean slate for its stories. A redelivered shard that is already done still tries
+* to finalize the build, in case the run that finished it died or failed before it could.
+*/
+async function executeCaptureShard(input, options) {
+	const picked = await pickShard(input, options);
+	if ("status" in picked) return picked;
+	const final = input.final !== false;
+	if (picked.shard.status === "done") return await reduceFinished(picked.target, input, final);
+	await runShard(picked.target, picked.shard, input, final);
+	return await reduceRendered(picked.target, input, final);
+}
+/** The shard is done: if it was the last one, this run finalizes the build. */
+async function reduceRendered(target, input, final) {
+	const summary = await reduceBuild(target, final);
+	if (!summary) return {
+		status: "rendered",
+		finalized: false
+	};
+	await input.onFinalized?.(summary);
+	return {
+		status: "rendered",
+		finalized: true,
+		summary
+	};
+}
+/** A redelivered shard that an earlier run finished: finalize the build if nobody has. */
+async function reduceFinished(target, input, final) {
+	const summary = await reduceBuild(target, final);
+	if (!summary) return {
+		status: "skipped",
+		reason: "shard already finished"
+	};
+	await input.onFinalized?.(summary);
+	return {
+		status: "reduced",
+		summary
+	};
+}
+/** Run the shard; a failure is recorded on its row (and, if final, reduces the build) then rethrown. */
+async function runShard(target, shard, input, final) {
+	const shards = new CaptureShardModel(target.options.db);
+	await shards.markRunning(shard.id);
+	input.progress?.();
+	try {
+		await renderShard(target, shard, input.progress);
+	} catch (error) {
+		await recordFailure(shards, shard, error, final);
+		if (final) await finalizeAfterFailure(target, input, error);
+		throw error;
+	}
+}
+/**
+* The shard failed for good: if it was the last one open, it ends the build, and only then does
+* this run report it. A failure here is logged, not thrown: the shard's own error is the news.
+*/
+async function finalizeAfterFailure(target, input, error) {
+	try {
+		const summary = await reduceBuild(target, true);
+		if (summary) await input.onFinalized?.(summary, error);
+	} catch (reduceError) {
+		target.options.logger?.error({
+			err: reduceError,
+			buildId: target.build.id
+		}, "finalizing after a failed shard failed");
+	}
+}
+/** The shard to run and what to run it against, or why there is nothing to do. */
+async function pickShard(input, options) {
+	const shard = await new CaptureShardModel(options.db).get(input.shard);
+	if (shard?.kind !== "render") return {
+		status: "skipped",
+		reason: "shard no longer exists"
+	};
+	const { build, project } = await loadTarget(options, input.buildId);
+	if (build.status !== "capturing") return {
+		status: "skipped",
+		reason: shard.status === "done" ? "shard already finished" : `build is ${build.status}`
+	};
+	return {
+		target: {
+			options,
+			build,
+			project
+		},
+		shard
+	};
+}
+async function recordFailure(shards, shard, error, final) {
+	const message = error instanceof Error ? error.message : String(error);
+	await (final ? shards.fail(shard.id, message) : shards.retry(shard.id, message));
+}
+async function renderShard(target, shard, progress) {
+	const { options, build, project } = target;
+	const payload = JSON.parse(shard.payload ?? "{}");
+	const started = performance.now();
+	const storybookDir = await extractStorybookToScratch(options.storage, options.scratchDir, project.id, build.id, shard.id, options.limits);
+	progress?.();
+	try {
+		const result = await renderAndPersist(target, payload, {
+			storybookDir,
+			runId: shard.id,
+			progress
+		});
+		const durationMs = Math.round(performance.now() - started);
+		await new CaptureShardModel(options.db).complete(shard.id, JSON.stringify({
+			...result,
+			durationMs
+		}));
+	} finally {
+		await removeShardScratch(options.scratchDir, project.id, build.id, shard.id, options.logger);
+	}
+}
+async function renderAndPersist(target, payload, run) {
+	const stories = payload.browsers.flatMap((engine) => engine.stories);
+	const browsers = payload.browsers.map((engine) => engine.browser);
+	const rendered = await renderWork(matrixInputOf(target, {
+		stories,
+		viewports: payload.viewports,
+		browsers,
+		storybookDir: run.storybookDir,
+		affectedPaths: null,
+		progress: run.progress,
+		runId: run.runId
+	}), payload.browsers);
+	const failures = classifyFailures(stories, rendered.failures);
+	await clearEarlierRun(target, payload);
+	const persisted = await persistRendered(contextOf(target, {
+		viewports: payload.viewports,
+		browsers,
+		captures: rendered.captures,
+		freshBrowsers: new Set(payload.fresh),
+		progress: run.progress
+	}), failures.blocking, failures.flaky, failures.a11y);
+	return {
+		failedStoryIds: [...persisted.failed],
+		flakyStoryIds: [...persisted.flaky],
+		a11yStoryIds: [...persisted.a11y],
+		captured: rendered.captures.length
+	};
+}
+/**
+* Drop what an interrupted earlier run of this shard persisted: the rendered rows of the
+* (story, engine) pairs it is about to write. The plan's inherited rows stay, including those of
+* these stories on engines or viewports this shard does not render.
+*/
+async function clearEarlierRun(target, payload) {
+	await new SnapshotModel(target.options.db, target.options.tables).removeRendered(target.build.id, payload.browsers.map((engine) => ({
+		browser: engine.browser,
+		storyIds: new Set(engine.stories.map((story) => story.id))
+	})));
+}
+//#endregion
+export { executeCaptureShard };
+
+//# sourceMappingURL=execute.mjs.map

package/dist/capture/shards/execute.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.mjs","names":[],"sources":["../../../src/capture/shards/execute.ts"],"sourcesContent":["/** The render stage: one shard of a sharded capture, run by whichever worker picked up its job. */\nimport { CaptureShardModel } from \"../../models/capture-shard.ts\";\nimport { SnapshotModel } from \"../../models/snapshot.ts\";\nimport type { CaptureShard } from \"../../schema/capture-shard.ts\";\nimport { classifyFailures } from \"../failure-sets.ts\";\nimport { renderWork } from \"../matrix.ts\";\nimport type { CaptureJobOptions } from \"../orchestrator.ts\";\nimport { persistRendered } from \"../pipeline.ts\";\nimport type { CaptureProgress } from \"../progress.ts\";\nimport { removeShardScratch } from \"../scratch.ts\";\nimport type { ShardPayload, ShardResult } from \"../shard-plan.ts\";\nimport { extractStorybookToScratch } from \"../statics.ts\";\nimport { loadTarget } from \"../target.ts\";\nimport { contextOf, matrixInputOf, type ShardTarget } from \"./context.ts\";\nimport { reduceBuild, type FinalSummary } from \"./reduce.ts\";\n\n/** A shard job being run. */\nexport interface ShardRunInput {\n  buildId: string;\n  shard: string;\n  reqId?: string | undefined;\n  /**\n   * Whether a failure now is the last word. A queue that redelivers failed jobs passes false until\n   * its retries are used up, so a shard that will be retried does not end the build.\n   */\n  final?: boolean | undefined;\n  /** Reports render and persist progress to the job's lease (see `leaseProgress`). */\n  progress?: CaptureProgress | undefined;\n  /**\n   * Called once by the run that finalized the build, and by no other, with the summary and, when\n   * the shard that ended the build failed, its error. The caller closes the plan's attempt here.\n   */\n  onFinalized?: ((summary: FinalSummary, error?: unknown) => Promise<void>) | undefined;\n}\n\n/** How a shard run ended. */\nexport type ShardOutcome =\n  | { status: \"skipped\"; reason: string }\n  | { status: \"rendered\"; finalized: false }\n  | { status: \"rendered\"; finalized: true; summary: FinalSummary }\n  /** The shard was already done, but the build was not: this run finalized it. */\n  | { status: \"reduced\"; summary: FinalSummary };\n\n/**\n * Render and persist one shard, record its outcome, and, if it was the last one, finalize the build.\n *\n * Safe to run twice: a shard already done is not rendered again, and a rerun of an interrupted one\n * starts from a clean slate for its stories. A redelivered shard that is already done still tries\n * to finalize the build, in case the run that finished it died or failed before it could.\n */\nexport async function executeCaptureShard(\n  input: ShardRunInput,\n  options: CaptureJobOptions,\n): Promise<ShardOutcome> {\n  const picked = await pickShard(input, options);\n  if (\"status\" in picked) {\n    return picked;\n  }\n  const final = input.final !== false;\n  if (picked.shard.status === \"done\") {\n    return await reduceFinished(picked.target, input, final);\n  }\n  await runShard(picked.target, picked.shard, input, final);\n  return await reduceRendered(picked.target, input, final);\n}\n\n/** The shard is done: if it was the last one, this run finalizes the build. */\nasync function reduceRendered(\n  target: ShardTarget,\n  input: ShardRunInput,\n  final: boolean,\n): Promise<ShardOutcome> {\n  const summary = await reduceBuild(target, final);\n  if (!summary) {\n    return { status: \"rendered\", finalized: false };\n  }\n  await input.onFinalized?.(summary);\n  return { status: \"rendered\", finalized: true, summary };\n}\n\n/** A redelivered shard that an earlier run finished: finalize the build if nobody has. */\nasync function reduceFinished(\n  target: ShardTarget,\n  input: ShardRunInput,\n  final: boolean,\n): Promise<ShardOutcome> {\n  const summary = await reduceBuild(target, final);\n  if (!summary) {\n    return { status: \"skipped\", reason: \"shard already finished\" };\n  }\n  await input.onFinalized?.(summary);\n  return { status: \"reduced\", summary };\n}\n\n/** Run the shard; a failure is recorded on its row (and, if final, reduces the build) then rethrown. */\nasync function runShard(\n  target: ShardTarget,\n  shard: CaptureShard,\n  input: ShardRunInput,\n  final: boolean,\n): Promise<void> {\n  const shards = new CaptureShardModel(target.options.db);\n  await shards.markRunning(shard.id);\n  input.progress?.();\n  try {\n    await renderShard(target, shard, input.progress);\n  } catch (error) {\n    await recordFailure(shards, shard, error, final);\n    if (final) {\n      await finalizeAfterFailure(target, input, error);\n    }\n    throw error;\n  }\n}\n\n/**\n * The shard failed for good: if it was the last one open, it ends the build, and only then does\n * this run report it. A failure here is logged, not thrown: the shard's own error is the news.\n */\nasync function finalizeAfterFailure(\n  target: ShardTarget,\n  input: ShardRunInput,\n  error: unknown,\n): Promise<void> {\n  try {\n    const summary = await reduceBuild(target, true);\n    if (summary) {\n      await input.onFinalized?.(summary, error);\n    }\n  } catch (reduceError) {\n    target.options.logger?.error(\n      { err: reduceError, buildId: target.build.id },\n      \"finalizing after a failed shard failed\",\n    );\n  }\n}\n\n/** The shard to run and what to run it against, or why there is nothing to do. */\nasync function pickShard(\n  input: ShardRunInput,\n  options: CaptureJobOptions,\n): Promise<\n  { target: ShardTarget; shard: CaptureShard } | Extract<ShardOutcome, { status: \"skipped\" }>\n> {\n  const shard = await new CaptureShardModel(options.db).get(input.shard);\n  if (shard?.kind !== \"render\") {\n    return { status: \"skipped\", reason: \"shard no longer exists\" };\n  }\n  const { build, project } = await loadTarget(options, input.buildId);\n  if (build.status !== \"capturing\") {\n    const reason = shard.status === \"done\" ? \"shard already finished\" : `build is ${build.status}`;\n    return { status: \"skipped\", reason };\n  }\n  return { target: { options, build, project }, shard };\n}\n\nasync function recordFailure(\n  shards: CaptureShardModel,\n  shard: CaptureShard,\n  error: unknown,\n  final: boolean,\n): Promise<void> {\n  const message = error instanceof Error ? error.message : String(error);\n  await (final ? shards.fail(shard.id, message) : shards.retry(shard.id, message));\n}\n\nasync function renderShard(\n  target: ShardTarget,\n  shard: CaptureShard,\n  progress: CaptureProgress | undefined,\n): Promise<void> {\n  const { options, build, project } = target;\n  const payload = JSON.parse(shard.payload ?? \"{}\") as ShardPayload;\n  const started = performance.now();\n  const storybookDir = await extractStorybookToScratch(\n    options.storage,\n    options.scratchDir,\n    project.id,\n    build.id,\n    shard.id,\n    options.limits,\n  );\n  progress?.();\n  try {\n    const result = await renderAndPersist(target, payload, {\n      storybookDir,\n      runId: shard.id,\n      progress,\n    });\n    const durationMs = Math.round(performance.now() - started);\n    await new CaptureShardModel(options.db).complete(\n      shard.id,\n      JSON.stringify({ ...result, durationMs } satisfies ShardResult),\n    );\n  } finally {\n    await removeShardScratch(options.scratchDir, project.id, build.id, shard.id, options.logger);\n  }\n}\n\nasync function renderAndPersist(\n  target: ShardTarget,\n  payload: ShardPayload,\n  run: { storybookDir: string; runId: string; progress: CaptureProgress | undefined },\n): Promise<Omit<ShardResult, \"durationMs\">> {\n  const stories = payload.browsers.flatMap((engine) => engine.stories);\n  const browsers = payload.browsers.map((engine) => engine.browser);\n  const rendered = await renderWork(\n    matrixInputOf(target, {\n      stories,\n      viewports: payload.viewports,\n      browsers,\n      storybookDir: run.storybookDir,\n      affectedPaths: null,\n      progress: run.progress,\n      runId: run.runId,\n    }),\n    payload.browsers,\n  );\n  const failures = classifyFailures(stories, rendered.failures);\n  await clearEarlierRun(target, payload);\n  const persisted = await persistRendered(\n    contextOf(target, {\n      viewports: payload.viewports,\n      browsers,\n      captures: rendered.captures,\n      freshBrowsers: new Set(payload.fresh),\n      progress: run.progress,\n    }),\n    failures.blocking,\n    failures.flaky,\n    failures.a11y,\n  );\n  return {\n    failedStoryIds: [...persisted.failed],\n    flakyStoryIds: [...persisted.flaky],\n    a11yStoryIds: [...persisted.a11y],\n    captured: rendered.captures.length,\n  };\n}\n\n/**\n * Drop what an interrupted earlier run of this shard persisted: the rendered rows of the\n * (story, engine) pairs it is about to write. The plan's inherited rows stay, including those of\n * these stories on engines or viewports this shard does not render.\n */\nasync function clearEarlierRun(target: ShardTarget, payload: ShardPayload): Promise<void> {\n  await new SnapshotModel(target.options.db, target.options.tables).removeRendered(\n    target.build.id,\n    payload.browsers.map((engine) => ({\n      browser: engine.browser,\n      storyIds: new Set(engine.stories.map((story) => story.id)),\n    })),\n  );\n}\n"],"mappings":"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"}

package/dist/capture/shards/fan-out.mjs

@@ -0,0 +1,126 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { CaptureAttemptModel, emitAttemptLog } from "../../models/capture-attempt.mjs";
+import { resolveStoryViewports } from "../storybook.mjs";
+import { affectedPathsFor } from "../affected.mjs";
+import { partitionBrowsers } from "../matrix.mjs";
+import { SnapshotModel } from "../../models/snapshot.mjs";
+import { freshBrowsersOf, persistInherited } from "../pipeline.mjs";
+import { CaptureShardModel } from "../../models/capture-shard.mjs";
+import { planShards, worthSharding } from "../shard-plan.mjs";
+import { contextOf, matrixInputOf } from "./context.mjs";
+import { storyDurations } from "./history.mjs";
+//#region src/capture/shards/fan-out.ts
+/**
+* The plan stage. When sharding is on and the build is big enough, decide what to render, record
+* the plan and its shards, and hand the shards to the queue; otherwise return null and the caller
+* renders the build in one piece as it always has.
+*
+* Inherited snapshots (affected capture) are written here, since nothing renders for them.
+*/
+async function fanOutCapture(args) {
+	const { options } = args;
+	if (!options.shardSize || !options.enqueue) return null;
+	const matrix = matrixInputOf(args, {
+		stories: args.stories,
+		viewports: args.viewports,
+		browsers: args.browsers,
+		storybookDir: "",
+		affectedPaths: affectedPathsFor(args.build),
+		logger: args.logger,
+		recordLog: args.input.recordLog,
+		progress: args.input.progress
+	});
+	const partition = await partitionBrowsers(matrix);
+	const capturesOf = (story) => resolveStoryViewports(story, args.viewports).length;
+	return worthSharding(partition.work, capturesOf, options.shardSize) ? await planAndCommit(args, partition, capturesOf) : null;
+}
+async function planAndCommit(args, partition, capturesOf) {
+	const durations = await storyDurations(args);
+	const slices = planShards(partition.work, capturesOf, args.options.shardSize, (storyId) => durations.get(storyId));
+	return slices.length === 0 ? null : await commitPlan({
+		...args,
+		timed: durations.size > 0
+	}, slices, partition);
+}
+async function commitPlan(args, slices, partition) {
+	await supersedeEarlierRuns(args);
+	const ctx = contextOf(args, {
+		viewports: args.viewports,
+		browsers: args.browsers,
+		inherited: partition.inherited,
+		progress: args.input.progress
+	});
+	const failedInherits = await persistInherited(ctx);
+	const storyIds = /* @__PURE__ */ new Set([...partition.work.flatMap((engine) => engine.stories.map((story) => story.id)), ...partition.inherited.map((inherited) => inherited.story.id)]);
+	const fresh = [...await freshBrowsersOf(ctx)];
+	const failed = /* @__PURE__ */ new Set([...failedInherits, ...args.testFailed ?? []]);
+	const rows = await recordPlan(args, slices, {
+		fresh,
+		storyIds,
+		failed
+	});
+	await handOut(args, rows);
+	await emitAttemptLog(args.input.recordLog, args.logger, "info", "capture planned", {
+		shards: rows.length,
+		stories: storyIds.size,
+		ordering: args.timed ? "longest-first" : "by-capture-count"
+	});
+	return {
+		storyCount: storyIds.size,
+		failedCount: failed.size,
+		shards: rows.length
+	};
+}
+/**
+* A new plan of a build (recovery requeue, retry, a redelivered plan job) starts clean: the
+* snapshots an earlier plan or its shards wrote are dropped, so inherited rows are not doubled,
+* and the attempts it left open are closed, since only the newest plan's attempt is ever closed.
+*/
+async function supersedeEarlierRuns(args) {
+	const { db, tables } = args.options;
+	await new SnapshotModel(db, tables).removeForBuild(args.build.id);
+	await new CaptureAttemptModel(db, tables).closeOthers(args.build.id, args.input.attempt?.id ?? null, "superseded by a new capture plan");
+}
+async function recordPlan(args, slices, plan) {
+	const shards = new CaptureShardModel(args.options.db);
+	await shards.clearBuild(args.build.id);
+	const settings = {
+		browsers: args.browsers,
+		fresh: plan.fresh,
+		shardSize: args.options.shardSize ?? 0,
+		total: slices.length
+	};
+	const result = {
+		storyIds: [...plan.storyIds],
+		failedStoryIds: [...plan.failed]
+	};
+	return await shards.createPlan(args.project.id, args.build.id, {
+		attemptId: args.input.attempt?.id ?? null,
+		payload: JSON.stringify(settings),
+		result: JSON.stringify(result)
+	}, slices.map((browsers) => ({ payload: shardPayload(args, browsers, plan.fresh) })));
+}
+function shardPayload(args, browsers, fresh) {
+	const payload = {
+		browsers,
+		viewports: args.viewports,
+		fresh
+	};
+	return JSON.stringify(payload);
+}
+/** Enqueue every shard in order; the caller marks the build failed if the queue refuses one. */
+async function handOut(args, rows) {
+	const { enqueue } = args.options;
+	for (const row of rows) await enqueue?.({
+		buildId: args.build.id,
+		shard: row.id,
+		reqId: args.input.reqId,
+		traceparent: args.input.traceparent
+	});
+}
+//#endregion
+export { fanOutCapture };
+
+//# sourceMappingURL=fan-out.mjs.map

package/dist/capture/shards/fan-out.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-out.mjs","names":[],"sources":["../../../src/capture/shards/fan-out.ts"],"sourcesContent":["/** The plan stage: decide what to render, record it as shards, and hand the shards to the queue. */\nimport type { Logger } from \"pino\";\nimport type { CaptureTarget } from \"../../adapters/capture-runner.ts\";\nimport { CaptureAttemptModel, emitAttemptLog } from \"../../models/capture-attempt.ts\";\nimport { CaptureShardModel } from \"../../models/capture-shard.ts\";\nimport { SnapshotModel } from \"../../models/snapshot.ts\";\nimport type { CaptureShard } from \"../../schema/capture-shard.ts\";\nimport type { Viewport } from \"../adapter.ts\";\nimport { affectedPathsFor, type InheritedStory } from \"../affected.ts\";\nimport { partitionBrowsers, type MatrixInput } from \"../matrix.ts\";\nimport type { CaptureJobInput, CaptureSummary } from \"../orchestrator.ts\";\nimport { freshBrowsersOf, persistInherited } from \"../pipeline.ts\";\nimport {\n  planShards,\n  worthSharding,\n  type EngineWork,\n  type PlanPayload,\n  type PlanResult,\n  type ShardPayload,\n} from \"../shard-plan.ts\";\nimport { resolveStoryViewports } from \"../storybook.ts\";\nimport { contextOf, matrixInputOf, type ShardTarget } from \"./context.ts\";\nimport { storyDurations } from \"./history.ts\";\n\n/** Inputs for {@link fanOutCapture}: the plan stage's view of the build. */\nexport interface FanOutInput extends ShardTarget {\n  input: CaptureJobInput;\n  stories: MatrixInput[\"stories\"];\n  viewports: Viewport[];\n  browsers: CaptureTarget[];\n  logger: Logger | undefined;\n  /** Test entries that failed in the plan stage (ADR 0004, decision 10): they fail the build. */\n  testFailed?: ReadonlySet<string> | undefined;\n  /** Set by the plan stage: whether past timings were available to order the shards by. */\n  timed?: boolean;\n}\n\n/**\n * The plan stage. When sharding is on and the build is big enough, decide what to render, record\n * the plan and its shards, and hand the shards to the queue; otherwise return null and the caller\n * renders the build in one piece as it always has.\n *\n * Inherited snapshots (affected capture) are written here, since nothing renders for them.\n */\nexport async function fanOutCapture(args: FanOutInput): Promise<CaptureSummary | null> {\n  const { options } = args;\n  if (!options.shardSize || !options.enqueue) {\n    return null;\n  }\n  const matrix = matrixInputOf(args, {\n    stories: args.stories,\n    viewports: args.viewports,\n    browsers: args.browsers,\n    storybookDir: \"\",\n    affectedPaths: affectedPathsFor(args.build),\n    logger: args.logger,\n    recordLog: args.input.recordLog,\n    progress: args.input.progress,\n  });\n  const partition = await partitionBrowsers(matrix);\n  const capturesOf = (story: MatrixInput[\"stories\"][number]): number =>\n    resolveStoryViewports(story, args.viewports).length;\n  // Past timings only order the shards: not worth a lookup for a build that runs in one piece.\n  return worthSharding(partition.work, capturesOf, options.shardSize)\n    ? await planAndCommit(args, partition, capturesOf)\n    : null;\n}\n\nasync function planAndCommit(\n  args: FanOutInput,\n  partition: { work: EngineWork[]; inherited: InheritedStory[] },\n  capturesOf: (story: MatrixInput[\"stories\"][number]) => number,\n): Promise<CaptureSummary | null> {\n  const durations = await storyDurations(args);\n  const slices = planShards(partition.work, capturesOf, args.options.shardSize, (storyId) =>\n    durations.get(storyId),\n  );\n  return slices.length === 0\n    ? null\n    : await commitPlan({ ...args, timed: durations.size > 0 }, slices, partition);\n}\n\nasync function commitPlan(\n  args: FanOutInput,\n  slices: EngineWork[][],\n  partition: { work: EngineWork[]; inherited: InheritedStory[] },\n): Promise<CaptureSummary> {\n  await supersedeEarlierRuns(args);\n  const ctx = contextOf(args, {\n    viewports: args.viewports,\n    browsers: args.browsers,\n    inherited: partition.inherited,\n    progress: args.input.progress,\n  });\n  const failedInherits = await persistInherited(ctx);\n  const storyIds = new Set([\n    ...partition.work.flatMap((engine) => engine.stories.map((story) => story.id)),\n    ...partition.inherited.map((inherited) => inherited.story.id),\n  ]);\n  const fresh = [...(await freshBrowsersOf(ctx))];\n  const failed = new Set([...failedInherits, ...(args.testFailed ?? [])]);\n  const rows = await recordPlan(args, slices, { fresh, storyIds, failed });\n  await handOut(args, rows);\n  await emitAttemptLog(args.input.recordLog, args.logger, \"info\", \"capture planned\", {\n    shards: rows.length,\n    stories: storyIds.size,\n    ordering: args.timed ? \"longest-first\" : \"by-capture-count\",\n  });\n  return { storyCount: storyIds.size, failedCount: failed.size, shards: rows.length };\n}\n\n/**\n * A new plan of a build (recovery requeue, retry, a redelivered plan job) starts clean: the\n * snapshots an earlier plan or its shards wrote are dropped, so inherited rows are not doubled,\n * and the attempts it left open are closed, since only the newest plan's attempt is ever closed.\n */\nasync function supersedeEarlierRuns(args: FanOutInput): Promise<void> {\n  const { db, tables } = args.options;\n  await new SnapshotModel(db, tables).removeForBuild(args.build.id);\n  await new CaptureAttemptModel(db, tables).closeOthers(\n    args.build.id,\n    args.input.attempt?.id ?? null,\n    \"superseded by a new capture plan\",\n  );\n}\n\nasync function recordPlan(\n  args: FanOutInput,\n  slices: EngineWork[][],\n  plan: { fresh: string[]; storyIds: Set<string>; failed: ReadonlySet<string> },\n): Promise<CaptureShard[]> {\n  const shards = new CaptureShardModel(args.options.db);\n  await shards.clearBuild(args.build.id);\n  const settings: PlanPayload = {\n    browsers: args.browsers,\n    fresh: plan.fresh,\n    shardSize: args.options.shardSize ?? 0,\n    total: slices.length,\n  };\n  const result: PlanResult = { storyIds: [...plan.storyIds], failedStoryIds: [...plan.failed] };\n  return await shards.createPlan(\n    args.project.id,\n    args.build.id,\n    {\n      attemptId: args.input.attempt?.id ?? null,\n      payload: JSON.stringify(settings),\n      result: JSON.stringify(result),\n    },\n    slices.map((browsers) => ({ payload: shardPayload(args, browsers, plan.fresh) })),\n  );\n}\n\nfunction shardPayload(args: FanOutInput, browsers: EngineWork[], fresh: string[]): string {\n  const payload: ShardPayload = { browsers, viewports: args.viewports, fresh };\n  return JSON.stringify(payload);\n}\n\n/** Enqueue every shard in order; the caller marks the build failed if the queue refuses one. */\nasync function handOut(args: FanOutInput, rows: CaptureShard[]): Promise<void> {\n  const { enqueue } = args.options;\n  for (const row of rows) {\n    // oxlint-disable-next-line no-await-in-loop -- shards are queued in plan order\n    await enqueue?.({\n      buildId: args.build.id,\n      shard: row.id,\n      reqId: args.input.reqId,\n      traceparent: args.input.traceparent,\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/capture/shards/history.mjs

@@ -0,0 +1,35 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { BuildModel } from "../../models/build.mjs";
+import { SnapshotModel } from "../../models/snapshot.mjs";
+//#region src/capture/shards/history.ts
+/** What the project's recent builds say a story costs, so a plan can order its work by it. */
+/**
+* Milliseconds each story cost, taken from the newest build of this project whose snapshots carry
+* timings. Older builds are a fair guide: story render cost moves with the story, not the build.
+*
+* Returns an empty map when nothing has been timed yet — a fresh project, a runner that reports no
+* durations, or a retention purge that took the timed builds with it — and the plan then falls back
+* to slicing by capture count alone.
+*/
+async function storyDurations(target) {
+	const { options, project, build } = target;
+	const builds = new BuildModel(options.db, options.tables);
+	const snapshots = new SnapshotModel(options.db, options.tables);
+	const recent = (await builds.list(project.id, { limit: BUILDS_SCANNED + 1 })).filter((candidate) => candidate.id !== build.id).slice(0, BUILDS_SCANNED);
+	for (const candidate of recent) {
+		const timings = await snapshots.durationsByStory(candidate.id);
+		if (timings.size > 0) return timings;
+	}
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Recent builds to look through for timings. More than a couple is wasted work: a build that
+* rendered nothing (everything inherited) carries none, but several in a row do not happen.
+*/
+const BUILDS_SCANNED = 3;
+//#endregion
+export { storyDurations };
+
+//# sourceMappingURL=history.mjs.map

package/dist/capture/shards/history.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.mjs","names":[],"sources":["../../../src/capture/shards/history.ts"],"sourcesContent":["/** What the project's recent builds say a story costs, so a plan can order its work by it. */\nimport { BuildModel } from \"../../models/build.ts\";\nimport { SnapshotModel } from \"../../models/snapshot.ts\";\nimport type { ShardTarget } from \"./context.ts\";\n\n/**\n * Milliseconds each story cost, taken from the newest build of this project whose snapshots carry\n * timings. Older builds are a fair guide: story render cost moves with the story, not the build.\n *\n * Returns an empty map when nothing has been timed yet — a fresh project, a runner that reports no\n * durations, or a retention purge that took the timed builds with it — and the plan then falls back\n * to slicing by capture count alone.\n */\nexport async function storyDurations(target: ShardTarget): Promise<Map<string, number>> {\n  const { options, project, build } = target;\n  const builds = new BuildModel(options.db, options.tables);\n  const snapshots = new SnapshotModel(options.db, options.tables);\n  // One extra in case the build being planned is among the newest.\n  const recent = (await builds.list(project.id, { limit: BUILDS_SCANNED + 1 }))\n    .filter((candidate) => candidate.id !== build.id)\n    .slice(0, BUILDS_SCANNED);\n  for (const candidate of recent) {\n    // oxlint-disable-next-line no-await-in-loop -- stops at the first build that carries timings\n    const timings = await snapshots.durationsByStory(candidate.id);\n    if (timings.size > 0) {\n      return timings;\n    }\n  }\n  return new Map();\n}\n\n/**\n * Recent builds to look through for timings. More than a couple is wasted work: a build that\n * rendered nothing (everything inherited) carries none, but several in a row do not happen.\n */\nconst BUILDS_SCANNED = 3;\n"],"mappings":";;;;;;;;;;;;;;;AAaA,eAAsB,eAAe,QAAmD;CACtF,MAAM,EAAE,SAAS,SAAS,UAAU;CACpC,MAAM,SAAS,IAAI,WAAW,QAAQ,IAAI,QAAQ,MAAM;CACxD,MAAM,YAAY,IAAI,cAAc,QAAQ,IAAI,QAAQ,MAAM;CAE9D,MAAM,UAAU,MAAM,OAAO,KAAK,QAAQ,IAAI,EAAE,OAAO,iBAAiB,EAAE,CAAC,EAAA,CACxE,QAAQ,cAAc,UAAU,OAAO,MAAM,EAAE,CAAC,CAChD,MAAM,GAAG,cAAc;CAC1B,KAAK,MAAM,aAAa,QAAQ;EAE9B,MAAM,UAAU,MAAM,UAAU,iBAAiB,UAAU,EAAE;EAC7D,IAAI,QAAQ,OAAO,GACjB,OAAO;CAEX;CACA,uBAAO,IAAI,IAAI;AACjB;;;;;AAMA,MAAM,iBAAiB"}

package/dist/capture/shards/reduce.mjs

@@ -0,0 +1,97 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { BuildModel } from "../../models/build.mjs";
+import { finalizeBuild } from "../pipeline.mjs";
+import { CaptureShardModel } from "../../models/capture-shard.mjs";
+import { contextOf } from "./context.mjs";
+//#region src/capture/shards/reduce.ts
+/** The reduce stage: when the last render shard ends, exactly one worker finishes the build. */
+/**
+* When every render shard has ended, claim the finalize (exactly one worker can) and finish the
+* build from the plan and the shards' outcomes. Returns the summary for the winner, else null.
+*
+* A finalize that throws gives its claim back, so the next run to reduce the build (a redelivery
+* of the same shard) finalizes it instead of finding the claim taken. On a last try (`final`)
+* nothing will come back for it, so the build is failed and the failure reported as the summary.
+*/
+async function reduceBuild(target, final = true) {
+	const shards = new CaptureShardModel(target.options.db);
+	const rows = await closedShards(shards, target.build.id);
+	if (!rows || !await shards.claimFinalize(target.project.id, target.build.id)) return null;
+	return await finalizeClaimed(target, shards, rows, final);
+}
+/** Finalize under the claim this run holds; on failure, give the claim back. */
+async function finalizeClaimed(target, shards, rows, final) {
+	const plan = await shards.plan(target.build.id);
+	try {
+		const summary = await finalizeSharded(target, rows, plan);
+		await shards.finishFinalize(target.build.id);
+		return summary;
+	} catch (error) {
+		await shards.releaseFinalize(target.build.id);
+		if (!final) throw error;
+		return await failFinalize(target, plan, error);
+	}
+}
+/** The build's render shards once every one has ended, else null (none, or some still open). */
+async function closedShards(shards, buildId) {
+	const rows = await shards.renderShards(buildId);
+	const open = rows.some((row) => row.status === "pending" || row.status === "running");
+	return rows.length === 0 || open ? null : rows;
+}
+async function finalizeSharded(target, rows, plan) {
+	const planResult = planResultOf(plan);
+	const sets = collectSets(rows, planResult);
+	await finalizeBuild(contextOf(target, {
+		viewports: [],
+		browsers: []
+	}), new Set(planResult.storyIds ?? []), sets.failed, sets.flaky, sets.a11y);
+	const finished = await new BuildModel(target.options.db, target.options.tables).get(target.build.id);
+	return {
+		storyCount: planResult.storyIds?.length ?? 0,
+		failedCount: sets.failed.size,
+		buildStatus: finished?.status ?? "failed",
+		attemptId: plan?.attemptId ?? null
+	};
+}
+/** The last try at finalizing failed: fail the build, so it does not sit in `capturing`. */
+async function failFinalize(target, plan, error) {
+	await new BuildModel(target.options.db, target.options.tables).setStatus(target.build.id, "failed");
+	return {
+		storyCount: planResultOf(plan).storyIds?.length ?? 0,
+		failedCount: 0,
+		buildStatus: "failed",
+		attemptId: plan?.attemptId ?? null,
+		error: error instanceof Error ? error.message : String(error)
+	};
+}
+function planResultOf(plan) {
+	return JSON.parse(plan?.result ?? "{}");
+}
+/** Union the plan's and every shard's failures; a shard that ended `failed` fails all its stories. */
+function collectSets(rows, plan) {
+	const union = {
+		failed: new Set(plan.failedStoryIds ?? []),
+		flaky: /* @__PURE__ */ new Set(),
+		a11y: /* @__PURE__ */ new Set()
+	};
+	for (const row of rows) if (row.status === "failed") addAll(union.failed, storyIdsOf(row));
+	else addShardResult(union, JSON.parse(row.result ?? "{}"));
+	return union;
+}
+function addShardResult(union, result) {
+	addAll(union.failed, result.failedStoryIds ?? []);
+	addAll(union.flaky, result.flakyStoryIds ?? []);
+	addAll(union.a11y, result.a11yStoryIds ?? []);
+}
+function addAll(into, ids) {
+	for (const id of ids) into.add(id);
+}
+function storyIdsOf(row) {
+	return (JSON.parse(row.payload ?? "{}").browsers ?? []).flatMap((engine) => engine.stories.map((story) => story.id));
+}
+//#endregion
+export { reduceBuild };
+
+//# sourceMappingURL=reduce.mjs.map

package/dist/capture/shards/reduce.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce.mjs","names":[],"sources":["../../../src/capture/shards/reduce.ts"],"sourcesContent":["/** The reduce stage: when the last render shard ends, exactly one worker finishes the build. */\nimport { BuildModel } from \"../../models/build.ts\";\nimport { CaptureShardModel } from \"../../models/capture-shard.ts\";\nimport type { CaptureShard } from \"../../schema/capture-shard.ts\";\nimport type { BuildStatus } from \"../../types.ts\";\nimport { finalizeBuild } from \"../pipeline.ts\";\nimport type { PlanResult, ShardPayload, ShardResult } from \"../shard-plan.ts\";\nimport { contextOf, type ShardTarget } from \"./context.ts\";\n\n/** The finished build, reported by whichever worker finalized it. */\nexport interface FinalSummary {\n  storyCount: number;\n  failedCount: number;\n  buildStatus: BuildStatus;\n  /** The attempt row the plan was made under, to be closed by the caller. */\n  attemptId: string | null;\n  /** Set when the finalize itself failed on a last try, and the build was failed for it. */\n  error?: string;\n}\n\n/**\n * When every render shard has ended, claim the finalize (exactly one worker can) and finish the\n * build from the plan and the shards' outcomes. Returns the summary for the winner, else null.\n *\n * A finalize that throws gives its claim back, so the next run to reduce the build (a redelivery\n * of the same shard) finalizes it instead of finding the claim taken. On a last try (`final`)\n * nothing will come back for it, so the build is failed and the failure reported as the summary.\n */\nexport async function reduceBuild(target: ShardTarget, final = true): Promise<FinalSummary | null> {\n  const shards = new CaptureShardModel(target.options.db);\n  const rows = await closedShards(shards, target.build.id);\n  if (!rows || !(await shards.claimFinalize(target.project.id, target.build.id))) {\n    return null;\n  }\n  return await finalizeClaimed(target, shards, rows, final);\n}\n\n/** Finalize under the claim this run holds; on failure, give the claim back. */\nasync function finalizeClaimed(\n  target: ShardTarget,\n  shards: CaptureShardModel,\n  rows: CaptureShard[],\n  final: boolean,\n): Promise<FinalSummary> {\n  const plan = await shards.plan(target.build.id);\n  try {\n    const summary = await finalizeSharded(target, rows, plan);\n    await shards.finishFinalize(target.build.id);\n    return summary;\n  } catch (error) {\n    await shards.releaseFinalize(target.build.id);\n    if (!final) {\n      throw error;\n    }\n    return await failFinalize(target, plan, error);\n  }\n}\n\n/** The build's render shards once every one has ended, else null (none, or some still open). */\nasync function closedShards(\n  shards: CaptureShardModel,\n  buildId: string,\n): Promise<CaptureShard[] | null> {\n  const rows = await shards.renderShards(buildId);\n  const open = rows.some((row) => row.status === \"pending\" || row.status === \"running\");\n  return rows.length === 0 || open ? null : rows;\n}\n\nasync function finalizeSharded(\n  target: ShardTarget,\n  rows: CaptureShard[],\n  plan: CaptureShard | null,\n): Promise<FinalSummary> {\n  const planResult = planResultOf(plan);\n  const sets = collectSets(rows, planResult);\n  await finalizeBuild(\n    contextOf(target, { viewports: [], browsers: [] }),\n    new Set(planResult.storyIds ?? []),\n    sets.failed,\n    sets.flaky,\n    sets.a11y,\n  );\n  const finished = await new BuildModel(target.options.db, target.options.tables).get(\n    target.build.id,\n  );\n  return {\n    storyCount: planResult.storyIds?.length ?? 0,\n    failedCount: sets.failed.size,\n    buildStatus: finished?.status ?? \"failed\",\n    attemptId: plan?.attemptId ?? null,\n  };\n}\n\n/** The last try at finalizing failed: fail the build, so it does not sit in `capturing`. */\nasync function failFinalize(\n  target: ShardTarget,\n  plan: CaptureShard | null,\n  error: unknown,\n): Promise<FinalSummary> {\n  await new BuildModel(target.options.db, target.options.tables).setStatus(\n    target.build.id,\n    \"failed\",\n  );\n  return {\n    storyCount: planResultOf(plan).storyIds?.length ?? 0,\n    failedCount: 0,\n    buildStatus: \"failed\",\n    attemptId: plan?.attemptId ?? null,\n    error: error instanceof Error ? error.message : String(error),\n  };\n}\n\nfunction planResultOf(plan: CaptureShard | null): Partial<PlanResult> {\n  return JSON.parse(plan?.result ?? \"{}\") as Partial<PlanResult>;\n}\n\ninterface FailureUnion {\n  failed: Set<string>;\n  flaky: Set<string>;\n  a11y: Set<string>;\n}\n\n/** Union the plan's and every shard's failures; a shard that ended `failed` fails all its stories. */\nfunction collectSets(rows: CaptureShard[], plan: Partial<PlanResult>): FailureUnion {\n  const union: FailureUnion = {\n    failed: new Set(plan.failedStoryIds ?? []),\n    flaky: new Set(),\n    a11y: new Set(),\n  };\n  for (const row of rows) {\n    if (row.status === \"failed\") {\n      addAll(union.failed, storyIdsOf(row));\n    } else {\n      addShardResult(union, JSON.parse(row.result ?? \"{}\") as Partial<ShardResult>);\n    }\n  }\n  return union;\n}\n\nfunction addShardResult(union: FailureUnion, result: Partial<ShardResult>): void {\n  addAll(union.failed, result.failedStoryIds ?? []);\n  addAll(union.flaky, result.flakyStoryIds ?? []);\n  addAll(union.a11y, result.a11yStoryIds ?? []);\n}\n\nfunction addAll(into: Set<string>, ids: readonly string[]): void {\n  for (const id of ids) {\n    into.add(id);\n  }\n}\n\nfunction storyIdsOf(row: CaptureShard): string[] {\n  const payload = JSON.parse(row.payload ?? \"{}\") as Partial<ShardPayload>;\n  return (payload.browsers ?? []).flatMap((engine) => engine.stories.map((story) => story.id));\n}\n"],"mappings":"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"}

package/dist/capture/sizing.mjs

@@ -1,7 +1,6 @@
 import "node:path";
 import "node:url";
 import.meta.url;
-import { sha256 } from "../utils/hash.mjs";
 //#region src/capture/sizing.ts
 /** Padding around the cropped component (8px each side). */
 const PAD = 16;
@@ -104,16 +103,7 @@ function parsedViewports(raw) {
 	} catch {}
 	return null;
 }
-/** Hash infra determinism: browser + viewports + sizing defaults. */
-function infraHashFor(browser, viewports, defaults = SIZING_DEFAULTS) {
-	const payload = JSON.stringify({
-		browser,
-		viewports,
-		defaults
-	});
-	return sha256(payload);
-}
 //#endregion
-export { SIZING_DEFAULTS, getScreenshotPlan, infraHashFor, resolveViewports };
+export { SIZING_DEFAULTS, getScreenshotPlan, resolveViewports };
 
 //# sourceMappingURL=sizing.mjs.map

package/dist/capture/sizing.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sizing.mjs","names":[],"sources":["../../src/capture/sizing.ts"],"sourcesContent":["import { sha256 } from \"../utils/hash.ts\";\nimport type { Viewport } from \"./adapter.ts\";\n\n/** Padding around the cropped component (8px each side). */\nconst PAD = 16;\nconst HALF_PAD = 8;\n\n/** Default min/max dimensions for cropped/fullPage screenshots (diff stability). */\nexport const SIZING_DEFAULTS = {\n  minWidth: 100,\n  minHeight: 100,\n  maxWidth: 2000,\n  maxHeight: 4000,\n  whitespaceThreshold: 0.6,\n} as const;\n\n/** Bounding box of #storybook-root as returned by Playwright/Puppeteer. */\nexport interface BoundingBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Options for computing the screenshot plan. */\nexport interface SizingOptions {\n  /** Per-story override: false forces full viewport, true forces crop when possible. */\n  autoCrop?: boolean;\n  /** Whitespace fraction (0..1) above which we crop; default 0.6. */\n  whitespaceThreshold?: number;\n  /** Whether overflow should trigger fullPage; default true. */\n  fullPageOnOverflow?: boolean;\n  /** Min dimensions for the final PNG (clamp after padding). */\n  minWidth?: number;\n  minHeight?: number;\n  /** Max dimensions for the final PNG (clamp after padding). */\n  maxWidth?: number;\n  maxHeight?: number;\n}\n\n/** Result of the sizing decision — what the runner should do. */\nexport interface ScreenshotPlan {\n  /** Viewport to set on the page before capture. */\n  viewport: Viewport;\n  /** Clip to use for page.screenshot({clip}). Undefined means full viewport. */\n  clip?: { x: number; y: number; width: number; height: number };\n  /** Whether to use fullPage screenshot (for overflow). */\n  fullPage: boolean;\n}\n\n/** Clamp value between min and max. */\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\nfunction isOverflowing(box: BoundingBox, viewport: Viewport): boolean {\n  return box.width > viewport.width || box.height > viewport.height;\n}\n\nfunction whitespaceOf(box: BoundingBox, viewport: Viewport): number {\n  const viewportArea = viewport.width * viewport.height;\n  const boxArea = box.width * box.height;\n  const coverage = viewportArea > 0 ? boxArea / viewportArea : 1;\n  return 1 - Math.min(coverage, 1);\n}\n\nfunction shouldCrop(\n  box: BoundingBox,\n  viewport: Viewport,\n  opts: SizingOptions,\n  threshold: number,\n): boolean {\n  if (opts.autoCrop === true) return true;\n  return whitespaceOf(box, viewport) > threshold;\n}\n\nfunction paddedClip(\n  box: BoundingBox,\n  minW: number,\n  maxW: number,\n  minH: number,\n  maxH: number,\n): BoundingBox {\n  const w = clamp(Math.ceil(box.width + PAD), minW, maxW);\n  const h = clamp(Math.ceil(box.height + PAD), minH, maxH);\n  return {\n    x: Math.max(0, box.x - HALF_PAD),\n    y: Math.max(0, box.y - HALF_PAD),\n    width: w,\n    height: h,\n  };\n}\n\n/**\n * Compute the screenshot plan for a single story×viewport.\n * Single prod owner for sizing logic — runners import this, never duplicate.\n */\nexport function getScreenshotPlan(\n  viewport: Viewport,\n  box: BoundingBox | null,\n  options: SizingOptions = {},\n): ScreenshotPlan {\n  if (options.autoCrop === false) return { viewport, fullPage: false };\n  if (!box) return { viewport, fullPage: false };\n  if (isOverflowing(box, viewport) && (options.fullPageOnOverflow ?? true)) {\n    return { viewport, fullPage: true };\n  }\n  if (isOverflowing(box, viewport)) {\n    return grownViewportPlan(viewport, box, options);\n  }\n  return maybeCroppedPlan(viewport, box, options);\n}\n\nfunction grownViewportPlan(\n  viewport: Viewport,\n  box: BoundingBox,\n  options: SizingOptions,\n): ScreenshotPlan {\n  const maxH = options.maxHeight ?? SIZING_DEFAULTS.maxHeight;\n  const grownHeight = clamp(Math.ceil(box.height + PAD), viewport.height, maxH);\n  return { viewport: { ...viewport, height: grownHeight }, fullPage: false };\n}\n\nfunction maybeCroppedPlan(\n  viewport: Viewport,\n  box: BoundingBox,\n  options: SizingOptions,\n): ScreenshotPlan {\n  const threshold = options.whitespaceThreshold ?? SIZING_DEFAULTS.whitespaceThreshold;\n  if (!shouldCrop(box, viewport, options, threshold)) return { viewport, fullPage: false };\n  const minW = options.minWidth ?? SIZING_DEFAULTS.minWidth;\n  const minH = options.minHeight ?? SIZING_DEFAULTS.minHeight;\n  const maxW = options.maxWidth ?? SIZING_DEFAULTS.maxWidth;\n  const maxH = options.maxHeight ?? SIZING_DEFAULTS.maxHeight;\n  const clip = paddedClip(box, minW, maxW, minH, maxH);\n  return {\n    viewport,\n    clip: { x: Math.round(clip.x), y: Math.round(clip.y), width: clip.width, height: clip.height },\n    fullPage: false,\n  };\n}\n\n/** Resolve viewports from project/server config with fallback to default (not sizing, just list). */\nexport function resolveViewports(\n  rawViewports: string | null | undefined,\n  fallback: Viewport[],\n  serverViewports?: Viewport[],\n): Viewport[] {\n  if (serverViewports && serverViewports.length > 0) return serverViewports;\n  if (rawViewports) return parsedViewports(rawViewports) ?? fallback;\n  return fallback;\n}\n\nfunction parsedViewports(raw: string): Viewport[] | null {\n  try {\n    const parsed = JSON.parse(raw) as Viewport[];\n    if (Array.isArray(parsed) && parsed.length > 0) return parsed;\n  } catch {\n    // fallback\n  }\n  return null;\n}\n\n/** Hash infra determinism: browser + viewports + sizing defaults. */\nexport function infraHashFor(\n  browser: string,\n  viewports: Viewport[],\n  defaults: typeof SIZING_DEFAULTS = SIZING_DEFAULTS,\n): string {\n  const payload = JSON.stringify({ browser, viewports, defaults });\n  return sha256(payload);\n}\n"],"mappings":"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"}
+{"version":3,"file":"sizing.mjs","names":[],"sources":["../../src/capture/sizing.ts"],"sourcesContent":["import type { Viewport } from \"./adapter.ts\";\n\n/** Padding around the cropped component (8px each side). */\nconst PAD = 16;\nconst HALF_PAD = 8;\n\n/** Default min/max dimensions for cropped/fullPage screenshots (diff stability). */\nexport const SIZING_DEFAULTS = {\n  minWidth: 100,\n  minHeight: 100,\n  maxWidth: 2000,\n  maxHeight: 4000,\n  whitespaceThreshold: 0.6,\n} as const;\n\n/** Bounding box of #storybook-root as returned by Playwright/Puppeteer. */\nexport interface BoundingBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Options for computing the screenshot plan. */\nexport interface SizingOptions {\n  /** Per-story override: false forces full viewport, true forces crop when possible. */\n  autoCrop?: boolean;\n  /** Whitespace fraction (0..1) above which we crop; default 0.6. */\n  whitespaceThreshold?: number;\n  /** Whether overflow should trigger fullPage; default true. */\n  fullPageOnOverflow?: boolean;\n  /** Min dimensions for the final PNG (clamp after padding). */\n  minWidth?: number;\n  minHeight?: number;\n  /** Max dimensions for the final PNG (clamp after padding). */\n  maxWidth?: number;\n  maxHeight?: number;\n}\n\n/** Result of the sizing decision — what the runner should do. */\nexport interface ScreenshotPlan {\n  /** Viewport to set on the page before capture. */\n  viewport: Viewport;\n  /** Clip to use for page.screenshot({clip}). Undefined means full viewport. */\n  clip?: { x: number; y: number; width: number; height: number };\n  /** Whether to use fullPage screenshot (for overflow). */\n  fullPage: boolean;\n}\n\n/** Clamp value between min and max. */\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.max(min, Math.min(max, value));\n}\n\nfunction isOverflowing(box: BoundingBox, viewport: Viewport): boolean {\n  return box.width > viewport.width || box.height > viewport.height;\n}\n\nfunction whitespaceOf(box: BoundingBox, viewport: Viewport): number {\n  const viewportArea = viewport.width * viewport.height;\n  const boxArea = box.width * box.height;\n  const coverage = viewportArea > 0 ? boxArea / viewportArea : 1;\n  return 1 - Math.min(coverage, 1);\n}\n\nfunction shouldCrop(\n  box: BoundingBox,\n  viewport: Viewport,\n  opts: SizingOptions,\n  threshold: number,\n): boolean {\n  if (opts.autoCrop === true) return true;\n  return whitespaceOf(box, viewport) > threshold;\n}\n\nfunction paddedClip(\n  box: BoundingBox,\n  minW: number,\n  maxW: number,\n  minH: number,\n  maxH: number,\n): BoundingBox {\n  const w = clamp(Math.ceil(box.width + PAD), minW, maxW);\n  const h = clamp(Math.ceil(box.height + PAD), minH, maxH);\n  return {\n    x: Math.max(0, box.x - HALF_PAD),\n    y: Math.max(0, box.y - HALF_PAD),\n    width: w,\n    height: h,\n  };\n}\n\n/**\n * Compute the screenshot plan for a single story×viewport.\n * Single prod owner for sizing logic — runners import this, never duplicate.\n */\nexport function getScreenshotPlan(\n  viewport: Viewport,\n  box: BoundingBox | null,\n  options: SizingOptions = {},\n): ScreenshotPlan {\n  if (options.autoCrop === false) return { viewport, fullPage: false };\n  if (!box) return { viewport, fullPage: false };\n  if (isOverflowing(box, viewport) && (options.fullPageOnOverflow ?? true)) {\n    return { viewport, fullPage: true };\n  }\n  if (isOverflowing(box, viewport)) {\n    return grownViewportPlan(viewport, box, options);\n  }\n  return maybeCroppedPlan(viewport, box, options);\n}\n\nfunction grownViewportPlan(\n  viewport: Viewport,\n  box: BoundingBox,\n  options: SizingOptions,\n): ScreenshotPlan {\n  const maxH = options.maxHeight ?? SIZING_DEFAULTS.maxHeight;\n  const grownHeight = clamp(Math.ceil(box.height + PAD), viewport.height, maxH);\n  return { viewport: { ...viewport, height: grownHeight }, fullPage: false };\n}\n\nfunction maybeCroppedPlan(\n  viewport: Viewport,\n  box: BoundingBox,\n  options: SizingOptions,\n): ScreenshotPlan {\n  const threshold = options.whitespaceThreshold ?? SIZING_DEFAULTS.whitespaceThreshold;\n  if (!shouldCrop(box, viewport, options, threshold)) return { viewport, fullPage: false };\n  const minW = options.minWidth ?? SIZING_DEFAULTS.minWidth;\n  const minH = options.minHeight ?? SIZING_DEFAULTS.minHeight;\n  const maxW = options.maxWidth ?? SIZING_DEFAULTS.maxWidth;\n  const maxH = options.maxHeight ?? SIZING_DEFAULTS.maxHeight;\n  const clip = paddedClip(box, minW, maxW, minH, maxH);\n  return {\n    viewport,\n    clip: { x: Math.round(clip.x), y: Math.round(clip.y), width: clip.width, height: clip.height },\n    fullPage: false,\n  };\n}\n\n/** Resolve viewports from project/server config with fallback to default (not sizing, just list). */\nexport function resolveViewports(\n  rawViewports: string | null | undefined,\n  fallback: Viewport[],\n  serverViewports?: Viewport[],\n): Viewport[] {\n  if (serverViewports && serverViewports.length > 0) return serverViewports;\n  if (rawViewports) return parsedViewports(rawViewports) ?? fallback;\n  return fallback;\n}\n\nfunction parsedViewports(raw: string): Viewport[] | null {\n  try {\n    const parsed = JSON.parse(raw) as Viewport[];\n    if (Array.isArray(parsed) && parsed.length > 0) return parsed;\n  } catch {\n    // fallback\n  }\n  return null;\n}\n"],"mappings":"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"}

package/dist/capture/skip-checks.mjs

@@ -2,75 +2,12 @@ import "node:path";
 import "node:url";
 import.meta.url;
 import { BuildModel } from "../models/build.mjs";
-import { StatusConfigModel } from "../models/status-config.mjs";
 //#region src/capture/skip-checks.ts
 /** Skip capture when another approved build already covers the same commit. */
 async function hasApprovedBuildForSha(db, tables, projectId, sha, excludeBuildId) {
-	return (await new BuildModel(db, tables).list(projectId)).some((b) => b.gitSha === sha && b.id !== excludeBuildId && b.status === "approved");
-}
-function findRowProvider(providers, row) {
-	return providers.find((p) => p.metadata.kind === row.provider);
-}
-function decodeRowConfig(provider, configJson) {
-	try {
-		const parsed = JSON.parse(configJson);
-		provider.metadata.schema.parse(parsed);
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-function decodeRowToken(model, row) {
-	try {
-		return model.decryptToken(row);
-	} catch {
-		return null;
-	}
-}
-function parseRow(model, row, providers) {
-	const provider = findRowProvider(providers, row);
-	if (!provider) return null;
-	const parsed = decodeRowConfig(provider, row.config);
-	if (parsed === null) return null;
-	const token = decodeRowToken(model, row);
-	if (token === null) return null;
-	return {
-		provider,
-		config: parsed,
-		token
-	};
-}
-async function checkRowMerged(parsed, sha, branch, logger) {
-	const adapter = parsed.provider.create({
-		config: parsed.config,
-		token: parsed.token,
-		logger
-	});
-	if (!adapter.isMerged) return false;
-	try {
-		return await adapter.isMerged({
-			sha,
-			branch
-		});
-	} catch {
-		return false;
-	}
-}
-/** Check one status-config row for an upstream merge. */
-async function checkRow(model, row, providers, sha, branch, logger) {
-	const parsed = parseRow(model, row, providers);
-	if (!parsed) return false;
-	return await checkRowMerged(parsed, sha, branch, logger);
-}
-/** True when any configured provider reports the commit already merged. */
-async function isAlreadyMerged(opts) {
-	if (opts.providers.length === 0) return false;
-	const model = new StatusConfigModel(opts.db, opts.tables, opts.secret);
-	const rows = await model.list(opts.projectId);
-	for (const row of rows) if (await checkRow(model, row, opts.providers, opts.sha, opts.branch, opts.logger)) return true;
-	return false;
+	return (await new BuildModel(db, tables).list(projectId, { status: "approved" })).some((build) => build.gitSha === sha && build.id !== excludeBuildId);
 }
 //#endregion
-export { hasApprovedBuildForSha, isAlreadyMerged };
+export { hasApprovedBuildForSha };
 
 //# sourceMappingURL=skip-checks.mjs.map