gutterpress 0.10.8 → 0.10.9

package/dist/{publish-zgmr99kd.js → publish-8s60vhx7.js}

@@ -11,17 +11,17 @@ import {
   publishProviderFor,
   resolvePublishFormat,
   runPublish
-} from "./cli-1hx14cgk.js";
+} from "./cli-8pg731p5.js";
 import {
   FileTokenStore,
   log
-} from "./cli-vxf151ea.js";
+} from "./cli-ypfvnhag.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-vcv5ewqj.js";
-import"./cli-4vtgt2ng.js";
+} from "./cli-rh05byck.js";
+import"./cli-bx950tb4.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/dist/schema/manifest.types.d.ts

@@ -1,19 +1,19 @@
 type CheckSeverity = "error" | "warning" | "info";
-export interface PluginConfig {
-    path?: string;
-    name?: string;
-    /** Exact project-local npm version. Legacy ranges remain informational. */
-    version?: string;
-    /** Named module export to use when the package has no default plugin export. */
-    export?: string;
+/**
+ * The object form of an `extensions:` entry (#265) — only for an entry that
+ * has to say more than its specifier. The common case is the bare string;
+ * `use` carries the same specifier in both forms.
+ */
+export interface ExtensionConfig {
     /**
-     * Load order (default 100). Higher loads first; built-in plugins always
-     * load before any user plugin regardless of this value. Advanced/rarely
-     * needed: a plugin needs the LOWER of two priorities to see tokens the
-     * other one produces, since it must load (and run) after it — see
-     * examples/gutterpress-user-guide/05-plugins.md#plugin-load-order.
+     * The specifier: a bundled feature name, a `./`/`../`/`/` path (relative
+     * to the manifest), or an npm package name, optionally pinned as
+     * `name@version`. See `lib/extension-specifier.ts` for the three rules.
      */
-    priority?: number;
+    use: string;
+    /** Named module export to use when the package has no default plugin export. */
+    export?: string;
+    /** Options passed straight through to the markdown-it plugin. */
     options?: Record<string, unknown>;
     /**
      * Per-project enable flag (#30). Absent or `true` = active; `false` = the
@@ -93,24 +93,6 @@ export interface GutterpressManifest {
     publish?: PublishSettings;
     /** How the book is designed (ADR 0008). The registry in lib/presets.ts is authoritative. */
     preset?: "dtrpg" | "book" | "custom";
-    /**
-     * Pagination engine. The Gutterpress engine (`src/engine/`, native Chromium
-     * pagination) is the only engine. This field and `--engine` on the CLI are
-     * accepted-but-ignored for backward compatibility: an explicit "paged"
-     * produces a one-line warning and the build proceeds natively regardless.
-     */
-    engine?: "paged" | "native";
-    /**
-     * Engine-conditional stylesheets, appended AFTER `styles`. `.native` is the
-     * only list this type declares; a manifest that still carries `.paged`
-     * (dual-engine era, pre-0.10.7) keeps parsing — `resolveConfig` reads it
-     * through a widened cast and warns once — but it is no longer part of the
-     * authored/autocompleted shape (see `manifest.schema.json`, which drops it
-     * too), since the native engine is the only engine.
-     */
-    engineStyles?: {
-        native?: string[];
-    };
     /**
      * Where the book is published (ADR 0008): publish-target ids whose
      * validation policies this book is checked against. Absent = the preset's
@@ -119,7 +101,13 @@ export interface GutterpressManifest {
      */
     targets?: string[];
     styles?: string[];
-    plugins?: (string | PluginConfig)[];
+    /**
+     * Extensions, in load order (#265): markdown-it plugins, looks, component
+     * libraries — from npm, a folder, or the bundled set. A later entry loads
+     * later, sees earlier entries' markdown output, and its CSS wins ties; the
+     * project's own `styles` always load after every extension.
+     */
+    extensions?: (string | ExtensionConfig)[];
     source?: {
         files?: string[] | null;
     };
@@ -203,14 +191,17 @@ export interface GutterpressManifest {
         };
     };
 }
-export interface ResolvedPluginConfig {
+export interface ResolvedExtensionConfig {
+    /** The specifier exactly as written (pin included) — for messages and manifest edits. */
+    use: string;
+    /** The path specifier, for a path entry; the loader resolves it against the manifest directory. */
     path?: string;
+    /** The package name, for a bundled or npm entry. */
     name?: string;
-    /** Exact version for a project-local vendored npm plugin. */
+    /** Exact version for a project-local vendored npm extension. */
     version?: string;
     /** Named module export selected as the plugin function. */
     export?: string;
-    priority: number;
     options: Record<string, unknown>;
 }
 /**
@@ -224,18 +215,11 @@ export interface ResolvedPluginConfig {
 export interface ResolvedConfig {
     title: string;
     authors: string[];
-    /**
-     * Resolved pagination engine. Always `"native"` — `manifest.ts` assigns the
-     * literal, warning and ignoring an author's `engine: paged`. Typed as the
-     * single value it can hold so no consumer can branch on an engine that
-     * cannot run. The INPUT union ({@link GutterpressManifest.engine}) keeps
-     * both spellings, because old manifests must go on parsing.
-     */
-    engine: "native";
     /** Validated publish-target ids for this book (may be empty). */
     targets: string[];
     styles?: string[];
-    plugins: ResolvedPluginConfig[];
+    /** Enabled extensions, in manifest (= load = cascade) order. */
+    extensions: ResolvedExtensionConfig[];
     source: {
         files: string[] | null;
     };

package/dist/{theme-cd6efzjw.json → theme-etj4gxck.json}

@@ -2,5 +2,8 @@
   "name": "Zine",
   "author": "gutterpress",
   "description": "High-contrast, punchy sans-serif look for short photocopier-friendly zines.",
-  "preview": null
+  "preview": null,
+  "styles": [
+    "theme.css"
+  ]
 }

package/dist/{theme-tqfypc1w.json → theme-s2rg7xe7.json}

@@ -2,5 +2,8 @@
   "name": "Technical Document",
   "author": "gutterpress",
   "description": "Clean sans-serif manual look with clear hierarchy, code styling, and tidy tables.",
-  "preview": null
+  "preview": null,
+  "styles": [
+    "theme.css"
+  ]
 }

package/dist/{theme-xt0hjb1b.json → theme-vktedy8q.json}

@@ -2,5 +2,8 @@
   "name": "Clean Book",
   "author": "gutterpress",
   "description": "A calm, classic book look: serif body, generous margins, restrained accents.",
-  "preview": null
+  "preview": null,
+  "styles": [
+    "theme.css"
+  ]
 }

package/dist/types.d.ts

@@ -27,11 +27,4 @@ export interface PreviewServerOptions {
     noWatch: boolean;
     /** Automatically open browser (default: true) */
     openBrowser: boolean;
-    /**
-     * CLI `--engine` override, fed into {@link resolveConfig} the same way
-     * `build`'s does — preview and PDF switch together, per project, behind
-     * one flag. `undefined` defers to the
-     * manifest's `engine:` field (or the "native" default).
-     */
-    engine?: "paged" | "native";
 }

package/dist/{validate-43hqgzz5.js → validate-awccx32r.js}

@@ -1,15 +1,15 @@
 import {
   executeAndReport
-} from "./cli-1hx14cgk.js";
+} from "./cli-8pg731p5.js";
 import {
   log
-} from "./cli-vxf151ea.js";
+} from "./cli-ypfvnhag.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-vcv5ewqj.js";
-import"./cli-4vtgt2ng.js";
+} from "./cli-rh05byck.js";
+import"./cli-bx950tb4.js";
 import"./cli-c41yr7he.js";
 import {
   EXIT_CODES

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gutterpress",
-  "version": "0.10.8",
+  "version": "0.10.9",
   "description": "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   "author": "itlackey",
   "license": "MPL-2.0",

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

@@ -1,106 +0,0 @@
-import { type NpmPluginInstallOptions } from "./npm-plugin-installer";
-/** Folder (relative to the project root) imported local plugins are copied to. */
-export { PLUGINS_DIR } from "./plugin-vendor";
-/** How a plugin entry is referenced in the manifest. */
-export type PluginKind = "local" | "npm";
-/** One configured plugin, as surfaced to the manager UI. */
-export interface ProjectPluginEntry {
-    /** Stable reference: the manifest `path` (local) or `name` (npm). */
-    ref: string;
-    /** `"local"` when referenced by file path, `"npm"` when by package name. */
-    kind: PluginKind;
-    /** Per-project enable flag. Absent in the manifest defaults to `true`. */
-    enabled: boolean;
-    /** Exact installed npm version. Absent for local, built-in, and legacy entries. */
-    version?: string;
-    /** Named module export selected as the plugin function. */
-    export?: string;
-    /** Non-fatal install notices, currently used for legacy SHA-1 registry entries. */
-    warnings?: string[];
-}
-interface PluginManagerInstallOptions extends NpmPluginInstallOptions {
-    exportName?: string;
-    __testFailBeforeManifestCommit?: () => void | Promise<void>;
-}
-/** Result of attempting to load one configured plugin. */
-export interface PluginValidationResult {
-    ref: string;
-    kind: PluginKind;
-    /** Mirrors the manifest enable flag. Disabled plugins are not load-tested. */
-    enabled: boolean;
-    /** `true` when the plugin loaded OK (or is disabled and skipped). */
-    ok: boolean;
-    /** The loader's fail-fast error message when `ok` is `false`. */
-    error?: string;
-}
-/** A curated markdown feature an author can turn on. */
-export interface RecommendedPlugin {
-    /** The npm package name (also the manifest entry that "Add" writes). */
-    name: string;
-    /** Short, plain-language feature name shown as the row title (the package
-     *  name is demoted to secondary text — a non-technical author shouldn't have
-     *  to read `markdown-it-*` ids to pick a feature). */
-    label: string;
-    /** One-line author-friendly description. */
-    description: string;
-    /**
-     * True when gutterpress ships this plugin (see `BUILTIN_OPTIONAL_PLUGINS`):
-     * "Add" enables it instantly, no install, works offline. All entries below
-     * are built-in — the always-on defaults (attrs/footnote/deflist, applied
-     * unconditionally in renderer.ts) are intentionally NOT listed here, since
-     * recommending the author "add" something already active is pure confusion.
-     */
-    builtin: true;
-}
-/**
- * Curated, BUILT-IN opt-in markdown features. Each is bundled with gutterpress
- * (`BUILTIN_OPTIONAL_PLUGINS`), so clicking "Add" writes the manifest entry AND
- * the feature works immediately — no terminal, no install, offline. This is the
- * non-technical-author happy path: "turn on a feature → it works".
- */
-export declare const RECOMMENDED_PLUGINS: RecommendedPlugin[];
-/**
- * List the project's configured plugins with their per-project enable flag.
- * Returns `[]` when there is no manifest or no `plugins:` list.
- *
- * For object-form entries, the kind is taken from the manifest KEY (`path:` →
- * local, `name:` → npm) rather than guessing from the value. This correctly
- * classifies e.g. `path: plugins/foo.js` (no `./` prefix) as local. Scalar
- * (string) entries fall back to the {@link isLocalRef} heuristic.
- */
-export declare function listProjectPlugins(projectDir: string): Promise<ProjectPluginEntry[]>;
-/**
- * Set the per-project enabled flag for the plugin identified by `ref` (its
- * path or npm name). A string-form entry is normalised to an object entry so
- * the flag can be attached. Persists to the manifest (preserving comments).
- * Throws when no entry matches `ref`.
- */
-export declare function setPluginEnabled(projectDir: string, ref: string, enabled: boolean): Promise<void>;
-/**
- * Install an npm markdown-it plugin without an external package manager, then
- * record its exact version in the manifest. Built-in optional plugins remain
- * offline: adding one only records its bundled package name.
- */
-export declare function addNpmPlugin(projectDir: string, packageSpec: string, exportName?: string): Promise<ProjectPluginEntry>;
-/** @internal Dependency/fault injection for focused installer tests. */
-export declare function addNpmPluginWithOptions(projectDir: string, packageSpec: string, options?: PluginManagerInstallOptions): Promise<ProjectPluginEntry>;
-/**
- * Import a local plugin by copying the source file OR folder into the
- * project's `plugins/` directory and adding a manifest entry that references
- * the copied path (so the plugin travels with the project). Returns the new
- * entry. Throws when `sourcePath` does not exist.
- */
-export declare function addLocalPlugin(projectDir: string, sourcePath: string): Promise<ProjectPluginEntry & {
-    path: string;
-}>;
-/**
- * Validate every configured plugin by attempting to LOAD it through the
- * existing lib loader (`loadPlugin`). Disabled plugins are reported as
- * disabled and NOT load-tested. Loader errors are CAUGHT and surfaced per
- * plugin (never thrown through) so the UI can flag erroring plugins clearly.
- *
- * This reuses the fail-fast loader path verbatim (§5) — including its
- * "not found / install it" message for unresolvable npm packages — rather than
- * reimplementing resolution.
- */
-export declare function validateProjectPlugins(projectDir: string): Promise<PluginValidationResult[]>;

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

@@ -1,242 +0,0 @@
-import { type ExtensionMetadata, assertExtensionContained, extensionEngineStyleList } from "./extension-manifest.ts";
-/** 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", "zine", "technical-doc"];
-export type BuiltInThemeId = (typeof BUILT_IN_THEME_IDS)[number];
-/**
- * Parsed theme metadata (every field optional in the file) — #241: a theme is
- * the degenerate "styles only" case of {@link ExtensionMetadata}, so this is
- * now a plain alias rather than a separate type. A `theme.json` file only
- * ever populates the fields this comment used to document in full
- * (`name`/`author`/`description`/`preview`/`styles`/`engineStyles`/
- * `tokensFile`, #239); the three newer fields (`markdown`/`components`/
- * `snippets`) are only reachable via a `gutterpress.json` — see
- * `extension-manifest.ts` for the complete, current field-by-field doc.
- */
-export type ThemeMetadata = ExtensionMetadata;
-/** Author-friendly metadata for one theme (built-in or project). */
-export interface ThemeInfo {
-    /** Stable id (a built-in id, or a slug for imported/applied themes). */
-    id: string;
-    /** Display name. */
-    name: string;
-    /** Theme author, when known. */
-    author?: string;
-    /** One-line description. */
-    description: string;
-    /** `"builtin"` (embedded) or `"project"` (copied into the project). */
-    kind: "builtin" | "project";
-    /** Optional preview image path relative to the theme folder. */
-    preview?: string | null;
-    /**
-     * #239 — the theme's declared stylesheets, relative to the theme folder, in
-     * cascade order. Always populated (defaults to `["theme.css"]` when the
-     * theme declares no `styles`), so a caller never needs to re-derive the
-     * default itself.
-     */
-    styles: string[];
-    /**
-     * #239 — which declared sheet (relative to the theme folder) carries the
-     * `:root` token surface — see {@link ThemeMetadata.tokensFile}. ALWAYS
-     * populated: an explicit `theme.json` declaration wins, otherwise this
-     * defaults to the theme's primary sheet (`styles[0]`) — `"theme.css"` for
-     * every legacy single-sheet theme, exactly as `styles` itself defaults.
-     * A caller (the Design panel) never needs its own "guess the token sheet"
-     * fallback.
-     */
-    tokensFile: string;
-    /**
-     * #241 — declared-relative path to a markdown-it entry, when this theme's
-     * `gutterpress.json` names one (never possible via the legacy `theme.json`
-     * shape). Informational only: the theme verbs (list/apply/import/revert/
-     * remove) do not load or wire it — a full extension carrying both styles
-     * AND markdown installs via `gutterpress plugin add <folder>` instead (see
-     * `plugins.ts`'s `loadExtensionFromDir`), which resolves and applies this
-     * SAME field. Surfaced here so a theme card can at least show "this
-     * extension also has a plugin half" rather than staying silent about it.
-     */
-    markdown?: string;
-    /** #241 — declared-relative path to a component catalog file, informational
-     *  only (same rationale as {@link markdown}); no catalog reader consumes
-     *  this yet. */
-    components?: string;
-    /** #241 — declared-relative path to a snippets folder, informational only
-     *  on THIS type (same rationale as {@link markdown} — the theme verbs
-     *  don't load it). The active theme's copy of this field IS consumed,
-     *  by `snippets.ts`'s `listMergedSnippets` (#242) via `getActiveTheme`. */
-    snippets?: string;
-}
-/** A built-in theme resolved to disk (extracted from the embedded assets). */
-export interface ResolvedTheme {
-    info: ThemeInfo;
-    /** Absolute path to the theme's `theme.css` (in the extracted assets dir). */
-    cssPath: string;
-    /** Absolute path to the theme's folder. */
-    dir: string;
-}
-/** Which theme to apply: a built-in id, or a project theme already on disk. */
-export type ApplyThemeTarget = {
-    kind: "builtin";
-    id: BuiltInThemeId | string;
-} | {
-    kind: "project";
-    id: string;
-};
-/**
- * A theme's declared stylesheets, relative to its folder, in cascade order
- * (#239). An absent OR empty `styles` defaults to `["theme.css"]` — the
- * single-file format every theme published before this field existed already
- * satisfies, so nothing needs migrating. Exported for `theme-import.ts`,
- * which validates every one of these (existence + print-safety) at import
- * time, the same way it always validated the lone `theme.css`.
- *
- * #241: layers that theme-only default on top of `extension-manifest.ts`'s
- * {@link extensionStyleList}, which does NOT apply it (a markdown-only
- * extension has no reason to require a `theme.css` it never declared) — one
- * shared "read the declared list" body, two defaulting rules.
- */
-export declare function themeStyleList(meta: ThemeMetadata): string[];
-/**
- * Every declared sheet (styles/engineStyles — #241: now also `markdown`/
- * `components`/`snippets`/`tokensFile`, since a `gutterpress.json`-formatted
- * theme can declare them too) must live INSIDE the theme folder. A theme is
- * self-contained by contract (apply copies the whole folder), and an imported
- * package is untrusted input: a `../` or absolute entry would make apply read
- * a file from anywhere on disk into the book.
- *
- * This is a WRITE-BOUNDARY guard — `applyTheme`, `importThemeFromFolder` and
- * `theme-import.ts`'s package validation call it before copying anything or
- * wiring a manifest. It deliberately does NOT live in {@link themeStyleList},
- * which the read paths (`listProjectThemes`, `getActiveTheme`,
- * `getPreviousTheme`, `readThemeCss`) also call: one hand-edited theme.json
- * must not take down listing every theme, the same reason `readThemeMeta`
- * returns `{}` for an unparseable file instead of throwing.
- *
- * #241 — a straight re-export of the extension-generic
- * {@link assertExtensionContained}: a theme's containment rule is not a
- * separate implementation, it IS the extension rule, applied to a metadata
- * object that (for a `theme.json`-only folder) never has the three newer
- * fields populated in the first place.
- */
-export declare const assertThemeSheetsContained: typeof assertExtensionContained;
-/**
- * A theme's declared engine-conditional sheets, relative to its folder
- * (#239). `Array.isArray` guards a malformed `engineStyles.native` (authored
- * as something other than a list) — treated as "none declared" rather than a
- * hard crash on a JSON author's typo. Exported for `theme-import.ts`'s import
- * validation, same reuse rationale as {@link themeStyleList}.
- *
- * #241 — a straight alias: `engineStyles.native` never had a theme-specific
- * default to layer on, so this is byte-identical to
- * {@link extensionEngineStyleList}.
- */
-export declare const themeEngineStyleList: typeof extensionEngineStyleList;
-/** List the built-in themes (metadata read from the extracted embedded assets). */
-export declare function listBuiltInThemes(): Promise<ThemeInfo[]>;
-/** Resolve a built-in theme to its extracted `theme.css` + parsed metadata. */
-export declare function resolveBuiltInTheme(id: string): Promise<ResolvedTheme>;
-/**
- * List the themes that live inside the project under `themes/<id>/` (each a
- * folder whose PRIMARY declared sheet exists — `theme.css` by default, or
- * `theme.json`'s `styles[0]` for a multi-sheet theme, #239). Returns `[]`
- * when there is no `themes/` folder.
- */
-export declare function listProjectThemes(projectDir: string): Promise<ThemeInfo[]>;
-/**
- * Read the project's currently active theme (the theme with an entry under
- * `themes/<id>/…` in the manifest `styles:` list AND whose folder's PRIMARY
- * declared sheet still exists on disk, #239). Returns `null` when no theme is
- * applied.
- */
-export declare function getActiveTheme(projectDir: string): Promise<ThemeInfo | null>;
-/**
- * Read the project's "previous theme" — the theme active immediately before the
- * current one (#106). Returns `null` when there is no recorded previous theme,
- * when its folder no longer exists, or when it is (somehow) already the active
- * theme. The reference is persisted indefinitely (no timer) in the manifest.
- */
-export declare function getPreviousTheme(projectDir: string): Promise<ThemeInfo | null>;
-/**
- * Revert to the previously active theme (#106): re-apply the theme recorded by
- * {@link getPreviousTheme}. Because {@link applyTheme} itself records the
- * now-current theme as the new "previous", reverting is a toggle — revert again
- * returns to where you were. Throws when there is no previous theme to revert to.
- */
-export declare function revertTheme(projectDir: string): Promise<ThemeInfo>;
-/**
- * Apply a theme to the project: COPY the theme folder into `themes/<id>/`
- * (built-in themes are copied out of the embedded assets; project themes are
- * already present) and wire the manifest so its `theme.css` is the active
- * stylesheet. Returns the applied {@link ThemeInfo}.
- *
- * No-data-loss mandate (UX review M6): a project theme's `theme.css` is the
- * exact file the Design panel writes token edits into, so re-copying a
- * built-in over an EXISTING `themes/<id>/` would silently discard every
- * customization the author made after the first apply. Applying a built-in
- * therefore never overwrites an existing project theme folder — if one is
- * already there (customized or not), the built-in is copied into a fresh id
- * (via the same {@link uniqueThemeId} helper import/folder-import uses) and
- * THAT becomes active, leaving the original folder untouched. In the normal UI flow the
- * Appearance grid hides a built-in card once its project copy exists (so this
- * path isn't reachable by clicking Apply twice); this guard is the
- * defense-in-depth backstop for any other caller of this function.
- */
-export declare function applyTheme(projectDir: string, target: ApplyThemeTarget): Promise<ThemeInfo>;
-/**
- * Import a theme from a local folder by copying it into the project's
- * `themes/<id>/`. The folder MUST contain its PRIMARY declared stylesheet —
- * `theme.css` by default, or `theme.json`'s `styles[0]` for a multi-sheet
- * theme (#239) that ships no `theme.css` at all. Metadata comes from its
- * `theme.json` (synthesised from the folder name when absent). The imported
- * theme becomes available to {@link applyTheme}; importing does NOT auto-apply.
- */
-export declare function importThemeFromFolder(projectDir: string, sourceDir: string): Promise<ThemeInfo>;
-/**
- * Import a theme from a URL using the global `fetch` (bundle-safe — no node http
- * client). Two shapes are supported:
- *
- *   - RAW CSS: a `…/theme.css` (or any `.css`) URL → fetched as the theme's
- *     `theme.css`; metadata is synthesised from the URL.
- *   - THEME FOLDER: a base URL (no `.css`) → we fetch `<base>/theme.json`
- *     (optional) and `<base>/theme.css` (required) to assemble the theme.
- *
- * The fetched theme is written into the project's `themes/<id>/`. Bundled fonts
- * are NOT followed for URL imports (a single CSS file + optional metadata) to
- * keep the fetch surface small and predictable; authors wanting bundled assets
- * use folder import.
- */
-export declare function importThemeFromUrl(projectDir: string, url: string): Promise<ThemeInfo>;
-/**
- * Read a theme's CSS for previewing. Built-in themes read from the embedded
- * assets; project themes read and concatenate EVERY sheet `theme.json`
- * declares (#239 — `theme.css` alone when it declares none), in cascade
- * order. Used by the host to feed the renderer a sample-render thumbnail (the
- * renderer never touches fs) — a read-only preview, so concatenation is fine
- * even though it wouldn't be for an editable surface.
- */
-export declare function readThemeCss(projectDir: string | null, source: {
-    kind: "builtin" | "project";
-    id: string;
-}): Promise<string>;
-/**
- * Remove an imported/applied project theme folder. If it was the active theme,
- * its ENTIRE block is dropped too — every `styles:` entry AND every
- * `engineStyles.native` entry under `themes/<id>/…` (#239), not just a single
- * `theme.css` href. Never touches built-in (embedded) themes.
- */
-export declare function removeProjectTheme(projectDir: string, id: string): Promise<void>;
-/**
- * #236 follow-through: detect a project whose `styles/book.css` is
- * byte-identical to a built-in theme's `theme.css` while NO theme is tracked
- * as active. That shape is exactly what a pre-0.10.7 `gutterpress new` (or
- * "set up as a book") produced — a real, working stylesheet that is simply
- * invisible to this command and to the desktop's Theme panel, and which will
- * keep loading AFTER (so silently override) whatever theme is applied next.
- * Read-only: this never modifies the project — it only surfaces a note so the
- * author can decide whether to run `theme apply` themselves.
- */
-export declare function detectLegacyForkedTheme(projectDir: string, active: ThemeInfo | null): Promise<{
-    id: string;
-    name: string;
-} | null>;