@storyshelf/core 0.6.2 → 0.7.0

package/dist/capture/publish/accept.d.mts

@@ -0,0 +1,39 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region src/capture/publish/accept.d.ts
+/**
+ * The one rule for when publishing accepts a build (ADR 0006, decision 2). Pure: callers read the
+ * facts, apply the verdict, and stay free of branching.
+ */
+/** Facts the verdict depends on. */
+interface PublishFacts {
+  /** Whether publishing succeeded. */
+  published: boolean;
+  /** Whether a capture will run for this build (`testing` is on); capture then owns the status. */
+  captureWillRun: boolean;
+  /** Whether the build is on the project's default branch. */
+  defaultBranch: boolean;
+  /** The project's review switch (`projects.review_enabled`, ADR 0013, decision 1). */
+  reviewEnabled: boolean;
+  /** The build's status right now. */
+  status: string;
+}
+/**
+ * What publishing does to the build's status.
+ *
+ * - A capture will run: `unchanged`, the capture sets the status.
+ * - Not `pending` any more (already accepted, failed, cancelled or reviewed): `unchanged`, so a repeated
+ *   publish (job redelivery after a lost lease) changes nothing.
+ * - Publish failed: `failed`.
+ * - Published on the default branch: `approved`, whatever the review switch says.
+ * - Published on another branch with review off: `approved`, nobody will sign it off.
+ * - Published on another branch with review on: `unchanged`, the build waits as `pending` for a
+ *   build-level verdict (ADR 0013, decision 3).
+ *
+ * Accepting here is not an approval: no event, webhook or notification (`build:created` announced
+ * the upload), so nothing is asked of a reviewer and nothing is reported as one.
+ */
+declare function publishVerdict(facts: PublishFacts): "approved" | "failed" | "unchanged";
+//#endregion
+export { PublishFacts, publishVerdict };
+//# sourceMappingURL=accept.d.mts.map

package/dist/capture/publish/accept.mjs

@@ -0,0 +1,28 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/publish/accept.ts
+/**
+* What publishing does to the build's status.
+*
+* - A capture will run: `unchanged`, the capture sets the status.
+* - Not `pending` any more (already accepted, failed, cancelled or reviewed): `unchanged`, so a repeated
+*   publish (job redelivery after a lost lease) changes nothing.
+* - Publish failed: `failed`.
+* - Published on the default branch: `approved`, whatever the review switch says.
+* - Published on another branch with review off: `approved`, nobody will sign it off.
+* - Published on another branch with review on: `unchanged`, the build waits as `pending` for a
+*   build-level verdict (ADR 0013, decision 3).
+*
+* Accepting here is not an approval: no event, webhook or notification (`build:created` announced
+* the upload), so nothing is asked of a reviewer and nothing is reported as one.
+*/
+function publishVerdict(facts) {
+	if (facts.captureWillRun || facts.status !== "pending") return "unchanged";
+	if (!facts.published) return "failed";
+	return facts.defaultBranch || !facts.reviewEnabled ? "approved" : "unchanged";
+}
+//#endregion
+export { publishVerdict };
+
+//# sourceMappingURL=accept.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accept.mjs","names":[],"sources":["../../../src/capture/publish/accept.ts"],"sourcesContent":["/**\n * The one rule for when publishing accepts a build (ADR 0006, decision 2). Pure: callers read the\n * facts, apply the verdict, and stay free of branching.\n */\n\n/** Facts the verdict depends on. */\nexport interface PublishFacts {\n  /** Whether publishing succeeded. */\n  published: boolean;\n  /** Whether a capture will run for this build (`testing` is on); capture then owns the status. */\n  captureWillRun: boolean;\n  /** Whether the build is on the project's default branch. */\n  defaultBranch: boolean;\n  /** The project's review switch (`projects.review_enabled`, ADR 0013, decision 1). */\n  reviewEnabled: boolean;\n  /** The build's status right now. */\n  status: string;\n}\n\n/**\n * What publishing does to the build's status.\n *\n * - A capture will run: `unchanged`, the capture sets the status.\n * - Not `pending` any more (already accepted, failed, cancelled or reviewed): `unchanged`, so a repeated\n *   publish (job redelivery after a lost lease) changes nothing.\n * - Publish failed: `failed`.\n * - Published on the default branch: `approved`, whatever the review switch says.\n * - Published on another branch with review off: `approved`, nobody will sign it off.\n * - Published on another branch with review on: `unchanged`, the build waits as `pending` for a\n *   build-level verdict (ADR 0013, decision 3).\n *\n * Accepting here is not an approval: no event, webhook or notification (`build:created` announced\n * the upload), so nothing is asked of a reviewer and nothing is reported as one.\n */\nexport function publishVerdict(facts: PublishFacts): \"approved\" | \"failed\" | \"unchanged\" {\n  if (facts.captureWillRun || facts.status !== \"pending\") {\n    return \"unchanged\";\n  }\n  if (!facts.published) {\n    return \"failed\";\n  }\n  return facts.defaultBranch || !facts.reviewEnabled ? \"approved\" : \"unchanged\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,eAAe,OAA0D;CACvF,IAAI,MAAM,kBAAkB,MAAM,WAAW,WAC3C,OAAO;CAET,IAAI,CAAC,MAAM,WACT,OAAO;CAET,OAAO,MAAM,iBAAiB,CAAC,MAAM,gBAAgB,aAAa;AACpE"}

package/dist/capture/publish/complete.d.mts

@@ -0,0 +1,46 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../../adapter/database.mjs";
+import { Logger } from "../../logger.mjs";
+import { Build } from "../../schema/build.mjs";
+import { Project } from "../../schema/project.mjs";
+//#region src/capture/publish/complete.d.ts
+/** How publishing ended. */
+type PublishOutcome = {
+  ok: true;
+} | {
+  ok: false;
+  error: string;
+};
+/** What an `afterPublish` hook is given. */
+interface AfterPublishContext {
+  /** The build as it is after the verdict was applied. */
+  build: Build;
+  project: Project;
+  outcome: PublishOutcome;
+  logger: Logger;
+}
+/** Runs once per finished publish (extension point of the catalog). Failures are logged, never thrown on. */
+type AfterPublishHook = (context: AfterPublishContext) => Promise<void>;
+/** Finishes a build's publishing. */
+interface PublishCompleter {
+  /**
+   * Record the end of a build's publishing. Resolves to the build, or null when it is gone.
+   * Safe to repeat: a build that left `pending` keeps its status.
+   */
+  complete(buildId: string, outcome: PublishOutcome): Promise<Build | null>;
+}
+/** What {@link createPublishCompleter} needs. */
+interface PublishCompleterOptions {
+  db: DatabaseAdapter;
+  /** Whether a capture runs for uploads (`testing`); capture then owns the build status. */
+  captureWillRun: boolean;
+  /** Hooks, read on every call so later registrations count. */
+  afterPublish: readonly AfterPublishHook[];
+  logger: Logger;
+}
+/** A completer over `options.db`. */
+declare function createPublishCompleter(options: PublishCompleterOptions): PublishCompleter;
+//#endregion
+export { AfterPublishContext, AfterPublishHook, PublishCompleter, PublishCompleterOptions, PublishOutcome, createPublishCompleter };
+//# sourceMappingURL=complete.d.mts.map

package/dist/capture/publish/complete.mjs

@@ -0,0 +1,64 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { BuildModel } from "../../models/build.mjs";
+import { ProjectModel } from "../../models/project.mjs";
+import { publishVerdict } from "./accept.mjs";
+//#region src/capture/publish/complete.ts
+/** A completer over `options.db`. */
+function createPublishCompleter(options) {
+	return { complete: async (buildId, outcome) => {
+		const target = await load(options.db, buildId);
+		if (!target) {
+			options.logger.warn({ buildId }, "build is gone; nothing to complete");
+			return null;
+		}
+		const build = await applyVerdict(options, target.build, target.project, outcome);
+		await runHooks(options, {
+			build,
+			project: target.project,
+			outcome
+		});
+		return build;
+	} };
+}
+async function load(db, buildId) {
+	const build = await new BuildModel(db).get(buildId);
+	const project = build ? await new ProjectModel(db).get(build.projectId) : null;
+	return build && project ? {
+		build,
+		project
+	} : null;
+}
+/** Move the build per the rule. No approval event or webhook: `build:created` announced the upload. */
+async function applyVerdict(options, build, project, outcome) {
+	const verdict = publishVerdict({
+		published: outcome.ok,
+		captureWillRun: options.captureWillRun,
+		defaultBranch: build.gitBranch === project.gitDefaultBranch,
+		reviewEnabled: project.reviewEnabled !== false,
+		status: build.status
+	});
+	if (!outcome.ok) options.logger.error({
+		buildId: build.id,
+		error: outcome.error,
+		verdict
+	}, "publish failed");
+	if (verdict === "unchanged") return build;
+	return await new BuildModel(options.db).setStatus(build.id, verdict);
+}
+async function runHooks(options, context) {
+	const logger = options.logger.child({ buildId: context.build.id });
+	for (const hook of options.afterPublish) try {
+		await hook({
+			...context,
+			logger
+		});
+	} catch (error) {
+		logger.error({ err: error }, "afterPublish hook failed");
+	}
+}
+//#endregion
+export { createPublishCompleter };
+
+//# sourceMappingURL=complete.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complete.mjs","names":[],"sources":["../../../src/capture/publish/complete.ts"],"sourcesContent":["/**\n * Publishing's end: apply {@link publishVerdict} to the build and run the `afterPublish` hooks.\n * Every publish route (inline zip, `publish` job, file-by-file manifest) ends here, so this is the\n * single owner of the acceptance rule.\n */\nimport type { DatabaseAdapter } from \"../../adapters/database.ts\";\nimport type { Logger } from \"../../logger.ts\";\nimport { BuildModel } from \"../../models/build.ts\";\nimport { ProjectModel } from \"../../models/project.ts\";\nimport type { Build } from \"../../schema/build.ts\";\nimport type { Project } from \"../../schema/project.ts\";\nimport { publishVerdict } from \"./accept.ts\";\n\n/** How publishing ended. */\nexport type PublishOutcome = { ok: true } | { ok: false; error: string };\n\n/** What an `afterPublish` hook is given. */\nexport interface AfterPublishContext {\n  /** The build as it is after the verdict was applied. */\n  build: Build;\n  project: Project;\n  outcome: PublishOutcome;\n  logger: Logger;\n}\n\n/** Runs once per finished publish (extension point of the catalog). Failures are logged, never thrown on. */\nexport type AfterPublishHook = (context: AfterPublishContext) => Promise<void>;\n\n/** Finishes a build's publishing. */\nexport interface PublishCompleter {\n  /**\n   * Record the end of a build's publishing. Resolves to the build, or null when it is gone.\n   * Safe to repeat: a build that left `pending` keeps its status.\n   */\n  complete(buildId: string, outcome: PublishOutcome): Promise<Build | null>;\n}\n\n/** What {@link createPublishCompleter} needs. */\nexport interface PublishCompleterOptions {\n  db: DatabaseAdapter;\n  /** Whether a capture runs for uploads (`testing`); capture then owns the build status. */\n  captureWillRun: boolean;\n  /** Hooks, read on every call so later registrations count. */\n  afterPublish: readonly AfterPublishHook[];\n  logger: Logger;\n}\n\n/** A completer over `options.db`. */\nexport function createPublishCompleter(options: PublishCompleterOptions): PublishCompleter {\n  return {\n    complete: async (buildId, outcome) => {\n      const target = await load(options.db, buildId);\n      if (!target) {\n        options.logger.warn({ buildId }, \"build is gone; nothing to complete\");\n        return null;\n      }\n      const build = await applyVerdict(options, target.build, target.project, outcome);\n      await runHooks(options, { build, project: target.project, outcome });\n      return build;\n    },\n  };\n}\n\nasync function load(\n  db: DatabaseAdapter,\n  buildId: string,\n): Promise<{ build: Build; project: Project } | null> {\n  const build = await new BuildModel(db).get(buildId);\n  const project = build ? await new ProjectModel(db).get(build.projectId) : null;\n  return build && project ? { build, project } : null;\n}\n\n/** Move the build per the rule. No approval event or webhook: `build:created` announced the upload. */\nasync function applyVerdict(\n  options: PublishCompleterOptions,\n  build: Build,\n  project: Project,\n  outcome: PublishOutcome,\n): Promise<Build> {\n  const verdict = publishVerdict({\n    published: outcome.ok,\n    captureWillRun: options.captureWillRun,\n    defaultBranch: build.gitBranch === project.gitDefaultBranch,\n    reviewEnabled: project.reviewEnabled !== false,\n    status: build.status,\n  });\n  if (!outcome.ok) {\n    options.logger.error({ buildId: build.id, error: outcome.error, verdict }, \"publish failed\");\n  }\n  if (verdict === \"unchanged\") {\n    return build;\n  }\n  return await new BuildModel(options.db).setStatus(build.id, verdict);\n}\n\nasync function runHooks(\n  options: PublishCompleterOptions,\n  context: Omit<AfterPublishContext, \"logger\">,\n): Promise<void> {\n  const logger = options.logger.child({ buildId: context.build.id });\n  for (const hook of options.afterPublish) {\n    try {\n      // eslint-disable-next-line no-await-in-loop -- hooks run in registration order\n      await hook({ ...context, logger });\n    } catch (error) {\n      logger.error({ err: error }, \"afterPublish hook failed\");\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAgDA,SAAgB,uBAAuB,SAAoD;CACzF,OAAO,EACL,UAAU,OAAO,SAAS,YAAY;EACpC,MAAM,SAAS,MAAM,KAAK,QAAQ,IAAI,OAAO;EAC7C,IAAI,CAAC,QAAQ;GACX,QAAQ,OAAO,KAAK,EAAE,QAAQ,GAAG,oCAAoC;GACrE,OAAO;EACT;EACA,MAAM,QAAQ,MAAM,aAAa,SAAS,OAAO,OAAO,OAAO,SAAS,OAAO;EAC/E,MAAM,SAAS,SAAS;GAAE;GAAO,SAAS,OAAO;GAAS;EAAQ,CAAC;EACnE,OAAO;CACT,EACF;AACF;AAEA,eAAe,KACb,IACA,SACoD;CACpD,MAAM,QAAQ,MAAM,IAAI,WAAW,EAAE,CAAC,CAAC,IAAI,OAAO;CAClD,MAAM,UAAU,QAAQ,MAAM,IAAI,aAAa,EAAE,CAAC,CAAC,IAAI,MAAM,SAAS,IAAI;CAC1E,OAAO,SAAS,UAAU;EAAE;EAAO;CAAQ,IAAI;AACjD;;AAGA,eAAe,aACb,SACA,OACA,SACA,SACgB;CAChB,MAAM,UAAU,eAAe;EAC7B,WAAW,QAAQ;EACnB,gBAAgB,QAAQ;EACxB,eAAe,MAAM,cAAc,QAAQ;EAC3C,eAAe,QAAQ,kBAAkB;EACzC,QAAQ,MAAM;CAChB,CAAC;CACD,IAAI,CAAC,QAAQ,IACX,QAAQ,OAAO,MAAM;EAAE,SAAS,MAAM;EAAI,OAAO,QAAQ;EAAO;CAAQ,GAAG,gBAAgB;CAE7F,IAAI,YAAY,aACd,OAAO;CAET,OAAO,MAAM,IAAI,WAAW,QAAQ,EAAE,CAAC,CAAC,UAAU,MAAM,IAAI,OAAO;AACrE;AAEA,eAAe,SACb,SACA,SACe;CACf,MAAM,SAAS,QAAQ,OAAO,MAAM,EAAE,SAAS,QAAQ,MAAM,GAAG,CAAC;CACjE,KAAK,MAAM,QAAQ,QAAQ,cACzB,IAAI;EAEF,MAAM,KAAK;GAAE,GAAG;GAAS;EAAO,CAAC;CACnC,SAAS,OAAO;EACd,OAAO,MAAM,EAAE,KAAK,MAAM,GAAG,0BAA0B;CACzD;AAEJ"}

package/dist/capture/publish/extract.d.mts

@@ -0,0 +1,20 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ExtractionLimits } from "./limits.mjs";
+import { Readable } from "node:stream";
+//#region src/capture/publish/extract.d.ts
+/** What an extraction produced. */
+interface ExtractionResult {
+  entries: number;
+  bytes: number;
+}
+/**
+ * Extract `source` (a zip stream) under `root`, which must exist.
+ *
+ * @throws {ZipLimitError} When a cap is exceeded or an entry path escapes `root`; the source is
+ *   destroyed at once, and the files written so far are left for the caller's scratch cleanup.
+ */
+declare function extractZipStream(source: Readable, root: string, limits: ExtractionLimits): Promise<ExtractionResult>;
+//#endregion
+export { ExtractionResult, extractZipStream };
+//# sourceMappingURL=extract.d.mts.map

package/dist/capture/publish/extract.mjs

@@ -0,0 +1,119 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { ZipLimitError } from "./limits.mjs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { Parse } from "unzipper";
+//#region src/capture/publish/extract.ts
+/**
+* Streaming, capped extraction of an uploaded Storybook zip into a directory. Entry count and
+* uncompressed bytes are counted while the archive streams (never from a header or from
+* `Content-Length`), and a path that leaves the target is refused.
+*/
+/**
+* Extract `source` (a zip stream) under `root`, which must exist.
+*
+* @throws {ZipLimitError} When a cap is exceeded or an entry path escapes `root`; the source is
+*   destroyed at once, and the files written so far are left for the caller's scratch cleanup.
+*/
+async function extractZipStream(source, root, limits) {
+	const run = new Extraction(resolve(root), limits);
+	const failure = await run.parse(source);
+	const outcomes = await Promise.allSettled(run.writes);
+	if (failure) throw failure;
+	const writeError = outcomes.find((outcome) => outcome.status === "rejected");
+	if (writeError) throw writeError.reason;
+	return {
+		entries: run.entries,
+		bytes: run.bytes
+	};
+}
+function ignore() {}
+/** State of one extraction. */
+var Extraction = class {
+	entries = 0;
+	bytes = 0;
+	writes = [];
+	root;
+	limits;
+	#failed = false;
+	#fail = ignore;
+	constructor(root, limits) {
+		this.root = root;
+		this.limits = limits;
+	}
+	/** Resolves with the first failure, or null once the archive was read to its end. */
+	parse(source) {
+		return new Promise((settle) => {
+			const parser = Parse();
+			this.#fail = (error) => {
+				if (!this.#failed) {
+					this.#failed = true;
+					source.destroy();
+					parser.destroy();
+					settle(error);
+				}
+			};
+			parser.on("entry", (entry) => {
+				this.#entry(entry);
+			});
+			parser.on("error", this.#fail);
+			parser.on("close", () => {
+				settle(null);
+			});
+			source.on("error", this.#fail);
+			source.pipe(parser);
+		});
+	}
+	#entry(entry) {
+		this.entries += 1;
+		const problem = this.#problemWith(entry);
+		if (problem) this.#fail(problem);
+		if (this.#failed || entry.type === "Directory") {
+			entry.autodrain();
+			return;
+		}
+		this.#write(entry);
+	}
+	#problemWith(entry) {
+		if (this.entries > this.limits.maxEntries) return new ZipLimitError(`Zip holds more than ${this.limits.maxEntries} entries`);
+		if (unsafePath(this.root, entry.path)) return new ZipLimitError(`Blocked path traversal in uploaded Storybook: ${entry.path}`);
+		return null;
+	}
+	#write(entry) {
+		const target = join(this.root, entry.path);
+		const done = (async () => {
+			await mkdir(dirname(target), { recursive: true });
+			await pipeline(entry, this.#counter(), createWriteStream(target));
+		})();
+		this.writes.push(done);
+		done.catch(ignore);
+	}
+	/** Counts the bytes that pass; past the cap the whole extraction fails at once. */
+	#counter() {
+		return new Transform({ transform: (chunk, _encoding, callback) => {
+			this.bytes += chunk.length;
+			if (this.bytes > this.limits.maxBytes) {
+				const error = new ZipLimitError(`Zip expands beyond ${this.limits.maxBytes} bytes`);
+				this.#fail(error);
+				callback(error);
+				return;
+			}
+			callback(null, chunk);
+		} });
+	}
+};
+/** Absolute paths, drive letters and anything resolving outside `root`. */
+function unsafePath(root, entryPath) {
+	if (isAbsolute(entryPath) || /^[a-zA-Z]:/u.test(entryPath)) return true;
+	const candidate = resolve(join(root, entryPath));
+	return candidate !== root && !candidate.startsWith(root + sep);
+}
+//#endregion
+export { extractZipStream };
+
+//# sourceMappingURL=extract.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract.mjs","names":[],"sources":["../../../src/capture/publish/extract.ts"],"sourcesContent":["/**\n * Streaming, capped extraction of an uploaded Storybook zip into a directory. Entry count and\n * uncompressed bytes are counted while the archive streams (never from a header or from\n * `Content-Length`), and a path that leaves the target is refused.\n */\nimport { createWriteStream } from \"node:fs\";\nimport { mkdir } from \"node:fs/promises\";\nimport { dirname, isAbsolute, join, resolve, sep } from \"node:path\";\nimport { Transform, type Readable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport { Parse, type Entry } from \"unzipper\";\nimport { ZipLimitError, type ExtractionLimits } from \"./limits.ts\";\n\n/** What an extraction produced. */\nexport interface ExtractionResult {\n  entries: number;\n  bytes: number;\n}\n\n/**\n * Extract `source` (a zip stream) under `root`, which must exist.\n *\n * @throws {ZipLimitError} When a cap is exceeded or an entry path escapes `root`; the source is\n *   destroyed at once, and the files written so far are left for the caller's scratch cleanup.\n */\nexport async function extractZipStream(\n  source: Readable,\n  root: string,\n  limits: ExtractionLimits,\n): Promise<ExtractionResult> {\n  const run = new Extraction(resolve(root), limits);\n  const failure = await run.parse(source);\n  // Writes may still be in flight after a failure; settle them before anyone removes the files.\n  const outcomes = await Promise.allSettled(run.writes);\n  if (failure) {\n    throw failure;\n  }\n  const writeError = outcomes.find(\n    (outcome): outcome is PromiseRejectedResult => outcome.status === \"rejected\",\n  );\n  if (writeError) {\n    throw writeError.reason;\n  }\n  return { entries: run.entries, bytes: run.bytes };\n}\n\nfunction ignore(): void {}\n\n/** State of one extraction. */\nclass Extraction {\n  entries = 0;\n  bytes = 0;\n  readonly writes: Promise<void>[] = [];\n  readonly root: string;\n  readonly limits: ExtractionLimits;\n  #failed = false;\n  #fail: (error: unknown) => void = ignore;\n\n  constructor(root: string, limits: ExtractionLimits) {\n    this.root = root;\n    this.limits = limits;\n  }\n\n  /** Resolves with the first failure, or null once the archive was read to its end. */\n  // oxlint-disable-next-line typescript/promise-function-async -- executor-style wrapper around stream events\n  parse(source: Readable): Promise<unknown> {\n    return new Promise((settle) => {\n      const parser = Parse();\n      this.#fail = (error: unknown): void => {\n        if (!this.#failed) {\n          this.#failed = true;\n          source.destroy();\n          parser.destroy();\n          settle(error);\n        }\n      };\n      parser.on(\"entry\", (entry: Entry) => {\n        this.#entry(entry);\n      });\n      parser.on(\"error\", this.#fail);\n      parser.on(\"close\", () => {\n        settle(null);\n      });\n      source.on(\"error\", this.#fail);\n      source.pipe(parser);\n    });\n  }\n\n  #entry(entry: Entry): void {\n    this.entries += 1;\n    const problem = this.#problemWith(entry);\n    if (problem) {\n      this.#fail(problem);\n    }\n    if (this.#failed || entry.type === \"Directory\") {\n      entry.autodrain();\n      return;\n    }\n    this.#write(entry);\n  }\n\n  #problemWith(entry: Entry): ZipLimitError | null {\n    if (this.entries > this.limits.maxEntries) {\n      return new ZipLimitError(`Zip holds more than ${this.limits.maxEntries} entries`);\n    }\n    if (unsafePath(this.root, entry.path)) {\n      return new ZipLimitError(`Blocked path traversal in uploaded Storybook: ${entry.path}`);\n    }\n    return null;\n  }\n\n  #write(entry: Entry): void {\n    const target = join(this.root, entry.path);\n    const done = (async (): Promise<void> => {\n      await mkdir(dirname(target), { recursive: true });\n      await pipeline(entry, this.#counter(), createWriteStream(target));\n    })();\n    this.writes.push(done);\n    done.catch(ignore); // Aggregated through allSettled by the caller\n  }\n\n  /** Counts the bytes that pass; past the cap the whole extraction fails at once. */\n  #counter(): Transform {\n    return new Transform({\n      transform: (chunk: Buffer, _encoding, callback) => {\n        this.bytes += chunk.length;\n        if (this.bytes > this.limits.maxBytes) {\n          const error = new ZipLimitError(`Zip expands beyond ${this.limits.maxBytes} bytes`);\n          this.#fail(error);\n          callback(error);\n          return;\n        }\n        callback(null, chunk);\n      },\n    });\n  }\n}\n\n/** Absolute paths, drive letters and anything resolving outside `root`. */\nfunction unsafePath(root: string, entryPath: string): boolean {\n  if (isAbsolute(entryPath) || /^[a-zA-Z]:/u.test(entryPath)) {\n    return true;\n  }\n  const candidate = resolve(join(root, entryPath));\n  return candidate !== root && !candidate.startsWith(root + sep);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyBA,eAAsB,iBACpB,QACA,MACA,QAC2B;CAC3B,MAAM,MAAM,IAAI,WAAW,QAAQ,IAAI,GAAG,MAAM;CAChD,MAAM,UAAU,MAAM,IAAI,MAAM,MAAM;CAEtC,MAAM,WAAW,MAAM,QAAQ,WAAW,IAAI,MAAM;CACpD,IAAI,SACF,MAAM;CAER,MAAM,aAAa,SAAS,MACzB,YAA8C,QAAQ,WAAW,UACpE;CACA,IAAI,YACF,MAAM,WAAW;CAEnB,OAAO;EAAE,SAAS,IAAI;EAAS,OAAO,IAAI;CAAM;AAClD;AAEA,SAAS,SAAe,CAAC;;AAGzB,IAAM,aAAN,MAAiB;CACf,UAAU;CACV,QAAQ;CACR,SAAmC,CAAC;CACpC;CACA;CACA,UAAU;CACV,QAAkC;CAElC,YAAY,MAAc,QAA0B;EAClD,KAAK,OAAO;EACZ,KAAK,SAAS;CAChB;;CAIA,MAAM,QAAoC;EACxC,OAAO,IAAI,SAAS,WAAW;GAC7B,MAAM,SAAS,MAAM;GACrB,KAAK,SAAS,UAAyB;IACrC,IAAI,CAAC,KAAK,SAAS;KACjB,KAAK,UAAU;KACf,OAAO,QAAQ;KACf,OAAO,QAAQ;KACf,OAAO,KAAK;IACd;GACF;GACA,OAAO,GAAG,UAAU,UAAiB;IACnC,KAAK,OAAO,KAAK;GACnB,CAAC;GACD,OAAO,GAAG,SAAS,KAAK,KAAK;GAC7B,OAAO,GAAG,eAAe;IACvB,OAAO,IAAI;GACb,CAAC;GACD,OAAO,GAAG,SAAS,KAAK,KAAK;GAC7B,OAAO,KAAK,MAAM;EACpB,CAAC;CACH;CAEA,OAAO,OAAoB;EACzB,KAAK,WAAW;EAChB,MAAM,UAAU,KAAK,aAAa,KAAK;EACvC,IAAI,SACF,KAAK,MAAM,OAAO;EAEpB,IAAI,KAAK,WAAW,MAAM,SAAS,aAAa;GAC9C,MAAM,UAAU;GAChB;EACF;EACA,KAAK,OAAO,KAAK;CACnB;CAEA,aAAa,OAAoC;EAC/C,IAAI,KAAK,UAAU,KAAK,OAAO,YAC7B,OAAO,IAAI,cAAc,uBAAuB,KAAK,OAAO,WAAW,SAAS;EAElF,IAAI,WAAW,KAAK,MAAM,MAAM,IAAI,GAClC,OAAO,IAAI,cAAc,iDAAiD,MAAM,MAAM;EAExF,OAAO;CACT;CAEA,OAAO,OAAoB;EACzB,MAAM,SAAS,KAAK,KAAK,MAAM,MAAM,IAAI;EACzC,MAAM,QAAQ,YAA2B;GACvC,MAAM,MAAM,QAAQ,MAAM,GAAG,EAAE,WAAW,KAAK,CAAC;GAChD,MAAM,SAAS,OAAO,KAAK,SAAS,GAAG,kBAAkB,MAAM,CAAC;EAClE,EAAA,CAAG;EACH,KAAK,OAAO,KAAK,IAAI;EACrB,KAAK,MAAM,MAAM;CACnB;;CAGA,WAAsB;EACpB,OAAO,IAAI,UAAU,EACnB,YAAY,OAAe,WAAW,aAAa;GACjD,KAAK,SAAS,MAAM;GACpB,IAAI,KAAK,QAAQ,KAAK,OAAO,UAAU;IACrC,MAAM,QAAQ,IAAI,cAAc,sBAAsB,KAAK,OAAO,SAAS,OAAO;IAClF,KAAK,MAAM,KAAK;IAChB,SAAS,KAAK;IACd;GACF;GACA,SAAS,MAAM,KAAK;EACtB,EACF,CAAC;CACH;AACF;;AAGA,SAAS,WAAW,MAAc,WAA4B;CAC5D,IAAI,WAAW,SAAS,KAAK,cAAc,KAAK,SAAS,GACvD,OAAO;CAET,MAAM,YAAY,QAAQ,KAAK,MAAM,SAAS,CAAC;CAC/C,OAAO,cAAc,QAAQ,CAAC,UAAU,WAAW,OAAO,GAAG;AAC/D"}

package/dist/capture/publish/handler.d.mts

@@ -0,0 +1,28 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../../adapter/database.mjs";
+import { Logger } from "../../logger.mjs";
+import { StorageAdapter } from "../../adapter/storage.mjs";
+import { ExtractionLimits } from "./limits.mjs";
+import { KindHandler } from "../consumer/types.mjs";
+import { PublishCompleter } from "./complete.mjs";
+//#region src/capture/publish/handler.d.ts
+/** What {@link createPublishHandler} needs. */
+interface PublishHandlerOptions {
+  db: DatabaseAdapter;
+  storage: StorageAdapter;
+  scratchDir: string;
+  limits: ExtractionLimits;
+  completer: PublishCompleter;
+  logger: Logger;
+}
+/**
+ * The handler. Resolving acks the job. A zip that breaks a cap is a final answer (retrying cannot
+ * help): the build is failed and the job acked. Any other error is retried by the consumer, and
+ * the build is failed on the last attempt. A redelivery after a lost lease repeats the extraction
+ * (same keys) and leaves an already accepted build alone.
+ */
+declare function createPublishHandler(options: PublishHandlerOptions): KindHandler;
+//#endregion
+export { PublishHandlerOptions, createPublishHandler };
+//# sourceMappingURL=handler.d.mts.map

package/dist/capture/publish/handler.mjs

@@ -0,0 +1,62 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { BuildModel } from "../../models/build.mjs";
+import { ZipLimitError } from "./limits.mjs";
+import { publishStoredZip } from "./run.mjs";
+//#region src/capture/publish/handler.ts
+/** A `publish` job needs the build to publish. */
+function hasBuild(job) {
+	return typeof job.buildId === "string" && job.buildId.length > 0;
+}
+/**
+* The handler. Resolving acks the job. A zip that breaks a cap is a final answer (retrying cannot
+* help): the build is failed and the job acked. Any other error is retried by the consumer, and
+* the build is failed on the last attempt. A redelivery after a lost lease repeats the extraction
+* (same keys) and leaves an already accepted build alone.
+*/
+function createPublishHandler(options) {
+	return {
+		accepts: hasBuild,
+		run: async (job, context) => {
+			const build = await new BuildModel(options.db).get(job.buildId);
+			if (!build) {
+				context.logger.warn("build is gone; dropping publish job");
+				return;
+			}
+			await publishOnce(options, job, context, build.projectId);
+		}
+	};
+}
+async function publishOnce(options, job, context, projectId) {
+	const { completer, storage, scratchDir, limits, db } = options;
+	try {
+		await publishStoredZip({
+			storage,
+			scratchDir,
+			limits,
+			db,
+			logger: context.logger,
+			touch: context.touch
+		}, {
+			projectId,
+			buildId: job.buildId
+		});
+	} catch (error) {
+		const permanent = error instanceof ZipLimitError;
+		if (permanent || (job.attempt ?? 1) >= (job.maxAttempts ?? 1)) await completer.complete(job.buildId, {
+			ok: false,
+			error: messageOf(error)
+		});
+		if (permanent) return;
+		throw error;
+	}
+	await completer.complete(job.buildId, { ok: true });
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { createPublishHandler };
+
+//# sourceMappingURL=handler.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handler.mjs","names":[],"sources":["../../../src/capture/publish/handler.ts"],"sourcesContent":["import type { DatabaseAdapter } from \"../../adapters/database.ts\";\n/** The `publish` job handler of the consumer (ADR 0006, decision 10): publish a stored zip, then complete the build. */\nimport type { StorageAdapter } from \"../../adapters/storage.ts\";\nimport type { Logger } from \"../../logger.ts\";\nimport { BuildModel } from \"../../models/build.ts\";\nimport type { ConsumerJob, KindHandler } from \"../consumer/types.ts\";\nimport type { PublishCompleter } from \"./complete.ts\";\nimport { ZipLimitError, type ExtractionLimits } from \"./limits.ts\";\nimport { publishStoredZip } from \"./run.ts\";\n\n/** What {@link createPublishHandler} needs. */\nexport interface PublishHandlerOptions {\n  db: DatabaseAdapter;\n  storage: StorageAdapter;\n  scratchDir: string;\n  limits: ExtractionLimits;\n  completer: PublishCompleter;\n  logger: Logger;\n}\n\n/** A `publish` job needs the build to publish. */\nfunction hasBuild(job: ConsumerJob): boolean {\n  return typeof job.buildId === \"string\" && job.buildId.length > 0;\n}\n\n/**\n * The handler. Resolving acks the job. A zip that breaks a cap is a final answer (retrying cannot\n * help): the build is failed and the job acked. Any other error is retried by the consumer, and\n * the build is failed on the last attempt. A redelivery after a lost lease repeats the extraction\n * (same keys) and leaves an already accepted build alone.\n */\nexport function createPublishHandler(options: PublishHandlerOptions): KindHandler {\n  return {\n    accepts: hasBuild,\n    run: async (job, context) => {\n      const build = await new BuildModel(options.db).get(job.buildId);\n      if (!build) {\n        context.logger.warn(\"build is gone; dropping publish job\");\n        return;\n      }\n      await publishOnce(options, job, context, build.projectId);\n    },\n  };\n}\n\nasync function publishOnce(\n  options: PublishHandlerOptions,\n  job: ConsumerJob,\n  context: { logger: Logger; touch: () => void },\n  projectId: string,\n): Promise<void> {\n  const { completer, storage, scratchDir, limits, db } = options;\n  try {\n    await publishStoredZip(\n      { storage, scratchDir, limits, db, logger: context.logger, touch: context.touch },\n      { projectId, buildId: job.buildId },\n    );\n  } catch (error) {\n    const permanent = error instanceof ZipLimitError;\n    if (permanent || (job.attempt ?? 1) >= (job.maxAttempts ?? 1)) {\n      await completer.complete(job.buildId, { ok: false, error: messageOf(error) });\n    }\n    if (permanent) {\n      return;\n    }\n    throw error;\n  }\n  await completer.complete(job.buildId, { ok: true });\n}\n\nfunction messageOf(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n"],"mappings":";;;;;;;;AAqBA,SAAS,SAAS,KAA2B;CAC3C,OAAO,OAAO,IAAI,YAAY,YAAY,IAAI,QAAQ,SAAS;AACjE;;;;;;;AAQA,SAAgB,qBAAqB,SAA6C;CAChF,OAAO;EACL,SAAS;EACT,KAAK,OAAO,KAAK,YAAY;GAC3B,MAAM,QAAQ,MAAM,IAAI,WAAW,QAAQ,EAAE,CAAC,CAAC,IAAI,IAAI,OAAO;GAC9D,IAAI,CAAC,OAAO;IACV,QAAQ,OAAO,KAAK,qCAAqC;IACzD;GACF;GACA,MAAM,YAAY,SAAS,KAAK,SAAS,MAAM,SAAS;EAC1D;CACF;AACF;AAEA,eAAe,YACb,SACA,KACA,SACA,WACe;CACf,MAAM,EAAE,WAAW,SAAS,YAAY,QAAQ,OAAO;CACvD,IAAI;EACF,MAAM,iBACJ;GAAE;GAAS;GAAY;GAAQ;GAAI,QAAQ,QAAQ;GAAQ,OAAO,QAAQ;EAAM,GAChF;GAAE;GAAW,SAAS,IAAI;EAAQ,CACpC;CACF,SAAS,OAAO;EACd,MAAM,YAAY,iBAAiB;EACnC,IAAI,cAAc,IAAI,WAAW,OAAO,IAAI,eAAe,IACzD,MAAM,UAAU,SAAS,IAAI,SAAS;GAAE,IAAI;GAAO,OAAO,UAAU,KAAK;EAAE,CAAC;EAE9E,IAAI,WACF;EAEF,MAAM;CACR;CACA,MAAM,UAAU,SAAS,IAAI,SAAS,EAAE,IAAI,KAAK,CAAC;AACpD;AAEA,SAAS,UAAU,OAAwB;CACzC,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D"}

package/dist/capture/publish/index.d.mts

@@ -0,0 +1,10 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DEFAULT_MAX_INLINE_UNZIP_SIZE, DEFAULT_MAX_UNZIPPED_BYTES, DEFAULT_MAX_ZIP_ENTRIES, ExtractionLimits, FILE_BY_FILE_HINT, PublishLimits, ZipLimitError, extractionLimitsOf, publishRoute, resolvePublishLimits } from "./limits.mjs";
+import { AfterPublishContext, AfterPublishHook, PublishCompleter, PublishCompleterOptions, PublishOutcome, createPublishCompleter } from "./complete.mjs";
+import { PublishHandlerOptions, createPublishHandler } from "./handler.mjs";
+import { PublishFacts, publishVerdict } from "./accept.mjs";
+import { publishingOf } from "./published.mjs";
+import { ExtractionResult, extractZipStream } from "./extract.mjs";
+import { PUBLISH_SCRATCH_ID, PublishZipOptions, publishStoredZip } from "./run.mjs";
+export { type AfterPublishContext, type AfterPublishHook, DEFAULT_MAX_INLINE_UNZIP_SIZE, DEFAULT_MAX_UNZIPPED_BYTES, DEFAULT_MAX_ZIP_ENTRIES, type ExtractionLimits, type ExtractionResult, FILE_BY_FILE_HINT, PUBLISH_SCRATCH_ID, type PublishCompleter, type PublishCompleterOptions, type PublishFacts, type PublishHandlerOptions, type PublishLimits, type PublishOutcome, type PublishZipOptions, ZipLimitError, createPublishCompleter, createPublishHandler, extractZipStream, extractionLimitsOf, publishRoute, publishStoredZip, publishVerdict, publishingOf, resolvePublishLimits };

package/dist/capture/publish/limits.d.mts

@@ -0,0 +1,37 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ShelfConfig } from "../../config.mjs";
+//#region src/capture/publish/limits.d.ts
+/** Zip size (bytes) up to which a zip is extracted inline in the upload request: 50 MB. */
+declare const DEFAULT_MAX_INLINE_UNZIP_SIZE: number;
+/** Entries an uploaded Storybook zip may hold. A large Storybook has some thousands of files. */
+declare const DEFAULT_MAX_ZIP_ENTRIES = 50000;
+/** Total uncompressed bytes an uploaded Storybook zip may expand to: 2 GiB. */
+declare const DEFAULT_MAX_UNZIPPED_BYTES: number;
+/** Caps enforced while a zip is extracted; the compressed size alone is no bound. */
+interface ExtractionLimits {
+  /** Most entries (files and directories) the archive may hold. */
+  maxEntries: number;
+  /** Most uncompressed bytes all files together may expand to, counted while streaming. */
+  maxBytes: number;
+}
+/** Everything the publish pipeline reads from `ShelfConfig`, defaults applied. */
+interface PublishLimits extends ExtractionLimits {
+  /** Largest zip extracted inline in the upload request; `0` sends every zip to a `publish` job. */
+  inlineBytes: number;
+}
+/** The effective publish limits of a config. */
+declare function resolvePublishLimits(config?: Pick<ShelfConfig, "maxInlineUnzipSize" | "maxZipEntries" | "maxUnzippedBytes">): PublishLimits;
+/** The extraction caps alone. */
+declare function extractionLimitsOf(limits: PublishLimits | ExtractionLimits): ExtractionLimits;
+/** How an upload of `zipBytes` is published: inline in the request, or by a `publish` job. */
+declare function publishRoute(zipBytes: number, limits: Pick<PublishLimits, "inlineBytes">): "inline" | "job";
+/** An archive that breaks a cap or tries to write outside the target; retrying cannot help. */
+declare class ZipLimitError extends Error {
+  readonly name = "ZipLimitError";
+}
+/** Message of the 413 an over-limit zip gets on a host with no `publish` consumer. */
+declare const FILE_BY_FILE_HINT: string;
+//#endregion
+export { DEFAULT_MAX_INLINE_UNZIP_SIZE, DEFAULT_MAX_UNZIPPED_BYTES, DEFAULT_MAX_ZIP_ENTRIES, ExtractionLimits, FILE_BY_FILE_HINT, PublishLimits, ZipLimitError, extractionLimitsOf, publishRoute, resolvePublishLimits };
+//# sourceMappingURL=limits.d.mts.map

package/dist/capture/publish/limits.mjs

@@ -0,0 +1,39 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/capture/publish/limits.ts
+/** Zip size (bytes) up to which a zip is extracted inline in the upload request: 50 MB. */
+const DEFAULT_MAX_INLINE_UNZIP_SIZE = 52428800;
+/** Entries an uploaded Storybook zip may hold. A large Storybook has some thousands of files. */
+const DEFAULT_MAX_ZIP_ENTRIES = 5e4;
+/** Total uncompressed bytes an uploaded Storybook zip may expand to: 2 GiB. */
+const DEFAULT_MAX_UNZIPPED_BYTES = 2147483648;
+/** The effective publish limits of a config. */
+function resolvePublishLimits(config) {
+	return {
+		inlineBytes: config?.maxInlineUnzipSize ?? 52428800,
+		maxEntries: config?.maxZipEntries ?? 5e4,
+		maxBytes: config?.maxUnzippedBytes ?? 2147483648
+	};
+}
+/** The extraction caps alone. */
+function extractionLimitsOf(limits) {
+	return {
+		maxEntries: limits.maxEntries,
+		maxBytes: limits.maxBytes
+	};
+}
+/** How an upload of `zipBytes` is published: inline in the request, or by a `publish` job. */
+function publishRoute(zipBytes, limits) {
+	return zipBytes <= limits.inlineBytes ? "inline" : "job";
+}
+/** An archive that breaks a cap or tries to write outside the target; retrying cannot help. */
+var ZipLimitError = class extends Error {
+	name = "ZipLimitError";
+};
+/** Message of the 413 an over-limit zip gets on a host with no `publish` consumer. */
+const FILE_BY_FILE_HINT = "Zip is larger than the inline publish limit and this host runs no publish consumer. Upload the Storybook file by file instead: POST /dedup, then PUT /content, then POST /manifest (the storyshelf CLI does this when it is given a directory).";
+//#endregion
+export { DEFAULT_MAX_INLINE_UNZIP_SIZE, DEFAULT_MAX_UNZIPPED_BYTES, DEFAULT_MAX_ZIP_ENTRIES, FILE_BY_FILE_HINT, ZipLimitError, extractionLimitsOf, publishRoute, resolvePublishLimits };
+
+//# sourceMappingURL=limits.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limits.mjs","names":[],"sources":["../../../src/capture/publish/limits.ts"],"sourcesContent":["/** Publish limits (ADR 0006, decision 10): the inline threshold and the extraction caps, with defaults. */\nimport type { ShelfConfig } from \"../../config.ts\";\n\n/** Zip size (bytes) up to which a zip is extracted inline in the upload request: 50 MB. */\nexport const DEFAULT_MAX_INLINE_UNZIP_SIZE = 50 * 1024 * 1024;\n\n/** Entries an uploaded Storybook zip may hold. A large Storybook has some thousands of files. */\nexport const DEFAULT_MAX_ZIP_ENTRIES = 50_000;\n\n/** Total uncompressed bytes an uploaded Storybook zip may expand to: 2 GiB. */\nexport const DEFAULT_MAX_UNZIPPED_BYTES = 2 * 1024 * 1024 * 1024;\n\n/** Caps enforced while a zip is extracted; the compressed size alone is no bound. */\nexport interface ExtractionLimits {\n  /** Most entries (files and directories) the archive may hold. */\n  maxEntries: number;\n  /** Most uncompressed bytes all files together may expand to, counted while streaming. */\n  maxBytes: number;\n}\n\n/** Everything the publish pipeline reads from `ShelfConfig`, defaults applied. */\nexport interface PublishLimits extends ExtractionLimits {\n  /** Largest zip extracted inline in the upload request; `0` sends every zip to a `publish` job. */\n  inlineBytes: number;\n}\n\n/** The effective publish limits of a config. */\nexport function resolvePublishLimits(\n  config?: Pick<ShelfConfig, \"maxInlineUnzipSize\" | \"maxZipEntries\" | \"maxUnzippedBytes\">,\n): PublishLimits {\n  return {\n    inlineBytes: config?.maxInlineUnzipSize ?? DEFAULT_MAX_INLINE_UNZIP_SIZE,\n    maxEntries: config?.maxZipEntries ?? DEFAULT_MAX_ZIP_ENTRIES,\n    maxBytes: config?.maxUnzippedBytes ?? DEFAULT_MAX_UNZIPPED_BYTES,\n  };\n}\n\n/** The extraction caps alone. */\nexport function extractionLimitsOf(limits: PublishLimits | ExtractionLimits): ExtractionLimits {\n  return { maxEntries: limits.maxEntries, maxBytes: limits.maxBytes };\n}\n\n/** How an upload of `zipBytes` is published: inline in the request, or by a `publish` job. */\nexport function publishRoute(\n  zipBytes: number,\n  limits: Pick<PublishLimits, \"inlineBytes\">,\n): \"inline\" | \"job\" {\n  return zipBytes <= limits.inlineBytes ? \"inline\" : \"job\";\n}\n\n/** An archive that breaks a cap or tries to write outside the target; retrying cannot help. */\nexport class ZipLimitError extends Error {\n  override readonly name = \"ZipLimitError\";\n}\n\n/** Message of the 413 an over-limit zip gets on a host with no `publish` consumer. */\nexport const FILE_BY_FILE_HINT =\n  \"Zip is larger than the inline publish limit and this host runs no publish consumer. \" +\n  \"Upload the Storybook file by file instead: POST /dedup, then PUT /content, then POST /manifest \" +\n  \"(the storyshelf CLI does this when it is given a directory).\";\n"],"mappings":";;;;;AAIA,MAAa,gCAAgC;;AAG7C,MAAa,0BAA0B;;AAGvC,MAAa,6BAA6B;;AAiB1C,SAAgB,qBACd,QACe;CACf,OAAO;EACL,aAAa,QAAQ,sBAAA;EACrB,YAAY,QAAQ,iBAAA;EACpB,UAAU,QAAQ,oBAAA;CACpB;AACF;;AAGA,SAAgB,mBAAmB,QAA4D;CAC7F,OAAO;EAAE,YAAY,OAAO;EAAY,UAAU,OAAO;CAAS;AACpE;;AAGA,SAAgB,aACd,UACA,QACkB;CAClB,OAAO,YAAY,OAAO,cAAc,WAAW;AACrD;;AAGA,IAAa,gBAAb,cAAmC,MAAM;CACvC,OAAyB;AAC3B;;AAGA,MAAa,oBACX"}

package/dist/capture/publish/published.d.mts

@@ -0,0 +1,15 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { StorageAdapter } from "../../adapter/storage.mjs";
+import { PublishingState } from "../../adapters/notifier/build-state.mjs";
+import { Build } from "../../schema/build.mjs";
+//#region src/capture/publish/published.d.ts
+/**
+ * How publishing the build stands. The manifest is written last, so its presence means done. A
+ * `failed` or `cancelled` build without one did not publish (or never uploaded); any other build waits. Without
+ * a storage adapter nothing can be read, so publishing reads as pending.
+ */
+declare function publishingOf(storage: StorageAdapter | undefined, build: Pick<Build, "id" | "projectId" | "status">): Promise<PublishingState>;
+//#endregion
+export { publishingOf };
+//# sourceMappingURL=published.d.mts.map

package/dist/capture/publish/published.mjs

@@ -0,0 +1,18 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { storybookDir } from "../../paths.mjs";
+//#region src/capture/publish/published.ts
+/**
+* How publishing the build stands. The manifest is written last, so its presence means done. A
+* `failed` or `cancelled` build without one did not publish (or never uploaded); any other build waits. Without
+* a storage adapter nothing can be read, so publishing reads as pending.
+*/
+async function publishingOf(storage, build) {
+	if (storage !== void 0 && await storage.exists(`${storybookDir(build.projectId, build.id)}/manifest.json`)) return "success";
+	return build.status === "failed" || build.status === "cancelled" ? "failure" : "pending";
+}
+//#endregion
+export { publishingOf };
+
+//# sourceMappingURL=published.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"published.mjs","names":[],"sources":["../../../src/capture/publish/published.ts"],"sourcesContent":["/**\n * Whether a build's Storybook is published: the one probe behind the `<prefix>/storybook` status\n * (ADR 0014) and the rule that a verdict waits for publishing to end (ADR 0013, decision 3).\n */\nimport type { PublishingState } from \"../../adapters/notifier/build-state.ts\";\nimport type { StorageAdapter } from \"../../adapters/storage.ts\";\nimport type { Build } from \"../../schema/build.ts\";\nimport { storybookDir } from \"../../utils/paths.ts\";\n\n/**\n * How publishing the build stands. The manifest is written last, so its presence means done. A\n * `failed` or `cancelled` build without one did not publish (or never uploaded); any other build waits. Without\n * a storage adapter nothing can be read, so publishing reads as pending.\n */\nexport async function publishingOf(\n  storage: StorageAdapter | undefined,\n  build: Pick<Build, \"id\" | \"projectId\" | \"status\">,\n): Promise<PublishingState> {\n  const published =\n    storage !== undefined &&\n    (await storage.exists(`${storybookDir(build.projectId, build.id)}/manifest.json`));\n  if (published) {\n    return \"success\";\n  }\n  return build.status === \"failed\" || build.status === \"cancelled\" ? \"failure\" : \"pending\";\n}\n"],"mappings":";;;;;;;;;;AAcA,eAAsB,aACpB,SACA,OAC0B;CAI1B,IAFE,YAAY,KAAA,KACX,MAAM,QAAQ,OAAO,GAAG,aAAa,MAAM,WAAW,MAAM,EAAE,EAAE,eAAe,GAEhF,OAAO;CAET,OAAO,MAAM,WAAW,YAAY,MAAM,WAAW,cAAc,YAAY;AACjF"}

package/dist/capture/publish/run.d.mts

@@ -0,0 +1,33 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../../adapter/database.mjs";
+import { Logger } from "../../logger.mjs";
+import { StorageAdapter } from "../../adapter/storage.mjs";
+import { ExtractionLimits } from "./limits.mjs";
+//#region src/capture/publish/run.d.ts
+/** Scratch id publishing uses, so it never shares a directory with the build's capture. */
+declare const PUBLISH_SCRATCH_ID = "publish";
+/** What {@link publishStoredZip} works with. */
+interface PublishZipOptions {
+  storage: StorageAdapter;
+  scratchDir: string;
+  limits: ExtractionLimits;
+  /** Records the persisted content in `content_refs`, so retention knows who still uses it. */
+  db?: DatabaseAdapter | undefined;
+  logger: Logger;
+  /** Called between stages (renews a job's lease). */
+  touch?: () => void;
+}
+/**
+ * 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.
+ */
+declare function publishStoredZip(options: PublishZipOptions, target: {
+  projectId: string;
+  buildId: string;
+}): Promise<void>;
+//#endregion
+export { PUBLISH_SCRATCH_ID, PublishZipOptions, publishStoredZip };
+//# sourceMappingURL=run.d.mts.map