gutterpress 0.0.0 → 0.9.0-alpha.2

package/dist/lib/remote-auth/github-repos.d.ts

@@ -28,8 +28,6 @@ export interface GitHubApiOptions {
     /** Injectable fetch for tests. Defaults to global fetch. */
     fetchImpl?: typeof fetch;
 }
-/** "Reconnect" message for revoked/expired tokens (ADR 0006 D7). */
-export declare const RECONNECT_MESSAGE = "Your GitHub connection has expired. Reconnect GitHub and try again.";
 /**
  * List every repository the user can access — own, collaborator, and org
  * member — via `GET /user/repos` (paginated). The OAuth `repo` scope makes

package/dist/lib/remote-auth/recovery/dispatch.d.ts

@@ -26,8 +26,3 @@ export type { RecoverFn, RecoveryContext, RecoveryResult, SyncErrorKind, Recover
 export { classifyGitError, classifyFromHealth, RepoNeedsRecoveryError, isRepoNeedsRecoveryError, } from "./classify.ts";
 export { inspectRepo, preflightStructuralReason, buildPreflightDiagnostics, verifyRepoReadable, isUnbornRepo, } from "./inspect.ts";
 export { buildRecoveryContext } from "./context.ts";
-export type { BuildRecoveryContextOptions } from "./context.ts";
-export { recoveryPolicy, policyFor, detachedHeadWithLocalChangesPolicy } from "./policy.ts";
-export { createRecoveryZip, assertZipReadable, zipEntries } from "./backup.ts";
-export { makeManualGuidance } from "./manual-guidance.ts";
-export { failSafeNoRepair, withBackupGate } from "./failsafe.ts";

package/dist/lib/remote-auth/recovery/outcome-mapping.d.ts

@@ -32,9 +32,9 @@ export declare const RETRY_AFTER_MS = 30000;
 /** The typed outcome unions the recovery handlers translate. */
 export type AnyOutcome = SyncOutcome | PullOutcome;
 /** Every status either outcome union can carry. */
-export type OutcomeStatus = AnyOutcome["status"];
+type OutcomeStatus = AnyOutcome["status"];
 /** Builds a RecoveryResult from the context and the (already-classified) outcome. */
-export type OutcomeBuilder = (ctx: RecoveryContext, outcome: AnyOutcome) => RecoveryResult;
+type OutcomeBuilder = (ctx: RecoveryContext, outcome: AnyOutcome) => RecoveryResult;
 /** Per-status overrides a handler supplies where it intentionally differs. */
 export type OutcomeOverrides = Partial<Record<OutcomeStatus, OutcomeBuilder>>;
 /**
@@ -56,3 +56,4 @@ export declare function syncOptionsFrom(ctx: RecoveryContext): {
  * first, then default — matching each handler's original `default:` arm.
  */
 export declare function mapOutcomeToResult(ctx: RecoveryContext, outcome: AnyOutcome, overrides?: OutcomeOverrides): RecoveryResult;
+export {};

package/dist/lib/remote-auth/recovery/recover-stale-lock.d.ts

@@ -48,14 +48,6 @@
  * says "leftover lock" / "temporary lock", never "lock file"/"index"/"ref".
  */
 import type { RecoveryContext, RecoveryResult } from "./types.ts";
-/**
- * Known top-level lock files git may leave directly under `.git/`. These are
- * scanned in addition to a shallow walk of `.git/refs/**` for `*.lock` files.
- * Exported (with findLockCandidates) as the SINGLE lock-discovery
- * implementation — inspect.ts's health probe consumes the same scan, so
- * health and handler can never disagree about which locks exist.
- */
-export declare const TOP_LEVEL_LOCK_NAMES: readonly ["index.lock", "HEAD.lock", "config.lock", "packed-refs.lock"];
 export interface LockCandidate {
     /** Absolute path to the lock file. */
     path: string;

package/dist/lib/remote-auth/sync.d.ts

@@ -1,17 +1,9 @@
 import { conflictFilesFrom, onAuthFor } from "./transport.ts";
-import type { PullOutcome, PushOutcome, SyncOutcome, SyncProjectOptions, SyncRetryOptions } from "./sync-types.ts";
+import type { PullOutcome, PushOutcome, SyncOutcome, SyncProjectOptions } from "./sync-types.ts";
 export { onAuthFor, conflictFilesFrom };
 export { onlineCopyPath, resolveConflicts } from "./conflict-resolution.ts";
 export { SYNC_SNAPSHOT_MESSAGE } from "./sync-messages.ts";
-export type { ConflictFile, ConflictKind, ConflictResolution, PullOutcome, PushOutcome, ResolveConflictsOptions, SyncOutcome, SyncProjectOptions, SyncRetryOptions, } from "./sync-types.ts";
-/**
- * Default sync retry budget (BUG 6): 3 bounded passes with a short backoff.
- * A fast-moving remote can race the push once or twice without the user seeing
- * the false "Someone else synced at the same moment" message; a remote that
- * genuinely races EVERY pass still terminates with that friendly message and
- * the work safely snapshotted.
- */
-export declare const DEFAULT_SYNC_RETRY: Required<Omit<SyncRetryOptions, "sleep">>;
+export type { ConflictFile, ConflictKind, ConflictResolution, PullOutcome, PushOutcome, ResolveConflictsOptions, SyncOutcome, SyncProjectOptions, } from "./sync-types.ts";
 /**
  * Snapshot-first sync (ADR 0006 D5) — the composition of {@link pullChanges}
  * then {@link pushChanges}. If someone pushes between our pull and our push,

package/dist/lib/remote-auth/test-access.d.ts

@@ -33,8 +33,6 @@ export declare function isSshRemoteUrl(url: string): boolean;
  * Exported for the wording guard in test-access.test.ts.
  */
 export declare const FAILURE_MESSAGES: Record<RemoteAccessFailureReason, string>;
-/** Map a raw transport error to a classified failure. Never echoes the URL. */
-export declare function classifyRemoteAccessError(e: unknown): RemoteAccessResult;
 /**
  * Probe a remote with a single refs listing (the `git ls-remote` equivalent).
  *

package/dist/lib/remote-auth/test-support/git-http-server.d.ts

@@ -2,34 +2,10 @@ import type httpNode from "isomorphic-git/http/node";
 type HttpClient = typeof httpNode;
 export declare function pkt(data: string | Buffer): Buffer;
 export declare const FLUSH: Buffer<ArrayBuffer>;
-export declare function parsePktLines(body: Buffer): string[];
-/**
- * isomorphic-git location options: a worktree repo (`dir`) or a bare repo
- * (`gitdir`). Bare support exists so the server can serve a real `--bare`
- * clone (used by the large-repo sync repro scripts).
- */
-type RepoLoc = {
-    dir: string;
-} | {
-    gitdir: string;
-};
 export declare function createFixtureRepo(dir: string): Promise<{
     head: string;
     first: string;
 }>;
-/**
- * Collect commit+tree+blob oids reachable from `commit`, to `depth` commits.
- *
- * `stopCommits` (the client's `have` lines) bounds the walk like a real
- * upload-pack: commits the client already has are neither read nor included.
- * `skipTrees` (the root trees of those have-commits) prunes tree recursion so
- * a fetch of message-only commits on a multi-GB repo packs ONLY the new
- * commit objects instead of re-walking the whole project tree.
- */
-export declare function collectOids(repo: RepoLoc, commit: string, depth: number, opts?: {
-    stopCommits?: Set<string>;
-    skipTrees?: Set<string>;
-}): Promise<string[]>;
 export interface GitServer {
     url: string;
     /** Authorization headers the server saw, in order. */
@@ -55,17 +31,4 @@ export declare function tempDir(prefix: string): Promise<string>;
  * dangling-tracking-ref failure). Shared by the transport and recovery tests.
  */
 export declare function packDroppingClient(inner: HttpClient): HttpClient;
-/**
- * Binary-safe pkt-line command parser for a receive-pack request body:
- * returns the `<old> <new> <ref>` commands and the byte offset where the raw
- * packfile starts (right after the flush-pkt).
- */
-export declare function parseReceivePackRequest(body: Buffer): {
-    commands: Array<{
-        oldOid: string;
-        newOid: string;
-        ref: string;
-    }>;
-    packfile: Buffer;
-};
 export {};

package/dist/lib/source-provider.d.ts

@@ -90,7 +90,6 @@ export interface SourceProvider {
     listHistoryPage(projectDir: string, options?: ListHistoryOptions): Promise<HistoryPage>;
     restore(options: RestoreSnapshotOptions): Promise<void>;
 }
-export declare const SNAPSHOT_STAGING_MARKER = "gutterpress-snapshot-staging";
 /**
  * Run `fn` exclusively per resolved project dir (FIFO promise chaining).
  * Exported for the remote-clone surface (#15) so clone/fetch operations share
@@ -104,19 +103,6 @@ export declare function withRepoLock<T>(projectDir: string, fn: () => Promise<T>
  * plugins.ts's `__resetPathPluginCacheForTests`.
  */
 export declare function __repoLockQueueSizeForTests(): number;
-/**
- * Resolve the commit author identity from an optional display name (exported
- * for the sync surface so merge commits carry the same identity as
- * snapshots).
- */
-export declare function gitAuthor(name?: string, email?: string): {
-    name: string;
-    email: string;
-};
-export declare function readGitAuthor(dir: string): Promise<{
-    name?: string;
-    email?: string;
-}>;
 /**
  * Resolve the author for a commit in `dir`, PER FIELD: caller-supplied →
  * existing repo config (`user.name` / `user.email`) → the gutterpress default.

package/dist/lib/static-serve.d.ts

@@ -33,11 +33,50 @@ export declare const STATIC_MIME: Record<string, string>;
  * query value as a filesystem-relative path must run it through this guard.
  */
 export declare function resolveWithinRoot(relPath: string, root: string): string | null;
+/**
+ * True if any path segment of `urlPathname` is a dotfile/dot-directory (e.g.
+ * `/.env`, `/.git/config`, `/foo/.hidden/bar`).
+ *
+ * This is the guard any server needs when it resolves request paths against a
+ * REAL project tree rather than a staged copy of generated output (the preview
+ * server's serve-in-place model). Containment alone is not sufficient there:
+ * `.env` and `.git/config` live INSIDE the served root, so
+ * {@link resolveWithinRoot} happily returns them — this is the one thing
+ * standing between a request and the project's actual secrets.
+ *
+ * It runs on the DECODED path so a percent-encoded segment (`%2e%2e`) can't
+ * spell a dot past a naive string check, and an encoding that fails to decode
+ * is refused rather than guessed at.
+ *
+ * BOTH `/` and `\` count as separators, on every platform. A raw backslash
+ * never survives the WHATWG URL parser (it normalizes to `/` for special
+ * schemes), but a percent-encoded one does: `/%5C.env` decodes to `/\.env`,
+ * whose only `/`-delimited segment is `\.env` — which does not START with a
+ * dot. `path.win32.resolve` DOES treat `\` as a separator, so on Windows that
+ * request resolved to `<root>\.env`, inside the root, and the preview served
+ * the project's real `.env`. Splitting on both separators closes that hole,
+ * and doing it platform-independently is what lets a POSIX test run pin the
+ * Windows behavior.
+ */
+export declare function hasDotSegment(urlPathname: string): boolean;
 /**
  * Resolve a request URL pathname to an absolute path inside `root`, guarding
  * against path traversal (`..`, encoded separators, absolute-looking paths).
  * Returns `null` if the pathname cannot be decoded or the resolved path
  * escapes `root` — callers turn that into a 403/404 as fits their route.
+ *
+ * Containment only — a caller serving a real project tree must ALSO run
+ * {@link hasDotSegment}, since dotfiles are contained but must stay unreachable.
+ *
+ * LEXICAL, deliberately: it normalizes `..`/`.` but does not resolve symlinks, so
+ * a symlink INSIDE the served root that points outside it resolves to its target
+ * when the file is read. That is a considered choice, not an oversight (reviewed
+ * 2026-07-29): these are localhost preview/pagination servers reading a tree the
+ * author owns and controls, and a project-local symlink into a shared foundation
+ * is a legitimate authoring layout — the desktop's own fs routes, which serve
+ * renderer-supplied paths and therefore face a real attacker, use the
+ * canonicalizing `isWithinAnyRootCanonical` instead. If this guard is ever reused
+ * for a path an untrusted party supplies, canonicalize first.
  */
 export declare function resolveStaticPath(urlPathname: string, root: string): string | null;
 /**

package/dist/lib/style-resolver.d.ts

@@ -26,5 +26,14 @@ export declare function resolveActiveStyles(projectDir: string, manifestStyles?:
  * (`resolveActiveStyles`, marked `active: true`) followed by the project's OTHER
  * discovered `.css` files (alphabetical). `projectDir` must be absolute. Returns
  * `[]` for a project with no stylesheets at all.
+ *
+ * Pass `repoRoot` for a book that lives inside a repository: the repo's shared
+ * stylesheets are then offered too (see {@link discoverSharedCssFiles}), named
+ * the way the manifest stores them — project-relative, e.g.
+ * `../../shared/styles/components.css` — so toggling one on writes the right
+ * entry. Omit it (or pass the project itself) for the single-project case, which
+ * behaves exactly as before.
  */
-export declare function listProjectStyles(projectDir: string): Promise<ProjectStyle[]>;
+export declare function listProjectStyles(projectDir: string, opts?: {
+    repoRoot?: string;
+}): Promise<ProjectStyle[]>;

package/dist/lib/targets.d.ts

@@ -0,0 +1,84 @@
+import type { ResolvedConfig } from "../schema/manifest.types";
+import { type VendorPreset } from "./presets";
+/**
+ * Publish targets — WHERE THE BOOK IS PUBLISHED (ADR 0008).
+ *
+ * A target is a named validation-policy overlay: the requirements a
+ * destination (DriveThruRPG, itch.io, …) places on the built PDF. Targets
+ * never change how the book renders — they change what the validator
+ * demands of the output — so one source can be validated against several
+ * destinations (`targets: [dtrpg, itch]` in the manifest).
+ *
+ * A target's overlay is DATA merged between the preset and the manifest,
+ * giving one precedence chain everywhere: cli > manifest > target > preset.
+ * The author's explicit manifest values therefore always win — the same
+ * sovereignty rule presets follow. The only hard enforcement a target adds
+ * is {@link PublishTarget.requiredChecks}: a required check that gets
+ * skipped because its tools are missing becomes a synthetic error, so
+ * "validated for dtrpg" can never silently mean "the dtrpg checks didn't
+ * run".
+ *
+ * Grown from the old `validate --profile dtrpg` (validation-profile.ts,
+ * deleted): the profile was this exact idea hardcoded for one destination.
+ */
+/** The deep-partial preset shape a target may overlay. */
+export type TargetOverlay = {
+    pdfx?: Partial<ResolvedConfig["pdfx"]>;
+    ink?: Partial<ResolvedConfig["ink"]>;
+    validate?: {
+        checks?: ResolvedConfig["validate"]["checks"];
+        assets?: Partial<ResolvedConfig["validate"]["assets"]>;
+        pdf?: Partial<ResolvedConfig["validate"]["pdf"]>;
+    };
+};
+export interface PublishTarget {
+    id: string;
+    /** Display name for reports and pickers. */
+    label: string;
+    /** Policy defaults merged between the preset and the manifest. */
+    overlay: TargetOverlay;
+    /**
+     * Check ids that must actually RUN for this target: when tool
+     * availability forces one to be skipped, validation reports a synthetic
+     * error instead of a false green. (An author who explicitly disables one
+     * of these in the manifest owns that choice — this guards silent
+     * environment gaps, not deliberate configuration.)
+     */
+    requiredChecks: readonly string[];
+    /**
+     * External system tools this destination's full pipeline depends on —
+     * building the compliant output AND running the required checks. Creation
+     * flows use this to warn, at target-selection time, that a compliant file
+     * can't be produced or verified until these are installed. Must cover at
+     * least the union of {@link requiredChecks}' own `requiredTools`
+     * (enforced by targets.test.ts); may add build-time tools the checks
+     * alone don't reveal (e.g. Ghostscript for the PDF/X conversion).
+     */
+    requiredTools: readonly string[];
+}
+export declare const TARGETS: Record<string, PublishTarget>;
+/** The registered target ids, in the order pickers should offer them. */
+export declare const TARGET_IDS: string[];
+/** Look up a target id; unknown ids are a usage error naming the registry. */
+export declare function publishTargetFor(id: string): PublishTarget;
+/**
+ * Resolve the effective target-id list for a run: the requested list when
+ * given (manifest `targets:` or `--target`), else the preset's defaults.
+ * Validates every id and dedupes while preserving order.
+ */
+export declare function resolveTargets(requested: readonly string[] | undefined, fallback: readonly string[]): string[];
+/**
+ * Merge a target's overlay onto a preset, producing the effective preset a
+ * target-scoped `resolveConfig` run merges the manifest over. This is what
+ * puts the overlay BELOW the manifest in the precedence chain.
+ */
+export declare function overlayPreset(preset: VendorPreset, target: PublishTarget): VendorPreset;
+/**
+ * The strict-PDF fill-ins applied to EVERY post-build PDF validation
+ * regardless of preset/target: any of these left `undefined` by the config
+ * becomes an error-severity check, without overwriting an author's explicit
+ * choice (including an explicit disable). Moved verbatim from
+ * validation-profile.ts (ARCH #21).
+ */
+export declare const DEFAULT_STRICT_PDF_CHECKS: readonly ["pdf.structure.qpdf", "pdf.print.pdfx-markers", "pdf.print.pdfx-metadata", "pdf.print.embedded-fonts"];
+export declare function applyDefaultPdfStrictChecks(config: ResolvedConfig): ResolvedConfig;

package/dist/lib/theme-import.d.ts

@@ -2,8 +2,6 @@ import { type PrintSafeWarning } from "./printsafe.ts";
 import { type ThemeInfo } from "./theme-manager.ts";
 /** Reject a raw archive larger than this before unzipping (zip-bomb surface). */
 export declare const MAX_THEME_ARCHIVE_BYTES: number;
-/** Reject an archive whose entries expand past this in total (zip-bomb surface). */
-export declare const MAX_THEME_UNZIPPED_BYTES: number;
 /** A non-fatal issue surfaced to the author after a successful import. */
 export interface ThemeImportWarning {
     code: "print-safety" | "no-theme-json" | "unnamed-theme" | "extra-files";

package/dist/lib/theme-manager.d.ts

@@ -1,7 +1,7 @@
 /** Folder (relative to the project root) themes are copied into on apply/import. */
 export declare const THEMES_DIR = "themes";
 /** The built-in themes shipped as embedded assets (ids are folder names). */
-export declare const BUILT_IN_THEME_IDS: readonly ["clean-book", "ttrpg-supplement", "zine", "technical-doc"];
+export declare const BUILT_IN_THEME_IDS: readonly ["clean-book", "zine", "technical-doc"];
 export type BuiltInThemeId = (typeof BUILT_IN_THEME_IDS)[number];
 /** Parsed `theme.json` metadata (every field optional in the file). */
 export interface ThemeMetadata {

package/dist/lib/validation-exec.d.ts

@@ -2,7 +2,6 @@ import { type OutputFormat } from "../checks/formatter";
 import { type RunnerOptions, type RunnerReport } from "../checks/runner";
 import { type ToolCheckResult } from "../checks/tool-check";
 import type { CheckContext, CheckResult } from "../checks/types";
-import { type ValidationProfile } from "./validation-profile";
 import type { ResolvedConfig } from "../schema/manifest.types";
 import "../checks/register-builtins";
 export interface ValidationExecutionArgs {
@@ -13,11 +12,13 @@ export interface ValidationExecutionArgs {
     only?: string;
     skip?: string;
     phase?: string;
-    profile?: string;
+    /** Publish-target ids (CSV) to validate against, overriding the manifest's `targets:` for this run. */
+    target?: string;
 }
 export interface ValidationExecutionResult {
     config: ResolvedConfig;
-    profile?: ValidationProfile;
+    /** The publish targets this run validated against (may be empty). */
+    targets: string[];
     context: CheckContext;
     runnerOptions: RunnerOptions;
     tools: ToolCheckResult;

package/dist/{lint-f63nxjfj.js → lint-96j9hrj4.js}

@@ -1,18 +1,18 @@
 import {
   MANIFEST_FILENAMES,
   runLint
-} from "./cli-7ykx7pp0.js";
+} from "./cli-k4bd06sd.js";
 import {
   log
-} from "./cli-h7phg3ka.js";
+} from "./cli-najycadg.js";
 import {
   EXIT_CODES,
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-hvqjs342.js";
-import"./cli-5bxx0c4y.js";
-import"./cli-1tyj4bk3.js";
+} from "./cli-e5zhb0xs.js";
+import"./cli-yzrh708h.js";
+import"./cli-wchtvxvw.js";
 import"./cli-yja077f6.js";
 import"./cli-37x76zdn.js";
 

package/dist/{manifest.schema-rn1dpdpn.json → manifest.schema-z61rzw44.json}

@@ -25,9 +25,15 @@
     },
     "preset": {
       "type": "string",
-      "description": "Vendor preset supplying the defaults for every other section (page geometry, ink limits, PDF/X settings, validation checks). Omitting it defaults to \"dtrpg\" for backward compatibility and logs a warning — set it explicitly.",
-      "enum": ["dtrpg", "book"],
-      "examples": ["dtrpg", "book"]
+      "description": "How the book is designed (ADR 0008): the base defaults for every other section — page geometry, ink limits, PDF/X settings, validation checks — all overridable field-by-field below. \"dtrpg\" = DriveThruRPG print-on-demand (the product default when omitted); \"book\" = neutral 6x9in trade book; \"custom\" = you supply page.width and page.height yourself (required).",
+      "enum": ["dtrpg", "book", "custom"],
+      "examples": ["dtrpg", "book", "custom"]
+    },
+    "targets": {
+      "type": "array",
+      "description": "Where the book is published (ADR 0008): publish targets whose requirements `gutterpress validate` checks the built PDF against — each target is validated separately, so one book can target several destinations. Omitting it uses the preset's default (dtrpg -> [\"dtrpg\"]; book/custom -> []).",
+      "items": { "type": "string", "enum": ["dtrpg", "itch"] },
+      "examples": [["dtrpg"], ["dtrpg", "itch"]]
     },
     "styles": {
       "type": "array",
@@ -517,12 +523,12 @@
       }
     },
     {
-      "title": "TTRPG Supplement",
-      "authors": ["Game Master"],
+      "title": "Print-Ready Supplement",
+      "authors": ["Author Name"],
       "preset": "dtrpg",
       "plugins": [
         {
-          "path": "plugins/dimm-city-plugin.js",
+          "path": "plugins/my-plugin.js",
           "priority": 100
         }
       ],

package/dist/new-8p38wavc.js

@@ -0,0 +1,185 @@
+import {
+  BUILT_IN_TEMPLATE_IDS,
+  PRESETS,
+  PRESET_IDS,
+  TARGETS,
+  TARGET_IDS,
+  scaffoldProject
+} from "./cli-k4bd06sd.js";
+import {
+  isToolAvailable,
+  resolveGhostscript
+} from "./cli-najycadg.js";
+import {
+  EXIT_CODES,
+  UsageError,
+  rejectExtraPositionals,
+  rejectUnknownFlags
+} from "./cli-e5zhb0xs.js";
+import"./cli-yzrh708h.js";
+import"./cli-wchtvxvw.js";
+import"./cli-yja077f6.js";
+import"./cli-37x76zdn.js";
+
+// src/commands/new.ts
+import { defineCommand } from "citty";
+import { resolve } from "node:path";
+var newArgs = {
+  name: {
+    type: "positional",
+    description: "Project name (becomes the title and folder name)",
+    required: true
+  },
+  preset: {
+    type: "string",
+    description: `Vendor preset the book is designed for: ${PRESET_IDS.join(", ")} (required; custom also needs --page-width/--page-height)`
+  },
+  author: {
+    type: "string",
+    description: "Author name to record in the project"
+  },
+  dir: {
+    type: "string",
+    description: "Parent directory to create the project in (default: current directory)"
+  },
+  folder: {
+    type: "string",
+    description: "Folder name to create (default: a slug of the project name)"
+  },
+  template: {
+    type: "string",
+    description: `Starter template: ${BUILT_IN_TEMPLATE_IDS.join(", ")} (default: book)`
+  },
+  targets: {
+    type: "string",
+    description: `Publish targets recorded in the manifest (comma-separated: ${TARGET_IDS.join(", ")}; or "none") — default: the preset's`
+  },
+  "page-width": {
+    type: "string",
+    description: "Trim width in points, 72pt = 1in (required with --preset custom; optional override otherwise)"
+  },
+  "page-height": {
+    type: "string",
+    description: "Trim height in points, 72pt = 1in (required with --preset custom; optional override otherwise)"
+  },
+  "page-tolerance": {
+    type: "string",
+    description: "Allowed trim deviation in points when validating a built PDF (default: 0.5)"
+  },
+  git: {
+    type: "boolean",
+    description: "Initialise local version history (default: true; use --no-git to skip)",
+    default: true
+  }
+};
+function parsePoints(raw, flag) {
+  if (typeof raw !== "string" || raw === "")
+    return;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) {
+    console.error(`Invalid ${flag} value: "${raw}". Expected a positive number of points (72pt = 1in).`);
+    process.exit(EXIT_CODES.USAGE);
+  }
+  return value;
+}
+var new_default = defineCommand({
+  meta: {
+    name: "new",
+    description: "Create a new Gutterpress project from a starter template"
+  },
+  args: newArgs,
+  async run({ args, rawArgs }) {
+    try {
+      rejectUnknownFlags(rawArgs, newArgs, "new");
+      rejectExtraPositionals(args._, 1, "new");
+    } catch (error) {
+      if (error instanceof UsageError) {
+        console.error(error.message);
+        process.exit(error.exitCode);
+      }
+      throw error;
+    }
+    const name = String(args.name);
+    const parentDir = resolve(typeof args.dir === "string" && args.dir ? args.dir : process.cwd());
+    let template;
+    if (typeof args.template === "string" && args.template) {
+      if (!BUILT_IN_TEMPLATE_IDS.includes(args.template)) {
+        console.error(`Unknown template "${args.template}". Choose one of: ${BUILT_IN_TEMPLATE_IDS.join(", ")}.`);
+        process.exit(EXIT_CODES.USAGE);
+      }
+      template = args.template;
+    }
+    const preset = typeof args.preset === "string" && args.preset ? args.preset : undefined;
+    if (!preset || !PRESET_IDS.includes(preset)) {
+      console.error(preset ? `Unknown preset "${preset}". Choose one of: ${PRESET_IDS.join(", ")}.` : `A preset is required: --preset <${PRESET_IDS.join("|")}>. ` + `Use "dtrpg" for DriveThruRPG print-on-demand, "book" for a neutral 6x9in trade book, ` + `or "custom" with --page-width/--page-height (points; 72pt = 1in).`);
+      process.exit(EXIT_CODES.USAGE);
+    }
+    let targets;
+    if (typeof args.targets === "string" && args.targets) {
+      targets = args.targets.trim().toLowerCase() === "none" ? [] : args.targets.split(",").map((s) => s.trim()).filter(Boolean);
+      const unknown = targets.filter((id) => !TARGETS[id]);
+      if (unknown.length > 0) {
+        console.error(`Unknown publish target${unknown.length > 1 ? "s" : ""} "${unknown.join('", "')}". ` + `Choose from: ${TARGET_IDS.join(", ")} — or "none" for no destination policies.`);
+        process.exit(EXIT_CODES.USAGE);
+      }
+    }
+    const pageWidth = parsePoints(args["page-width"], "--page-width");
+    const pageHeight = parsePoints(args["page-height"], "--page-height");
+    const pageTolerance = parsePoints(args["page-tolerance"], "--page-tolerance");
+    const customPage = pageWidth !== undefined && pageHeight !== undefined ? { width: pageWidth, height: pageHeight, ...pageTolerance !== undefined ? { tolerance: pageTolerance } : {} } : undefined;
+    if (preset === "custom" && !customPage) {
+      console.error("The custom preset needs a trim size: --page-width and --page-height in points (72pt = 1in — e.g. US Letter is 612 x 792).");
+      process.exit(EXIT_CODES.USAGE);
+    }
+    try {
+      const result = await scaffoldProject({
+        name,
+        author: typeof args.author === "string" ? args.author : undefined,
+        parentDir,
+        folderName: typeof args.folder === "string" && args.folder ? args.folder : undefined,
+        template,
+        preset,
+        targets,
+        customPage,
+        versionHistory: args.git === false ? "none" : "local-git"
+      });
+      const effectiveTargets = targets ?? [...PRESETS[preset].defaultTargets];
+      console.log(`Created project: ${result.projectDir}`);
+      console.log(`  manifest: ${result.manifestPath}`);
+      console.log(`  publish targets: ${effectiveTargets.length > 0 ? effectiveTargets.join(", ") : "none"}`);
+      console.log(`  start writing in: ${result.openFile}`);
+      if (result.versionHistory === "local-git") {
+        console.log("  version history: enabled (local snapshots)");
+      } else if (result.versionHistoryError) {
+        console.log(`  version history: not enabled (${result.versionHistoryError})`);
+      }
+      const neededTools = [
+        ...new Set(effectiveTargets.flatMap((id) => TARGETS[id]?.requiredTools ?? []))
+      ];
+      const missingTools = [];
+      for (const tool of neededTools) {
+        const found = tool === "gs" ? !!await resolveGhostscript() : await isToolAvailable(tool);
+        if (!found)
+          missingTools.push(tool === "gs" ? "Ghostscript (gs)" : tool);
+      }
+      if (missingTools.length > 0) {
+        const plural = missingTools.length > 1;
+        console.log("");
+        console.log(`  note: ${missingTools.join(" and ")} ${plural ? "are" : "is"} not installed — a ` + `print-compliant (PDF/X) file can't be built or verified until ${plural ? "they are" : "it is"}.`);
+        console.log("        Install them (User Guide, Chapter 7 — System Setup), or set `targets: []` in");
+        console.log("        manifest.yaml to skip destination checks for now.");
+      }
+      console.log("");
+      console.log(`Next: gutterpress preview "${result.projectDir}"`);
+    } catch (e) {
+      const err = e;
+      const code = err && typeof err.code === "string" ? err.code : "scaffold-io";
+      console.error(`Could not create project: ${err?.message ?? String(e)}`);
+      process.exit(code === "scaffold-io" ? EXIT_CODES.PIPELINE : EXIT_CODES.USAGE);
+    }
+  }
+});
+export {
+  newArgs,
+  new_default as default
+};