gutterpress 0.11.15 → 0.11.16-alpha.1

package/dist/lib/snippets.d.ts

@@ -1,23 +1,11 @@
 /** Folder (relative to the project root) snippets live in. */
 export declare const SNIPPETS_DIR = "snippets";
 /**
- * Where a merged-list entry came from (#242).
- *
- * `{ kind: "project" }` — the author's own snippet, from `<projectDir>/
- * snippets/`. This is the ONLY provenance `saveSnippet`/`deleteSnippet` ever
- * produce or touch, and therefore the ONLY provenance the picker may offer to
- * edit or delete — a `source` this shape is the single flag the UI needs to
- * gate those actions, so "can this be deleted" never drifts out of sync with
- * "where did this come from" (one field, not two that could disagree).
- *
- * `{ kind: "extension", ref, name }` — a READ-ONLY snippet merged in from an
- * installed, ENABLED extension (see {@link listInstalledExtensions}). `name`
- * is the extension's display name — the picker's group label, so an author
- * always sees WHICH extension a snippet came from, never just "not mine".
- * `ref` is the extension's manifest specifier (`ProjectExtensionEntry.use`);
- * it is round-tripped back into {@link readExtensionSnippet} so that function
- * can re-derive the extension's folder itself from a small, validated
- * identifier instead of trusting a filesystem path a caller could construct.
+ * Which level a snippet comes from. `project` is the book's own (the only
+ * level `saveSnippet`/`deleteSnippet` touch, so the only one the picker offers
+ * to delete); `extension` is read-only, from an enabled extension — `name` is
+ * its display name, `ref` its manifest specifier; `core` is reserved for
+ * snippets Gutterpress itself will ship.
  */
 export type SnippetSource = {
     kind: "project";
@@ -25,20 +13,24 @@ export type SnippetSource = {
     kind: "extension";
     ref: string;
     name: string;
+} | {
+    kind: "core";
 };
-/** One snippet's metadata for the picker (no body — read lazily). */
+/** One snippet, as the picker lists it. */
 export interface SnippetEntry {
-    /** Display name (derived from the `.md` filename stem, prettified). */
+    /** Display name (derived from the filename stem, prettified). */
     name: string;
-    /** The on-disk filename, e.g. `callout.md`. Stable id for read/delete
-     *  WITHIN its own source — an extension entry's `fileName` is only ever
-     *  resolved back to a file via {@link readExtensionSnippet} (which also
-     *  needs `source`), never via the project-only {@link readSnippet}. */
+    /** The file, relative to its level's snippets folder (an extension
+     *  component's explicit `snippet:` path is relative to the extension). */
     fileName: string;
     /** Distinct `{{variable}}` names parsed from the body, in first-seen order. */
     variables: string[];
-    /** Provenance (#242) — see {@link SnippetSource}. */
+    /** The snippet's text. */
+    body: string;
+    /** Which level it comes from — see {@link SnippetSource}. */
     source: SnippetSource;
+    /** Set when this is the example snippet for that component (marker name). */
+    component?: string;
 }
 /**
  * Parse the distinct `{{variable}}` placeholder names from a template, in the
@@ -52,19 +44,8 @@ export declare function extractVariables(template: string): string[];
  * Pure.
  */
 export declare function substituteVariables(template: string, values: Record<string, string>): string;
-/**
- * List the project's OWN snippets only — `<projectDir>/snippets/`, exactly as
- * before #242. The picker itself now calls {@link listMergedSnippets} (which
- * calls this as its first step); this stays exported and unchanged in
- * behavior because it is independently useful (and independently tested) as
- * "just the author's own snippets", with no extension-discovery cost paid by
- * a caller that doesn't need it.
- */
+/** The book's own snippets only — `<projectDir>/snippets/`. */
 export declare function listSnippets(projectDir: string): Promise<SnippetEntry[]>;
-/** Read one snippet's raw body. Refuses path traversal. Project snippets
- *  only — see {@link readExtensionSnippet} for the merged-list counterpart
- *  that reads an extension-provided entry instead. */
-export declare function readSnippet(projectDir: string, fileName: string): Promise<string>;
 /**
  * Save a snippet body under `snippets/<slug(name)>.md`, creating the folder when
  * absent. Returns the stored entry (with its filename + parsed variables). The
@@ -91,61 +72,22 @@ export declare function saveSnippet(projectDir: string, name: string, body: stri
  */
 export declare function deleteSnippet(projectDir: string, fileName: string): Promise<void>;
 /**
- * The project's own snippets, merged with every installed-and-active
- * extension's (#242) — this is "the snippet host" the picker actually calls;
- * `listSnippets` above is now just its first ingredient.
- *
- * PRECEDENCE / collision (issue's suggested shape, point 2): when an
- * extension snippet's FILENAME — the slugified identity `saveSnippet` itself
- * derives a name into, so two different-cased spellings of the same name
- * collide exactly as they would on a real re-save — matches a project
- * snippet's, the project one wins outright and the extension's copy is
- * dropped from this call's result. It is not renamed, not kept reachable
- * under a second key, and nothing on disk is touched: the comparison and the
- * drop happen freshly on every call, so the instant the author renames (or
- * deletes) their colliding snippet, the extension's becomes visible again
- * with no separate "restore" step. Rationale: the moment an author saves
- * their own snippet under a name an extension already used, the natural
- * reading is "I'm overriding this one for my project" — a picker entry that
- * silently stays inserted from the extension forever after would contradict
- * that, and a picker entry that just isn't there is a far smaller surprise
- * than two identically-named rows the author has to guess between.
- *
- * This precedence rule is PROJECT-vs-EXTENSION only. Two different
- * extensions that each happen to ship a same-named snippet are NOT
- * deduplicated against each other — both survive, each under its own group
- * header (see GROUPING below), because there is no ambiguity to resolve:
- * unlike the project-vs-extension case, neither copy could be mistaken for
- * "the author's own", so there is nothing here for one to silently win over.
- *
- * GROUPING: the result is ordered project-first (`listSnippets`'s own
- * alphabetical order), then one contiguous run per extension — extensions
- * alphabetical by display name, each run alphabetical by snippet name. The
- * picker groups purely by noticing `source` change between consecutive
- * entries; there is no separate grouped/tree shape to keep in sync with this
- * flat list.
+ * One plugin-declared marker (a "component", `export const markers`) the
+ * project can use, with the example snippet the editor inserts for it.
+ * Unrelated to the `gutterpress.components` catalog file, which nothing reads.
  */
+export interface MarkerComponent {
+    /** The marker name, without `@` — e.g. `term-box`. */
+    name: string;
+    /** The extension that declares it. */
+    source: Extract<SnippetSource, {
+        kind: "extension";
+    }>;
+    /** The winning example snippet's body (book, then extension, then core). */
+    snippet?: string;
+}
+/** Every snippet the project can insert, from every level — see {@link collectLibrary}. */
 export declare function listMergedSnippets(projectDir: string): Promise<SnippetEntry[]>;
-/**
- * Read one extension-provided snippet's raw body (#242) — the read-only
- * counterpart to `readSnippet` for entries `listMergedSnippets` tagged with
- * an extension `source`.
- *
- * Deliberately NOT a raw-path read: `source` carries only the same small,
- * stable `{ kind, ref }` pair `listMergedSnippets` already handed back (see
- * {@link SnippetSource}), and this function re-runs the EXACT SAME discovery
- * {@link listMergedSnippets} used ({@link listInstalledExtensions}) to find
- * the matching extension's folder again, rather than trusting any path a
- * caller could construct directly — the same defense-in-depth stance
- * `resolveSnippetPath` already takes for the project's own snippets, now
- * extended to a second, per-extension root instead of a single project one.
- *
- * Throws when `source` no longer resolves to an installed, active extension
- * (it was disabled or removed since the list was fetched — the picker's existing `error` display already handles a
- * thrown read the same way a vanished project snippet would) or when
- * `fileName` escapes that extension's snippets folder.
- */
-export declare function readExtensionSnippet(projectDir: string, source: {
-    kind: "extension";
-    ref: string;
-}, fileName: string): Promise<string>;
+/** Every component the project's enabled extensions declare, each with its
+ *  winning example snippet (book > extension > core) — see {@link collectLibrary}. */
+export declare function listMarkerComponents(projectDir: string): Promise<MarkerComponent[]>;

package/dist/{new-cmmshb37.js → new-daeh9p9p.js}

@@ -7,16 +7,16 @@ import {
   TARGET_IDS,
   scaffoldExtension,
   scaffoldProject
-} from "./cli-s99rpea3.js";
+} from "./cli-sq0awkbf.js";
 import {
   resolveGhostscript
-} from "./cli-bhs0ssm2.js";
+} from "./cli-6tfc4ed6.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-ar54jmc5.js";
-import"./cli-mc3waxaw.js";
+} from "./cli-p8xwsknv.js";
+import"./cli-d55z7rtk.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/dist/{plugin.js-aszz0zgh.tpl → plugin.js-z492w01r.tpl}

@@ -67,6 +67,34 @@ const PREFIX = "{{PREFIX}}";
  *   variants    extra classes keyed by the marker's bare word
  *   label       a label element built from one of the marker's attributes
  *   autoCloseAt ["eof"] closes an unclosed container at end of file
+ *   snippet     example content the editor inserts for this component, as a
+ *               path inside this folder (default: snippets/<name>.md — so
+ *               `snippets/term-box.md` is term-box's example already)
+ *   validate    a function that checks what an author put inside the
+ *               component and returns problems — see below
+ *
+ * VALIDATE — opt-in structure checks
+ *
+ *   Gutterpress calls `validate(component)` for every use of the component
+ *   whenever it checks a book (the desktop Problems panel, `gutterpress
+ *   validate`, builds). `component` is a plain object — no markdown-it, no
+ *   Gutterpress internals:
+ *
+ *     component.name     "term-box"
+ *     component.variant  the bare word after the marker ("note"), or null
+ *     component.attrs    the marker's attributes, e.g. { label: "…" }
+ *     component.line     the marker's line in the file
+ *     component.text     the raw markdown inside the component
+ *     component.blocks   its content, in order, each with `type` and `line`:
+ *                        heading {level, text} · paragraph {text} ·
+ *                        image {alt, src} · list {ordered, items} ·
+ *                        quote {text} · code {lang, text} · table · rule ·
+ *                        html {text} · component {name}
+ *
+ *   Return nothing when it is fine, or a list of problems. A problem is a
+ *   message string, or `{ message, line, severity }` to point at a line or
+ *   choose "error" / "warning" (the default) / "info". The function must be
+ *   synchronous; if it throws, the author sees that as a problem too.
  *
  * Names are validated when the book loads: lower-case letters, digits and
  * hyphens; they may not start with `end-`, and they may not shadow a core
@@ -88,6 +116,22 @@ export const markers = {
       from: "attr:label",
     },
     autoCloseAt: ["eof"],
+    // snippet: "examples/term-box.md",  // only needed to override snippets/term-box.md
+    validate(box) {
+      const problems = [];
+      if (!box.attrs.label) {
+        problems.push('Give the term box a label: @term-box note label="Your term"');
+      }
+      if (!box.blocks.some((block) => block.type === "paragraph")) {
+        problems.push("Add a paragraph explaining the term.");
+      }
+      for (const block of box.blocks) {
+        if (block.type === "heading") {
+          problems.push({ message: "Use the label instead of a heading.", line: block.line });
+        }
+      }
+      return problems;
+    },
   },
 };
 

package/dist/{plugin.test.js-nw7c84s6.tpl → plugin.test.js-6n8ct5e3.tpl}

@@ -30,6 +30,8 @@
  * package cannot import core (see README.md, "Why you cannot import
  * gutterpress"). So the table's CONTRACT is checked here, and the rendered
  * container is checked by running `gutterpress preview` on a real book.
+ * A component's `validate` needs no core at all — it takes a plain object —
+ * so it is tested directly, with hand-written components.
  */
 import { describe, expect, test } from "bun:test";
 import { existsSync, readFileSync } from "node:fs";
@@ -212,6 +214,37 @@ describe("conventions", () => {
     }
   });
 
+  test("each component's snippet opens and closes its own marker", () => {
+    // The editor inserts this file when an author picks the component, so it
+    // is the example of the structure the component expects.
+    for (const [name, decl] of Object.entries(markers)) {
+      if (decl.deprecated !== undefined || decl.alias !== undefined) continue;
+      const rel = decl.snippet ?? `${pkg.gutterpress?.snippets ?? "snippets"}/${name}.md`;
+      if (!existsSync(path.join(root, rel))) continue;
+      const snippet = read(rel);
+      expect(snippet.trimStart().startsWith(`@${name}`)).toBe(true);
+      expect(snippet).toContain(`@end-${name}`);
+    }
+  });
+
+  test("term-box's validate accepts a well-formed box and explains what a bad one is missing", () => {
+    // A component exactly as Gutterpress hands it to `validate`.
+    const good = {
+      name: "term-box",
+      variant: "note",
+      attrs: { label: "Gutter" },
+      line: 1,
+      text: "The space between two facing pages.",
+      blocks: [{ type: "paragraph", text: "The space between two facing pages.", line: 2 }],
+    };
+    expect(markers["term-box"].validate(good)).toEqual([]);
+
+    const bad = { ...good, attrs: {}, blocks: [{ type: "heading", level: 3, text: "Gutter", line: 2 }] };
+    const problems = markers["term-box"].validate(bad);
+    expect(problems).toHaveLength(3);
+    expect(problems).toContainEqual({ message: "Use the label instead of a heading.", line: 2 });
+  });
+
   test("every public custom property carries the prefix too", () => {
     // `--x` declared at :root is global. An unprefixed one would collide with
     // the book's own tokens exactly as an unprefixed class would.
@@ -226,6 +259,7 @@ describe("conventions", () => {
     // Gutterpress wraps this extension's CSS in `@layer ext.<name>` itself,
     // in `extensions:` list order — see the header comment in
     // styles/plugin.css. A layer declared here would only nest inside it.
-    expect(css).not.toMatch(/@layer/);
+    // Rules only: that header comment itself mentions `@layer`.
+    expect(cssRules).not.toMatch(/@layer/);
   });
 });

package/dist/{preflight-93xdp9jk.js → preflight-bfvw2qe5.js}

@@ -2,16 +2,16 @@ import {
   executeValidation,
   publishTargetFor,
   reportMissingTools
-} from "./cli-s99rpea3.js";
+} from "./cli-sq0awkbf.js";
 import {
   log
-} from "./cli-bhs0ssm2.js";
+} from "./cli-6tfc4ed6.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-ar54jmc5.js";
-import"./cli-mc3waxaw.js";
+} from "./cli-p8xwsknv.js";
+import"./cli-d55z7rtk.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/dist/{preview-dhjma9fn.js → preview-00298rvf.js}

@@ -6,10 +6,10 @@ import {
   runBuild,
   splitOutPath,
   startPreviewServer
-} from "./cli-s99rpea3.js";
+} from "./cli-sq0awkbf.js";
 import {
   log
-} from "./cli-bhs0ssm2.js";
+} from "./cli-6tfc4ed6.js";
 import {
   UsageError,
   parseFormat,
@@ -17,8 +17,8 @@ import {
   rejectExtraPositionals,
   rejectUnknownFlags,
   resolvePort
-} from "./cli-ar54jmc5.js";
-import"./cli-mc3waxaw.js";
+} from "./cli-p8xwsknv.js";
+import"./cli-d55z7rtk.js";
 import {
   BuildError
 } from "./cli-46ycxe6r.js";

package/dist/{publish-a28ajgqt.js → publish-jn9t18mr.js}

@@ -11,17 +11,17 @@ import {
   publishProviderFor,
   resolvePublishFormat,
   runPublish
-} from "./cli-s99rpea3.js";
+} from "./cli-sq0awkbf.js";
 import {
   FileTokenStore,
   log
-} from "./cli-bhs0ssm2.js";
+} from "./cli-6tfc4ed6.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-ar54jmc5.js";
-import"./cli-mc3waxaw.js";
+} from "./cli-p8xwsknv.js";
+import"./cli-d55z7rtk.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/dist/render.js

@@ -172,6 +172,133 @@ function warn(env, line, type, message, marker) {
     env.layoutWarnings = [];
   env.layoutWarnings.push({ line, type, message, marker });
 }
+var COMPONENT_SEVERITIES = ["error", "warning", "info"];
+function blockEnd(tokens, i) {
+  if (tokens[i].nesting !== 1)
+    return i;
+  let depth = 0;
+  for (let j = i;j < tokens.length; j++) {
+    depth += tokens[j].nesting;
+    if (depth === 0)
+      return j;
+  }
+  return tokens.length - 1;
+}
+function inlineText(tokens, from, to) {
+  const parts = [];
+  for (let k = from;k <= to; k++)
+    if (tokens[k].type === "inline")
+      parts.push(tokens[k].content);
+  return parts.join(`
+`);
+}
+function soleImage(inline) {
+  const parts = (inline && inline.children || []).filter((c) => c.type !== "softbreak" && !(c.type === "text" && !c.content.trim()));
+  return parts.length === 1 && parts[0].type === "image" ? parts[0] : null;
+}
+function toComponentBlocks(tokens, fallbackLine) {
+  const blocks = [];
+  for (let i = 0;i < tokens.length; i++) {
+    const tok = tokens[i];
+    const end = blockEnd(tokens, i);
+    const line = tok.map ? tok.map[0] + 1 : tok.meta && tok.meta.line || fallbackLine;
+    switch (tok.type) {
+      case "heading_open":
+        blocks.push({ type: "heading", level: Number(tok.tag.slice(1)), text: inlineText(tokens, i, end), line });
+        break;
+      case "paragraph_open": {
+        const image = soleImage(tokens[i + 1]);
+        blocks.push(image ? { type: "image", alt: image.content, src: image.attrGet("src") || "", line } : { type: "paragraph", text: inlineText(tokens, i, end), line });
+        break;
+      }
+      case "bullet_list_open":
+      case "ordered_list_open": {
+        const items = [];
+        for (let k = i + 1;k < end; k++) {
+          if (tokens[k].type !== "list_item_open" || tokens[k].level !== tok.level + 1)
+            continue;
+          const itemEnd = blockEnd(tokens, k);
+          const first = tokens.slice(k + 1, itemEnd).find((t) => t.type === "inline");
+          items.push(first ? first.content : "");
+          k = itemEnd;
+        }
+        blocks.push({ type: "list", ordered: tok.type === "ordered_list_open", items, line });
+        break;
+      }
+      case "blockquote_open":
+        blocks.push({ type: "quote", text: inlineText(tokens, i, end), line });
+        break;
+      case "fence":
+      case "code_block":
+        blocks.push({ type: "code", lang: (tok.info || "").trim().split(/\s+/)[0] || "", text: tok.content, line });
+        break;
+      case "table_open":
+        blocks.push({ type: "table", line });
+        break;
+      case "hr":
+        blocks.push({ type: "rule", line });
+        break;
+      case "html_block":
+        blocks.push({ type: "html", text: tok.content, line });
+        break;
+      case "layout_component_open":
+        blocks.push({ type: "component", name: tok.meta.component, line });
+        break;
+      default:
+        blocks.push({ type: tok.type.replace(/_open$/, ""), line });
+    }
+    i = end;
+  }
+  return blocks;
+}
+function runComponentValidate(env, decl, meta, tokens, lines) {
+  const name = meta.component;
+  const line = meta.line || 0;
+  const report = (at, type, message, severity) => {
+    if (!env.layoutWarnings)
+      env.layoutWarnings = [];
+    env.layoutWarnings.push(severity ? { line: at, type, message, severity } : { line: at, type, message });
+  };
+  const failed = (why) => report(line, "component_validate_failed", `@${name}: plugin "${decl.validateOwner}"'s validate() ${why}`);
+  let lastLine = line;
+  for (const t of tokens)
+    if (t.map && t.map[1] > lastLine)
+      lastLine = t.map[1];
+  const component = {
+    name,
+    variant: meta.variant || null,
+    attrs: { ...meta.attrs },
+    line,
+    text: lines.slice(line, lastLine).join(`
+`),
+    blocks: toComponentBlocks(tokens, line)
+  };
+  let result;
+  try {
+    result = decl.validate(component);
+  } catch (error) {
+    failed(`threw: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (result === undefined || result === null)
+    return;
+  if (typeof result === "string")
+    result = [result];
+  if (!Array.isArray(result)) {
+    failed("must return a message, an array of problems, or nothing (and must not be async).");
+    return;
+  }
+  for (const entry of result) {
+    const problem = typeof entry === "string" ? { message: entry } : entry;
+    if (!problem || typeof problem.message !== "string" || !problem.message.trim()) {
+      failed("returned a problem without a message.");
+      continue;
+    }
+    const at = Number.isInteger(problem.line) && problem.line > 0 ? problem.line : line;
+    const severity = COMPONENT_SEVERITIES.includes(problem.severity) ? problem.severity : undefined;
+    report(at, "component_invalid", `@${name}: ${problem.message}`, severity);
+  }
+}
 function proseEscapeHint(kind) {
   return ` If this line is prose that happens to begin with "@${kind}" — a wrapped sentence, for` + ` instance — escape it as \\@${kind} or write it as \`@${kind}\` in backticks, and it stays text.`;
 }
@@ -274,13 +401,20 @@ function resolveContainerShape(name, pluginName, decl) {
     }
     autoCloseAtEof = decl.autoCloseAt.includes("eof");
   }
-  return { tag, classBase, variants, label, autoCloseAtEof };
+  if (decl.validate !== undefined && typeof decl.validate !== "function") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`validate\` that is not a function.`);
+  }
+  const check = decl.validate ? { validate: decl.validate, validateOwner: pluginName } : {};
+  return { tag, classBase, variants, label, autoCloseAtEof, ...check };
 }
 function resolveMarkerDeclaration(name, rawDecl, rawRegistry, originOf) {
   const pluginName = originOf.get(name);
   if (typeof rawDecl !== "object" || rawDecl === null || Array.isArray(rawDecl)) {
     throw new Error(`Plugin "${pluginName}"'s marker "@${name}" is not a plain object.`);
   }
+  if (rawDecl.snippet !== undefined && (typeof rawDecl.snippet !== "string" || !rawDecl.snippet.trim())) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`snippet\` that is not a non-empty path string.`);
+  }
   if (rawDecl.deprecated !== undefined) {
     if (typeof rawDecl.deprecated !== "string" || !rawDecl.deprecated) {
       throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`deprecated\` value that is not a non-empty string.`);
@@ -495,8 +629,8 @@ function plugin(md, pluginOptions = {}) {
     }
     function openDeclaredMarker(meta, decl) {
       const t = new state.Token("layout_component_open", decl.tag, 1);
-      t.meta = { line: meta.__line };
       const variant = meta.name || decl.presetVariant || null;
+      t.meta = { line: meta.__line, component: meta.kind, variant, attrs: meta.attrs || {}, labelled: false };
       const variantClass = variant && decl.variants && decl.variants[variant] || "";
       const baseClass = [decl.classBase, variantClass].filter(Boolean).join(" ");
       addClasses(t, baseClass, meta.attrs && meta.attrs.class ? meta.attrs.class : "");
@@ -510,6 +644,7 @@ function plugin(md, pluginOptions = {}) {
           labelToken.content = `<${decl.label.tag} class="${escapeAttr(decl.label.class)}">${escapeHtml(value)}</${decl.label.tag}>
 `;
           out.push(labelToken);
+          t.meta.labelled = true;
         }
       }
     }
@@ -771,6 +906,25 @@ function plugin(md, pluginOptions = {}) {
     stack.closeAll();
     state.tokens = out;
   });
+  if (declaredMarkers && [...declaredMarkers.values()].some((d) => d.validate)) {
+    md.core.ruler.push("gp_component_validate", function(state) {
+      let lines = null;
+      const tokens = state.tokens;
+      for (let i = 0;i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok.type !== "layout_component_open")
+          continue;
+        const decl = declaredMarkers.get(tok.meta.component);
+        if (!decl || !decl.validate)
+          continue;
+        if (!lines)
+          lines = state.src.split(`
+`);
+        const from = i + (tok.meta.labelled ? 2 : 1);
+        runComponentValidate(state.env, decl, tok.meta, tokens.slice(from, blockEnd(tokens, i)), lines);
+      }
+    });
+  }
   md.renderer.rules.layout_page_break = (tokens, idx) => {
     const cls = tokens[idx].attrGet("class") || "gp-page-break";
     const rangeAttr = tokens[idx].attrGet("data-source-range");

package/dist/{validate-any9f0df.js → validate-cm1m5bbf.js}

@@ -1,15 +1,15 @@
 import {
   executeAndReport
-} from "./cli-s99rpea3.js";
+} from "./cli-sq0awkbf.js";
 import {
   log
-} from "./cli-bhs0ssm2.js";
+} from "./cli-6tfc4ed6.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-ar54jmc5.js";
-import"./cli-mc3waxaw.js";
+} from "./cli-p8xwsknv.js";
+import"./cli-d55z7rtk.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/package.json

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