@storyshelf/core 0.6.1 → 0.7.0

package/dist/capture/publish/run.mjs

@@ -0,0 +1,30 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { removeShardScratch } from "../scratch.mjs";
+import { extractStorybookToScratch, persistStorybookStatics } from "../statics.mjs";
+//#region src/capture/publish/run.ts
+/** Scratch id publishing uses, so it never shares a directory with the build's capture. */
+const PUBLISH_SCRATCH_ID = "publish";
+/**
+* Extract `storybook.zip` of a build and persist its statics. The manifest is written last, so a
+* build serves only once complete and a repeat run rewrites the same keys.
+*
+* @throws {ZipLimitError} When the zip breaks a cap or tries to escape the target.
+*/
+async function publishStoredZip(options, target) {
+	const { storage, scratchDir, logger } = options;
+	const { projectId, buildId } = target;
+	try {
+		const dir = await extractStorybookToScratch(storage, scratchDir, projectId, buildId, PUBLISH_SCRATCH_ID, options.limits);
+		options.touch?.();
+		await persistStorybookStatics(storage, dir, projectId, buildId, options.db);
+		options.touch?.();
+	} finally {
+		await removeShardScratch(scratchDir, projectId, buildId, PUBLISH_SCRATCH_ID, logger);
+	}
+}
+//#endregion
+export { PUBLISH_SCRATCH_ID, publishStoredZip };
+
+//# sourceMappingURL=run.mjs.map

package/dist/capture/publish/run.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.mjs","names":[],"sources":["../../../src/capture/publish/run.ts"],"sourcesContent":["/** Publish a build's stored zip: extract with the caps, persist statics and manifest, clean the scratch. */\nimport type { DatabaseAdapter } from \"../../adapters/database.ts\";\nimport type { StorageAdapter } from \"../../adapters/storage.ts\";\nimport type { Logger } from \"../../logger.ts\";\nimport { removeShardScratch } from \"../scratch.ts\";\nimport { extractStorybookToScratch, persistStorybookStatics } from \"../statics.ts\";\nimport type { ExtractionLimits } from \"./limits.ts\";\n\n/** Scratch id publishing uses, so it never shares a directory with the build's capture. */\nexport const PUBLISH_SCRATCH_ID = \"publish\";\n\n/** What {@link publishStoredZip} works with. */\nexport interface PublishZipOptions {\n  storage: StorageAdapter;\n  scratchDir: string;\n  limits: ExtractionLimits;\n  /** Records the persisted content in `content_refs`, so retention knows who still uses it. */\n  db?: DatabaseAdapter | undefined;\n  logger: Logger;\n  /** Called between stages (renews a job's lease). */\n  touch?: () => void;\n}\n\n/**\n * Extract `storybook.zip` of a build and persist its statics. The manifest is written last, so a\n * build serves only once complete and a repeat run rewrites the same keys.\n *\n * @throws {ZipLimitError} When the zip breaks a cap or tries to escape the target.\n */\nexport async function publishStoredZip(\n  options: PublishZipOptions,\n  target: { projectId: string; buildId: string },\n): Promise<void> {\n  const { storage, scratchDir, logger } = options;\n  const { projectId, buildId } = target;\n  try {\n    const dir = await extractStorybookToScratch(\n      storage,\n      scratchDir,\n      projectId,\n      buildId,\n      PUBLISH_SCRATCH_ID,\n      options.limits,\n    );\n    options.touch?.();\n    await persistStorybookStatics(storage, dir, projectId, buildId, options.db);\n    options.touch?.();\n  } finally {\n    await removeShardScratch(scratchDir, projectId, buildId, PUBLISH_SCRATCH_ID, logger);\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAa,qBAAqB;;;;;;;AAoBlC,eAAsB,iBACpB,SACA,QACe;CACf,MAAM,EAAE,SAAS,YAAY,WAAW;CACxC,MAAM,EAAE,WAAW,YAAY;CAC/B,IAAI;EACF,MAAM,MAAM,MAAM,0BAChB,SACA,YACA,WACA,SACA,oBACA,QAAQ,MACV;EACA,QAAQ,QAAQ;EAChB,MAAM,wBAAwB,SAAS,KAAK,WAAW,SAAS,QAAQ,EAAE;EAC1E,QAAQ,QAAQ;CAClB,UAAU;EACR,MAAM,mBAAmB,YAAY,WAAW,SAAS,oBAAoB,MAAM;CACrF;AACF"}

package/dist/capture/rediff.d.mts

@@ -1,8 +1,8 @@
 import __tsdown_shims_path from 'node:path';
 import __tsdown_shims_url from 'node:url';
 import { DatabaseAdapter } from "../adapter/database.mjs";
-import { StorageAdapter } from "../adapter/storage.mjs";
 import { Logger } from "../logger.mjs";
+import { StorageAdapter } from "../adapter/storage.mjs";
 import { Build } from "../schema/build.mjs";
 import { Project } from "../schema/project.mjs";
 //#region src/capture/rediff.d.ts

package/dist/capture/rediff.mjs

@@ -5,6 +5,7 @@ import { diffPath } from "../paths.mjs";
 import { BaselineModel } from "../models/baseline.mjs";
 import { NO_BASELINE } from "../models/baseline-status.mjs";
 import { SnapshotModel } from "../models/snapshot.mjs";
+import { mapLimit } from "../utils/map-limit.mjs";
 import { diffStoredScreenshots, writeDiffOverlay } from "./diff-record.mjs";
 import { diffStatus } from "./pipeline.mjs";
 //#region src/capture/rediff.ts
@@ -27,7 +28,7 @@ const REDIFFABLE_SNAPSHOT_STATUSES = /* @__PURE__ */ new Set([
 */
 async function rediffBuild(deps, project, build) {
 	const rows = (await new SnapshotModel(deps.db).listByBuild(build.id)).filter((row) => !row.inherited && REDIFFABLE_SNAPSHOT_STATUSES.has(row.status));
-	const outcomes = await Promise.all(rows.map(async (row) => await rediffSnapshot(deps, project, build, row)));
+	const outcomes = await mapLimit(rows, 4, async (row) => await rediffSnapshot(deps, project, build, row));
 	const result = {
 		rediffed: outcomes.filter((outcome) => outcome !== "missing").length,
 		statusChanged: outcomes.filter((outcome) => outcome === "changed").length,
@@ -41,7 +42,7 @@ async function rediffBuild(deps, project, build) {
 }
 async function rediffSnapshot(deps, project, build, row) {
 	if (!await deps.storage.exists(row.screenshotPath)) return "missing";
-	const baseline = await new BaselineModel(deps.db).resolve(project.id, row.storyId, row.viewportName, build.gitBranch, project.gitDefaultBranch);
+	const baseline = await new BaselineModel(deps.db).resolve(project.id, row.storyId, row.viewportName, build.gitBranch, project.gitDefaultBranch, row.browser);
 	const patch = baseline ? await diffPatch(deps, project, build, row, baseline) : noBaselinePatch();
 	await new SnapshotModel(deps.db).update(row.id, patch);
 	return patch.status === row.status ? "same" : "changed";
@@ -59,7 +60,7 @@ function noBaselinePatch() {
 }
 async function diffPatch(deps, project, build, row, baseline) {
 	const result = await diffStoredScreenshots(deps.storage, project, baseline.screenshotPath, row.screenshotPath);
-	const target = diffPath(project.id, build.id, row.storyId, row.viewportName);
+	const target = diffPath(project.id, build.id, row.storyId, row.viewportName, row.browser);
 	const overlay = await writeDiffOverlay(deps.storage, target, result, result.passed);
 	return {
 		status: diffStatus(result.passed, false),

package/dist/capture/rediff.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rediff.mjs","names":[],"sources":["../../src/capture/rediff.ts"],"sourcesContent":["/** Recompute a build's diffs against the baselines that apply now, without re-rendering. */\nimport type { DatabaseAdapter } from \"../adapters/database.ts\";\nimport type { StorageAdapter } from \"../adapters/storage.ts\";\nimport type { Logger } from \"../logger.ts\";\nimport { NO_BASELINE } from \"../models/baseline-status.ts\";\nimport { BaselineModel } from \"../models/baseline.ts\";\nimport { SnapshotModel } from \"../models/snapshot.ts\";\nimport type { Baseline } from \"../schema/baseline.ts\";\nimport type { Build } from \"../schema/build.ts\";\nimport type { Project } from \"../schema/project.ts\";\nimport type { Snapshot } from \"../schema/snapshot.ts\";\nimport { diffPath } from \"../utils/paths.ts\";\nimport { diffStoredScreenshots, writeDiffOverlay } from \"./diff-record.ts\";\nimport { diffStatus } from \"./pipeline.ts\";\n\n/** Dependencies for {@link rediffBuild}. */\nexport interface RediffDeps {\n  db: DatabaseAdapter;\n  storage: StorageAdapter;\n  logger?: Logger;\n}\n\n/** Outcome of a re-diff run. */\nexport interface RediffResult {\n  /** Snapshots diffed against their current baseline. */\n  rediffed: number;\n  /** Snapshots whose status changed (for example `changed` to `unchanged`). */\n  statusChanged: number;\n  /** Snapshot ids skipped because their stored screenshot is gone. */\n  missingScreenshots: string[];\n}\n\n/** Build statuses a re-diff may run in; earlier or failed builds have no complete snapshot set. */\nexport const REDIFFABLE_BUILD_STATUSES: ReadonlySet<string> = new Set([\n  \"reviewing\",\n  \"approved\",\n  \"rejected\",\n]);\n\nconst REDIFFABLE_SNAPSHOT_STATUSES: ReadonlySet<string> = new Set([\"new\", \"changed\", \"unchanged\"]);\n\n/**\n * Re-diff the build's undecided snapshots against the baselines that apply today.\n *\n * Approved and rejected snapshots are decisions and stay untouched; inherited snapshots were never\n * rendered. The caller refreshes the build rollup afterwards.\n */\nexport async function rediffBuild(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n): Promise<RediffResult> {\n  const snapshots = new SnapshotModel(deps.db);\n  const rows = (await snapshots.listByBuild(build.id)).filter(\n    (row) => !row.inherited && REDIFFABLE_SNAPSHOT_STATUSES.has(row.status),\n  );\n  const outcomes = await Promise.all(\n    rows.map(async (row) => await rediffSnapshot(deps, project, build, row)),\n  );\n  const result: RediffResult = {\n    rediffed: outcomes.filter((outcome) => outcome !== \"missing\").length,\n    statusChanged: outcomes.filter((outcome) => outcome === \"changed\").length,\n    missingScreenshots: rows\n      .filter((_row, index) => outcomes[index] === \"missing\")\n      .map((row) => row.id),\n  };\n  deps.logger?.info({ buildId: build.id, ...result }, \"build re-diffed against current baselines\");\n  return result;\n}\n\ntype Outcome = \"same\" | \"changed\" | \"missing\";\n\nasync function rediffSnapshot(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n  row: Snapshot,\n): Promise<Outcome> {\n  if (!(await deps.storage.exists(row.screenshotPath))) {\n    return \"missing\";\n  }\n  const baseline = await new BaselineModel(deps.db).resolve(\n    project.id,\n    row.storyId,\n    row.viewportName,\n    build.gitBranch,\n    project.gitDefaultBranch,\n  );\n  const patch = baseline ? await diffPatch(deps, project, build, row, baseline) : noBaselinePatch();\n  await new SnapshotModel(deps.db).update(row.id, patch);\n  return patch.status === row.status ? \"same\" : \"changed\";\n}\n\nfunction noBaselinePatch(): Partial<Snapshot> {\n  return {\n    status: \"new\",\n    diffPath: null,\n    diffPixels: null,\n    diffRatio: null,\n    diffPassed: null,\n    baselineId: null,\n    baselineVersion: NO_BASELINE,\n  };\n}\n\nasync function diffPatch(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n  row: Snapshot,\n  baseline: Baseline,\n): Promise<Partial<Snapshot>> {\n  const result = await diffStoredScreenshots(\n    deps.storage,\n    project,\n    baseline.screenshotPath,\n    row.screenshotPath,\n  );\n  const target = diffPath(project.id, build.id, row.storyId, row.viewportName);\n  const overlay = await writeDiffOverlay(deps.storage, target, result, result.passed);\n  return {\n    status: diffStatus(result.passed, false),\n    diffPath: overlay,\n    diffPixels: result.diffPixels,\n    diffRatio: result.diffRatio,\n    diffPassed: result.passed,\n    baselineId: baseline.id,\n    baselineVersion: baseline.updatedAt,\n  };\n}\n"],"mappings":";;;;;;;;;;;AAiCA,MAAa,4CAAiD,IAAI,IAAI;CACpE;CACA;CACA;AACF,CAAC;AAED,MAAM,+CAAoD,IAAI,IAAI;CAAC;CAAO;CAAW;AAAW,CAAC;;;;;;;AAQjG,eAAsB,YACpB,MACA,SACA,OACuB;CAEvB,MAAM,QAAQ,MAAM,IADE,cAAc,KAAK,EACb,CAAC,CAAC,YAAY,MAAM,EAAE,EAAA,CAAG,QAClD,QAAQ,CAAC,IAAI,aAAa,6BAA6B,IAAI,IAAI,MAAM,CACxE;CACA,MAAM,WAAW,MAAM,QAAQ,IAC7B,KAAK,IAAI,OAAO,QAAQ,MAAM,eAAe,MAAM,SAAS,OAAO,GAAG,CAAC,CACzE;CACA,MAAM,SAAuB;EAC3B,UAAU,SAAS,QAAQ,YAAY,YAAY,SAAS,CAAC,CAAC;EAC9D,eAAe,SAAS,QAAQ,YAAY,YAAY,SAAS,CAAC,CAAC;EACnE,oBAAoB,KACjB,QAAQ,MAAM,UAAU,SAAS,WAAW,SAAS,CAAC,CACtD,KAAK,QAAQ,IAAI,EAAE;CACxB;CACA,KAAK,QAAQ,KAAK;EAAE,SAAS,MAAM;EAAI,GAAG;CAAO,GAAG,2CAA2C;CAC/F,OAAO;AACT;AAIA,eAAe,eACb,MACA,SACA,OACA,KACkB;CAClB,IAAI,CAAE,MAAM,KAAK,QAAQ,OAAO,IAAI,cAAc,GAChD,OAAO;CAET,MAAM,WAAW,MAAM,IAAI,cAAc,KAAK,EAAE,CAAC,CAAC,QAChD,QAAQ,IACR,IAAI,SACJ,IAAI,cACJ,MAAM,WACN,QAAQ,gBACV;CACA,MAAM,QAAQ,WAAW,MAAM,UAAU,MAAM,SAAS,OAAO,KAAK,QAAQ,IAAI,gBAAgB;CAChG,MAAM,IAAI,cAAc,KAAK,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI,KAAK;CACrD,OAAO,MAAM,WAAW,IAAI,SAAS,SAAS;AAChD;AAEA,SAAS,kBAAqC;CAC5C,OAAO;EACL,QAAQ;EACR,UAAU;EACV,YAAY;EACZ,WAAW;EACX,YAAY;EACZ,YAAY;EACZ,iBAAiB;CACnB;AACF;AAEA,eAAe,UACb,MACA,SACA,OACA,KACA,UAC4B;CAC5B,MAAM,SAAS,MAAM,sBACnB,KAAK,SACL,SACA,SAAS,gBACT,IAAI,cACN;CACA,MAAM,SAAS,SAAS,QAAQ,IAAI,MAAM,IAAI,IAAI,SAAS,IAAI,YAAY;CAC3E,MAAM,UAAU,MAAM,iBAAiB,KAAK,SAAS,QAAQ,QAAQ,OAAO,MAAM;CAClF,OAAO;EACL,QAAQ,WAAW,OAAO,QAAQ,KAAK;EACvC,UAAU;EACV,YAAY,OAAO;EACnB,WAAW,OAAO;EAClB,YAAY,OAAO;EACnB,YAAY,SAAS;EACrB,iBAAiB,SAAS;CAC5B;AACF"}
+{"version":3,"file":"rediff.mjs","names":[],"sources":["../../src/capture/rediff.ts"],"sourcesContent":["/** Recompute a build's diffs against the baselines that apply now, without re-rendering. */\nimport type { DatabaseAdapter } from \"../adapters/database.ts\";\nimport type { StorageAdapter } from \"../adapters/storage.ts\";\nimport type { Logger } from \"../logger.ts\";\nimport { NO_BASELINE } from \"../models/baseline-status.ts\";\nimport { BaselineModel } from \"../models/baseline.ts\";\nimport { SnapshotModel } from \"../models/snapshot.ts\";\nimport type { Baseline } from \"../schema/baseline.ts\";\nimport type { Build } from \"../schema/build.ts\";\nimport type { Project } from \"../schema/project.ts\";\nimport type { Snapshot } from \"../schema/snapshot.ts\";\nimport { mapLimit } from \"../utils/map-limit.ts\";\nimport { diffPath } from \"../utils/paths.ts\";\nimport { diffStoredScreenshots, writeDiffOverlay } from \"./diff-record.ts\";\nimport { diffStatus, PERSIST_CONCURRENCY } from \"./pipeline.ts\";\n\n/** Dependencies for {@link rediffBuild}. */\nexport interface RediffDeps {\n  db: DatabaseAdapter;\n  storage: StorageAdapter;\n  logger?: Logger;\n}\n\n/** Outcome of a re-diff run. */\nexport interface RediffResult {\n  /** Snapshots diffed against their current baseline. */\n  rediffed: number;\n  /** Snapshots whose status changed (for example `changed` to `unchanged`). */\n  statusChanged: number;\n  /** Snapshot ids skipped because their stored screenshot is gone. */\n  missingScreenshots: string[];\n}\n\n/** Build statuses a re-diff may run in; earlier or failed builds have no complete snapshot set. */\nexport const REDIFFABLE_BUILD_STATUSES: ReadonlySet<string> = new Set([\n  \"reviewing\",\n  \"approved\",\n  \"rejected\",\n]);\n\nconst REDIFFABLE_SNAPSHOT_STATUSES: ReadonlySet<string> = new Set([\"new\", \"changed\", \"unchanged\"]);\n\n/**\n * Re-diff the build's undecided snapshots against the baselines that apply today.\n *\n * Approved and rejected snapshots are decisions and stay untouched; inherited snapshots were never\n * rendered. The caller refreshes the build rollup afterwards.\n */\nexport async function rediffBuild(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n): Promise<RediffResult> {\n  const snapshots = new SnapshotModel(deps.db);\n  const rows = (await snapshots.listByBuild(build.id)).filter(\n    (row) => !row.inherited && REDIFFABLE_SNAPSHOT_STATUSES.has(row.status),\n  );\n  const outcomes = await mapLimit(\n    rows,\n    PERSIST_CONCURRENCY,\n    async (row) => await rediffSnapshot(deps, project, build, row),\n  );\n  const result: RediffResult = {\n    rediffed: outcomes.filter((outcome) => outcome !== \"missing\").length,\n    statusChanged: outcomes.filter((outcome) => outcome === \"changed\").length,\n    missingScreenshots: rows\n      .filter((_row, index) => outcomes[index] === \"missing\")\n      .map((row) => row.id),\n  };\n  deps.logger?.info({ buildId: build.id, ...result }, \"build re-diffed against current baselines\");\n  return result;\n}\n\ntype Outcome = \"same\" | \"changed\" | \"missing\";\n\nasync function rediffSnapshot(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n  row: Snapshot,\n): Promise<Outcome> {\n  if (!(await deps.storage.exists(row.screenshotPath))) {\n    return \"missing\";\n  }\n  const baseline = await new BaselineModel(deps.db).resolve(\n    project.id,\n    row.storyId,\n    row.viewportName,\n    build.gitBranch,\n    project.gitDefaultBranch,\n    row.browser,\n  );\n  const patch = baseline ? await diffPatch(deps, project, build, row, baseline) : noBaselinePatch();\n  await new SnapshotModel(deps.db).update(row.id, patch);\n  return patch.status === row.status ? \"same\" : \"changed\";\n}\n\nfunction noBaselinePatch(): Partial<Snapshot> {\n  return {\n    status: \"new\",\n    diffPath: null,\n    diffPixels: null,\n    diffRatio: null,\n    diffPassed: null,\n    baselineId: null,\n    baselineVersion: NO_BASELINE,\n  };\n}\n\nasync function diffPatch(\n  deps: RediffDeps,\n  project: Project,\n  build: Build,\n  row: Snapshot,\n  baseline: Baseline,\n): Promise<Partial<Snapshot>> {\n  const result = await diffStoredScreenshots(\n    deps.storage,\n    project,\n    baseline.screenshotPath,\n    row.screenshotPath,\n  );\n  const target = diffPath(project.id, build.id, row.storyId, row.viewportName, row.browser);\n  const overlay = await writeDiffOverlay(deps.storage, target, result, result.passed);\n  return {\n    status: diffStatus(result.passed, false),\n    diffPath: overlay,\n    diffPixels: result.diffPixels,\n    diffRatio: result.diffRatio,\n    diffPassed: result.passed,\n    baselineId: baseline.id,\n    baselineVersion: baseline.updatedAt,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,MAAa,4CAAiD,IAAI,IAAI;CACpE;CACA;CACA;AACF,CAAC;AAED,MAAM,+CAAoD,IAAI,IAAI;CAAC;CAAO;CAAW;AAAW,CAAC;;;;;;;AAQjG,eAAsB,YACpB,MACA,SACA,OACuB;CAEvB,MAAM,QAAQ,MAAM,IADE,cAAc,KAAK,EACb,CAAC,CAAC,YAAY,MAAM,EAAE,EAAA,CAAG,QAClD,QAAQ,CAAC,IAAI,aAAa,6BAA6B,IAAI,IAAI,MAAM,CACxE;CACA,MAAM,WAAW,MAAM,SACrB,MAAA,GAEA,OAAO,QAAQ,MAAM,eAAe,MAAM,SAAS,OAAO,GAAG,CAC/D;CACA,MAAM,SAAuB;EAC3B,UAAU,SAAS,QAAQ,YAAY,YAAY,SAAS,CAAC,CAAC;EAC9D,eAAe,SAAS,QAAQ,YAAY,YAAY,SAAS,CAAC,CAAC;EACnE,oBAAoB,KACjB,QAAQ,MAAM,UAAU,SAAS,WAAW,SAAS,CAAC,CACtD,KAAK,QAAQ,IAAI,EAAE;CACxB;CACA,KAAK,QAAQ,KAAK;EAAE,SAAS,MAAM;EAAI,GAAG;CAAO,GAAG,2CAA2C;CAC/F,OAAO;AACT;AAIA,eAAe,eACb,MACA,SACA,OACA,KACkB;CAClB,IAAI,CAAE,MAAM,KAAK,QAAQ,OAAO,IAAI,cAAc,GAChD,OAAO;CAET,MAAM,WAAW,MAAM,IAAI,cAAc,KAAK,EAAE,CAAC,CAAC,QAChD,QAAQ,IACR,IAAI,SACJ,IAAI,cACJ,MAAM,WACN,QAAQ,kBACR,IAAI,OACN;CACA,MAAM,QAAQ,WAAW,MAAM,UAAU,MAAM,SAAS,OAAO,KAAK,QAAQ,IAAI,gBAAgB;CAChG,MAAM,IAAI,cAAc,KAAK,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI,KAAK;CACrD,OAAO,MAAM,WAAW,IAAI,SAAS,SAAS;AAChD;AAEA,SAAS,kBAAqC;CAC5C,OAAO;EACL,QAAQ;EACR,UAAU;EACV,YAAY;EACZ,WAAW;EACX,YAAY;EACZ,YAAY;EACZ,iBAAiB;CACnB;AACF;AAEA,eAAe,UACb,MACA,SACA,OACA,KACA,UAC4B;CAC5B,MAAM,SAAS,MAAM,sBACnB,KAAK,SACL,SACA,SAAS,gBACT,IAAI,cACN;CACA,MAAM,SAAS,SAAS,QAAQ,IAAI,MAAM,IAAI,IAAI,SAAS,IAAI,cAAc,IAAI,OAAO;CACxF,MAAM,UAAU,MAAM,iBAAiB,KAAK,SAAS,QAAQ,QAAQ,OAAO,MAAM;CAClF,OAAO;EACL,QAAQ,WAAW,OAAO,QAAQ,KAAK;EACvC,UAAU;EACV,YAAY,OAAO;EACnB,WAAW,OAAO;EAClB,YAAY,OAAO;EACnB,YAAY,SAAS;EACrB,iBAAiB,SAAS;CAC5B;AACF"}

package/dist/capture/render.mjs

@@ -0,0 +1,53 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import "../utils/storybook-token.mjs";
+import { redactSecrets } from "../utils/redact.mjs";
+//#region src/capture/render.ts
+/** Default budget for one render call before the orchestrator cancels it. */
+const RENDER_TIMEOUT_MS = 9e5;
+/**
+* Budget for one render call: an explicit setting wins; otherwise the default
+* floor, raised to a per-capture allowance for large matrices. Bounded page
+* concurrency on small hosts makes big builds legitimately take longer than 15 minutes.
+*/
+function renderBudgetMs(captureCount, explicitMs) {
+	return explicitMs ?? Math.max(9e5, captureCount * 15e3);
+}
+/** Failure error text cap (persisted rows and logs stay bounded). */
+const FAILURE_ERROR_MAX = 500;
+/** Cap failure error text so one chatty runner cannot flood rows and logs. */
+function capFailures(result) {
+	return {
+		...result,
+		captures: result.captures,
+		failures: result.failures.map((failure) => ({
+			...failure,
+			error: redactSecrets(failure.error).slice(0, FAILURE_ERROR_MAX)
+		}))
+	};
+}
+/** Render with a timeout; cancels the runner when the budget expires. */
+async function renderWithTimeout(runner, request, timeoutMs) {
+	let timedOut = false;
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			timedOut = true;
+			reject(/* @__PURE__ */ new Error(`Render timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	timer?.unref?.();
+	try {
+		return capFailures(await Promise.race([runner.render(request), timeout]));
+	} catch (error) {
+		if (timedOut) await runner.cancel(request.buildId, request.runId).catch(() => {});
+		throw error;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+export { RENDER_TIMEOUT_MS, renderBudgetMs, renderWithTimeout };
+
+//# sourceMappingURL=render.mjs.map

package/dist/capture/render.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.mjs","names":[],"sources":["../../src/capture/render.ts"],"sourcesContent":["/** Render one engine's pass with a budget; shared by the orchestrator's browser loop. */\nimport type { Logger } from \"pino\";\nimport type {\n  CaptureTarget,\n  CaptureRunner,\n  RenderResult,\n  RenderedSnapshot,\n} from \"../adapters/capture-runner.ts\";\nimport { redactSecrets } from \"../utils/redact.ts\";\nimport { PER_CAPTURE_BUDGET_MS } from \"../utils/storybook-token.ts\";\n\n/** Default budget for one render call before the orchestrator cancels it. */\nexport const RENDER_TIMEOUT_MS = 15 * 60_000;\n\n/**\n * Budget for one render call: an explicit setting wins; otherwise the default\n * floor, raised to a per-capture allowance for large matrices. Bounded page\n * concurrency on small hosts makes big builds legitimately take longer than 15 minutes.\n */\nexport function renderBudgetMs(captureCount: number, explicitMs?: number): number {\n  return explicitMs ?? Math.max(RENDER_TIMEOUT_MS, captureCount * PER_CAPTURE_BUDGET_MS);\n}\n\n/** Failure error text cap (persisted rows and logs stay bounded). */\nconst FAILURE_ERROR_MAX = 500;\n\n/** Render input assembled by the orchestrator for one build. */\nexport interface RenderRequest {\n  buildId: string;\n  /** This render's cancel handle within the build (see `CaptureRunner.render`). */\n  runId?: string | undefined;\n  storybookDir: string;\n  stories: Parameters<CaptureRunner[\"render\"]>[0][\"stories\"];\n  viewports: Parameters<CaptureRunner[\"render\"]>[0][\"viewports\"];\n  logger: Logger | undefined;\n  executePlay: boolean;\n  playTimeoutMs: number;\n  runA11y: boolean;\n  target: CaptureTarget;\n  /** The signed URL a `reach: \"url\"` target opens (never logged); absent for every other target. */\n  storybookUrl?: string | undefined;\n  onCapture?: (capture: RenderedSnapshot) => Promise<void>;\n}\n\n/** Cap failure error text so one chatty runner cannot flood rows and logs. */\nfunction capFailures(result: RenderResult): RenderResult {\n  return {\n    ...result,\n    captures: result.captures,\n    failures: result.failures.map((failure) => ({\n      ...failure,\n      // A runner's error can quote the URL it failed to open, which carries a signed token.\n      error: redactSecrets(failure.error).slice(0, FAILURE_ERROR_MAX),\n    })),\n  };\n}\n\n/** Render with a timeout; cancels the runner when the budget expires. */\nexport async function renderWithTimeout(\n  runner: CaptureRunner,\n  request: RenderRequest,\n  timeoutMs: number,\n): Promise<RenderResult> {\n  let timedOut = false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const timeout = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => {\n      timedOut = true;\n      reject(new Error(`Render timed out after ${timeoutMs}ms`));\n    }, timeoutMs);\n  });\n  timer?.unref?.();\n  try {\n    return capFailures(await Promise.race([runner.render(request), timeout]));\n  } catch (error) {\n    if (timedOut) {\n      // Only this render: a sibling shard of the same build may be rendering in this process.\n      await runner.cancel(request.buildId, request.runId).catch(() => {});\n    }\n    throw error;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"],"mappings":";;;;;;;AAYA,MAAa,oBAAoB;;;;;;AAOjC,SAAgB,eAAe,cAAsB,YAA6B;CAChF,OAAO,cAAc,KAAK,IAAA,KAAuB,eAAA,IAAoC;AACvF;;AAGA,MAAM,oBAAoB;;AAqB1B,SAAS,YAAY,QAAoC;CACvD,OAAO;EACL,GAAG;EACH,UAAU,OAAO;EACjB,UAAU,OAAO,SAAS,KAAK,aAAa;GAC1C,GAAG;GAEH,OAAO,cAAc,QAAQ,KAAK,CAAC,CAAC,MAAM,GAAG,iBAAiB;EAChE,EAAE;CACJ;AACF;;AAGA,eAAsB,kBACpB,QACA,SACA,WACuB;CACvB,IAAI,WAAW;CACf,IAAI;CACJ,MAAM,UAAU,IAAI,SAAgB,GAAG,WAAW;EAChD,QAAQ,iBAAiB;GACvB,WAAW;GACX,uBAAO,IAAI,MAAM,0BAA0B,UAAU,GAAG,CAAC;EAC3D,GAAG,SAAS;CACd,CAAC;CACD,OAAO,QAAQ;CACf,IAAI;EACF,OAAO,YAAY,MAAM,QAAQ,KAAK,CAAC,OAAO,OAAO,OAAO,GAAG,OAAO,CAAC,CAAC;CAC1E,SAAS,OAAO;EACd,IAAI,UAEF,MAAM,OAAO,OAAO,QAAQ,SAAS,QAAQ,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC;EAEpE,MAAM;CACR,UAAU;EACR,aAAa,KAAK;CACpB;AACF"}

package/dist/capture/scratch.d.mts

@@ -0,0 +1,44 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Logger } from "../logger.mjs";
+//#region src/capture/scratch.d.ts
+/**
+ * Subtree of `scratchDir` that holds extracted Storybooks.
+ *
+ * `scratchDir` is often also the local storage root (dev server, generated servers), where
+ * `<project>/builds/<build>/...` holds screenshots and published statics. Keeping scratch in its
+ * own subtree means removing it can never touch a storage key.
+ */
+declare const SCRATCH_DIRNAME = ".storyshelf-scratch";
+/** Scratch dirs untouched for this long are assumed orphaned by a crash (no capture runs this long). */
+declare const SCRATCH_MAX_AGE_MS: number;
+/** Scratch directory owned by one build: `<scratchDir>/.storyshelf-scratch/<projectId>/<buildId>`. */
+declare function buildScratchDir(scratchDir: string, projectId: string, buildId: string): string;
+/**
+ * Remove the scratch of the build's own job (the plan, or the whole build when it is not sharded)
+ * and the build directory too if nothing else is left in it.
+ *
+ * Shards live in their own `shards/` directory beside `job/`, so this can never reach one: the plan
+ * hands its shards to the queue before it cleans up, and a worker may already be extracting.
+ */
+declare function removeJobScratch(scratchDir: string, projectId: string, buildId: string, logger?: Logger): Promise<void>;
+/** Remove a build's scratch directory. Best effort: a failure is logged, never thrown. */
+declare function removeBuildScratch(scratchDir: string, projectId: string, buildId: string, logger?: Logger): Promise<void>;
+/** Options for {@link sweepOrphanedScratch}. */
+interface ScratchSweepOptions {
+  /** Remove build scratch dirs not modified for this long (default {@link SCRATCH_MAX_AGE_MS}). */
+  maxAgeMs?: number;
+  /** Clock override for tests. */
+  now?: number;
+  logger?: Logger;
+}
+/**
+ * Boot-time sweep for scratch dirs a crash left behind. Age-gated rather than wholesale so a
+ * second process sharing the same `scratchDir` (server plus worker) keeps its live captures.
+ *
+ * @returns How many build scratch directories were removed.
+ */
+declare function sweepOrphanedScratch(scratchDir: string, options?: ScratchSweepOptions): Promise<number>;
+//#endregion
+export { SCRATCH_DIRNAME, SCRATCH_MAX_AGE_MS, ScratchSweepOptions, buildScratchDir, removeBuildScratch, removeJobScratch, sweepOrphanedScratch };
+//# sourceMappingURL=scratch.d.mts.map

package/dist/capture/scratch.mjs

@@ -0,0 +1,138 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { join } from "node:path";
+import { readdir, rm, rmdir, stat } from "node:fs/promises";
+//#region src/capture/scratch.ts
+/** Per-build scratch directories: where they live, removing them, and sweeping crash leftovers. */
+/**
+* Subtree of `scratchDir` that holds extracted Storybooks.
+*
+* `scratchDir` is often also the local storage root (dev server, generated servers), where
+* `<project>/builds/<build>/...` holds screenshots and published statics. Keeping scratch in its
+* own subtree means removing it can never touch a storage key.
+*/
+const SCRATCH_DIRNAME = ".storyshelf-scratch";
+/** Scratch dirs untouched for this long are assumed orphaned by a crash (no capture runs this long). */
+const SCRATCH_MAX_AGE_MS = 216e5;
+/** Directory inside a build's scratch directory that holds one subdirectory per shard. */
+const SHARDS_DIRNAME = "shards";
+/** Directory inside a build's scratch directory for the build's own job, apart from its shards. */
+const JOB_DIRNAME = "job";
+/** Scratch directory owned by one build: `<scratchDir>/.storyshelf-scratch/<projectId>/<buildId>`. */
+function buildScratchDir(scratchDir, projectId, buildId) {
+	return join(scratchDir, SCRATCH_DIRNAME, projectId, buildId);
+}
+/** Scratch directory of the build's own job (plan or whole build): `<build>/job`, beside `shards/`. */
+function jobScratchDir(scratchDir, projectId, buildId) {
+	return join(buildScratchDir(scratchDir, projectId, buildId), JOB_DIRNAME);
+}
+/** Scratch directory of one shard of a build, inside the build's: shards of a build can share a host. */
+function shardScratchDir(scratchDir, projectId, buildId, shardId) {
+	return join(buildScratchDir(scratchDir, projectId, buildId), SHARDS_DIRNAME, shardId);
+}
+/**
+* Remove one shard's scratch directory, leaving the build's other shards alone, then the build's
+* directories if that left them empty: whichever shard finishes last tidies up. Best effort.
+*/
+async function removeShardScratch(scratchDir, projectId, buildId, shardId, logger) {
+	try {
+		await rm(shardScratchDir(scratchDir, projectId, buildId, shardId), {
+			recursive: true,
+			force: true
+		});
+		await pruneBuildScratch(scratchDir, projectId, buildId);
+	} catch (error) {
+		logger?.warn({
+			err: error,
+			buildId,
+			shardId
+		}, "failed to remove shard scratch directory");
+	}
+}
+/**
+* Remove the scratch of the build's own job (the plan, or the whole build when it is not sharded)
+* and the build directory too if nothing else is left in it.
+*
+* Shards live in their own `shards/` directory beside `job/`, so this can never reach one: the plan
+* hands its shards to the queue before it cleans up, and a worker may already be extracting.
+*/
+async function removeJobScratch(scratchDir, projectId, buildId, logger) {
+	try {
+		await rm(jobScratchDir(scratchDir, projectId, buildId), {
+			recursive: true,
+			force: true
+		});
+		await pruneBuildScratch(scratchDir, projectId, buildId);
+	} catch (error) {
+		logger?.warn({
+			err: error,
+			buildId
+		}, "failed to remove job scratch directory");
+	}
+}
+/**
+* Remove the build's scratch directories that are empty, and nothing that is not. A shard that is
+* still running (a redelivered duplicate of one that already finished) keeps its directory; its own
+* cleanup, or the boot sweep, removes it later. `rmdir` fails on a non-empty directory, which is
+* the point.
+*/
+async function pruneBuildScratch(scratchDir, projectId, buildId) {
+	const buildDir = buildScratchDir(scratchDir, projectId, buildId);
+	await rmdir(join(buildDir, SHARDS_DIRNAME)).catch(ignore);
+	await rmdir(buildDir).catch(ignore);
+}
+/** Remove a build's scratch directory. Best effort: a failure is logged, never thrown. */
+async function removeBuildScratch(scratchDir, projectId, buildId, logger) {
+	try {
+		await rm(buildScratchDir(scratchDir, projectId, buildId), {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		logger?.warn({
+			err: error,
+			buildId
+		}, "failed to remove build scratch directory");
+	}
+}
+/**
+* Boot-time sweep for scratch dirs a crash left behind. Age-gated rather than wholesale so a
+* second process sharing the same `scratchDir` (server plus worker) keeps its live captures.
+*
+* @returns How many build scratch directories were removed.
+*/
+async function sweepOrphanedScratch(scratchDir, options = {}) {
+	const root = join(scratchDir, SCRATCH_DIRNAME);
+	const cutoff = (options.now ?? Date.now()) - (options.maxAgeMs ?? 216e5);
+	const projects = await readdir(root).catch(() => []);
+	const total = (await Promise.all(projects.map(async (projectId) => await sweepProject(join(root, projectId), cutoff)))).reduce((sum, count) => sum + count, 0);
+	if (total > 0) options.logger?.info({ removed: total }, "removed orphaned capture scratch directories");
+	return total;
+}
+async function sweepProject(projectDir, cutoff) {
+	const builds = await readdir(projectDir).catch(() => []);
+	const results = await Promise.all(builds.map(async (buildId) => await sweepBuild(join(projectDir, buildId), cutoff)));
+	if ((await readdir(projectDir).catch(() => ["x"])).length === 0) await rm(projectDir, {
+		recursive: true,
+		force: true
+	}).catch(ignore);
+	return results.filter(Boolean).length;
+}
+async function sweepBuild(buildDir, cutoff) {
+	try {
+		if ((await stat(buildDir)).mtimeMs >= cutoff) return false;
+		await rm(buildDir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function ignore() {}
+//#endregion
+export { SCRATCH_DIRNAME, SCRATCH_MAX_AGE_MS, buildScratchDir, jobScratchDir, pruneBuildScratch, removeBuildScratch, removeJobScratch, removeShardScratch, shardScratchDir, sweepOrphanedScratch };
+
+//# sourceMappingURL=scratch.mjs.map

package/dist/capture/scratch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch.mjs","names":[],"sources":["../../src/capture/scratch.ts"],"sourcesContent":["/** Per-build scratch directories: where they live, removing them, and sweeping crash leftovers. */\nimport { readdir, rm, rmdir, stat } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport type { Logger } from \"../logger.ts\";\n\n/**\n * Subtree of `scratchDir` that holds extracted Storybooks.\n *\n * `scratchDir` is often also the local storage root (dev server, generated servers), where\n * `<project>/builds/<build>/...` holds screenshots and published statics. Keeping scratch in its\n * own subtree means removing it can never touch a storage key.\n */\nexport const SCRATCH_DIRNAME = \".storyshelf-scratch\";\n\n/** Scratch dirs untouched for this long are assumed orphaned by a crash (no capture runs this long). */\nexport const SCRATCH_MAX_AGE_MS = 6 * 60 * 60 * 1000;\n\n/** Directory inside a build's scratch directory that holds one subdirectory per shard. */\nconst SHARDS_DIRNAME = \"shards\";\n\n/** Directory inside a build's scratch directory for the build's own job, apart from its shards. */\nconst JOB_DIRNAME = \"job\";\n\n/** Scratch directory owned by one build: `<scratchDir>/.storyshelf-scratch/<projectId>/<buildId>`. */\nexport function buildScratchDir(scratchDir: string, projectId: string, buildId: string): string {\n  return join(scratchDir, SCRATCH_DIRNAME, projectId, buildId);\n}\n\n/** Scratch directory of the build's own job (plan or whole build): `<build>/job`, beside `shards/`. */\nexport function jobScratchDir(scratchDir: string, projectId: string, buildId: string): string {\n  return join(buildScratchDir(scratchDir, projectId, buildId), JOB_DIRNAME);\n}\n\n/** Scratch directory of one shard of a build, inside the build's: shards of a build can share a host. */\nexport function shardScratchDir(\n  scratchDir: string,\n  projectId: string,\n  buildId: string,\n  shardId: string,\n): string {\n  return join(buildScratchDir(scratchDir, projectId, buildId), SHARDS_DIRNAME, shardId);\n}\n\n/**\n * Remove one shard's scratch directory, leaving the build's other shards alone, then the build's\n * directories if that left them empty: whichever shard finishes last tidies up. Best effort.\n */\nexport async function removeShardScratch(\n  scratchDir: string,\n  projectId: string,\n  buildId: string,\n  shardId: string,\n  logger?: Logger,\n): Promise<void> {\n  try {\n    await rm(shardScratchDir(scratchDir, projectId, buildId, shardId), {\n      recursive: true,\n      force: true,\n    });\n    await pruneBuildScratch(scratchDir, projectId, buildId);\n  } catch (error) {\n    logger?.warn({ err: error, buildId, shardId }, \"failed to remove shard scratch directory\");\n  }\n}\n\n/**\n * Remove the scratch of the build's own job (the plan, or the whole build when it is not sharded)\n * and the build directory too if nothing else is left in it.\n *\n * Shards live in their own `shards/` directory beside `job/`, so this can never reach one: the plan\n * hands its shards to the queue before it cleans up, and a worker may already be extracting.\n */\nexport async function removeJobScratch(\n  scratchDir: string,\n  projectId: string,\n  buildId: string,\n  logger?: Logger,\n): Promise<void> {\n  try {\n    await rm(jobScratchDir(scratchDir, projectId, buildId), { recursive: true, force: true });\n    await pruneBuildScratch(scratchDir, projectId, buildId);\n  } catch (error) {\n    logger?.warn({ err: error, buildId }, \"failed to remove job scratch directory\");\n  }\n}\n\n/**\n * Remove the build's scratch directories that are empty, and nothing that is not. A shard that is\n * still running (a redelivered duplicate of one that already finished) keeps its directory; its own\n * cleanup, or the boot sweep, removes it later. `rmdir` fails on a non-empty directory, which is\n * the point.\n */\nexport async function pruneBuildScratch(\n  scratchDir: string,\n  projectId: string,\n  buildId: string,\n): Promise<void> {\n  const buildDir = buildScratchDir(scratchDir, projectId, buildId);\n  await rmdir(join(buildDir, SHARDS_DIRNAME)).catch(ignore);\n  await rmdir(buildDir).catch(ignore);\n}\n\n/** Remove a build's scratch directory. Best effort: a failure is logged, never thrown. */\nexport async function removeBuildScratch(\n  scratchDir: string,\n  projectId: string,\n  buildId: string,\n  logger?: Logger,\n): Promise<void> {\n  try {\n    await rm(buildScratchDir(scratchDir, projectId, buildId), { recursive: true, force: true });\n  } catch (error) {\n    logger?.warn({ err: error, buildId }, \"failed to remove build scratch directory\");\n  }\n}\n\n/** Options for {@link sweepOrphanedScratch}. */\nexport interface ScratchSweepOptions {\n  /** Remove build scratch dirs not modified for this long (default {@link SCRATCH_MAX_AGE_MS}). */\n  maxAgeMs?: number;\n  /** Clock override for tests. */\n  now?: number;\n  logger?: Logger;\n}\n\n/**\n * Boot-time sweep for scratch dirs a crash left behind. Age-gated rather than wholesale so a\n * second process sharing the same `scratchDir` (server plus worker) keeps its live captures.\n *\n * @returns How many build scratch directories were removed.\n */\nexport async function sweepOrphanedScratch(\n  scratchDir: string,\n  options: ScratchSweepOptions = {},\n): Promise<number> {\n  const root = join(scratchDir, SCRATCH_DIRNAME);\n  const cutoff = (options.now ?? Date.now()) - (options.maxAgeMs ?? SCRATCH_MAX_AGE_MS);\n  const projects = await readdir(root).catch(() => [] as string[]);\n  const removed = await Promise.all(\n    projects.map(async (projectId) => await sweepProject(join(root, projectId), cutoff)),\n  );\n  const total = removed.reduce((sum, count) => sum + count, 0);\n  if (total > 0) {\n    options.logger?.info({ removed: total }, \"removed orphaned capture scratch directories\");\n  }\n  return total;\n}\n\nasync function sweepProject(projectDir: string, cutoff: number): Promise<number> {\n  const builds = await readdir(projectDir).catch(() => [] as string[]);\n  const results = await Promise.all(\n    builds.map(async (buildId) => await sweepBuild(join(projectDir, buildId), cutoff)),\n  );\n  // Drop the project dir once empty; `rmdir` semantics via a non-recursive remove that fails if not.\n  if ((await readdir(projectDir).catch(() => [\"x\"])).length === 0) {\n    await rm(projectDir, { recursive: true, force: true }).catch(ignore);\n  }\n  return results.filter(Boolean).length;\n}\n\nasync function sweepBuild(buildDir: string, cutoff: number): Promise<boolean> {\n  try {\n    if ((await stat(buildDir)).mtimeMs >= cutoff) {\n      return false;\n    }\n    await rm(buildDir, { recursive: true, force: true });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction ignore(): void {}\n"],"mappings":"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"}

package/dist/capture/shard-plan.mjs

@@ -0,0 +1,128 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/shard-plan.ts
+/**
+* Split the work into shards of about `size` captures, keeping a story's engines together so
+* a newly enabled engine can still bootstrap from its counterpart in the same shard.
+*
+* Returns `[]` when sharding is off or the build is too small to be worth it (up to twice the
+* shard size runs as one shard, exactly as before).
+*
+* Without timings the slices are contiguous runs of stories in their original order. Given
+* `weightOf`, the stories are packed longest-first into shards of equal capture capacity and the
+* shards come back heaviest first, so the slow work starts early and no shard straggles.
+*
+* @param work - Per-engine render lists, primary engine first.
+* @param capturesOf - Captures one story produces on one engine (its viewport count).
+* @param size - Target captures per shard; undefined or below 1 turns sharding off.
+* @param weightOf - What a story cost last time, in milliseconds; unknown for a story returns undefined.
+*/
+function planShards(work, capturesOf, size, weightOf) {
+	if (!size || !worthSharding(work, capturesOf, size)) return [];
+	const costs = storyCosts(work, capturesOf);
+	const weights = weightOf ? weighted(costs, weightOf) : void 0;
+	return (weights ? packLongestFirst(costs, weights, size) : sliceByCost(costs, size)).map((ids) => restrictTo(work, new Set(ids)));
+}
+/**
+* Whether {@link planShards} would split this work at all: sharding is on (`size` of at least 1)
+* and the work is more than twice the shard size. Lets the plan stage skip work only an ordering needs.
+*/
+function worthSharding(work, capturesOf, size) {
+	return size !== void 0 && size >= 1 && totalCaptures(work, capturesOf) > size * 2;
+}
+/** Total captures the work produces. */
+function totalCaptures(work, capturesOf) {
+	return [...storyCosts(work, capturesOf).values()].reduce((sum, cost) => sum + cost, 0);
+}
+/** Captures per story id, summed over the engines that render it, in first-seen order. */
+function storyCosts(work, capturesOf) {
+	const costs = /* @__PURE__ */ new Map();
+	for (const engine of work) for (const story of engine.stories) costs.set(story.id, (costs.get(story.id) ?? 0) + capturesOf(story));
+	return costs;
+}
+/**
+* What each story is expected to cost in milliseconds. A story nothing is known about is priced at
+* the average cost of one capture, so a new story is treated as ordinary rather than free.
+*/
+function weighted(costs, weightOf) {
+	const known = [...costs.keys()].flatMap((id) => {
+		const weight = weightOf(id);
+		return typeof weight === "number" && weight > 0 ? [[id, weight]] : [];
+	});
+	if (known.length === 0) return;
+	const knownCaptures = known.reduce((sum, [id]) => sum + (costs.get(id) ?? 0), 0);
+	const perCapture = known.reduce((sum, [, weight]) => sum + weight, 0) / Math.max(knownCaptures, 1);
+	const weights = new Map(known);
+	for (const [id, captures] of costs) if (!weights.has(id)) weights.set(id, perCapture * captures);
+	return weights;
+}
+/**
+* Longest-processing-time packing: the dearest stories are placed first, each into the shard that
+* has the least work so far and still has room for its captures. Shards come back heaviest first.
+*/
+function packLongestFirst(costs, weights, size) {
+	const count = Math.max(1, Math.ceil(sumOf(costs) / size));
+	const bins = Array.from({ length: count }, newBin);
+	for (const id of byWeightDescending(costs, weights)) {
+		const captures = costs.get(id) ?? 0;
+		const bin = binFor(bins, captures, size);
+		bin.ids.push(id);
+		bin.captures += captures;
+		bin.weight += weights.get(id) ?? 0;
+	}
+	return bins.filter((bin) => bin.ids.length > 0).toSorted((left, right) => right.weight - left.weight).map((bin) => bin.ids);
+}
+/** Story ids dearest first; equal cost keeps the order they were planned in. */
+function byWeightDescending(costs, weights) {
+	return [...costs.keys()].toSorted((left, right) => (weights.get(right) ?? 0) - (weights.get(left) ?? 0));
+}
+function newBin() {
+	return {
+		ids: [],
+		captures: 0,
+		weight: 0
+	};
+}
+/**
+* The shard with the least work that still has room for `captures`. When none has room the last
+* stories did not fit anywhere, so a shard is added: one more beats overfilling one, just as an
+* oversized story gets a shard of its own when there are no timings.
+*/
+function binFor(bins, captures, size) {
+	const [lightest] = bins.filter((bin) => bin.captures + captures <= size).toSorted((left, right) => left.weight - right.weight);
+	if (lightest) return lightest;
+	const fresh = newBin();
+	bins.push(fresh);
+	return fresh;
+}
+function sumOf(costs) {
+	return [...costs.values()].reduce((sum, cost) => sum + cost, 0);
+}
+/** Contiguous runs of ids whose cost stays within `size` (a single oversized story gets its own). */
+function sliceByCost(costs, size) {
+	const slices = [];
+	for (const id of costs.keys()) {
+		const cost = costs.get(id) ?? 0;
+		const last = slices.at(-1);
+		if (last && last.used + cost <= size) {
+			last.ids.push(id);
+			last.used += cost;
+		} else slices.push({
+			ids: [id],
+			used: cost
+		});
+	}
+	return slices.map((slice) => slice.ids);
+}
+/** The work restricted to some stories; engines left with nothing to render are dropped. */
+function restrictTo(work, ids) {
+	return work.map((engine) => ({
+		browser: engine.browser,
+		stories: engine.stories.filter((story) => ids.has(story.id))
+	})).filter((engine) => engine.stories.length > 0);
+}
+//#endregion
+export { planShards, totalCaptures, worthSharding };
+
+//# sourceMappingURL=shard-plan.mjs.map

package/dist/capture/shard-plan.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shard-plan.mjs","names":[],"sources":["../../src/capture/shard-plan.ts"],"sourcesContent":["/** Splitting a build's render work into shards (ADR 0005 phase 5). Pure: no I/O, no clock. */\nimport type { CaptureTarget } from \"../adapters/capture-runner.ts\";\nimport type { StoryEntry, Viewport } from \"./adapter.ts\";\n\n/** What one engine has to render this build (after affected-capture partitioning). */\nexport interface EngineWork {\n  browser: CaptureTarget;\n  stories: StoryEntry[];\n}\n\n/** One render shard: a slice of stories, with the engines each of them is rendered on. */\nexport interface ShardPayload {\n  /** Engines of the slice, primary first; each lists only the stories it renders. */\n  browsers: EngineWork[];\n  /** Viewports the stories resolve against. */\n  viewports: Viewport[];\n  /** Engines with no baseline yet when the plan was made (fixed at plan time, not per shard). */\n  fresh: string[];\n}\n\n/** Settings of the plan itself, kept on the plan row. */\nexport interface PlanPayload {\n  browsers: string[];\n  fresh: string[];\n  /** Captures per shard the plan aimed for. */\n  shardSize: number;\n  /** Captures (story x viewport x engine) the plan covers. */\n  total: number;\n}\n\n/** Outcome of one render shard, kept on its row. */\nexport interface ShardResult {\n  failedStoryIds: string[];\n  flakyStoryIds: string[];\n  a11yStoryIds: string[];\n  captured: number;\n  durationMs: number;\n}\n\n/** Outcome of the plan stage: every story of the build, and stories whose inherited snapshot failed. */\nexport interface PlanResult {\n  storyIds: string[];\n  failedStoryIds: string[];\n}\n\n/**\n * Split the work into shards of about `size` captures, keeping a story's engines together so\n * a newly enabled engine can still bootstrap from its counterpart in the same shard.\n *\n * Returns `[]` when sharding is off or the build is too small to be worth it (up to twice the\n * shard size runs as one shard, exactly as before).\n *\n * Without timings the slices are contiguous runs of stories in their original order. Given\n * `weightOf`, the stories are packed longest-first into shards of equal capture capacity and the\n * shards come back heaviest first, so the slow work starts early and no shard straggles.\n *\n * @param work - Per-engine render lists, primary engine first.\n * @param capturesOf - Captures one story produces on one engine (its viewport count).\n * @param size - Target captures per shard; undefined or below 1 turns sharding off.\n * @param weightOf - What a story cost last time, in milliseconds; unknown for a story returns undefined.\n */\nexport function planShards(\n  work: readonly EngineWork[],\n  capturesOf: (story: StoryEntry) => number,\n  size: number | undefined,\n  weightOf?: (storyId: string) => number | undefined,\n): EngineWork[][] {\n  if (!size || !worthSharding(work, capturesOf, size)) {\n    return [];\n  }\n  const costs = storyCosts(work, capturesOf);\n  const weights = weightOf ? weighted(costs, weightOf) : undefined;\n  const slices = weights ? packLongestFirst(costs, weights, size) : sliceByCost(costs, size);\n  return slices.map((ids) => restrictTo(work, new Set(ids)));\n}\n\n/**\n * Whether {@link planShards} would split this work at all: sharding is on (`size` of at least 1)\n * and the work is more than twice the shard size. Lets the plan stage skip work only an ordering needs.\n */\nexport function worthSharding(\n  work: readonly EngineWork[],\n  capturesOf: (story: StoryEntry) => number,\n  size: number | undefined,\n): boolean {\n  return size !== undefined && size >= 1 && totalCaptures(work, capturesOf) > size * 2;\n}\n\n/** Total captures the work produces. */\nexport function totalCaptures(\n  work: readonly EngineWork[],\n  capturesOf: (story: StoryEntry) => number,\n): number {\n  return [...storyCosts(work, capturesOf).values()].reduce((sum, cost) => sum + cost, 0);\n}\n\n/** Captures per story id, summed over the engines that render it, in first-seen order. */\nfunction storyCosts(\n  work: readonly EngineWork[],\n  capturesOf: (story: StoryEntry) => number,\n): Map<string, number> {\n  const costs = new Map<string, number>();\n  for (const engine of work) {\n    for (const story of engine.stories) {\n      costs.set(story.id, (costs.get(story.id) ?? 0) + capturesOf(story));\n    }\n  }\n  return costs;\n}\n\n/**\n * What each story is expected to cost in milliseconds. A story nothing is known about is priced at\n * the average cost of one capture, so a new story is treated as ordinary rather than free.\n */\nfunction weighted(\n  costs: Map<string, number>,\n  weightOf: (storyId: string) => number | undefined,\n): Map<string, number> | undefined {\n  const known = [...costs.keys()].flatMap((id) => {\n    const weight = weightOf(id);\n    return typeof weight === \"number\" && weight > 0 ? [[id, weight] as const] : [];\n  });\n  if (known.length === 0) {\n    return undefined;\n  }\n  const knownCaptures = known.reduce((sum, [id]) => sum + (costs.get(id) ?? 0), 0);\n  const perCapture =\n    known.reduce((sum, [, weight]) => sum + weight, 0) / Math.max(knownCaptures, 1);\n  const weights = new Map(known);\n  for (const [id, captures] of costs) {\n    if (!weights.has(id)) {\n      weights.set(id, perCapture * captures);\n    }\n  }\n  return weights;\n}\n\n/**\n * Longest-processing-time packing: the dearest stories are placed first, each into the shard that\n * has the least work so far and still has room for its captures. Shards come back heaviest first.\n */\nfunction packLongestFirst(\n  costs: Map<string, number>,\n  weights: Map<string, number>,\n  size: number,\n): string[][] {\n  const count = Math.max(1, Math.ceil(sumOf(costs) / size));\n  const bins: Bin[] = Array.from({ length: count }, newBin);\n  for (const id of byWeightDescending(costs, weights)) {\n    const captures = costs.get(id) ?? 0;\n    const bin = binFor(bins, captures, size);\n    bin.ids.push(id);\n    bin.captures += captures;\n    bin.weight += weights.get(id) ?? 0;\n  }\n  return bins\n    .filter((bin) => bin.ids.length > 0)\n    .toSorted((left, right) => right.weight - left.weight)\n    .map((bin) => bin.ids);\n}\n\n/** Story ids dearest first; equal cost keeps the order they were planned in. */\nfunction byWeightDescending(costs: Map<string, number>, weights: Map<string, number>): string[] {\n  return [...costs.keys()].toSorted(\n    (left, right) => (weights.get(right) ?? 0) - (weights.get(left) ?? 0),\n  );\n}\n\n/** One shard being filled: the stories in it, their captures and what they are expected to cost. */\ninterface Bin {\n  ids: string[];\n  captures: number;\n  weight: number;\n}\n\nfunction newBin(): Bin {\n  return { ids: [], captures: 0, weight: 0 };\n}\n\n/**\n * The shard with the least work that still has room for `captures`. When none has room the last\n * stories did not fit anywhere, so a shard is added: one more beats overfilling one, just as an\n * oversized story gets a shard of its own when there are no timings.\n */\nfunction binFor(bins: Bin[], captures: number, size: number): Bin {\n  const withRoom = bins.filter((bin) => bin.captures + captures <= size);\n  const [lightest] = withRoom.toSorted((left, right) => left.weight - right.weight);\n  if (lightest) {\n    return lightest;\n  }\n  const fresh = newBin();\n  bins.push(fresh);\n  return fresh;\n}\n\nfunction sumOf(costs: Map<string, number>): number {\n  return [...costs.values()].reduce((sum, cost) => sum + cost, 0);\n}\n\n/** Contiguous runs of ids whose cost stays within `size` (a single oversized story gets its own). */\nfunction sliceByCost(costs: Map<string, number>, size: number): string[][] {\n  const slices: { ids: string[]; used: number }[] = [];\n  for (const id of costs.keys()) {\n    const cost = costs.get(id) ?? 0;\n    const last = slices.at(-1);\n    if (last && last.used + cost <= size) {\n      last.ids.push(id);\n      last.used += cost;\n    } else {\n      slices.push({ ids: [id], used: cost });\n    }\n  }\n  return slices.map((slice) => slice.ids);\n}\n\n/** The work restricted to some stories; engines left with nothing to render are dropped. */\nfunction restrictTo(work: readonly EngineWork[], ids: ReadonlySet<string>): EngineWork[] {\n  return work\n    .map((engine) => ({\n      browser: engine.browser,\n      stories: engine.stories.filter((story) => ids.has(story.id)),\n    }))\n    .filter((engine) => engine.stories.length > 0);\n}\n"],"mappings":"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"}

package/dist/capture/shards/context.mjs

@@ -0,0 +1,51 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { storybookUrlSource } from "../storybook-urls.mjs";
+//#region src/capture/shards/context.ts
+/** A capture context for the persist and finalize steps of one stage. */
+function contextOf(target, parts) {
+	const { options } = target;
+	return {
+		db: options.db,
+		tables: options.tables,
+		storage: options.storage,
+		project: target.project,
+		build: target.build,
+		viewports: parts.viewports,
+		browsers: parts.browsers,
+		captures: parts.captures ?? [],
+		inherited: parts.inherited ?? [],
+		...parts.freshBrowsers ? { freshBrowsers: parts.freshBrowsers } : {},
+		progress: parts.progress,
+		...options.logger ? { logger: options.logger } : {},
+		...options.secret ? { secret: options.secret } : {}
+	};
+}
+/** The matrix input for rendering `stories` from `storybookDir` on `browsers`. */
+function matrixInputOf(target, parts) {
+	const { options } = target;
+	return {
+		db: options.db,
+		storage: options.storage,
+		tables: options.tables,
+		runner: options.runner,
+		build: target.build,
+		project: target.project,
+		stories: parts.stories,
+		viewports: parts.viewports,
+		storybookDir: parts.storybookDir,
+		browsers: parts.browsers,
+		affectedPaths: parts.affectedPaths,
+		renderTimeoutMs: options.renderTimeoutMs,
+		storybookUrl: storybookUrlSource(options, target),
+		logger: parts.logger ?? options.logger,
+		recordLog: parts.recordLog,
+		progress: parts.progress,
+		runId: parts.runId
+	};
+}
+//#endregion
+export { contextOf, matrixInputOf };
+
+//# sourceMappingURL=context.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../../../src/capture/shards/context.ts"],"sourcesContent":["/** What every stage of a sharded capture works against. */\nimport type { Logger } from \"pino\";\nimport type { CaptureTarget } from \"../../adapters/capture-runner.ts\";\nimport type { Build } from \"../../schema/build.ts\";\nimport type { Project } from \"../../schema/project.ts\";\nimport type { Viewport } from \"../adapter.ts\";\nimport type { MatrixInput } from \"../matrix.ts\";\nimport type { CaptureJobOptions } from \"../orchestrator.ts\";\nimport type { CaptureContext } from \"../pipeline.ts\";\nimport type { CaptureProgress } from \"../progress.ts\";\nimport { storybookUrlSource } from \"../storybook-urls.ts\";\n\n/** The build being captured and the adapters to capture it with. */\nexport interface ShardTarget {\n  options: CaptureJobOptions;\n  build: Build;\n  project: Project;\n}\n\n/** A capture context for the persist and finalize steps of one stage. */\nexport function contextOf(\n  target: ShardTarget,\n  parts: {\n    viewports: Viewport[];\n    browsers: CaptureTarget[];\n    captures?: CaptureContext[\"captures\"];\n    inherited?: NonNullable<CaptureContext[\"inherited\"]>;\n    freshBrowsers?: ReadonlySet<string>;\n    progress?: CaptureProgress | undefined;\n  },\n): CaptureContext {\n  const { options } = target;\n  return {\n    db: options.db,\n    tables: options.tables,\n    storage: options.storage,\n    project: target.project,\n    build: target.build,\n    viewports: parts.viewports,\n    browsers: parts.browsers,\n    captures: parts.captures ?? [],\n    inherited: parts.inherited ?? [],\n    ...(parts.freshBrowsers ? { freshBrowsers: parts.freshBrowsers } : {}),\n    progress: parts.progress,\n    ...(options.logger ? { logger: options.logger } : {}),\n    ...(options.secret ? { secret: options.secret } : {}),\n  };\n}\n\n/** The matrix input for rendering `stories` from `storybookDir` on `browsers`. */\nexport function matrixInputOf(\n  target: ShardTarget,\n  parts: {\n    stories: MatrixInput[\"stories\"];\n    viewports: Viewport[];\n    browsers: CaptureTarget[];\n    storybookDir: string;\n    affectedPaths: string[] | null;\n    logger?: Logger | undefined;\n    recordLog?: MatrixInput[\"recordLog\"];\n    progress?: CaptureProgress | undefined;\n    runId?: string | undefined;\n  },\n): MatrixInput {\n  const { options } = target;\n  return {\n    db: options.db,\n    storage: options.storage,\n    tables: options.tables,\n    runner: options.runner,\n    build: target.build,\n    project: target.project,\n    stories: parts.stories,\n    viewports: parts.viewports,\n    storybookDir: parts.storybookDir,\n    browsers: parts.browsers,\n    affectedPaths: parts.affectedPaths,\n    renderTimeoutMs: options.renderTimeoutMs,\n    storybookUrl: storybookUrlSource(options, target),\n    logger: parts.logger ?? options.logger,\n    recordLog: parts.recordLog,\n    progress: parts.progress,\n    runId: parts.runId,\n  };\n}\n"],"mappings":";;;;;;AAoBA,SAAgB,UACd,QACA,OAQgB;CAChB,MAAM,EAAE,YAAY;CACpB,OAAO;EACL,IAAI,QAAQ;EACZ,QAAQ,QAAQ;EAChB,SAAS,QAAQ;EACjB,SAAS,OAAO;EAChB,OAAO,OAAO;EACd,WAAW,MAAM;EACjB,UAAU,MAAM;EAChB,UAAU,MAAM,YAAY,CAAC;EAC7B,WAAW,MAAM,aAAa,CAAC;EAC/B,GAAI,MAAM,gBAAgB,EAAE,eAAe,MAAM,cAAc,IAAI,CAAC;EACpE,UAAU,MAAM;EAChB,GAAI,QAAQ,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,CAAC;EACnD,GAAI,QAAQ,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,CAAC;CACrD;AACF;;AAGA,SAAgB,cACd,QACA,OAWa;CACb,MAAM,EAAE,YAAY;CACpB,OAAO;EACL,IAAI,QAAQ;EACZ,SAAS,QAAQ;EACjB,QAAQ,QAAQ;EAChB,QAAQ,QAAQ;EAChB,OAAO,OAAO;EACd,SAAS,OAAO;EAChB,SAAS,MAAM;EACf,WAAW,MAAM;EACjB,cAAc,MAAM;EACpB,UAAU,MAAM;EAChB,eAAe,MAAM;EACrB,iBAAiB,QAAQ;EACzB,cAAc,mBAAmB,SAAS,MAAM;EAChD,QAAQ,MAAM,UAAU,QAAQ;EAChC,WAAW,MAAM;EACjB,UAAU,MAAM;EAChB,OAAO,MAAM;CACf;AACF"}