gutterpress 0.0.0 → 0.9.0-alpha.2

package/dist/{cli-7ykx7pp0.js → cli-k4bd06sd.js}

@@ -20,13 +20,13 @@ import {
   stampCreator,
   stripAnnotations,
   warn
-} from "./cli-h7phg3ka.js";
+} from "./cli-najycadg.js";
 import {
   BuildError,
   DEBOUNCE,
   UsageError,
   resolvePort
-} from "./cli-hvqjs342.js";
+} from "./cli-e5zhb0xs.js";
 import {
   gitDirFor,
   gitScopeFor,
@@ -40,11 +40,11 @@ import {
   snapshotWorkingTreeUnlocked,
   stageChanges,
   withRepoLock
-} from "./cli-5bxx0c4y.js";
+} from "./cli-yzrh708h.js";
 import {
   detectProjectSource,
   syncRemoteFor
-} from "./cli-1tyj4bk3.js";
+} from "./cli-wchtvxvw.js";
 import {
   defaultGitHttp
 } from "./cli-yja077f6.js";
@@ -52,14 +52,10 @@ import {
   __require
 } from "./cli-37x76zdn.js";
 
-// src/lib/manifest.ts
-import { readFile } from "node:fs/promises";
-import { existsSync, statSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { parse as parseYaml, YAMLParseError } from "yaml";
-
 // src/lib/presets.ts
+var PRESET_IDS = ["dtrpg", "book", "custom"];
 var DTRPG_PRESET = {
+  defaultTargets: ["dtrpg"],
   plugins: [],
   source: {
     files: null
@@ -131,6 +127,7 @@ var DTRPG_PRESET = {
   }
 };
 var BOOK_PRESET = {
+  defaultTargets: [],
   plugins: [],
   source: {
     files: null
@@ -195,9 +192,15 @@ var BOOK_PRESET = {
     }
   }
 };
+var CUSTOM_PRESET = {
+  ...BOOK_PRESET,
+  page: null,
+  defaultTargets: []
+};
 var PRESETS = {
   dtrpg: DTRPG_PRESET,
-  book: BOOK_PRESET
+  book: BOOK_PRESET,
+  custom: CUSTOM_PRESET
 };
 var warnedIds = new Set;
 function warnOnce(id, message, sink = defaultWarnSink) {
@@ -211,7 +214,7 @@ function defaultWarnSink(message) {
 }
 function resolvePreset(presetName) {
   if (presetName === undefined) {
-    warnOnce("no-preset-set", '[gutterpress] No `preset` set in manifest.yaml — defaulting to "dtrpg" ' + "(DriveThruRPG trim size, TAC cap 240, forced PDF/X) for backward " + "compatibility. Set `preset: dtrpg` to keep this explicitly, or " + "`preset: book` for a neutral 6x9in trade-book default with no " + "vendor TAC cap or PDF/X forcing.");
+    warnOnce("no-preset-set", '[gutterpress] No `preset` in manifest.yaml — using "dtrpg" ' + "(DriveThruRPG print-ready defaults). Set `preset: dtrpg`, `book`, " + "or `custom` to choose explicitly.");
     return DTRPG_PRESET;
   }
   const preset = PRESETS[presetName];
@@ -221,7 +224,126 @@ function resolvePreset(presetName) {
   return preset;
 }
 
+// src/lib/targets.ts
+var DTRPG_TARGET = {
+  id: "dtrpg",
+  label: "DriveThruRPG",
+  overlay: {
+    pdfx: { flavor: DTRPG_PRESET.pdfx.flavor },
+    ink: {
+      maxTac: DTRPG_PRESET.ink.maxTac,
+      tacTolerance: DTRPG_PRESET.ink.tacTolerance
+    },
+    validate: {
+      checks: {
+        "pdf.structure.qpdf": { enabled: true, severity: "error" },
+        "pdf.print.pdfx-markers": { enabled: true, severity: "error" },
+        "pdf.print.pdfx-metadata": { enabled: true, severity: "error" },
+        "pdf.print.embedded-fonts": { enabled: true, severity: "error" }
+      },
+      assets: {
+        allowedColorSpaces: [...DTRPG_PRESET.validate.assets.allowedColorSpaces]
+      },
+      pdf: {
+        forbidTransparency: DTRPG_PRESET.validate.pdf.forbidTransparency,
+        minImageResolution: DTRPG_PRESET.validate.pdf.minImageResolution
+      }
+    }
+  },
+  requiredChecks: [
+    "pdf.structure.qpdf",
+    "pdf.print.pdfx-markers",
+    "pdf.print.pdfx-metadata",
+    "pdf.print.embedded-fonts"
+  ],
+  requiredTools: ["qpdf", "gs"]
+};
+var ITCH_TARGET = {
+  id: "itch",
+  label: "itch.io",
+  overlay: {
+    validate: {
+      checks: {
+        "pdf.structure.qpdf": { enabled: true, severity: "error" },
+        "pdf.print.embedded-fonts": { enabled: true, severity: "error" },
+        "pdf.print.pdfx-markers": false,
+        "pdf.print.pdfx-metadata": false,
+        "pdf.print.ink-coverage": false,
+        "asset.image.tac-raster": false
+      },
+      assets: {
+        allowedColorSpaces: ["RGB", "CMYK", "Grayscale"],
+        allowAlpha: true
+      },
+      pdf: {
+        forbidTransparency: false,
+        requireBleed: false
+      }
+    }
+  },
+  requiredChecks: ["pdf.structure.qpdf", "pdf.print.embedded-fonts"],
+  requiredTools: []
+};
+var TARGETS = {
+  dtrpg: DTRPG_TARGET,
+  itch: ITCH_TARGET
+};
+var TARGET_IDS = Object.keys(TARGETS);
+function publishTargetFor(id) {
+  const target = TARGETS[id];
+  if (!target) {
+    throw new UsageError(`Unknown publish target "${id}". Known targets: ${TARGET_IDS.join(", ")}.`);
+  }
+  return target;
+}
+function resolveTargets(requested, fallback) {
+  const ids = requested ?? fallback;
+  const seen = new Set;
+  const out = [];
+  for (const id of ids) {
+    publishTargetFor(id);
+    if (!seen.has(id)) {
+      seen.add(id);
+      out.push(id);
+    }
+  }
+  return out;
+}
+function overlayPreset(preset, target) {
+  const o = target.overlay;
+  return {
+    ...preset,
+    pdfx: { ...preset.pdfx, ...o.pdfx },
+    ink: { ...preset.ink, ...o.ink },
+    validate: {
+      ...preset.validate,
+      checks: { ...preset.validate.checks, ...o.validate?.checks },
+      assets: { ...preset.validate.assets, ...o.validate?.assets },
+      pdf: { ...preset.validate.pdf, ...o.validate?.pdf }
+    }
+  };
+}
+var DEFAULT_STRICT_PDF_CHECKS = [
+  "pdf.structure.qpdf",
+  "pdf.print.pdfx-markers",
+  "pdf.print.pdfx-metadata",
+  "pdf.print.embedded-fonts"
+];
+function applyDefaultPdfStrictChecks(config) {
+  const next = structuredClone(config);
+  for (const checkId of DEFAULT_STRICT_PDF_CHECKS) {
+    if (next.validate.checks[checkId] === undefined) {
+      next.validate.checks[checkId] = { enabled: true, severity: "error" };
+    }
+  }
+  return next;
+}
+
 // src/lib/manifest.ts
+import { readFile } from "node:fs/promises";
+import { existsSync, statSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { parse as parseYaml, YAMLParseError } from "yaml";
 var MANIFEST_FILENAMES = [
   "manifest.yaml"
 ];
@@ -298,8 +420,34 @@ function mergeShape(cli, manifest, preset) {
   return out;
 }
 function resolveConfig(cliOverrides, manifest) {
+  const presetName = cliOverrides.preset ?? manifest.preset;
+  return resolveWithPreset(cliOverrides, manifest, resolvePreset(presetName));
+}
+function resolveConfigForTarget(cliOverrides, manifest, targetId) {
   const presetName = cliOverrides.preset ?? manifest.preset;
   const preset = resolvePreset(presetName);
+  return resolveWithPreset(cliOverrides, manifest, overlayPreset(preset, publishTargetFor(targetId)));
+}
+function resolveCustomPage(c, m) {
+  const width = c.page?.width ?? m.page?.width;
+  const height = c.page?.height ?? m.page?.height;
+  const missing = [
+    width === undefined ? "page.width" : null,
+    height === undefined ? "page.height" : null
+  ].filter((f) => f !== null);
+  if (missing.length > 0) {
+    throw new UsageError(`preset: custom requires ${missing.join(" and ")} in manifest.yaml ` + `(points; 72pt = 1in). Example for US Letter:
+` + `  page:
+    width: 612
+    height: 792`);
+  }
+  return {
+    width,
+    height,
+    tolerance: c.page?.tolerance ?? m.page?.tolerance ?? 0.5
+  };
+}
+function resolveWithPreset(cliOverrides, manifest, preset) {
   const m = manifest;
   const c = cliOverrides;
   const legacy = m;
@@ -321,9 +469,10 @@ function resolveConfig(cliOverrides, manifest) {
     authors: c.authors ?? m.authors ?? [],
     styles: c.styles ?? m.styles,
     plugins,
+    targets: resolveTargets(c.targets ?? m.targets, preset.defaultTargets),
     source: mergeShape(c.source, m.source, preset.source),
     pdfx: mergeShape(c.pdfx, m.pdfx, preset.pdfx),
-    page: mergeShape(c.page, m.page, preset.page),
+    page: preset.page ? mergeShape(c.page, m.page, preset.page) : resolveCustomPage(c, m),
     ink: mergeShape(c.ink, m.ink, preset.ink),
     lint: mergeShape(c.lint, m.lint, preset.lint),
     validate: {
@@ -2575,6 +2724,22 @@ function decodeRef(ref) {
 function toPosix(p) {
   return p.split(path3.sep).join("/");
 }
+function escapesProjectRoot(projectDir, absPath) {
+  const rel = path3.relative(projectDir, absPath);
+  return rel === ".." || rel.startsWith(`..${path3.sep}`) || path3.isAbsolute(rel);
+}
+function proseImageRefError(ref, projectDir) {
+  const cleaned = stripUrlSuffix(decodeRef(ref));
+  if (path3.isAbsolute(cleaned)) {
+    return `Image reference must be relative to the project: ${ref}
+` + `  Copy the file into your project folder and reference it from there.`;
+  }
+  if (escapesProjectRoot(projectDir, path3.resolve(projectDir, cleaned))) {
+    return `Image reference points outside the project: ${ref}
+` + `  Copy the file into your project folder and reference it from there.`;
+  }
+  return null;
+}
 function mimeFor(ext) {
   return MIME_BY_EXT[ext] ?? "application/octet-stream";
 }
@@ -2677,7 +2842,7 @@ async function inlineOne(cssPath, projectDir, copies, warnings, seen) {
         return dataUri(bytes, ext);
       }
       const projectRel = path3.relative(projectDir, absAsset);
-      const dest = projectRel && !projectRel.startsWith("..") && !path3.isAbsolute(projectRel) ? toPosix(projectRel) : `${HASHED_ASSET_DIR}/${contentHash(bytes)}${ext}`;
+      const dest = projectRel && !escapesProjectRoot(projectDir, absAsset) ? toPosix(projectRel) : `${HASHED_ASSET_DIR}/${contentHash(bytes)}${ext}`;
       copies.set(dest, { from: absAsset, to: dest });
       return dest;
     });
@@ -2768,19 +2933,14 @@ async function planImageCopies(projectDir, refs) {
   for (const ref of refs) {
     if (isNonFileUrl(ref))
       continue;
-    const cleaned = stripUrlSuffix(decodeRef(ref));
-    if (path3.isAbsolute(cleaned)) {
-      errors.push(`Image reference must be relative to the project: ${ref}
-` + `  Copy the file into your project folder and reference it from there.`);
+    const refError = proseImageRefError(ref, projectDir);
+    if (refError) {
+      errors.push(refError);
       continue;
     }
+    const cleaned = stripUrlSuffix(decodeRef(ref));
     const abs = path3.resolve(projectDir, cleaned);
     const rel = path3.relative(projectDir, abs);
-    if (rel.startsWith("..")) {
-      errors.push(`Image reference points outside the project: ${ref}
-` + `  Copy the file into your project folder and reference it from there.`);
-      continue;
-    }
     const dest = toPosix(rel);
     copies.set(dest, { from: abs, to: dest });
   }
@@ -2814,6 +2974,16 @@ var check19 = {
           if (inFence)
             continue;
           for (const { ref, kind } of extractLocalRefs(line)) {
+            const escape = kind === "image" ? proseImageRefError(ref, ctx.inputDir) : null;
+            if (escape) {
+              results.push(finding(check19.id, {
+                severity: "error",
+                message: escape,
+                file,
+                line: i + 1
+              }));
+              continue;
+            }
             if (localRefExists(ref, kind, file, ctx.inputDir))
               continue;
             results.push(finding(check19.id, {
@@ -3796,7 +3966,7 @@ function reportMissingTools(result) {
 
 // src/lib/validation-exec.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { join as join2, resolve as resolve6 } from "node:path";
+import { dirname as dirname3, join as join2, resolve as resolve6 } from "node:path";
 
 // src/lib/output-paths.ts
 import path4 from "node:path";
@@ -4396,17 +4566,6 @@ async function assembleBookHtml(opts) {
     throw new Error("No markdown files to render");
   }
   const md = createMarkdownRenderer(opts.plugins);
-  let sourceChapter = null;
-  if (opts.wrapChapters) {
-    const renderToken = md.renderer.renderToken.bind(md.renderer);
-    md.renderer.renderToken = (tokens, idx, options) => {
-      const token = tokens[idx];
-      if (sourceChapter !== null && token.level === 0 && token.map !== null && token.type.endsWith("_open")) {
-        token.attrSet("data-chapter-src", sourceChapter);
-      }
-      return renderToken(tokens, idx, options);
-    };
-  }
   let bodyContent = "";
   const imageRefs = new Set;
   for (const file of files) {
@@ -4419,20 +4578,22 @@ async function assembleBookHtml(opts) {
       throw new Error(`Failed to read file ${file}: ${errorMsg}`);
     }
     const env = {};
-    sourceChapter = opts.wrapChapters ? chapterId : null;
-    let rendered;
-    try {
-      rendered = md.render(content, env);
-    } finally {
-      sourceChapter = null;
-    }
+    const rendered = md.render(content, env);
     if (env.layoutWarnings && env.layoutWarnings.length > 0) {
       opts.onChapterWarnings?.(chapterId, env.layoutWarnings);
     }
     for (const ref of env.imageRefs ?? [])
       imageRefs.add(ref);
-    bodyContent += rendered + `
+    if (opts.wrapChapters) {
+      const safe = chapterId.replace(/&/g, "&").replace(/"/g, """);
+      bodyContent += `<div class="gutterpress-chapter" data-chapter-src="${safe}">
+${rendered}
+</div>
+`;
+    } else {
+      bodyContent += rendered + `
 `;
+    }
   }
   if (opts.onImageRefs) {
     for (const ref of collectHtmlImageRefs(bodyContent))
@@ -4523,19 +4684,19 @@ function formatReport(report, format = "text") {
 }
 function formatText(report) {
   for (const r of report.infos) {
-    const loc = formatLocation(r.file, r.line, r.column);
+    const loc = targetPrefix(r.target) + formatLocation(r.file, r.line, r.column);
     log.info(`${loc}${r.message}`);
     if (r.detail)
       log.info(`  ${r.detail}`);
   }
   for (const r of report.warnings) {
-    const loc = formatLocation(r.file, r.line, r.column);
+    const loc = targetPrefix(r.target) + formatLocation(r.file, r.line, r.column);
     log.warn(`${loc}${r.message}`);
     if (r.detail)
       log.warn(`  ${r.detail}`);
   }
   for (const r of report.errors) {
-    const loc = formatLocation(r.file, r.line, r.column);
+    const loc = targetPrefix(r.target) + formatLocation(r.file, r.line, r.column);
     log.error(`${loc}${r.message}`);
     if (r.detail)
       log.error(`  ${r.detail}`);
@@ -4549,6 +4710,9 @@ function formatText(report) {
     log.success("VALIDATION PASSED");
   }
 }
+function targetPrefix(target) {
+  return target ? `[${target}] ` : "";
+}
 function formatJson(report) {
   console.log(JSON.stringify({
     results: report.results,
@@ -4650,58 +4814,46 @@ function emptyReport() {
   };
 }
 
-// src/lib/validation-profile.ts
-var DTRPG_STRICT_PDF_CHECKS = [
-  "pdf.structure.qpdf",
-  "pdf.print.pdfx-markers",
-  "pdf.print.pdfx-metadata",
-  "pdf.print.embedded-fonts"
-];
-function enforceStrictPdfChecks(config, overwrite = false) {
-  for (const checkId of DTRPG_STRICT_PDF_CHECKS) {
-    if (overwrite || config.validate.checks[checkId] === undefined) {
-      config.validate.checks[checkId] = {
-        enabled: true,
-        severity: "error"
-      };
-    }
+// src/lib/validation-exec.ts
+var SHIPPED_ASSET_EXTS = new Set([
+  ".woff2",
+  ".woff",
+  ".ttf",
+  ".otf",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".svg",
+  ".tif",
+  ".tiff"
+]);
+async function sharedAssetDirs(manifestDir, relStyles, inputDir) {
+  let closure;
+  try {
+    closure = await collectStyleDependencies(manifestDir, relStyles);
+  } catch {
+    return [];
   }
-}
-function applyDefaultPdfStrictChecks(config) {
-  const next = structuredClone(config);
-  enforceStrictPdfChecks(next, false);
-  return next;
-}
-var applyDtrpgPdfDefaults = applyDefaultPdfStrictChecks;
-function applyValidationProfile(config, profile) {
-  const next = structuredClone(config);
-  if (profile === "dtrpg") {
-    next.pdfx.flavor = DTRPG_PRESET.pdfx.flavor;
-    next.ink.maxTac = DTRPG_PRESET.ink.maxTac;
-    next.ink.tacTolerance = DTRPG_PRESET.ink.tacTolerance;
-    next.validate.pdf.forbidTransparency = DTRPG_PRESET.validate.pdf.forbidTransparency;
-    next.validate.pdf.minImageResolution = DTRPG_PRESET.validate.pdf.minImageResolution;
-    next.validate.assets.allowedColorSpaces = [
-      ...DTRPG_PRESET.validate.assets.allowedColorSpaces
-    ];
-    enforceStrictPdfChecks(next, true);
+  const projectRoot = resolve6(inputDir);
+  const dirs = new Set;
+  for (const file of closure) {
+    const ext = file.slice(file.lastIndexOf(".")).toLowerCase();
+    if (!SHIPPED_ASSET_EXTS.has(ext))
+      continue;
+    const dir = dirname3(resolve6(file));
+    if (escapesProjectRoot(projectRoot, dir))
+      dirs.add(dir);
   }
-  return next;
+  return [...dirs];
 }
-
-// src/lib/validation-exec.ts
 function parseCsv(value) {
   if (!value)
     return;
   return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
-function parseProfile(raw) {
-  if (!raw)
-    return;
-  if (raw === "dtrpg")
-    return raw;
-  throw new Error(`Unsupported profile: ${raw}. Supported profiles: dtrpg`);
-}
 function resolvePhaseArg(raw) {
   const normalized = raw.trim().toLowerCase();
   if (normalized === "pre" || normalized === "pre-build")
@@ -4724,20 +4876,16 @@ function resolveCategoryArg(raw) {
   }
   return parsed;
 }
-function withProfileRequiredCheckErrors(report, tools, profile) {
-  if (!profile)
-    return report;
-  const required = profile === "dtrpg" ? DTRPG_STRICT_PDF_CHECKS : [];
-  if (required.length === 0)
-    return report;
+function withTargetRequiredCheckErrors(report, tools, target) {
   const skippedSet = new Set(tools.skippedChecks);
-  const missingRequired = required.filter((checkId) => skippedSet.has(checkId));
+  const missingRequired = target.requiredChecks.filter((checkId) => skippedSet.has(checkId));
   if (missingRequired.length === 0)
     return report;
   const syntheticErrors = missingRequired.map((checkId) => ({
     checkId,
+    target: target.id,
     severity: "error",
-    message: `Profile ${profile} requires check ${checkId}, but it was skipped because required tools are not available.`
+    message: `Target ${target.id} requires check ${checkId}, but it was skipped because required tools are not available.`
   }));
   const results = [...report.results, ...syntheticErrors];
   const errors = [...report.errors, ...syntheticErrors];
@@ -4751,19 +4899,115 @@ function withProfileRequiredCheckErrors(report, tools, profile) {
     }
   };
 }
+var TARGET_INDEPENDENT_CATEGORIES = ["source", "heuristic"];
+var TARGET_DEPENDENT_CATEGORIES = ["asset", "pdf"];
+function tagReport(report, targetId) {
+  const tag = (r) => ({ ...r, target: targetId });
+  return {
+    results: report.results.map(tag),
+    errors: report.errors.map(tag),
+    warnings: report.warnings.map(tag),
+    infos: report.infos.map(tag),
+    passed: report.passed,
+    summary: report.summary
+  };
+}
+function mergeReports(reports) {
+  const merged = {
+    results: [],
+    errors: [],
+    warnings: [],
+    infos: [],
+    passed: [],
+    summary: { total: 0, errors: 0, warnings: 0, infos: 0, passed: 0 }
+  };
+  for (const r of reports) {
+    merged.results.push(...r.results);
+    merged.errors.push(...r.errors);
+    merged.warnings.push(...r.warnings);
+    merged.infos.push(...r.infos);
+    merged.passed.push(...r.passed);
+    merged.summary.total += r.summary.total;
+    merged.summary.errors += r.summary.errors;
+    merged.summary.warnings += r.summary.warnings;
+    merged.summary.infos += r.summary.infos;
+    merged.summary.passed += r.summary.passed;
+  }
+  return merged;
+}
+function mergeTools(results) {
+  const available = new Set;
+  const missing = new Set;
+  const skippedChecks = new Set;
+  const toolToChecks = new Map;
+  for (const r of results) {
+    for (const t of r.available)
+      available.add(t);
+    for (const t of r.missing)
+      missing.add(t);
+    for (const id of r.skippedChecks)
+      skippedChecks.add(id);
+    for (const [tool, ids] of r.toolToChecks) {
+      const merged = new Set([...toolToChecks.get(tool) ?? [], ...ids]);
+      toolToChecks.set(tool, [...merged]);
+    }
+  }
+  return {
+    available: [...available],
+    missing: [...missing],
+    skippedChecks: [...skippedChecks],
+    toolToChecks
+  };
+}
+function planRuns(opts) {
+  const { manifest, baseConfig, targetIds, pdfPath, categories, only } = opts;
+  const finalize = (config) => pdfPath ? applyDefaultPdfStrictChecks(config) : config;
+  if (targetIds.length === 0) {
+    return [{ targetId: null, config: finalize(baseConfig), category: categories, only }];
+  }
+  const requested = categories ?? [...TARGET_INDEPENDENT_CATEGORIES, ...TARGET_DEPENDENT_CATEGORIES];
+  const independentCats = requested.filter((c) => TARGET_INDEPENDENT_CATEGORIES.includes(c));
+  const dependentCats = requested.filter((c) => TARGET_DEPENDENT_CATEGORIES.includes(c));
+  let baseOnly;
+  let dependentOnly;
+  if (only && only.length > 0) {
+    const { resolved, unmatched } = resolveCheckSelectors(only);
+    const categoryById = new Map(getChecks({}).map((c) => [c.id, c.category]));
+    const independentIds = resolved.filter((id) => TARGET_INDEPENDENT_CATEGORIES.includes(categoryById.get(id) ?? ""));
+    const dependentIds = resolved.filter((id) => TARGET_DEPENDENT_CATEGORIES.includes(categoryById.get(id) ?? ""));
+    baseOnly = [...independentIds, ...unmatched];
+    dependentOnly = dependentIds;
+  }
+  const runs = [];
+  const baseWanted = only ? (baseOnly?.length ?? 0) > 0 : independentCats.length > 0;
+  if (baseWanted) {
+    runs.push({
+      targetId: null,
+      config: baseConfig,
+      category: only ? undefined : independentCats,
+      only: baseOnly
+    });
+  }
+  const dependentWanted = only ? (dependentOnly?.length ?? 0) > 0 : dependentCats.length > 0;
+  if (dependentWanted) {
+    for (const targetId of targetIds) {
+      runs.push({
+        targetId,
+        config: finalize(resolveConfigForTarget({}, manifest, targetId)),
+        category: only ? undefined : dependentCats,
+        only: dependentOnly
+      });
+    }
+  }
+  return runs;
+}
 async function executeValidation(args) {
   const manifestPath = typeof args.manifest === "string" ? args.manifest : undefined;
   const { manifest, manifestDir } = await loadManifestWithPath(manifestPath ?? args.input ?? undefined, { explicit: manifestPath !== undefined });
-  const profile = parseProfile(typeof args.profile === "string" ? args.profile : undefined);
-  let config = resolveConfig({}, manifest);
+  const config = resolveConfig({}, manifest);
+  const targetIds = resolveTargets(parseCsv(typeof args.target === "string" ? args.target : undefined), config.targets);
   const pdfPath = typeof args.pdf === "string" ? resolve6(args.pdf) : undefined;
   const inputDir = typeof args.input === "string" ? resolve6(args.input) : undefined;
-  if (pdfPath) {
-    config = applyDtrpgPdfDefaults(config);
-  }
-  if (profile) {
-    config = applyValidationProfile(config, profile);
-  }
   if (pdfPath && !existsSync7(pdfPath)) {
     throw new Error(`File not found: ${pdfPath}`);
   }
@@ -4792,11 +5036,11 @@ async function executeValidation(args) {
   let htmlPath;
   const outDir = resolveOutputDir(manifestDir, config.title);
   if (inputDir) {
-    const relMarkdown = await resolveActiveMarkdownFiles(inputDir, config.source.files);
-    markdownFiles = relMarkdown.map((f) => join2(inputDir, canonicalChapterId(f)));
-    const relStyles = await resolveActiveStyles(inputDir, config.styles);
-    cssFiles = relStyles.map((rel) => resolve6(inputDir, rel)).filter((f) => !f.endsWith(".min.css"));
-    assetDirs = [inputDir];
+    const relMarkdown = await resolveActiveMarkdownFiles(manifestDir, config.source.files);
+    markdownFiles = relMarkdown.map((f) => join2(manifestDir, canonicalChapterId(f)));
+    const relStyles = await resolveActiveStyles(manifestDir, config.styles);
+    cssFiles = relStyles.map((rel) => resolve6(manifestDir, rel)).filter((f) => !f.endsWith(".min.css"));
+    assetDirs = [inputDir, ...await sharedAssetDirs(manifestDir, relStyles, inputDir)];
     const possibleHtml = join2(outDir, BOOK_HTML_FILENAME);
     if (existsSync7(possibleHtml)) {
       htmlPath = possibleHtml;
@@ -4818,15 +5062,30 @@ async function executeValidation(args) {
     only,
     skip
   };
-  const tools = await checkToolAvailability(config, runnerOptions);
-  const initialReport = await runChecks(context, {
-    ...runnerOptions,
-    skipMissingTools: tools.skippedChecks
-  });
-  const report = withProfileRequiredCheckErrors(initialReport, tools, profile);
+  const runs = planRuns({ manifest, baseConfig: config, targetIds, pdfPath, categories, only });
+  const reports = [];
+  const toolResults = [];
+  for (const run of runs) {
+    const runOptions = {
+      category: run.category,
+      phase,
+      only: run.only,
+      skip
+    };
+    const runTools = await checkToolAvailability(run.config, runOptions);
+    toolResults.push(runTools);
+    let runReport = await runChecks({ ...context, config: run.config }, { ...runOptions, skipMissingTools: runTools.skippedChecks });
+    if (run.targetId !== null) {
+      runReport = withTargetRequiredCheckErrors(runReport, runTools, publishTargetFor(run.targetId));
+      runReport = tagReport(runReport, run.targetId);
+    }
+    reports.push(runReport);
+  }
+  const tools = mergeTools(toolResults);
+  const report = mergeReports(reports);
   return {
     config,
-    profile,
+    targets: targetIds,
     context,
     runnerOptions,
     tools,
@@ -4887,7 +5146,7 @@ import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync8, lstatSync, realpathSync, rmSync, statSync as statSync2, unlinkSync } from "node:fs";
 import { cp, link, mkdir as mkdir2, mkdtemp, readFile as readFile16, rm, unlink, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { resolve as resolve7, join as join3, dirname as dirname3, basename, extname, relative, isAbsolute } from "node:path";
+import { resolve as resolve7, join as join3, dirname as dirname4, basename, extname, relative, isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import Module, { builtinModules, createRequire } from "node:module";
 import { parse as parseJavaScript } from "acorn";
@@ -5256,7 +5515,7 @@ async function createIsolatedVendorTree(verified, address) {
     for (let index = 0;index < sorted.length; index++) {
       const source = sorted[index];
       const destination = join3(loadRoot, "packages", String(index), "package");
-      await mkdir2(dirname3(destination), { recursive: true });
+      await mkdir2(dirname4(destination), { recursive: true });
       await cp(source.packageDir, destination, {
         recursive: true,
         filter: (candidate) => isolatedPackageCopyFilter(source.packageDir, candidate)
@@ -5315,7 +5574,7 @@ async function snapshotAndIsolateVendoredPlugin(baseDir, packageName, version) {
   const snapshotProject = join3(container, "project");
   const snapshotRoot = vendoredNpmPluginRoot(snapshotProject, packageName, version);
   try {
-    await mkdir2(dirname3(snapshotRoot), { recursive: true });
+    await mkdir2(dirname4(snapshotRoot), { recursive: true });
     await cp(sourceRoot, snapshotRoot, {
       recursive: true,
       dereference: false,
@@ -5453,7 +5712,7 @@ function shadowPathFor(pluginPath, mtimeMs) {
   const ext = extname(pluginPath);
   const stem = basename(pluginPath, ext);
   const token = String(mtimeMs).replace(/\./g, "-");
-  return join3(dirname3(pluginPath), `.${stem}.gutterpress-reload-${token}${ext}`);
+  return join3(dirname4(pluginPath), `.${stem}.gutterpress-reload-${process.pid}-${token}${ext}`);
 }
 async function loadCachedPathPluginModule(pluginPath) {
   const mtimeMs = statSync2(pluginPath).mtimeMs;
@@ -5731,7 +5990,7 @@ async function writeBuildFingerprint(input) {
         iccPath: input.pdfx.iccPath,
         stripAnnotations: input.pdfx.stripAnnotations
       },
-      outputDir
+      outputDir: input.recordedOutputDir ? path5.resolve(input.recordedOutputDir) : outputDir
     },
     sourceRevision,
     tools
@@ -5745,23 +6004,23 @@ async function writeBuildFingerprint(input) {
 import { existsSync as existsSync9 } from "node:fs";
 import { mkdtemp as mkdtemp2, mkdir as mkdir4, writeFile as writeFile4, readFile as readFile17 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname4, join as join4, resolve as resolve8 } from "node:path";
+import { dirname as dirname5, join as join4, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/assets/favicon.ico
 var favicon_default = "./favicon-wkbm9cjn.ico";
 
 // src/assets/manifest.schema.json
-var manifest_schema_default = "./manifest.schema-rn1dpdpn.json";
+var manifest_schema_default = "./manifest.schema-z61rzw44.json";
 
 // src/assets/preview/scripts/pagedjs-interface.js
-var pagedjs_interface_default = "./pagedjs-interface-80g3xa8p.js";
+var pagedjs_interface_default = "./pagedjs-interface-qxvzgwd7.js";
 
 // src/assets/preview/scripts/pagedjs-bridge.js
 var pagedjs_bridge_default = "./pagedjs-bridge-vn4hk9fx.js";
 
 // src/assets/preview/scripts/preview-shell.js
-var preview_shell_default = "./preview-shell-rghtfmc8.js";
+var preview_shell_default = "./preview-shell-6dqexx1m.js";
 
 // src/assets/vendor/paged.polyfill.js
 var paged_polyfill_default = "./paged.polyfill-n95pbxfn.js";
@@ -5775,23 +6034,17 @@ var manifest_default = "./manifest-n1gh3qw5.yaml";
 // src/assets/templates/book/chapter-01.md
 var chapter_01_default = "./chapter-01-rkpyvjna.md";
 
-// src/assets/templates/ttrpg/manifest.yaml
-var manifest_default2 = "./manifest-ryyg71nf.yaml";
-
-// src/assets/templates/ttrpg/chapter-01.md
-var chapter_01_default2 = "./chapter-01-jj8ftn4c.md";
-
 // src/assets/templates/zine/manifest.yaml
-var manifest_default3 = "./manifest-n1gh3qw5.yaml";
+var manifest_default2 = "./manifest-n1gh3qw5.yaml";
 
 // src/assets/templates/zine/chapter-01.md
-var chapter_01_default3 = "./chapter-01-7jwqg1ct.md";
+var chapter_01_default2 = "./chapter-01-7jwqg1ct.md";
 
 // src/assets/templates/technical/manifest.yaml
-var manifest_default4 = "./manifest-n1gh3qw5.yaml";
+var manifest_default3 = "./manifest-n1gh3qw5.yaml";
 
 // src/assets/templates/technical/chapter-01.md
-var chapter_01_default4 = "./chapter-01-6fn9pvd0.md";
+var chapter_01_default3 = "./chapter-01-6fn9pvd0.md";
 
 // src/assets/themes/clean-book/theme.css
 var theme_default = "./theme-570zmh2t.css";
@@ -5799,26 +6052,20 @@ var theme_default = "./theme-570zmh2t.css";
 // src/assets/themes/clean-book/theme.json
 var theme_default2 = "./theme-xt0hjb1b.json";
 
-// src/assets/themes/ttrpg-supplement/theme.css
-var theme_default3 = "./theme-0yzvthe8.css";
-
-// src/assets/themes/ttrpg-supplement/theme.json
-var theme_default4 = "./theme-6a2fngc8.json";
-
 // src/assets/themes/zine/theme.css
-var theme_default5 = "./theme-zz2ktzqs.css";
+var theme_default3 = "./theme-zz2ktzqs.css";
 
 // src/assets/themes/zine/theme.json
-var theme_default6 = "./theme-cd6efzjw.json";
+var theme_default4 = "./theme-cd6efzjw.json";
 
 // src/assets/themes/technical-doc/theme.css
-var theme_default7 = "./theme-nya4nqh6.css";
+var theme_default5 = "./theme-nya4nqh6.css";
 
 // src/assets/themes/technical-doc/theme.json
-var theme_default8 = "./theme-tqfypc1w.json";
+var theme_default6 = "./theme-tqfypc1w.json";
 
 // src/lib/embedded-assets.ts
-var __libdir = dirname4(fileURLToPath2(import.meta.url));
+var __libdir = dirname5(fileURLToPath2(import.meta.url));
 var abs = (p) => resolve8(__libdir, p);
 var filePath = (v) => v;
 var EMBEDDED_ASSETS = {
@@ -5831,27 +6078,23 @@ var EMBEDDED_ASSETS = {
   "profiles/CGATS21_CRPC1.icc": abs(filePath(CGATS21_CRPC1_default)),
   "templates/book/manifest.yaml": abs(filePath(manifest_default)),
   "templates/book/chapter-01.md": abs(filePath(chapter_01_default)),
-  "templates/ttrpg/manifest.yaml": abs(filePath(manifest_default2)),
-  "templates/ttrpg/chapter-01.md": abs(filePath(chapter_01_default2)),
-  "templates/zine/manifest.yaml": abs(filePath(manifest_default3)),
-  "templates/zine/chapter-01.md": abs(filePath(chapter_01_default3)),
-  "templates/technical/manifest.yaml": abs(filePath(manifest_default4)),
-  "templates/technical/chapter-01.md": abs(filePath(chapter_01_default4)),
+  "templates/zine/manifest.yaml": abs(filePath(manifest_default2)),
+  "templates/zine/chapter-01.md": abs(filePath(chapter_01_default2)),
+  "templates/technical/manifest.yaml": abs(filePath(manifest_default3)),
+  "templates/technical/chapter-01.md": abs(filePath(chapter_01_default3)),
   "themes/clean-book/theme.css": abs(filePath(theme_default)),
   "themes/clean-book/theme.json": abs(filePath(theme_default2)),
-  "themes/ttrpg-supplement/theme.css": abs(filePath(theme_default3)),
-  "themes/ttrpg-supplement/theme.json": abs(filePath(theme_default4)),
-  "themes/zine/theme.css": abs(filePath(theme_default5)),
-  "themes/zine/theme.json": abs(filePath(theme_default6)),
-  "themes/technical-doc/theme.css": abs(filePath(theme_default7)),
-  "themes/technical-doc/theme.json": abs(filePath(theme_default8))
+  "themes/zine/theme.css": abs(filePath(theme_default3)),
+  "themes/zine/theme.json": abs(filePath(theme_default4)),
+  "themes/technical-doc/theme.css": abs(filePath(theme_default5)),
+  "themes/technical-doc/theme.json": abs(filePath(theme_default6))
 };
 var extractPromise = null;
 async function extractAssets() {
   const root = await mkdtemp2(join4(tmpdir2(), "gutterpress-assets-"));
   for (const [relPath, srcPath] of Object.entries(EMBEDDED_ASSETS)) {
     const dest = join4(root, relPath);
-    await mkdir4(dirname4(dest), { recursive: true });
+    await mkdir4(dirname5(dest), { recursive: true });
     const bytes = await readFile17(srcPath);
     await writeFile4(dest, bytes);
   }
@@ -5905,7 +6148,7 @@ ${m.installHint}`).join(`
 
 ${list}
 
-Install the missing tools and re-run, or set GHOSTSCRIPT_PATH, CHROMIUM_PATH, or system PATH so gutterpress can find them. See the User Guide Chapter 8 (System Setup) at examples/gutterpress-user-guide/08-system-setup.md for the full per-feature matrix.`, 2);
+Install the missing tools and re-run, or set GHOSTSCRIPT_PATH, CHROMIUM_PATH, or system PATH so gutterpress can find them. See the User Guide Chapter 7 (System Setup) at examples/gutterpress-user-guide/07-system-setup.md for the full per-feature matrix.`, 2);
 }
 function computeGates(format, opts, config) {
   if (format === "html") {
@@ -5999,6 +6242,15 @@ function resolveWithinRoot(relPath, root) {
   }
   return candidate;
 }
+function hasDotSegment(urlPathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(urlPathname);
+  } catch {
+    return true;
+  }
+  return decoded.split(/[/\\]/).some((segment) => segment.startsWith("."));
+}
 function resolveStaticPath(urlPathname, root) {
   let decoded;
   try {
@@ -6397,14 +6649,25 @@ async function resolveBuildContext(opts) {
   const outDir = target.kind === "file" ? path9.dirname(target.file) : target.dir;
   const gates = computeGates(format, opts, config);
   const workDir = target.kind === "project" ? path9.join(path9.dirname(target.dir), `.${path9.basename(target.dir)}-build-${randomBytes(6).toString("hex")}`) : path9.join(os2.tmpdir(), `gutterpress-build-${randomBytes(6).toString("hex")}`);
-  return { opts, format, inputDir, outDir, workDir, target, manifestDir, config, gates };
+  return {
+    opts,
+    format,
+    inputDir,
+    renderDir: manifestDir,
+    outDir,
+    workDir,
+    target,
+    manifestDir,
+    config,
+    gates
+  };
 }
 async function runQualityGates(ctx) {
-  const { gates, opts, inputDir } = ctx;
+  const { gates, opts, renderDir } = ctx;
   if (gates.lint) {
     log.info("Lint: CSS print-safety");
     const lintResult = await runLint({
-      manifest: opts.manifestPath ?? inputDir
+      manifest: opts.manifestPath ?? renderDir
     });
     if (!lintResult.ok) {
       throw new BuildError("CSS lint failed", 2);
@@ -6413,7 +6676,7 @@ async function runQualityGates(ctx) {
   if (gates.preValidate) {
     log.info("Pre-build validation");
     const result = await executeAndReport({
-      input: inputDir,
+      input: renderDir,
       phase: "pre-build",
       manifest: opts.manifestPath
     }, "text");
@@ -6423,7 +6686,7 @@ async function runQualityGates(ctx) {
   }
 }
 async function renderBook(ctx) {
-  const { config, manifestDir, inputDir, workDir } = ctx;
+  const { config, renderDir, workDir } = ctx;
   if (config.source.files && config.source.files.length > 0) {
     log.info(`Using specified files (${config.source.files.length} total)`);
   } else {
@@ -6432,13 +6695,13 @@ async function renderBook(ctx) {
   if (config.plugins.length > 0) {
     log.info(`Loading ${config.plugins.length} plugin(s)...`);
   }
-  const { plugins, pluginCss } = await loadPluginsWithCss(config.plugins, manifestDir);
+  const { plugins, pluginCss } = await loadPluginsWithCss(config.plugins, renderDir);
   if (plugins && plugins.length > 0) {
     log.success(`Loaded ${plugins.length} plugin(s)`);
   }
   const imageRefs = [];
   const cssAssets = [];
-  const htmlFile = await renderChaptersToFile(inputDir, workDir, {
+  const htmlFile = await renderChaptersToFile(renderDir, workDir, {
     title: config.title,
     styles: config.styles,
     files: config.source.files,
@@ -6457,7 +6720,7 @@ async function renderBook(ctx) {
     }
   });
   log.success(`Wrote ${htmlFile}`);
-  const { copies: imageCopies, errors } = await planImageCopies(inputDir, imageRefs);
+  const { copies: imageCopies, errors } = await planImageCopies(renderDir, imageRefs);
   if (errors.length > 0) {
     throw new BuildError(`Cannot resolve ${errors.length} image reference(s):
 ` + errors.map((e) => `  - ${e}`).join(`
@@ -6496,7 +6759,8 @@ async function resolveIccProfile(icc, manifestDir, explicitIccPath) {
 async function finalizeBuild(ctx, fingerprint, wroteMessage, paths, artifactName2 = null) {
   const workFingerprint = await writeBuildFingerprint({
     ...fingerprint,
-    outputDir: ctx.workDir
+    outputDir: ctx.workDir,
+    recordedOutputDir: fingerprint.outputDir
   });
   await publishBuild(ctx, artifactName2);
   const delivered = ctx.target.kind !== "file";
@@ -6587,7 +6851,9 @@ class PdfOutput {
       await renderHtmlToPdf(htmlFile, rawPdf, opts.pdfRenderer, staticHtmlRaw);
       if (staticHtmlRaw && fs2.existsSync(staticHtmlRaw)) {
         await finalizeStaticBook(await fsp3.readFile(staticHtmlRaw, "utf-8"), htmlFile, workDir);
-        log.success(`Wrote static desktop: ${path9.join(outDir, BOOK_HTML)}`);
+        if (ctx.target.kind !== "file") {
+          log.success(`Wrote static desktop: ${path9.join(outDir, BOOK_HTML)}`);
+        }
       }
       if (!pdfxMode) {
         try {
@@ -6749,6 +7015,7 @@ async function renderPreviewBook(inputPath, config, opts) {
     plugins,
     pluginCss,
     wrapChapters: opts.wrapChapters,
+    ...opts.onCssAssets ? { onCssAssets: opts.onCssAssets } : {},
     onChapterWarnings: (file, warnings) => {
       for (const w of warnings) {
         warn(`  ${file}, line ${w.line}: ${w.message}`);
@@ -6756,23 +7023,70 @@ async function renderPreviewBook(inputPath, config, opts) {
     }
   });
 }
-function injectPreviewScripts(html) {
+function injectPreviewScripts(html, pageIsolateChapters) {
   const iface = `<script src="/preview/scripts/pagedjs-interface.js"></script>
   ` + `<script src="/preview/scripts/pagedjs-bridge.js"></script>
   `;
-  return html.replace(pagedjsPolyfillTagRegex(), iface + BREAK_INSIDE_HANDLER + `
+  let output = html.replace(pagedjsPolyfillTagRegex(), iface + BREAK_INSIDE_HANDLER + `
   <script src="/vendor/paged.polyfill.js"></script>`);
+  if (pageIsolateChapters && /<\/head>/i.test(output)) {
+    output = output.replace(/<\/head>/i, `<style>.gutterpress-chapter{break-before:page}</style>
+</head>`);
+  }
+  return output;
 }
-async function generateAndWriteHtml(inputPath, tempDir, config) {
+async function generateAndWriteHtml(inputPath, tempDir, config, cssAssets) {
   if (!inputPath) {
+    cssAssets.clear();
     await fsp4.writeFile(path10.join(tempDir, BOOK_HTML_FILENAME), EMPTY_BOOK_HTML, "utf-8");
     return;
   }
+  const nextAssets = new Map;
+  const incremental = incrementalPreviewEnabled();
   const html = await renderPreviewBook(inputPath, config, {
     files: config.source?.files ?? null,
+    wrapChapters: incremental,
+    onCssAssets: (copies) => {
+      for (const copy of copies)
+        nextAssets.set(copy.to, copy.from);
+    }
+  });
+  cssAssets.clear();
+  for (const [to, from] of nextAssets)
+    cssAssets.set(to, from);
+  await fsp4.writeFile(path10.join(tempDir, BOOK_HTML_FILENAME), injectPreviewScripts(html, incremental), "utf-8");
+}
+async function renderChapterPreviewHtml(inputPath, file, config) {
+  const html = await renderPreviewBook(inputPath, config, {
+    files: [canonicalChapterId(file)],
     wrapChapters: true
   });
-  await fsp4.writeFile(path10.join(tempDir, BOOK_HTML_FILENAME), injectPreviewScripts(html), "utf-8");
+  return injectPreviewScripts(html, true);
+}
+function describeChanges(changes, inputResolved) {
+  const files = [];
+  for (const [changedPath, event] of changes) {
+    const relative2 = path10.relative(inputResolved, path10.resolve(changedPath));
+    if (relative2 === "" || relative2 === ".." || relative2.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative2))
+      continue;
+    files.push({
+      relativePath: canonicalChapterId(relative2),
+      ext: path10.extname(changedPath).toLowerCase(),
+      event
+    });
+  }
+  return files;
+}
+function decideBroadcast(files, changeCount, incremental) {
+  const only = files.length === 1 ? files[0] : null;
+  if (incremental && changeCount === 1 && only?.ext === ".md" && only.event !== "unlink" && only.event !== "unlinkDir") {
+    return {
+      kind: "chapter-splice",
+      chapterId: canonicalChapterId(only.relativePath),
+      relativePath: only.relativePath
+    };
+  }
+  return { kind: "full-reload" };
 }
 function isDotPathUnderRoot(candidatePath, root) {
   const normalizedRoot = root.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -6789,11 +7103,24 @@ function isDotPathUnderRoot(candidatePath, root) {
     return false;
   return rel.split("/").some((segment) => segment.startsWith("."));
 }
+function isGeneratedProjectPath(relative2) {
+  const segments = relative2.split("/");
+  for (let i = 0;i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment === "dist" || segment === "node_modules")
+      return true;
+    if (segment === "plugins" && segments[i + 1] === "npm")
+      return true;
+  }
+  return false;
+}
 function isIgnoredWatchPath(candidatePath, projectRoot) {
   const normalizedRoot = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
   const normalizedPath = candidatePath.replace(/\\/g, "/");
-  const inProject = normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
-  return inProject ? isDotPathUnderRoot(candidatePath, projectRoot) : false;
+  if (!normalizedPath.startsWith(normalizedRoot + "/"))
+    return false;
+  const relative2 = normalizedPath.slice(normalizedRoot.length + 1);
+  return isDotPathUnderRoot(candidatePath, projectRoot) || isGeneratedProjectPath(relative2);
 }
 function isExternalWatchCandidate(candidatePath, targets) {
   const candidate = path10.resolve(candidatePath);
@@ -6878,21 +7205,43 @@ function createFileWatcher(state) {
   let closed = false;
   const pendingChanges = new Map;
   const suppressInitialExternalAdds = new Set;
+  const settledWrites = new Map;
+  let immediatePending = false;
   function scheduleRebuild() {
     if (closed)
       return;
     if (state.rebuildTimer)
       clearTimeout(state.rebuildTimer);
-    state.rebuildTimer = setTimeout(runRebuild, DEBOUNCE.FILE_WATCH);
-  }
-  function recordChange(event, filePath2) {
+    const timer = setTimeout(() => {
+      if (state.rebuildTimer === timer)
+        state.rebuildTimer = null;
+      runRebuild();
+    }, DEBOUNCE.FILE_WATCH);
+    state.rebuildTimer = timer;
+  }
+  async function recordChange(event, filePath2) {
     if (closed)
       return;
-    debug(`File ${event}: ${filePath2}`);
-    pendingChanges.set(path10.resolve(filePath2), event);
+    const target = path10.resolve(filePath2);
+    const settled = settledWrites.get(target);
+    if (settled && event !== "unlink" && Date.now() <= settled.expiresAt) {
+      const diskContent = await fsp4.readFile(target, "utf8").catch(() => null);
+      if (closed)
+        return;
+      if (settledWrites.get(target) === settled && diskContent === settled.content) {
+        debug(`Suppressed settled-write watcher echo: ${target}`);
+        return;
+      }
+    }
+    if (settledWrites.get(target) === settled)
+      settledWrites.delete(target);
+    debug(`File ${event}: ${target}`);
+    pendingChanges.set(target, event);
     scheduleRebuild();
   }
-  watcher.on("all", recordChange);
+  watcher.on("all", (event, filePath2) => {
+    recordChange(event, filePath2);
+  });
   externalWatcher.on("all", (event, filePath2) => {
     const target = path10.resolve(filePath2);
     if (!desiredExternals.has(target))
@@ -6901,6 +7250,43 @@ function createFileWatcher(state) {
       return;
     recordChange(event, target);
   });
+  function isWatchedSource(target) {
+    const rel = path10.relative(inputResolved, target);
+    const inProject = rel === "" || rel !== ".." && !rel.startsWith(`..${path10.sep}`) && !path10.isAbsolute(rel);
+    if (inProject)
+      return !isIgnoredWatchPath(target, inputResolved);
+    return desiredExternals.has(target);
+  }
+  function acceptSettledWrite(target, writtenContent) {
+    const settled = { content: writtenContent, expiresAt: Date.now() + 2000 };
+    settledWrites.set(target, settled);
+    const expiry = setTimeout(() => {
+      if (settledWrites.get(target) === settled)
+        settledWrites.delete(target);
+    }, 2000);
+    expiry.unref?.();
+    pendingChanges.set(target, "change");
+    immediatePending = true;
+    if (state.rebuildTimer) {
+      clearTimeout(state.rebuildTimer);
+      state.rebuildTimer = null;
+    }
+    if (!state.isRebuilding)
+      runRebuild();
+  }
+  state.notifySettledWrite = (filePath2, writtenContent) => {
+    if (closed)
+      return;
+    const target = path10.resolve(filePath2);
+    if (isWatchedSource(target)) {
+      acceptSettledWrite(target, writtenContent);
+      return;
+    }
+    syncQueue.then(() => {
+      if (!closed && isWatchedSource(target))
+        acceptSettledWrite(target, writtenContent);
+    });
+  };
   let watchedExternalRoots = new Set;
   let syncQueue = Promise.resolve();
   function syncExternalWatches() {
@@ -6952,10 +7338,15 @@ function createFileWatcher(state) {
   async function runRebuild() {
     if (closed || state.isRebuilding)
       return;
+    if (state.rebuildTimer) {
+      clearTimeout(state.rebuildTimer);
+      state.rebuildTimer = null;
+    }
     const changes = [...pendingChanges.entries()];
     pendingChanges.clear();
     if (changes.length === 0)
       return;
+    immediatePending = false;
     state.isRebuilding = true;
     let resolveInFlight;
     const inFlight = new Promise((resolve9) => {
@@ -6972,11 +7363,17 @@ function createFileWatcher(state) {
       await syncExternalWatches();
       if (closed)
         return;
-      await generateAndWriteHtml(inputResolved, state.tempDir, updatedConfig);
+      await generateAndWriteHtml(inputResolved, state.tempDir, updatedConfig, state.cssAssets);
       if (closed)
         return;
-      state.previewServer?.broadcastReload();
-      info(changes.length > 1 ? `Preview updated (${changes.length} files changed — full reload)` : "Preview updated");
+      const decision = decideBroadcast(describeChanges(changes, inputResolved), changes.length, incrementalPreviewEnabled());
+      if (decision.kind === "chapter-splice") {
+        state.previewServer?.broadcastContentUpdate(decision.chapterId);
+        info(`Chapter updated: ${decision.relativePath}`);
+      } else {
+        state.previewServer?.broadcastReload();
+        info(changes.length > 1 ? `Preview updated (${changes.length} files changed — full reload)` : "Preview updated");
+      }
     } catch (err) {
       error("Failed to regenerate preview:", err);
     } finally {
@@ -6984,13 +7381,19 @@ function createFileWatcher(state) {
       resolveInFlight();
       if (state.rebuildPromise === inFlight)
         state.rebuildPromise = null;
-      if (!closed && pendingChanges.size > 0)
-        scheduleRebuild();
+      if (!closed && pendingChanges.size > 0) {
+        if (immediatePending)
+          runRebuild();
+        else
+          scheduleRebuild();
+      }
     }
   }
   const closeBookWatcher = watcher.close.bind(watcher);
   watcher.close = async () => {
     closed = true;
+    state.notifySettledWrite = null;
+    settledWrites.clear();
     await syncQueue.catch(() => {});
     await state.rebuildPromise?.catch(() => {});
     await externalWatcher.close();
@@ -7089,7 +7492,7 @@ async function restartPreview(newInputPath, state) {
   state.currentInputPath = newInputPath;
   const manifest = await loadManifest(newInputPath);
   state.config = resolveConfig({}, manifest);
-  await generateAndWriteHtml(newInputPath, state.tempDir, state.config);
+  await generateAndWriteHtml(newInputPath, state.tempDir, state.config, state.cssAssets);
   startFileWatcher(state);
   state.previewServer?.broadcastReload();
   info("Preview restarted successfully");
@@ -7143,22 +7546,26 @@ function createServerState(inputPath, tempDir, config, options) {
     rebuildTimer: null,
     isRebuilding: false,
     rebuildPromise: null,
+    notifySettledWrite: null,
     previewServer: null,
     isShuttingDown: false,
     tempDir,
     config,
-    options
+    options,
+    cssAssets: new Map
   };
 }
 
 // src/preview/http-server.ts
 import http2 from "node:http";
 import net from "node:net";
+import { randomUUID } from "node:crypto";
 import { readFile as readFile20, stat as stat4 } from "node:fs/promises";
 import path12 from "path";
 import { WebSocket, WebSocketServer } from "ws";
 var HMR_PATH = "/__gutterpress-hmr";
-var HMR_CLIENT_SNIPPET = `
+function hmrClientSnippet(initialRevision, instanceId) {
+  return `
 <script>
   (function () {
     // When loaded by the preview SHELL (iframe double-buffer), the shell loads us
@@ -7168,6 +7575,10 @@ var HMR_CLIENT_SNIPPET = `
     // for scroll-anchor and reload.
     if (/[?&]gutterpressshell=1/.test(location.search)) return;
   var ANCHOR_KEY = 'gutterpress-scroll-anchor';
+  var appliedRevision = ${initialRevision};
+  var appliedInstance = ${JSON.stringify(instanceId)};
+  var readyToAcknowledge = false;
+  var reloadRequested = false;
 
     // Find the element nearest the top of the viewport that carries a source
     // line (markdown-it-source-map emits data-source-line on block elements).
@@ -7218,7 +7629,13 @@ var HMR_CLIENT_SNIPPET = `
           }
         }
         if (el) {
-          window.scrollBy(0, el.getBoundingClientRect().top - a.offset);
+          window.scrollBy({
+            top: el.getBoundingClientRect().top - a.offset,
+            behavior: 'instant'
+          });
+          if (window.previewAPI && typeof window.previewAPI.refresh === 'function') {
+            window.previewAPI.refresh();
+          }
           return;
         }
         if (tries++ < 240) setTimeout(attempt, 25); // wait for pagination
@@ -7226,44 +7643,100 @@ var HMR_CLIENT_SNIPPET = `
     }
     var restored = false;
     function restoreOnce() { if (restored) return; restored = true; restoreAnchor(); }
+    function finishInitialRender() {
+      restoreOnce();
+      readyToAcknowledge = true;
+      acknowledge();
+    }
     // CRITICAL ordering: when the Paged.js polyfill is present it re-paginates on
-    // load and its PagedConfig.after calls scrollTo(0,0) THEN fires
+    // load and its PagedConfig.after scrolls to the document start THEN fires
     // 'renderingComplete'. So in engine mode we MUST wait for that event —
-    // restoring earlier would be wiped by the scrollTo(0,0). In static mode (no
+    // restoring earlier would be wiped by that initial scroll. In static mode (no
     // engine) the content is final immediately, so restore right after load.
-    var hasEngine = !!document.querySelector('script[src*="paged.polyfill"], script[src*="pagedjs"]');
-    window.addEventListener('renderingComplete', restoreOnce);
+    var hasEngine = !!document.querySelector('script[src*="paged.polyfill"]');
+    window.addEventListener('renderingComplete', finishInitialRender);
     if (!hasEngine) {
       if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function () { setTimeout(restoreOnce, 50); });
+        document.addEventListener('DOMContentLoaded', function () { setTimeout(finishInitialRender, 50); });
       } else {
-        setTimeout(restoreOnce, 50);
+        setTimeout(finishInitialRender, 50);
       }
     }
-    setTimeout(restoreOnce, 10000); // safety net if renderingComplete never fires
+    var ws = null;
+    var reconnectTimer = null;
+    var reconnectDelay = 250;
+    var stopped = false;
+
+    function acknowledge() {
+      if (!readyToAcknowledge || !ws || ws.readyState !== 1) return;
+      try {
+        ws.send(JSON.stringify({
+          type: 'reload-applied',
+          instance: appliedInstance,
+          revision: appliedRevision
+        }));
+      } catch (_) {}
+    }
 
-    var ws = new WebSocket(location.origin.replace(/^http/, 'ws') + '${HMR_PATH}');
-    ws.onmessage = function (e) {
-      var msg;
-      try { msg = JSON.parse(e.data); } catch (_) { return; }
-      if (msg.type === 'full-reload') {
+    function connect() {
+      if (stopped) return;
+      ws = new WebSocket(location.origin.replace(/^http/, 'ws') + '${HMR_PATH}');
+      ws.onopen = function () {
+        reconnectDelay = 250;
+        acknowledge();
+      };
+      ws.onmessage = function (e) {
+        var msg;
+        try { msg = JSON.parse(e.data); } catch (_) { return; }
+        if (
+          msg.type !== 'reload-state' &&
+          msg.type !== 'full-reload' &&
+          msg.type !== 'content-update'
+        ) return;
+        var instance = typeof msg.instance === 'string' ? msg.instance : null;
+        var revision = Number(msg.revision);
+        if (!instance || !Number.isSafeInteger(revision) || revision < 0) return;
+        if (instance === appliedInstance && revision <= appliedRevision) {
+          acknowledge();
+          return;
+        }
+        if (reloadRequested) return;
+        reloadRequested = true;
         try { var a = captureAnchor(); if (a) sessionStorage.setItem(ANCHOR_KEY, JSON.stringify(a)); } catch (_) {}
         location.reload();
-        return;
-      }
-    };
+      };
+      ws.onclose = function () {
+        ws = null;
+        if (stopped || reconnectTimer !== null) return;
+        reconnectTimer = setTimeout(function () {
+          reconnectTimer = null;
+          connect();
+        }, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 5000);
+      };
+      ws.onerror = function () { try { ws.close(); } catch (_) {} };
+    }
+
+    window.addEventListener('beforeunload', function () {
+      stopped = true;
+      if (reconnectTimer !== null) clearTimeout(reconnectTimer);
+    });
+    connect();
   })();
 </script>
 `;
-var SHELL_HTML = `<!doctype html>
+}
+function shellHtml(initialRevision, instanceId) {
+  return `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><title>gutterpress preview</title>
 <style>html,body{margin:0;height:100%;background:#fff;overflow:hidden}
 iframe{position:absolute;inset:0;width:100%;height:100%;border:0;display:block}</style>
 </head><body>
 <iframe id="gutterpress-active" src="/book.html?gutterpressshell=1" title="preview"></iframe>
-<script>window.__GUTTERPRESS_HMR=${JSON.stringify(HMR_PATH)};</script>
+<script>window.__GUTTERPRESS_HMR=${JSON.stringify(HMR_PATH)};window.__GUTTERPRESS_INSTANCE=${JSON.stringify(instanceId)};window.__GUTTERPRESS_REVISION=${initialRevision};</script>
 <script src="/preview/scripts/preview-shell.js"></script>
 </body></html>`;
+}
 function probePort(port, host) {
   return new Promise((resolve9) => {
     const srv = net.createServer();
@@ -7305,13 +7778,14 @@ async function findAvailablePort(startPort, host = "127.0.0.1") {
   }
   throw new BuildError(`Could not find an available port on ${host} from ${firstPort} to ${port - 1}; all are already in use. ` + "Stop another preview server or pass --port with an available port.", undefined, { cause: lastBusyError });
 }
-function injectHmrClient(html) {
+function injectHmrClient(html, revision, instanceId) {
+  const snippet = hmrClientSnippet(revision, instanceId);
   const closingBody = html.lastIndexOf("</body>");
   if (closingBody === -1)
-    return html + HMR_CLIENT_SNIPPET;
-  return html.slice(0, closingBody) + HMR_CLIENT_SNIPPET + html.slice(closingBody);
+    return html + snippet;
+  return html.slice(0, closingBody) + snippet + html.slice(closingBody);
 }
-async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders = {}) {
+async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders = {}, hmrRevision = 0, hmrInstance = "") {
   let filePath2 = absPath;
   try {
     const s = await stat4(filePath2);
@@ -7332,7 +7806,7 @@ async function serveStatic(absPath, res, cacheControl = "no-store", extraHeaders
   }
   const isHtml = filePath2.endsWith(".html") || filePath2.endsWith(".htm");
   if (isHtml) {
-    const withHmr = injectHmrClient(data.toString("utf-8"));
+    const withHmr = injectHmrClient(data.toString("utf-8"), hmrRevision, hmrInstance);
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
     res.end(withHmr);
     return;
@@ -7350,21 +7824,89 @@ function matchesEmbedded(urlPathname) {
     return true;
   return EMBEDDED_PREFIXES.some((p) => urlPathname.startsWith(p));
 }
-function isDotfileRequest(urlPathname) {
-  let decoded;
-  try {
-    decoded = decodeURIComponent(urlPathname);
-  } catch {
-    return true;
-  }
-  return decoded.split("/").some((segment) => segment.startsWith("."));
-}
 async function createPreviewServer(state, port) {
-  const clients = new Set;
+  const ACK_RETRY_MS = 2000;
+  const MAX_ACK_RETRIES = 95;
+  const instanceId = randomUUID();
+  let reloadRevision = 0;
+  const clients = new Map;
+  function sendRevision(ws, type, file) {
+    if (ws.readyState !== WebSocket.OPEN)
+      return;
+    try {
+      ws.send(JSON.stringify({
+        type,
+        instance: instanceId,
+        revision: reloadRevision,
+        ...file ? { file } : {}
+      }));
+    } catch {}
+  }
+  function waitForAcknowledgement(ws) {
+    const client = clients.get(ws);
+    if (!client)
+      return;
+    if (client.acknowledgedRevision >= reloadRevision) {
+      if (client.retryTimer !== null)
+        clearTimeout(client.retryTimer);
+      client.retryTimer = null;
+      client.retryAttempts = 0;
+      return;
+    }
+    if (client.retryTimer !== null)
+      return;
+    client.retryTimer = setTimeout(() => {
+      const current = clients.get(ws);
+      if (!current)
+        return;
+      current.retryTimer = null;
+      if (current.retryAttempts >= MAX_ACK_RETRIES) {
+        ws.terminate();
+        return;
+      }
+      current.retryAttempts++;
+      sendRevision(ws, "reload-state");
+      waitForAcknowledgement(ws);
+    }, ACK_RETRY_MS);
+    client.retryTimer.unref?.();
+  }
+  function removeClient(ws) {
+    const client = clients.get(ws);
+    if (client && client.retryTimer !== null)
+      clearTimeout(client.retryTimer);
+    clients.delete(ws);
+  }
   const wss = new WebSocketServer({ noServer: true });
   wss.on("connection", (ws) => {
-    clients.add(ws);
-    ws.on("close", () => clients.delete(ws));
+    clients.set(ws, { acknowledgedRevision: -1, retryAttempts: 0, retryTimer: null });
+    ws.on("message", (raw) => {
+      let message;
+      try {
+        message = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (!message || typeof message !== "object")
+        return;
+      const payload = message;
+      if (payload.type !== "reload-applied")
+        return;
+      const revision = Number(payload.revision);
+      if (payload.instance !== instanceId || !Number.isSafeInteger(revision) || revision < 0 || revision > reloadRevision)
+        return;
+      const client = clients.get(ws);
+      if (!client)
+        return;
+      client.acknowledgedRevision = Math.max(client.acknowledgedRevision, revision);
+      waitForAcknowledgement(ws);
+    });
+    ws.on("close", () => removeClient(ws));
+    ws.on("error", () => {
+      removeClient(ws);
+      ws.terminate();
+    });
+    sendRevision(ws, "reload-state");
+    waitForAcknowledgement(ws);
   });
   const server = http2.createServer(async (req, res) => {
     const url = new URL(req.url, "http://127.0.0.1");
@@ -7387,6 +7929,34 @@ async function createPreviewServer(state, port) {
       res.end("Not Found");
       return;
     }
+    if (url.pathname === "/__chapter" && req.method === "GET") {
+      const rawFile = url.searchParams.get("file");
+      const file = rawFile ? canonicalChapterId(rawFile) : "";
+      const revision = Number(url.searchParams.get("revision"));
+      const configuredFiles = state.config.source?.files;
+      if (!file || !state.currentInputPath || !incrementalPreviewEnabled() || !Number.isSafeInteger(revision) || revision !== reloadRevision || path12.extname(file).toLowerCase() !== ".md" || hasDotSegment(file) || !resolveWithinRoot(file, state.currentInputPath) || Array.isArray(configuredFiles) && configuredFiles.length > 0 && !configuredFiles.some((configured) => canonicalChapterId(configured) === file)) {
+        res.writeHead(400);
+        res.end("Bad Request");
+        return;
+      }
+      try {
+        const html = await renderChapterPreviewHtml(state.currentInputPath, file, state.config);
+        if (revision !== reloadRevision) {
+          res.writeHead(409);
+          res.end("Superseded");
+          return;
+        }
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-store"
+        });
+        res.end(html);
+      } catch (error2) {
+        res.writeHead(500);
+        res.end(error2 instanceof Error ? error2.message : String(error2));
+      }
+      return;
+    }
     if (matchesEmbedded(url.pathname)) {
       if (req.headers["if-none-match"] === EMBEDDED_ETAG) {
         res.writeHead(304, { ETag: EMBEDDED_ETAG, "Cache-Control": EMBEDDED_CACHE_CONTROL });
@@ -7405,12 +7975,22 @@ async function createPreviewServer(state, port) {
     }
     if (url.pathname === "/" && incrementalPreviewEnabled()) {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
-      res.end(SHELL_HTML);
+      res.end(shellHtml(reloadRevision, instanceId));
       return;
     }
     const pathname = url.pathname === "/" ? "/book.html" : url.pathname;
+    const cssAssetSource = state.cssAssets.get(pathname.replace(/^\/+/, ""));
+    if (cssAssetSource) {
+      await serveStatic(cssAssetSource, res).catch((err) => {
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end(`Internal Server Error: ${err.message}`);
+        }
+      });
+      return;
+    }
     const servingProjectRoot = pathname !== "/book.html";
-    if (servingProjectRoot && (!state.currentInputPath || isDotfileRequest(pathname))) {
+    if (servingProjectRoot && (!state.currentInputPath || hasDotSegment(pathname))) {
       res.writeHead(404);
       res.end("Not Found");
       return;
@@ -7422,7 +8002,7 @@ async function createPreviewServer(state, port) {
       res.end("Not Found");
       return;
     }
-    await serveStatic(absPath, res).catch((err) => {
+    await serveStatic(absPath, res, "no-store", {}, reloadRevision, instanceId).catch((err) => {
       if (!res.headersSent) {
         res.writeHead(500);
         res.end(`Internal Server Error: ${err.message}`);
@@ -7449,23 +8029,33 @@ async function createPreviewServer(state, port) {
     openPath(serverUrl).catch(() => {});
   }
   let stopped = false;
-  const broadcast = (payload) => {
+  const broadcastUpdate = (type, file) => {
     if (stopped)
       return;
-    const message = JSON.stringify(payload);
-    for (const ws of clients) {
-      if (ws.readyState === WebSocket.OPEN)
-        ws.send(message);
+    reloadRevision++;
+    for (const [ws] of clients) {
+      sendRevision(ws, type, file);
+      waitForAcknowledgement(ws);
     }
   };
+  const updateInFlight = () => {
+    for (const client of clients.values()) {
+      if (client.acknowledgedRevision < reloadRevision)
+        return true;
+    }
+    return false;
+  };
   return {
     port: boundPort,
     async close() {
       if (stopped)
         return;
       stopped = true;
-      for (const ws of clients)
+      for (const [ws, client] of clients) {
+        if (client.retryTimer !== null)
+          clearTimeout(client.retryTimer);
         ws.terminate();
+      }
       clients.clear();
       wss.close();
       await new Promise((resolve9) => {
@@ -7476,7 +8066,13 @@ async function createPreviewServer(state, port) {
       });
     },
     broadcastReload() {
-      broadcast({ type: "full-reload" });
+      broadcastUpdate("full-reload");
+    },
+    broadcastContentUpdate(file) {
+      if (updateInFlight())
+        broadcastUpdate("full-reload");
+      else
+        broadcastUpdate("content-update", canonicalChapterId(file));
     }
   };
 }
@@ -7495,8 +8091,8 @@ async function startPreviewServer(options) {
   }
   const config = await initializeConfiguration(inputPath);
   const tempDir = await initializePreviewDirectories();
-  await generateAndWriteHtml(inputPath, tempDir, config);
   const state = createServerState(inputPath, tempDir, config, options);
+  await generateAndWriteHtml(inputPath, tempDir, config, state.cssAssets);
   const restartPreview2 = async (newInputPath) => {
     await restartPreview(newInputPath, state);
   };
@@ -7529,17 +8125,74 @@ async function startPreviewServer(options) {
       }
       await shutdownServer(state);
     },
-    restart: restartPreview2
+    restart: restartPreview2,
+    notifySettledWrite: (filePath2, writtenContent) => {
+      state.notifySettledWrite?.(filePath2, writtenContent);
+    }
   };
 }
 
 // src/lib/project-scaffold.ts
-import { access, copyFile, cp as cp2, mkdir as mkdir6, readdir as readdir5, readFile as readFile21, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
-import { constants as FS, existsSync as existsSync10 } from "node:fs";
+import { access, copyFile, cp as cp2, mkdir as mkdir7, readdir as readdir5, readFile as readFile22, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
+import { constants as FS, existsSync as existsSync11 } from "node:fs";
+import path14 from "node:path";
+
+// src/lib/manifest-doc.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir6, open, readFile as readFile21, rename, rm as rm2 } from "node:fs/promises";
 import path13 from "node:path";
+import { parseDocument, isSeq, YAMLSeq } from "yaml";
+function resolveManifestPath(projectDir) {
+  const existing = MANIFEST_FILENAMES.find((name) => existsSync10(path13.join(projectDir, name)));
+  return path13.join(projectDir, existing ?? MANIFEST_FILENAMES[0]);
+}
+async function loadManifestDoc(projectDir) {
+  const file = resolveManifestPath(projectDir);
+  let text = "";
+  try {
+    text = await readFile21(file, "utf8");
+  } catch (error2) {
+    if (error2.code !== "ENOENT")
+      throw error2;
+  }
+  return { doc: parseDocument(text), file };
+}
+async function writeManifestDoc(file, doc) {
+  const dir = path13.dirname(file);
+  await mkdir6(dir, { recursive: true });
+  const temporary = path13.join(dir, `.${path13.basename(file)}.tmp-${process.pid}-${randomUUID2()}`);
+  try {
+    const handle = await open(temporary, "wx", 438);
+    try {
+      await handle.writeFile(doc.toString(), "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(temporary, file);
+    const directory = await open(dir, "r").catch(() => null);
+    if (directory) {
+      await directory.sync().catch(() => {});
+      await directory.close();
+    }
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+}
+function ensureSeq(doc, key) {
+  let seq = doc.get(key, true);
+  if (!isSeq(seq)) {
+    const fresh = new YAMLSeq(doc.schema);
+    doc.set(key, fresh);
+    seq = fresh;
+  }
+  return seq;
+}
+
+// src/lib/project-scaffold.ts
 var STARTER_THEME_FOR_TEMPLATE = {
   book: "clean-book",
-  ttrpg: "ttrpg-supplement",
   zine: "zine",
   technical: "technical-doc"
 };
@@ -7559,6 +8212,39 @@ function escapeYamlScalar(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }
 var DEFAULT_AUTHOR = "Anonymous";
+function isPositivePoints(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function requirePreset(preset, customPage) {
+  if (!preset || !PRESET_IDS.includes(preset)) {
+    const got = preset ? ` (got "${preset}")` : "";
+    throw new CreateProjectErrorImpl("preset-required", `A preset is required to create a book${got}. Choose one of: ${PRESET_IDS.join(", ")}.`);
+  }
+  if (preset === "custom") {
+    const missing = [];
+    if (!customPage || !isPositivePoints(customPage.width))
+      missing.push("page width");
+    if (!customPage || !isPositivePoints(customPage.height))
+      missing.push("page height");
+    if (missing.length > 0) {
+      throw new CreateProjectErrorImpl("custom-page-required", `The custom preset needs a trim size: ${missing.join(" and ")} in points ` + `(72pt = 1in — e.g. US Letter is 612 x 792).`);
+    }
+  } else if (customPage && (!isPositivePoints(customPage.width) || !isPositivePoints(customPage.height))) {
+    throw new CreateProjectErrorImpl("custom-page-required", "Page overrides need a positive width and height in points (72pt = 1in).");
+  }
+  if (customPage?.tolerance !== undefined && !isPositivePoints(customPage.tolerance)) {
+    throw new CreateProjectErrorImpl("custom-page-required", "Page tolerance must be a positive number of points.");
+  }
+  return preset;
+}
+function resolveScaffoldTargets(requested, preset) {
+  const ids = requested ?? [...PRESETS[preset].defaultTargets];
+  const unknown = ids.filter((id) => !TARGETS[id]);
+  if (unknown.length > 0) {
+    throw new CreateProjectErrorImpl("invalid-targets", `Unknown publish target${unknown.length > 1 ? "s" : ""} "${unknown.join('", "')}". ` + `Known targets: ${TARGET_IDS.join(", ")}.`);
+  }
+  return [...new Set(ids)];
+}
 async function scaffoldProject(options) {
   const name = (options.name ?? "").trim();
   if (!name) {
@@ -7570,7 +8256,7 @@ async function scaffoldProject(options) {
     throw new CreateProjectErrorImpl("invalid-name", `Could not derive a valid folder name from "${name}".`);
   }
   const parentDir = options.parentDir;
-  if (!parentDir || !path13.isAbsolute(parentDir)) {
+  if (!parentDir || !path14.isAbsolute(parentDir)) {
     throw new CreateProjectErrorImpl("parent-not-writable", "The save location must be an absolute path.");
   }
   try {
@@ -7578,7 +8264,7 @@ async function scaffoldProject(options) {
   } catch {
     throw new CreateProjectErrorImpl("parent-not-writable", `The chosen save location can't be written to: ${parentDir}`);
   }
-  const projectDir = path13.join(parentDir, folderName);
+  const projectDir = path14.join(parentDir, folderName);
   let targetExists = true;
   try {
     await access(projectDir, FS.F_OK);
@@ -7590,26 +8276,28 @@ async function scaffoldProject(options) {
   }
   const template = options.template ?? "book";
   const customTemplateDir = options.templateDir;
+  const preset = customTemplateDir && options.preset === undefined ? undefined : requirePreset(options.preset, options.customPage);
+  const targets = preset ? resolveScaffoldTargets(options.targets, preset) : undefined;
   try {
-    await mkdir6(projectDir, { recursive: true });
+    await mkdir7(projectDir, { recursive: true });
     if (customTemplateDir) {
       const entries = await readdir5(customTemplateDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === ".gutterpress-template.json")
           continue;
-        await cp2(path13.join(customTemplateDir, entry.name), path13.join(projectDir, entry.name), { recursive: true });
+        await cp2(path14.join(customTemplateDir, entry.name), path14.join(projectDir, entry.name), { recursive: true });
       }
-      await mkdir6(path13.join(projectDir, "assets"), { recursive: true });
+      await mkdir7(path14.join(projectDir, "assets"), { recursive: true });
     } else {
       const tplManifest = await getAssetPath(`templates/${template}/manifest.yaml`);
       const tplChapter = await getAssetPath(`templates/${template}/chapter-01.md`);
-      await mkdir6(path13.join(projectDir, "assets"), { recursive: true });
-      await copyFile(tplManifest, path13.join(projectDir, MANIFEST_FILENAMES[0]));
-      await copyFile(tplChapter, path13.join(projectDir, "chapter-01.md"));
+      await mkdir7(path14.join(projectDir, "assets"), { recursive: true });
+      await copyFile(tplManifest, path14.join(projectDir, MANIFEST_FILENAMES[0]));
+      await copyFile(tplChapter, path14.join(projectDir, "chapter-01.md"));
       const starterThemeId = STARTER_THEME_FOR_TEMPLATE[template] ?? "clean-book";
       const starterCss = await getAssetPath(`themes/${starterThemeId}/theme.css`);
-      await mkdir6(path13.join(projectDir, "styles"), { recursive: true });
-      await copyFile(starterCss, path13.join(projectDir, "styles", "book.css"));
+      await mkdir7(path14.join(projectDir, "styles"), { recursive: true });
+      await copyFile(starterCss, path14.join(projectDir, "styles", "book.css"));
     }
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not create the project files: ${e instanceof Error ? e.message : String(e)}`);
@@ -7619,18 +8307,34 @@ async function scaffoldProject(options) {
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not write .gitignore: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const manifestPath = MANIFEST_FILENAMES.map((name2) => path13.join(projectDir, name2)).find(existsSync10) ?? path13.join(projectDir, MANIFEST_FILENAMES[0]);
+  const manifestPath = MANIFEST_FILENAMES.map((name2) => path14.join(projectDir, name2)).find(existsSync11) ?? path14.join(projectDir, MANIFEST_FILENAMES[0]);
   const author = (options.author ?? "").trim() || DEFAULT_AUTHOR;
   const substitutions = {
     "{{TITLE}}": escapeYamlScalar(name),
     "{{AUTHOR}}": escapeYamlScalar(author)
   };
-  let openFile = path13.join(projectDir, "chapter-01.md");
+  let openFile = path14.join(projectDir, "chapter-01.md");
   try {
     await fillTemplateFile(manifestPath, substitutions);
+    if (preset) {
+      const { doc, file } = await loadManifestDoc(projectDir);
+      doc.set("preset", preset);
+      doc.set("targets", doc.createNode(targets ?? []));
+      if (options.customPage) {
+        const page = {
+          width: options.customPage.width,
+          height: options.customPage.height
+        };
+        if (options.customPage.tolerance !== undefined) {
+          page.tolerance = options.customPage.tolerance;
+        }
+        doc.set("page", doc.createNode(page));
+      }
+      await writeManifestDoc(file, doc);
+    }
     const firstSource = await firstSourceFile(manifestPath);
     if (firstSource)
-      openFile = path13.join(projectDir, firstSource);
+      openFile = path14.join(projectDir, firstSource);
     await fillTemplateFile(openFile, { "{{TITLE}}": name }).catch(() => {});
   } catch (e) {
     throw new CreateProjectErrorImpl("scaffold-io", `Could not finalise the project files: ${e instanceof Error ? e.message : String(e)}`);
@@ -7640,7 +8344,7 @@ async function scaffoldProject(options) {
   let versionHistoryError;
   if (requested === "local-git") {
     try {
-      const { providerFor } = await import("./source-provider-hp96b5jf.js");
+      const { providerFor } = await import("./source-provider-c1rjm2c0.js");
       const provider = providerFor({ type: "local-folder", path: projectDir });
       await provider.initVersionHistory({
         projectDir,
@@ -7650,9 +8354,9 @@ async function scaffoldProject(options) {
       versionHistory = "local-git";
     } catch (e) {
       versionHistory = "none";
-      const { findEnclosingRepoDir } = await import("./project-source-0tg0r6vm.js");
+      const { findEnclosingRepoDir } = await import("./project-source-p0gn1wd5.js");
       const enclosingRepoDir = await findEnclosingRepoDir(projectDir);
-      versionHistoryError = enclosingRepoDir ? `This book was added to ${path13.basename(enclosingRepoDir)}'s shared version history; save a snapshot to record it.` : e instanceof Error ? e.message : String(e);
+      versionHistoryError = enclosingRepoDir ? `This book was added to ${path14.basename(enclosingRepoDir)}'s shared version history; save a snapshot to record it.` : e instanceof Error ? e.message : String(e);
     }
   }
   const result = {
@@ -7667,10 +8371,10 @@ async function scaffoldProject(options) {
   return result;
 }
 async function ensureGitignoreHasDist(projectDir) {
-  const gitignorePath = path13.join(projectDir, ".gitignore");
+  const gitignorePath = path14.join(projectDir, ".gitignore");
   let existing = null;
   try {
-    existing = await readFile21(gitignorePath, "utf8");
+    existing = await readFile22(gitignorePath, "utf8");
   } catch {}
   if (existing === null) {
     await writeFile6(gitignorePath, `dist/
@@ -7690,7 +8394,7 @@ async function ensureGitignoreHasDist(projectDir) {
 async function firstSourceFile(manifestPath) {
   let text;
   try {
-    text = await readFile21(manifestPath, "utf8");
+    text = await readFile22(manifestPath, "utf8");
   } catch {
     return;
   }
@@ -7702,7 +8406,7 @@ async function firstSourceFile(manifestPath) {
   return m ? m[1].trim() : undefined;
 }
 async function fillTemplateFile(filePath2, substitutions) {
-  let text = await readFile21(filePath2, "utf8");
+  let text = await readFile22(filePath2, "utf8");
   for (const [token, value] of Object.entries(substitutions)) {
     text = text.split(token).join(value);
   }
@@ -7710,9 +8414,9 @@ async function fillTemplateFile(filePath2, substitutions) {
 }
 
 // src/lib/project-templates.ts
+import { isMap, isScalar, isSeq as isSeq2, parseDocument as parseDocument2 } from "yaml";
 var BUILT_IN_TEMPLATE_IDS = [
   "book",
-  "ttrpg",
   "zine",
   "technical"
 ];
@@ -7728,63 +8432,10 @@ var SKIP_ENTRIES = new Set([
 
 // src/lib/plugin-manager.ts
 import path16 from "node:path";
-import { isSeq as isSeq2, isMap, isScalar, YAMLMap, Scalar } from "yaml";
-
-// src/lib/manifest-doc.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { mkdir as mkdir7, open, readFile as readFile22, rename, rm as rm2 } from "node:fs/promises";
-import path14 from "node:path";
-import { parseDocument, isSeq, YAMLSeq } from "yaml";
-function resolveManifestPath(projectDir) {
-  const existing = MANIFEST_FILENAMES.find((name) => existsSync11(path14.join(projectDir, name)));
-  return path14.join(projectDir, existing ?? MANIFEST_FILENAMES[0]);
-}
-async function loadManifestDoc(projectDir) {
-  const file = resolveManifestPath(projectDir);
-  let text = "";
-  try {
-    text = await readFile22(file, "utf8");
-  } catch (error2) {
-    if (error2.code !== "ENOENT")
-      throw error2;
-  }
-  return { doc: parseDocument(text), file };
-}
-async function writeManifestDoc(file, doc) {
-  const dir = path14.dirname(file);
-  await mkdir7(dir, { recursive: true });
-  const temporary = path14.join(dir, `.${path14.basename(file)}.tmp-${process.pid}-${randomUUID()}`);
-  try {
-    const handle = await open(temporary, "wx", 438);
-    try {
-      await handle.writeFile(doc.toString(), "utf8");
-      await handle.sync();
-    } finally {
-      await handle.close();
-    }
-    await rename(temporary, file);
-    const directory = await open(dir, "r").catch(() => null);
-    if (directory) {
-      await directory.sync().catch(() => {});
-      await directory.close();
-    }
-  } finally {
-    await rm2(temporary, { force: true });
-  }
-}
-function ensureSeq(doc, key) {
-  let seq = doc.get(key, true);
-  if (!isSeq(seq)) {
-    const fresh = new YAMLSeq(doc.schema);
-    doc.set(key, fresh);
-    seq = fresh;
-  }
-  return seq;
-}
+import { isSeq as isSeq3, isMap as isMap2, isScalar as isScalar2, YAMLMap, Scalar } from "yaml";
 
 // src/lib/npm-plugin-installer.ts
-import { createHash as createHash4, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import {
   lstat as lstat2,
@@ -8460,7 +9111,7 @@ async function installNpmPlugin(projectDirInput, packageSpec, options = {}) {
     }
     try {
       await lstat2(finalRoot);
-      backupRoot = `${finalRoot}.backup-${randomUUID2()}`;
+      backupRoot = `${finalRoot}.backup-${randomUUID3()}`;
       await rename2(finalRoot, backupRoot);
     } catch (error2) {
       if (error2.code !== "ENOENT")
@@ -8549,9 +9200,9 @@ function isLocalRef2(ref) {
   return ref.startsWith("./") || ref.startsWith("../") || ref.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(ref) || /\.(m?js|cjs|ts)$/i.test(ref) || !ref.startsWith("@") && ref.includes("/");
 }
 function itemRef(item) {
-  if (isScalar(item))
+  if (isScalar2(item))
     return typeof item.value === "string" ? item.value : null;
-  if (isMap(item)) {
+  if (isMap2(item)) {
     const p = item.get("path");
     const n = item.get("name");
     if (typeof p === "string")
@@ -8567,7 +9218,7 @@ function refKind(ref) {
 async function listProjectPlugins(projectDir) {
   const { doc } = await loadManifestDoc(projectDir);
   const seq = doc.get("plugins", true);
-  if (!isSeq2(seq))
+  if (!isSeq3(seq))
     return [];
   const out = [];
   for (const item of seq.items) {
@@ -8578,7 +9229,7 @@ async function listProjectPlugins(projectDir) {
     let kind;
     let version;
     let exportName;
-    if (isMap(item)) {
+    if (isMap2(item)) {
       const e = item.get("enabled");
       if (e === false)
         enabled = false;
@@ -8623,7 +9274,7 @@ async function recordInstalledNpmPlugin(projectDir, name, version, exportName) {
   const seq = ensureSeq(doc, "plugins");
   const idx = indexOfRef(seq, name);
   let map;
-  if (idx >= 0 && isMap(seq.items[idx])) {
+  if (idx >= 0 && isMap2(seq.items[idx])) {
     map = seq.items[idx];
   } else {
     map = new YAMLMap(doc.schema);
@@ -9955,8 +10606,8 @@ var drivethrurpgProvider = {
     }
     issues.push({
       severity: "info",
-      id: "drivethrurpg/validate-profile",
-      message: "Tip: run `gutterpress validate --profile dtrpg` for DriveThruRPG's print-compliance checks before uploading."
+      id: "drivethrurpg/validate-target",
+      message: "Tip: run `gutterpress validate --target dtrpg` for DriveThruRPG's print-compliance checks before uploading."
     });
     return issues;
   },
@@ -10070,7 +10721,7 @@ var info4 = {
   label: "itch.io",
   kind: "api",
   format: "pdf",
-  description: "Upload the PDF to your itch.io project page (games, TTRPG supplements, zines).",
+  description: "Upload the PDF to your itch.io project page (games, zines, and other printable projects).",
   configFields: [
     { key: "target", label: "Project (user/game)", placeholder: "you/your-book" },
     { key: "channel", label: "Channel", placeholder: "pdf" }
@@ -12253,7 +12904,7 @@ async function dispatchToHandler(kind, ctx, error2) {
   return result;
 }
 // src/lib/theme-manager.ts
-import { isSeq as isSeq3, Scalar as Scalar2 } from "yaml";
+import { isSeq as isSeq4, Scalar as Scalar2 } from "yaml";
 var THEMES_DIR = "themes";
 var THEME_HREF_RE = new RegExp(`^${THEMES_DIR}/([^/]+)/theme\\.css$`);
 // src/lib/theme-import.ts
@@ -12277,7 +12928,7 @@ var ALLOWED_ASSET_EXTS = new Set([
   ".css"
 ]);
 // src/lib/manifest-config.ts
-import { isSeq as isSeq4, isMap as isMap2, YAMLSeq as YAMLSeq3, Scalar as Scalar3 } from "yaml";
+import { isSeq as isSeq5, isMap as isMap3, YAMLSeq as YAMLSeq3, Scalar as Scalar3 } from "yaml";
 // src/lib/host-policy.ts
 var AUTO_SNAPSHOT_MAX_MINUTES = 24 * 60;
 var AUTO_SYNC_MAX_MINUTES = 24 * 60;
@@ -12374,5 +13025,5 @@ function normalizeProjectKey(projectDir) {
   return projectDir.replace(/[\\/]+$/, "");
 }
 // src/lib/publish/manifest-publish.ts
-import { isMap as isMap3 } from "yaml";
-export { MANIFEST_FILENAMES, parseNpmPluginSpec, runLint, reportMissingTools, executeValidation, executeAndReport, splitOutPath, runBuild, openPath, startPreviewServer, scaffoldProject, BUILT_IN_TEMPLATE_IDS, addNpmPlugin, isAppHeartbeatFresh, classifyFromHealth, classifyGitError, makeManualGuidance, inspectRepo, verifyRepoReadable, isUnbornRepo, publishCredentialKey, publishConnectionStatus, listPublishAccounts, listPublishProviders, publishProviderFor, runPublish, connectPublishProvider, buildRecoveryContext, recover16 as recover };
+import { isMap as isMap4 } from "yaml";
+export { PRESET_IDS, PRESETS, TARGETS, TARGET_IDS, publishTargetFor, MANIFEST_FILENAMES, parseNpmPluginSpec, runLint, reportMissingTools, executeValidation, executeAndReport, splitOutPath, runBuild, openPath, startPreviewServer, scaffoldProject, BUILT_IN_TEMPLATE_IDS, addNpmPlugin, isAppHeartbeatFresh, classifyFromHealth, classifyGitError, makeManualGuidance, inspectRepo, verifyRepoReadable, isUnbornRepo, publishCredentialKey, publishConnectionStatus, listPublishAccounts, listPublishProviders, publishProviderFor, runPublish, connectPublishProvider, buildRecoveryContext, recover16 as recover };