gutterpress 0.10.7 → 0.10.8

package/dist/{index-a0xpm188.js → index-rpt4vtby.js}

@@ -4,7 +4,7 @@ import {
   launchChromium,
   marginBoxAlign,
   marginBoxRectPt
-} from "./index-837htyjy.js";
+} from "./index-9pbaznww.js";
 
 // src/engine/compiler/build.ts
 import { readFile } from "node:fs/promises";

package/dist/index.js

@@ -8,18 +8,22 @@ import {
   AUTO_SYNC_PUSH_INTERVAL_MINUTES,
   BUILT_IN_TEMPLATE_IDS,
   BUILT_IN_THEME_IDS,
+  EXTENSION_KINDS,
+  EXTENSION_MANIFEST_FILENAME,
   FileTokenStore,
   GDRIVE_HOST,
   GITHUB_HOST,
   GOOGLE_NOT_CONFIGURED_MESSAGE,
   GitHubAuthProvider,
   GoogleAuthProvider,
+  LEGACY_THEME_MANIFEST_FILENAME,
   MANIFEST_FILENAMES,
   PLUGINS_DIR,
   PRESETS,
   PRESET_IDS,
   PublishSelectionsStore,
   RECOMMENDED_PLUGINS,
+  RESERVED_PREFIX,
   SNIPPETS_DIR,
   SYNC_SNAPSHOT_MESSAGE,
   TARGETS,
@@ -29,6 +33,7 @@ import {
   addNpmPlugin,
   adoptFolder,
   applyTheme,
+  assertExtensionContained,
   autoSnapshotDelayMs,
   autoSyncDelayMs,
   checkCss,
@@ -45,6 +50,8 @@ import {
   escapeYamlScalar,
   executeAndReport,
   executeValidation,
+  extensionEngineStyleList,
+  extensionStyleList,
   extractUrlCredential,
   extractVariables,
   forgeKindForHost,
@@ -68,6 +75,7 @@ import {
   listCustomTemplates,
   listGitHubBranches,
   listGitHubRepositories,
+  listMergedSnippets,
   listProjectPlugins,
   listProjectStyles,
   listProjectThemes,
@@ -80,11 +88,14 @@ import {
   log,
   openPath,
   parseRemoteOrigin,
+  pathEscapesFolder,
   pkceChallengeFromVerifier,
   publishConnectionStatus,
   publishCredentialKey,
   publishProviderFor,
   publishTargetFor,
+  readExtensionMeta,
+  readExtensionSnippet,
   readManifestFields,
   readPublishSettings,
   readSnippet,
@@ -96,6 +107,8 @@ import {
   resolveBuiltInTheme,
   resolveCheckSelectors,
   resolveConfig,
+  resolveExtension,
+  resolveExtensionPrefix,
   resolveGitHubClientId,
   resolveGoogleClientId,
   resolveGoogleClientSecret,
@@ -113,6 +126,7 @@ import {
   sanitizeCloneFolderName,
   saveProjectAsTemplate,
   saveSnippet,
+  scaffoldExtension,
   scaffoldProject,
   setActiveStyles,
   setManifestFields,
@@ -125,15 +139,15 @@ import {
   syncProject,
   testRemoteAccess,
   validateProjectPlugins
-} from "./index-r4ny4fyr.js";
+} from "./index-dfw8hn8q.js";
 import {
   BUILD_DIAGNOSTIC_CODES
-} from "./index-a0xpm188.js";
+} from "./index-rpt4vtby.js";
 import {
   BuildError,
   DEFAULT_PRINT_OPTS,
   readyProbeExpr
-} from "./index-837htyjy.js";
+} from "./index-9pbaznww.js";
 import {
   AUTO_SNAPSHOT_MESSAGE,
   HISTORY_PAGE_LIMIT,
@@ -164,6 +178,7 @@ export {
   setManifestFields,
   setActiveStyles,
   scaffoldProject,
+  scaffoldExtension,
   saveSnippet,
   saveProjectAsTemplate,
   sanitizeCloneFolderName,
@@ -183,6 +198,8 @@ export {
   resolveGoogleClientSecret,
   resolveGoogleClientId,
   resolveGitHubClientId,
+  resolveExtensionPrefix,
+  resolveExtension,
   resolveConfig,
   resolveCheckSelectors,
   resolveBuiltInTheme,
@@ -197,12 +214,15 @@ export {
   readSnippet,
   readPublishSettings,
   readManifestFields,
+  readExtensionSnippet,
+  readExtensionMeta,
   publishTargetFor,
   publishProviderFor,
   publishCredentialKey,
   publishConnectionStatus,
   providerFor,
   pkceChallengeFromVerifier,
+  pathEscapesFolder,
   parseRemoteOrigin,
   openPath,
   log,
@@ -215,6 +235,7 @@ export {
   listProjectThemes,
   listProjectStyles,
   listProjectPlugins,
+  listMergedSnippets,
   listGitHubRepositories,
   listGitHubBranches,
   listCustomTemplates,
@@ -240,6 +261,8 @@ export {
   findEnclosingRepoDir,
   extractVariables,
   extractUrlCredential,
+  extensionStyleList,
+  extensionEngineStyleList,
   executeValidation,
   executeAndReport,
   escapeYamlScalar,
@@ -258,6 +281,7 @@ export {
   capabilitiesFor,
   autoSyncDelayMs,
   autoSnapshotDelayMs,
+  assertExtensionContained,
   applyTheme,
   adoptFolder,
   addNpmPlugin,
@@ -268,12 +292,14 @@ export {
   SYNC_SNAPSHOT_MESSAGE,
   SNIPPETS_DIR,
   RESTORE_BACKUP_MESSAGE,
+  RESERVED_PREFIX,
   RECOMMENDED_PLUGINS,
   PublishSelectionsStore,
   PRESET_IDS,
   PRESETS,
   PLUGINS_DIR,
   MANIFEST_FILENAMES,
+  LEGACY_THEME_MANIFEST_FILENAME,
   HISTORY_PAGE_LIMIT,
   GoogleAuthProvider,
   GitHubAuthProvider,
@@ -281,6 +307,8 @@ export {
   GITHUB_HOST,
   GDRIVE_HOST,
   FileTokenStore,
+  EXTENSION_MANIFEST_FILENAME,
+  EXTENSION_KINDS,
   DEFAULT_PRINT_OPTS,
   BuildError,
   BUILT_IN_THEME_IDS,

package/dist/lib/build-runner.d.ts

@@ -1,4 +1,5 @@
 import { resolveConfig } from "./manifest";
+import { type LoadedPluginsWithCss } from "./markdown/plugins";
 import { RENDER_TIMEOUT_MS } from "./browser-pool";
 import { BuildError } from "./build-error";
 import type { BuildDiagnostic } from "../engine/compiler/build.ts";
@@ -165,6 +166,29 @@ export interface BuildContext {
      * warning from the final render path.
      */
     prevalidatedLayoutWarningKeys: Set<string>;
+    /**
+     * The build's ONE plugin load (#262). `null` until {@link loadBuildPlugins}
+     * runs; every stage that needs plugins (the lint gate and preValidate gate
+     * in {@link runQualityGates}, and {@link renderBook}) calls that function
+     * and gets the SAME resolved `{ plugins, pluginCss, pluginStylePaths }`
+     * back, whichever of them runs first.
+     *
+     * Before this, `runQualityGates`'s lint gate and `renderBook` each called
+     * `loadPluginsWithCss` independently for the identical manifest. For an
+     * npm-vendored plugin, EVERY load re-runs `verifyVendoredPlugin` ->
+     * `computeVendorTreeDigest` (plugin-vendor.ts) — a recursive walk of the
+     * vendored tree plus a full read-and-SHA-256 of every file, with no cache
+     * anywhere in that module BY DESIGN (the digest exists to detect tampering
+     * with the vendored tree; a cache keyed on anything less than the file
+     * contents themselves — e.g. the receipt's mtime — would not notice an
+     * edited vendored file). A `gutterpress build` with the lint gate on
+     * therefore paid that cost twice for no reason: same manifest, same
+     * `renderDir` anchor (see that field's doc comment — the two call sites'
+     * base dirs were the historical risk here, and they are now provably the
+     * same value), same plugin list. Memoizing the ONE load on the context
+     * removes the duplicate work without caching anything security-relevant.
+     */
+    plugins: LoadedPluginsWithCss | null;
 }
 /**
  * Stage 1 — load the manifest, merge CLI overrides into the resolved config,
@@ -173,6 +197,34 @@ export interface BuildContext {
  * flags-ignored notice. Everything downstream reads from the returned context.
  */
 export declare function resolveBuildContext(opts: BuildRunnerOptions): Promise<BuildContext>;
+/**
+ * Load every plugin the manifest configures, exactly once for the whole
+ * build (#262). Memoized on `ctx.plugins`: the lint gate, the preValidate
+ * gate (both in {@link runQualityGates}), and {@link renderBook} each call
+ * this instead of `loadPluginsWithCss` directly, and only the first caller
+ * does real work — the rest get the cached result back, however the gates
+ * are configured and whichever stage happens to run first (a test calling
+ * {@link renderBook} directly, without going through `runQualityGates`, gets
+ * a fresh load here exactly as it would have before this existed).
+ *
+ * Fail-fast (no `onError`), matching `renderBook`'s pre-existing behavior:
+ * a build/export must never silently omit author-configured formatting (see
+ * `loadPlugins`'s doc comment in markdown/plugins.ts on the two failure
+ * modes). One consequence: a plugin that fails to load now aborts the build
+ * as soon as quality gates start, instead of (as before) the lint gate's own
+ * degrade-and-report call warning-and-skipping that same plugin only for
+ * `renderBook` to hard-fail on it moments later — the build failed either
+ * way, this just stops wasting the lint pass first.
+ *
+ * Resolves plugin `path:` entries against `ctx.renderDir`, which is by
+ * construction identical to `ctx.manifestDir` for the life of one
+ * `BuildContext` (see {@link BuildContext.renderDir}'s doc comment and
+ * build-runner.output-dir.test.ts's anchor tests) — so hoisting this load
+ * ahead of the gates cannot resolve a plugin against a different root than
+ * `renderBook` used to, including under an explicit `--manifest` outside
+ * `--input`.
+ */
+export declare function loadBuildPlugins(ctx: BuildContext): Promise<LoadedPluginsWithCss>;
 /**
  * Stage 3 — load configured plugins, render the markdown chapters to
  * `outDir/book.html`, and copy user asset directories. Returns the path to the

package/dist/lib/extension-manifest.d.ts

@@ -0,0 +1,164 @@
+/** The unified package's metadata filename — checked before the legacy
+ *  theme-only filename by {@link readExtensionMeta}. */
+export declare const EXTENSION_MANIFEST_FILENAME = "gutterpress.json";
+/** The pre-#241 theme-only metadata filename. Still fully supported: a folder
+ *  with only this file (no `gutterpress.json`) is a theme, i.e. "an extension
+ *  with only styles" — see {@link readExtensionMeta}. */
+export declare const LEGACY_THEME_MANIFEST_FILENAME = "theme.json";
+/**
+ * Parsed extension metadata — a superset of the pre-#241 theme metadata
+ * shape. Every field is optional, and a folder declaring only the theme-era
+ * fields (`name`/`author`/`description`/`preview`/`styles`/`engineStyles`/
+ * `tokensFile`) IS a valid extension: "theme ≡ extension with only styles."
+ * Symmetrically, a bare `.js` plugin file (no metadata file at all) never
+ * constructs one of these — "plugin ≡ extension with only markdown" needs no
+ * metadata file until it wants more than a function (see `plugins.ts`'s
+ * `loadExtensionFromDir`, which only reaches this type for a `path` that
+ * names a folder).
+ */
+export interface ExtensionMetadata {
+    name?: string;
+    author?: string;
+    description?: string;
+    /** Optional preview image path (relative to the extension folder). */
+    preview?: string | null;
+    /**
+     * Ordered stylesheets, relative to the extension folder. Absent/empty means
+     * "no styles declared" here — {@link extensionStyleList} does NOT default
+     * to `["theme.css"]`; that default is theme-manager.ts's OWN, layered on
+     * top for its theme-shaped callers (a plain markdown-only extension folder
+     * has no reason to require a `theme.css` it never declared).
+     */
+    styles?: string[];
+    /** Engine-conditional sheets, relative to the extension folder, appended
+     *  after `styles` (mirrors the manifest's own `engineStyles.native`). */
+    engineStyles?: {
+        native?: string[];
+    };
+    /** Which declared sheet (a path from `styles`) carries the author-facing
+     *  `:root` token surface for the Design panel's guided editor. Purely
+     *  advisory — nothing in this module enforces or existence-checks it,
+     *  matching the pre-#241 theme behavior it generalizes. */
+    tokensFile?: string;
+    /**
+     * Markdown-it entry, relative to the extension folder — a path to a JS
+     * module exporting a plugin function exactly like a bare-file plugin
+     * (`export default function (md, options) { ... }`, optionally `metadata`/
+     * `css`/`styles`, #238). Absent means "no markdown behavior" — the
+     * degenerate case that makes a styles-only folder indistinguishable from a
+     * theme. CLAUDE.md §5 is unaffected: this field is DATA a loader resolves
+     * to a file, then loads through the exact same plain-markdown-it-plugin
+     * contract every other plugin module does — no new plugin API is
+     * introduced.
+     */
+    markdown?: string;
+    /**
+     * Component catalog file, relative to the extension folder (the CSS
+     * architecture review's `components.yaml`, #242). Parsed for existence/
+     * containment only by this module — the catalog SCHEMA and the registry
+     * that reads it are #242's scope, not this one's.
+     */
+    components?: string;
+    /**
+     * Snippets folder, relative to the extension folder, merged into the
+     * project's snippet picker under the extension's name (#240). Parsed for
+     * existence/containment only by this module — the merge itself is #240's
+     * scope, not this one's.
+     */
+    snippets?: string;
+}
+/**
+ * Read an extension folder's metadata: `gutterpress.json` when present,
+ * otherwise the legacy `theme.json` — ONE reader for both filenames, which is
+ * what makes "the theme verbs keep working on the extension format" true
+ * everywhere a real on-disk extension/theme folder is read (project themes,
+ * apply, import, revert). `gutterpress.json` wins outright when present (no
+ * silent merge with a sibling `theme.json` — a package declares itself
+ * through exactly one file), matching {@link readJsonMetaFile}'s tolerant
+ * contract when that one file is missing or broken.
+ */
+export declare function readExtensionMeta(dir: string): Promise<ExtensionMetadata>;
+/**
+ * An extension's declared stylesheets, relative to its folder, in cascade
+ * order. UNLIKE `theme-manager.ts`'s `themeStyleList` (which layers a
+ * `["theme.css"]` default on top of this for its theme-shaped callers), an
+ * absent/empty `styles` here means exactly "none declared" — a markdown-only
+ * extension folder must not be forced to carry a `theme.css` it never wanted.
+ */
+export declare function extensionStyleList(meta: ExtensionMetadata): string[];
+/** An extension's declared engine-conditional sheets, relative to its folder. */
+export declare function extensionEngineStyleList(meta: ExtensionMetadata): string[];
+/**
+ * True when a declared relative path escapes its own folder (absolute, or a
+ * `..` segment) — the traversal shape every containment check in this
+ * package rejects.
+ *
+ * Exported (#242) for `snippets.ts`'s installed-extension snippet merge,
+ * which needs this SAME single-field check but cannot use
+ * {@link assertExtensionContained}: that guard throws on ANY escaping field
+ * (styles/markdown/components/tokensFile too), which is correct for a
+ * write-boundary check at install/apply time but wrong for a tolerant
+ * listing — an extension with a broken, unrelated `styles` entry must not
+ * make its perfectly fine `snippets` folder disappear from the picker (the
+ * same "one hand-edited file must not take down listing everyone else's"
+ * doctrine {@link readExtensionMeta}'s tolerant JSON parse already follows).
+ */
+export declare function pathEscapesFolder(rel: string): boolean;
+/**
+ * Every path an extension declares must live INSIDE its own folder — an
+ * extension is self-contained by contract (apply/install copies the whole
+ * folder), and an imported/vendored package is untrusted input: a `../` or
+ * absolute entry would make apply/load read a file from anywhere on disk.
+ *
+ * Generalizes the pre-#241 theme-only `assertThemeSheetsContained` (still
+ * exported under that name from `theme-manager.ts`, now a re-export of this
+ * function) to the three new fields: a `gutterpress.json`-formatted theme
+ * folder can declare `markdown`/`components`/`snippets` too, so the SAME
+ * write-boundary guard must cover them, not just `styles`/`engineStyles`.
+ * `tokensFile` is included even though it is advisory/unenforced elsewhere —
+ * defense in depth against a future consumer reading it unchecked.
+ *
+ * A WRITE-BOUNDARY guard, not a read-path check (mirrors the theme-only
+ * predecessor): callers invoke this before copying anything or wiring a
+ * manifest, never from a plain listing/read path, so one hand-edited
+ * metadata file cannot take down listing every extension.
+ */
+export declare function assertExtensionContained(meta: ExtensionMetadata): void;
+/**
+ * An extension's declared paths, resolved to absolute, existence-checked
+ * filesystem paths — every list/single-path field goes through the SAME
+ * {@link resolveDeclaredStyles} a plugin's `styles` export and a theme's
+ * `styles`/`engineStyles.native` already resolve through, so a broken
+ * declaration (a missing file) throws HERE, at load/apply time, instead of
+ * failing silently deep in the render pipeline (or never, for `components`/
+ * `snippets`, which nothing yet reads — #240/#242).
+ *
+ * `tokensFile` is the one exception, kept as declared (relative, not
+ * existence-checked) — it stays purely advisory, matching
+ * `ThemeInfo.tokensFile`'s pre-#241 contract.
+ */
+export interface ResolvedExtension {
+    /** Absolute path to the markdown-it entry module, when declared. */
+    markdown?: string;
+    /** Absolute paths, in cascade order, when any are declared. */
+    styles?: string[];
+    /** Absolute paths, in cascade order, when any are declared. */
+    engineStyles?: string[];
+    /** Declared-relative path of the `:root` token surface — advisory. */
+    tokensFile?: string;
+    /** Absolute path to the component catalog file, when declared (#242). */
+    components?: string;
+    /** Absolute path to the snippets folder, when declared (#240). */
+    snippets?: string;
+}
+/**
+ * Resolve every path {@link ExtensionMetadata} declares, relative to `dir`
+ * (the extension's own folder). `subject` names the declaring thing for a
+ * resolution error, e.g. `Plugin "my-extension"` — passed straight through to
+ * `resolveDeclaredStyles`, so a broken `markdown`/`components`/`snippets`
+ * entry throws the same "declares stylesheet ... but no file exists" shape a
+ * broken `styles` entry always has (the wording says "stylesheet" for every
+ * field — a small, accepted cost of resolving all of them through one
+ * function rather than inventing per-field messages).
+ */
+export declare function resolveExtension(dir: string, meta: ExtensionMetadata, subject: string): ResolvedExtension;

package/dist/lib/extension-scaffold.d.ts

@@ -0,0 +1,65 @@
+/** Which starter package to create. */
+export type ExtensionKind = "plugin" | "theme";
+/** The kinds `--kind` accepts, for CLI help text and pickers. */
+export declare const EXTENSION_KINDS: readonly ["plugin", "theme"];
+/**
+ * The class/property prefix a scaffolded extension is FORBIDDEN to take.
+ * `gp-` is Gutterpress core's own vocabulary (CLAUDE.md §6); an extension
+ * using it does not conflict with core, it silently overrides it.
+ */
+export declare const RESERVED_PREFIX = "gp-";
+/** Inputs the CLI / desktop collect. Only `name`, `kind` and `parentDir` are
+ *  required; everything else is derived. */
+export interface ScaffoldExtensionOptions {
+    /** Human-friendly package name, e.g. "Field Notes". Required. */
+    name: string;
+    /** Which starter to create. Required. */
+    kind: ExtensionKind;
+    /** Absolute path to the PARENT directory the folder is created in. */
+    parentDir: string;
+    /** Folder name under `parentDir`. Defaults to a slug of `name`. */
+    folderName?: string;
+    /**
+     * Class / custom-property / marker prefix this package claims. Defaults to
+     * the slug plus a hyphen (`field-notes-`). A trailing hyphen is added when
+     * missing — the templates concatenate it directly onto a name, so
+     * `.${PREFIX}callout` has to produce `.field-notes-callout`.
+     */
+    prefix?: string;
+    /** Author display name. Defaults to "Anonymous". */
+    author?: string;
+    /** One-line description for the metadata and the README. */
+    description?: string;
+}
+export interface ScaffoldExtensionResult {
+    /** Absolute path of the created folder. */
+    extensionDir: string;
+    /** Absolute path of its `gutterpress.json`. */
+    manifestPath: string;
+    kind: ExtensionKind;
+    /** Folder name / package name that was used. */
+    slug: string;
+    /** The prefix baked into the scaffolded files. */
+    prefix: string;
+    /** Absolute path of the file worth opening first. */
+    openFile: string;
+    /** Every file written, relative to `extensionDir`, in write order. */
+    files: string[];
+}
+/**
+ * Normalize an author-supplied prefix, or derive one from the slug.
+ *
+ * The prefix is the single most load-bearing convention an extension has
+ * (#245's "which conventions are load-bearing and why"), so it is validated
+ * here rather than left to fail as a puzzling CSS bug later: it must read
+ * like a CSS identifier, and it must not be core's.
+ */
+export declare function resolveExtensionPrefix(slug: string, requested?: string): string;
+/**
+ * Create a plugin or theme starter package.
+ *
+ * Resolves with a {@link ScaffoldExtensionResult}; throws a
+ * {@link CreateProjectError} (the SAME error type `scaffoldProject` throws, so
+ * one `catch` handles both) on any precondition failure.
+ */
+export declare function scaffoldExtension(options: ScaffoldExtensionOptions): Promise<ScaffoldExtensionResult>;

package/dist/lib/lint-runner.d.ts

@@ -1,6 +1,18 @@
 export interface LintRunnerOptions {
     files?: string;
     manifest?: string;
+    /**
+     * Pre-loaded, absolute plugin `styles` file paths (#262) — supplied by the
+     * build pipeline (`build-runner.ts`'s `runQualityGates`, via
+     * `loadBuildPlugins`) so this call does not load plugins a second time in
+     * the same build. `undefined` (the default — every standalone
+     * `gutterpress lint` invocation) makes this function load plugins itself,
+     * exactly as before, with the same degrade-and-report (warn-and-skip)
+     * behavior for a plugin that fails to load. An explicit `[]` from a caller
+     * that already knows there is nothing to add is honored as-is, not treated
+     * as "unset".
+     */
+    pluginStylePaths?: string[];
 }
 export interface LintRunnerResult {
     ok: boolean;

package/dist/lib/markdown/assemble.d.ts

@@ -12,6 +12,18 @@ export type ReadText = (relPath: string) => Promise<string>;
  * emitted by `gp-pin-scope.js`'s `gp_pin_scope_check`, same as
  * `pin_outside_page`, see #226).
  *
+ * #240 (declarative container components) adds three more, all emitted by
+ * `markers.js`'s `layout_transform`/`scanForUnknownDeclaredMarkers` for a
+ * plugin-DECLARED marker: `deprecated_marker` (a `{ deprecated: "…" }`
+ * marker, or its `@end-` form, was used), `declared_marker_close_without_open`
+ * (an `@end-<name>` with nothing of that kind open — the declared-marker
+ * twin of `continue_without_section`), and `declared_marker_eof_close` (an
+ * open declared container reached EOF without `autoCloseAt: ["eof"]` — the
+ * declared-marker twin of `spread_eof_close`). `unknown_marker` above is
+ * reused, not duplicated: a typo close to a DECLARED name warns through the
+ * same type, via a second, unconditional check modeled on `unknown_gp_class`
+ * rather than the core-only `scanForMistypedMarkers`.
+ *
  * `section_without_page` and `implicit_page` were REMOVED 2026-08-12: a
  * @section with no open @page is valid authoring (audited, 17/17 false
  * positives across two real books), and the `implicitPage` option that

package/dist/lib/markdown/markers.d.ts

@@ -1,3 +1,23 @@
+/**
+ * Merge every loaded plugin's `markers` export into ONE flat, resolved
+ * registry — `Map<name, ResolvedDecl>` — validating collisions at LOAD TIME
+ * (#240 / P2): a declared name that shadows a core reserved name, or that
+ * two different plugins both declare, throws immediately, naming both
+ * sides, instead of the pre-#240 silent-skip footgun (core claims its
+ * `@`-names during block parsing, before any plugin runs, so a colliding
+ * plugin marker used to never run and never warn — see the header comment
+ * on `KNOWN_KINDS`).
+ *
+ * @param {{ pluginName: string, markers: Record<string, unknown> }[]} sources
+ *   One entry per LOADED plugin that declared a non-empty `markers` export,
+ *   in plugin load order. A plugin with no `markers` export is simply
+ *   omitted by the caller — this function never sees it.
+ * @returns {Map<string, object>} empty when `sources` is empty.
+ */
+export function buildDeclaredMarkerRegistry(sources: {
+    pluginName: string;
+    markers: Record<string, unknown>;
+}[]): Map<string, object>;
 export default function plugin(md: any, pluginOptions?: {}): void;
 /**
  * The minimal CSS the DOM this module emits requires. Author utility

package/dist/lib/markdown/plugins.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedPluginConfig } from "../../schema/manifest.types";
 import type { LoadedPlugin } from "./renderer";
-export type { GutterpressPlugin, GutterpressPluginMetadata, GutterpressPluginExport, LoadedPlugin, } from "./renderer";
+export type { GutterpressMarkerDeclaration, GutterpressMarkerLabel, GutterpressMarkerTable, GutterpressPlugin, GutterpressPluginMetadata, GutterpressPluginExport, LoadedPlugin, } from "./renderer";
 export { applyPlugins, collectPluginCss, collectPluginStylePaths } from "./renderer";
 /** Test-only mutation seam between snapshot completion and snapshot verification. */
 export declare function __setVendorSnapshotHookForTests(hook?: (sourceRoot: string, snapshotRoot: string) => void | Promise<void>): void;