@tycoworks/tycoslide 0.8.0 → 0.9.0

package/dist/markdown/inline.d.ts

@@ -0,0 +1,26 @@
+import type { PhrasingContent } from "mdast";
+import type { TextRun } from "../engine/index.js";
+/** The subset of MdastType values that are PhrasingContent (dispatched by walkPhrasing). */
+export declare const PHRASING_TYPES: ReadonlySet<string>;
+/**
+ * Parse inline markdown formatting in a single line of text into TextRun arrays.
+ * Handles **bold**, *italic*, ***bold italic***, ~~strikethrough~~, ++underline++,
+ * [link](url), and `inline code`.
+ */
+export declare function parseInlineRuns(text: string): TextRun[];
+/**
+ * Inline formatting carried down the phrasing walk. `breakAsNewline` is the one
+ * block-vs-inline knob: in block aggregation a markdown hard `break` node must
+ * split the paragraph, so the walk emits it as a `"\n"` run (which the block
+ * text splitter then breaks on); the single-line `parseInlineRuns` path leaves
+ * it unset, so a hard break stays a space.
+ */
+export interface InlineState {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    underline?: boolean;
+    link?: string;
+    breakAsNewline?: boolean;
+}
+export declare function walkPhrasingChildren(children: PhrasingContent[], state: InlineState): TextRun[];

package/dist/markdown/inline.js

@@ -0,0 +1,136 @@
+import { MdastType, parseInline } from "./mdast.js";
+/** The subset of MdastType values that are PhrasingContent (dispatched by walkPhrasing). */
+export const PHRASING_TYPES = new Set([
+    MdastType.Text,
+    MdastType.InlineCode,
+    MdastType.Strong,
+    MdastType.Emphasis,
+    MdastType.Delete,
+    MdastType.Insert,
+    MdastType.Link,
+    MdastType.Break,
+]);
+/**
+ * Parse inline markdown formatting in a single line of text into TextRun arrays.
+ * Handles **bold**, *italic*, ***bold italic***, ~~strikethrough~~, ++underline++,
+ * [link](url), and `inline code`.
+ */
+export function parseInlineRuns(text) {
+    if (!text)
+        return [{ text: "" }];
+    // Fast path: no formatting characters means plain text.
+    if (!text.includes("*") && !text.includes("[") && !text.includes("`") && !text.includes("~") && !text.includes("+")) {
+        return [{ text }];
+    }
+    const tree = parseInline(text);
+    const runs = walkInlineRoot(tree, {});
+    return runs.length > 0 ? runs : [{ text: "" }];
+}
+function makeRun(text, state) {
+    const run = { text };
+    if (state.bold)
+        run.bold = true;
+    if (state.italic)
+        run.italic = true;
+    if (state.strikethrough)
+        run.strikethrough = true;
+    if (state.underline)
+        run.underline = true;
+    if (state.link)
+        run.link = state.link;
+    return run;
+}
+/**
+ * Walk a `PhrasingContent` node, converting inline formatting into TextRun[].
+ *
+ * The `node.type` case strings are the mdast library's own discriminators;
+ * TypeScript narrows each case to the concrete node interface (Text, Strong,
+ * Emphasis, …) so misspellings and dropped cases are compile errors, not
+ * silent fallthroughs. `remark-ins` augments PhrasingContentMap with
+ * "insert", so that case narrows to the Insert node type.
+ */
+function walkPhrasing(node, state) {
+    switch (node.type) {
+        case MdastType.Text:
+            return [makeRun(node.value, state)];
+        case MdastType.InlineCode:
+            return [makeRun(node.value, state)];
+        case MdastType.Strong:
+            return walkPhrasingChildren(node.children, { ...state, bold: true });
+        case MdastType.Emphasis:
+            return walkPhrasingChildren(node.children, { ...state, italic: true });
+        case MdastType.Delete:
+            return walkPhrasingChildren(node.children, { ...state, strikethrough: true });
+        case MdastType.Insert:
+            return walkPhrasingChildren(node.children, { ...state, underline: true });
+        case MdastType.Link:
+            return walkPhrasingChildren(node.children, { ...state, link: node.url });
+        case MdastType.Break:
+            // A markdown hard break. In block aggregation it splits the paragraph
+            // (emit a "\n" run the splitter breaks on); on the single-line inline
+            // path it collapses to a space.
+            return [makeRun(state.breakAsNewline ? "\n" : " ", state)];
+        default:
+            // Any other phrasing node with a literal `value` (footnote references,
+            // etc.) — emit its text if it has one, otherwise nothing.
+            if ("value" in node && typeof node.value === "string") {
+                return [makeRun(node.value, state)];
+            }
+            return [];
+    }
+}
+export function walkPhrasingChildren(children, state) {
+    const out = [];
+    for (const child of children)
+        out.push(...walkPhrasing(child, state));
+    return out;
+}
+/** Walk the root's children, entering each block-level container's phrasing. */
+function walkInlineRoot(root, state) {
+    const out = [];
+    for (const child of root.children)
+        out.push(...walkBlock(child, state));
+    return out;
+}
+/**
+ * Enter a block-level node. remarkParse on a single line produces a `Root`
+ * whose children include block-level nodes (Paragraph, most commonly), which
+ * in turn hold phrasing content. Anything unexpected (Heading, Blockquote,
+ * List, …) recurses via its phrasing-holding children when applicable.
+ */
+function walkBlock(node, state) {
+    switch (node.type) {
+        case MdastType.Paragraph:
+            return walkPhrasingChildren(node.children, state);
+        case MdastType.Heading:
+            return walkPhrasingChildren(node.children, state);
+        default:
+            // Fall back: some block nodes carry phrasing content among their
+            // children. Recurse into typed children when the shape is known;
+            // otherwise return nothing rather than guess.
+            if ("children" in node && Array.isArray(node.children)) {
+                const out = [];
+                for (const child of node.children) {
+                    out.push(...walkUnknown(child, state));
+                }
+                return out;
+            }
+            return [];
+    }
+}
+/**
+ * Handle a child of unknown shape: dispatch to phrasing- or block-level walker
+ * based on the node's type discriminator. Preserves discriminated-union
+ * narrowing by explicitly re-checking the type against known mdast unions.
+ */
+function walkUnknown(node, state) {
+    if (typeof node !== "object" || node === null || !("type" in node))
+        return [];
+    const typed = node;
+    // Phrasing-content types we handle directly:
+    if (PHRASING_TYPES.has(typed.type))
+        return walkPhrasing(node, state);
+    // Otherwise treat as a block-content node; walkBlock will recurse or
+    // return nothing.
+    return walkBlock(node, state);
+}

package/dist/markdown/mdast.d.ts

@@ -0,0 +1,25 @@
+import type { Root } from "mdast";
+/** mdast node type discriminators we handle. Backing const so switch/if cases
+ * reference named tokens rather than raw magic strings. Exported so the
+ * per-kind block handlers in `blocks/` recognize their node against the same
+ * tokens the inline walk uses. */
+export declare const MdastType: {
+    readonly Text: "text";
+    readonly InlineCode: "inlineCode";
+    readonly Strong: "strong";
+    readonly Emphasis: "emphasis";
+    readonly Delete: "delete";
+    readonly Insert: "insert";
+    readonly Link: "link";
+    readonly Break: "break";
+    readonly Paragraph: "paragraph";
+    readonly Heading: "heading";
+    readonly Code: "code";
+    readonly Image: "image";
+    readonly List: "list";
+    readonly Table: "table";
+};
+/** Parse a single line of markdown into a raw mdast tree. */
+export declare function parseInline(text: string): Root;
+/** Parse a whole body/`::name::` region into a real mdast tree. */
+export declare function parseRegion(text: string): Root;

package/dist/markdown/mdast.js

@@ -0,0 +1,49 @@
+import remarkGfm from "remark-gfm";
+import remarkIns from "remark-ins";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+/** mdast node type discriminators we handle. Backing const so switch/if cases
+ * reference named tokens rather than raw magic strings. Exported so the
+ * per-kind block handlers in `blocks/` recognize their node against the same
+ * tokens the inline walk uses. */
+export const MdastType = {
+    Text: "text",
+    InlineCode: "inlineCode",
+    Strong: "strong",
+    Emphasis: "emphasis",
+    Delete: "delete",
+    Insert: "insert",
+    Link: "link",
+    Break: "break",
+    Paragraph: "paragraph",
+    Heading: "heading",
+    Code: "code",
+    Image: "image",
+    List: "list",
+    Table: "table",
+};
+// remark-parse establishes the processor as Processor<Root>; remarkGfm and
+// remarkIns extend the parser but don't transform the tree shape, so
+// runSync's output is still a Root. Unified's TailTree generic defaults to
+// undefined and widens runSync's return to the base Node, hence the narrowing
+// casts below — kept to a single hop, no double-cast. Shared by both entry
+// points: neither plugin adds a transform phase, so `.parse()` alone already
+// yields the final tree (gfm tables/delete, ins nodes included); `runSync` is
+// only needed by the inline path below.
+const processor = unified().use(remarkParse).use(remarkGfm).use(remarkIns);
+// ══════════════════════════════════════════════════════════════════════════════
+// INLINE / PROSE PARSING
+// ══════════════════════════════════════════════════════════════════════════════
+/** Parse a single line of markdown into a raw mdast tree. */
+export function parseInline(text) {
+    return processor.runSync(processor.parse(text));
+}
+// ══════════════════════════════════════════════════════════════════════════════
+// BLOCK / REGION PARSING
+// ══════════════════════════════════════════════════════════════════════════════
+// Region splitting (::name::) happens above the slot, so a region is plain
+// GFM+ins markdown — `.parse()` alone is enough, no `runSync` needed here.
+/** Parse a whole body/`::name::` region into a real mdast tree. */
+export function parseRegion(text) {
+    return processor.parse(text);
+}

package/dist/markdown/schema/deckSchema.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+import type { CompilerLayout } from "../types.js";
+/**
+ * Per-layout frontmatter validation for a deck `.md`. The old tycoslide validated
+ * every slide's frontmatter against a Zod schema carried by the layout program;
+ * current layouts are JSON DATA, so the schema is BUILT dynamically from a layout's
+ * declared `parameters` using the same key-derivation the compiler already uses
+ * (`deckCompiler.ts`): an image parameter contributes its `key`; a template
+ * parameter contributes one field per `{key}` placeholder in its template (NOT its
+ * `shapeName`, which addresses `step.content`, not frontmatter).
+ *
+ * Commit-1 scope is unknown-key detection ONLY — zero behavior change:
+ * - Every field is `z.coerce.string()` (values are `String()`-coerced today, so a
+ *   YAML number like `year: 2026` must still pass — plain `z.string()` would regress)
+ *   and `.optional()` (`required` is per-parameter, enforced in `compileStep`, not
+ *   "all a template's keys present"). Value-typing and required-encoding are deliberate
+ *   later commits.
+ * The strict object IS the unknown-key check that used to be imperative in
+ * `compileStep`; a stray frontmatter key throws instead of being silently ignored.
+ */
+export declare function deckFrontmatterSchema(layout: CompilerLayout): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;
+/**
+ * Validate one slide's frontmatter against its layout, throwing a fail-fast error
+ * prefixed with the slide index (naming the unknown key + the valid set, via the
+ * shared `strict` "Valid keys: …" formatter). Reserved keys (`layout`, `notes`) are
+ * slide-level metadata, not parameters, so they are stripped before `safeParse`.
+ */
+export declare function validateSlideFrontmatter(frontmatter: Record<string, unknown>, layout: CompilerLayout, slideIdx: number): void;

package/dist/markdown/schema/deckSchema.js

@@ -0,0 +1,51 @@
+import * as z from "zod";
+import { templateKeys } from "../textTemplate.js";
+import { ParameterType, RESERVED_KEY } from "../types.js";
+import { strict } from "./strict.js";
+/**
+ * Per-layout frontmatter validation for a deck `.md`. The old tycoslide validated
+ * every slide's frontmatter against a Zod schema carried by the layout program;
+ * current layouts are JSON DATA, so the schema is BUILT dynamically from a layout's
+ * declared `parameters` using the same key-derivation the compiler already uses
+ * (`deckCompiler.ts`): an image parameter contributes its `key`; a template
+ * parameter contributes one field per `{key}` placeholder in its template (NOT its
+ * `shapeName`, which addresses `step.content`, not frontmatter).
+ *
+ * Commit-1 scope is unknown-key detection ONLY — zero behavior change:
+ * - Every field is `z.coerce.string()` (values are `String()`-coerced today, so a
+ *   YAML number like `year: 2026` must still pass — plain `z.string()` would regress)
+ *   and `.optional()` (`required` is per-parameter, enforced in `compileStep`, not
+ *   "all a template's keys present"). Value-typing and required-encoding are deliberate
+ *   later commits.
+ * The strict object IS the unknown-key check that used to be imperative in
+ * `compileStep`; a stray frontmatter key throws instead of being silently ignored.
+ */
+export function deckFrontmatterSchema(layout) {
+    const shape = {};
+    for (const param of layout.parameters) {
+        switch (param.type) {
+            case ParameterType.Image:
+                shape[param.key] = z.coerce.string().optional();
+                break;
+            case ParameterType.Template:
+                for (const key of templateKeys(param.template)) {
+                    shape[key] = z.coerce.string().optional();
+                }
+                break;
+        }
+    }
+    return strict(shape);
+}
+/**
+ * Validate one slide's frontmatter against its layout, throwing a fail-fast error
+ * prefixed with the slide index (naming the unknown key + the valid set, via the
+ * shared `strict` "Valid keys: …" formatter). Reserved keys (`layout`, `notes`) are
+ * slide-level metadata, not parameters, so they are stripped before `safeParse`.
+ */
+export function validateSlideFrontmatter(frontmatter, layout, slideIdx) {
+    const { [RESERVED_KEY.LAYOUT]: _layout, [RESERVED_KEY.NOTES]: _notes, ...params } = frontmatter;
+    const result = deckFrontmatterSchema(layout).safeParse(params);
+    if (!result.success) {
+        throw new Error(`Slide ${slideIdx}: ${z.prettifyError(result.error)}`);
+    }
+}

package/dist/markdown/schema/strict.d.ts

@@ -0,0 +1,9 @@
+import * as z from "zod";
+/**
+ * A strict object whose unrecognized-key error also lists the valid key set,
+ * matching the deck frontmatter validators' "Valid keys: …" style
+ * (`deckCompiler.ts`). The `error` callback only rewrites `unrecognized_keys`
+ * issues; returning `undefined` falls back to Zod's default message for every
+ * other issue code.
+ */
+export declare function strict<T extends z.ZodRawShape>(shape: T): z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>;

package/dist/markdown/schema/strict.js

@@ -0,0 +1,18 @@
+import * as z from "zod";
+/**
+ * A strict object whose unrecognized-key error also lists the valid key set,
+ * matching the deck frontmatter validators' "Valid keys: …" style
+ * (`deckCompiler.ts`). The `error` callback only rewrites `unrecognized_keys`
+ * issues; returning `undefined` falls back to Zod's default message for every
+ * other issue code.
+ */
+export function strict(shape) {
+    return z.strictObject(shape, {
+        error: (issue) => {
+            if (issue.code === "unrecognized_keys") {
+                return `Unknown key(s): ${issue.keys.join(", ")}. Valid keys: ${Object.keys(shape).join(", ")}`;
+            }
+            return undefined;
+        },
+    });
+}

package/dist/markdown/schema/themeConfigSchema.d.ts

@@ -0,0 +1,99 @@
+import * as z from "zod";
+import { type CompilerConfig, type CompilerThemeConfig } from "../types.js";
+export declare const ThemeConfigSchema: z.ZodObject<{
+    layouts: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        slideNumber: z.ZodNumber;
+        description: z.ZodOptional<z.ZodString>;
+        whenToUse: z.ZodOptional<z.ZodString>;
+        whenNotToUse: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            shapeName: z.ZodString;
+            limit: z.ZodOptional<z.ZodObject<{
+                maxChars: z.ZodOptional<z.ZodNumber>;
+                maxLines: z.ZodOptional<z.ZodNumber>;
+                maxItems: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            type: z.ZodLiteral<"template">;
+            template: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            shapeName: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            key: z.ZodString;
+            type: z.ZodLiteral<"image">;
+        }, z.core.$strict>], "type">>;
+        slots: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            accepts: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    text: "text";
+                    table: "table";
+                    image: "image";
+                }>;
+                sourceSlide: z.ZodNumber;
+                shapeName: z.ZodString;
+                startAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            frame: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                cx: z.ZodNumber;
+                cy: z.ZodNumber;
+            }, z.core.$strict>>;
+            limit: z.ZodOptional<z.ZodObject<{
+                maxChars: z.ZodOptional<z.ZodNumber>;
+                maxLines: z.ZodOptional<z.ZodNumber>;
+                maxItems: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    assets: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodEnum<{
+            image: "image";
+            icon: "icon";
+            background: "background";
+        }>;
+        description: z.ZodString;
+        whenToUse: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    template: z.ZodString;
+    outputDir: z.ZodOptional<z.ZodString>;
+    mermaid: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        primary: z.ZodString;
+        primaryContrast: z.ZodString;
+        text: z.ZodString;
+        line: z.ZodString;
+        surface: z.ZodString;
+        surfaceBorder: z.ZodString;
+        fontFamily: z.ZodString;
+        accents: z.ZodArray<z.ZodString>;
+        accentOpacity: z.ZodNumber;
+        accentTextColor: z.ZodString;
+        groupCornerRadius: z.ZodNumber;
+    }, z.core.$strict>>>;
+    fonts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        family: z.ZodString;
+        path: z.ZodString;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    codeTheme: z.ZodOptional<z.ZodString>;
+    mermaidVariant: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Parse+validate a raw `theme.json` value into a `CompilerThemeConfig`, throwing
+ * a fail-fast error (naming the source file and, for unknown keys, the valid set)
+ * on any structural violation. This is the ONE loader both the CLI and the
+ * programmatic entry route through, so every caller validates identically.
+ */
+export declare function parseThemeConfig(raw: unknown, sourcePath: string): CompilerThemeConfig;
+/**
+ * Read, validate, and root a `theme.json` at `absPath` into a `CompilerConfig`.
+ * The single loader the CLI and programmatic callers share: file read/JSON
+ * failures fail fast with the path; structural failures go through
+ * `parseThemeConfig`. `rootDir` (the config's directory) is attached AFTER
+ * validation — it is not a JSON field.
+ */
+export declare function loadThemeConfig(absPath: string): CompilerConfig;

package/dist/markdown/schema/themeConfigSchema.js

@@ -0,0 +1,145 @@
+import { readFileSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import * as z from "zod";
+import { AcceptType, AssetType, ParameterType } from "../types.js";
+import { strict } from "./strict.js";
+/**
+ * Fail-fast runtime validation for a `theme.json`. The hand-written types in
+ * `types.ts` stay canonical (they carry load-bearing doc-comments and export the
+ * const-object enums used as runtime values); this schema is declared alongside
+ * and bound to them by a compile-time drift guard (`_drift` below). The guard
+ * catches required-field and type drift in either direction, but — because TS
+ * structural assignability is lenient about ADDITIVE optional fields — it will
+ * NOT catch a schema that's missing an optional field the hand-written type
+ * declares. The `fullTheme()` fixture in `themeConfigSchema.test.ts`, which
+ * populates every optional field, is the runtime backstop for that gap.
+ *
+ * Every object is a `strictObject` so an unknown key throws instead of being
+ * silently dropped — strictness does NOT propagate, so each nested object is
+ * independently strict. The two exceptions are the `AssetCatalog` and `mermaid`
+ * records, whose keys are user-defined category/asset/variant names (a
+ * `z.record`, open by design); strictness lands on their leaf entries.
+ */
+// Reuse the const-object enums as runtime values — no third copy of the literals.
+const acceptTypeSchema = z.enum(Object.values(AcceptType));
+const assetTypeSchema = z.enum(Object.values(AssetType));
+// Re-declared here (not imported from the engine) so the schema layer never
+// depends on the engine — mirrors engine `Frame`, guarded by `_drift`.
+const FrameSchema = strict({
+    x: z.number(),
+    y: z.number(),
+    cx: z.number(),
+    cy: z.number(),
+});
+const LimitSchema = strict({
+    maxChars: z.number().optional(),
+    maxLines: z.number().optional(),
+    maxItems: z.number().optional(),
+});
+const AssetEntrySchema = strict({
+    path: z.string(),
+    type: assetTypeSchema,
+    description: z.string(),
+    whenToUse: z.string().optional(),
+});
+// AssetCatalog: `{ category: { name: AssetEntry } }`. The two record levels are
+// OPEN (names are user-defined); only the leaf entry is strict.
+const AssetCatalogSchema = z.record(z.string(), z.record(z.string(), AssetEntrySchema));
+const MermaidVariantSchema = strict({
+    primary: z.string(),
+    primaryContrast: z.string(),
+    text: z.string(),
+    line: z.string(),
+    surface: z.string(),
+    surfaceBorder: z.string(),
+    fontFamily: z.string(),
+    accents: z.array(z.string()),
+    accentOpacity: z.number(),
+    accentTextColor: z.string(),
+    groupCornerRadius: z.number(),
+});
+// MermaidConfig: `Record<variantName, MermaidVariant>` — open keys, strict leaf.
+const MermaidConfigSchema = z.record(z.string(), MermaidVariantSchema);
+const ThemeFontSchema = strict({
+    family: z.string(),
+    path: z.string(),
+    weight: z.number().optional(),
+});
+const TemplateParamSchema = strict({
+    shapeName: z.string(),
+    limit: LimitSchema.optional(),
+    required: z.boolean().optional(),
+    type: z.literal(ParameterType.Template),
+    template: z.string(),
+});
+const ImageParamSchema = strict({
+    shapeName: z.string(),
+    required: z.boolean().optional(),
+    key: z.string(),
+    type: z.literal(ParameterType.Image),
+});
+const ParameterSchema = z.discriminatedUnion("type", [TemplateParamSchema, ImageParamSchema]);
+const BlockSchema = strict({
+    type: acceptTypeSchema,
+    sourceSlide: z.number(),
+    shapeName: z.string(),
+    startAt: z.number().optional(),
+});
+const SlotSchema = strict({
+    key: z.string(),
+    accepts: z.array(BlockSchema),
+    frame: FrameSchema.optional(),
+    limit: LimitSchema.optional(),
+    required: z.boolean().optional(),
+});
+const LayoutSchema = strict({
+    name: z.string(),
+    slideNumber: z.number(),
+    description: z.string().optional(),
+    whenToUse: z.string().optional(),
+    whenNotToUse: z.string().optional(),
+    parameters: z.array(ParameterSchema),
+    slots: z.array(SlotSchema),
+});
+export const ThemeConfigSchema = strict({
+    layouts: z.array(LayoutSchema),
+    assets: AssetCatalogSchema,
+    template: z.string(),
+    outputDir: z.string().optional(),
+    mermaid: MermaidConfigSchema.optional(),
+    fonts: z.array(ThemeFontSchema).optional(),
+    codeTheme: z.string().optional(),
+    mermaidVariant: z.string().optional(),
+});
+const _drift = true;
+void _drift;
+/**
+ * Parse+validate a raw `theme.json` value into a `CompilerThemeConfig`, throwing
+ * a fail-fast error (naming the source file and, for unknown keys, the valid set)
+ * on any structural violation. This is the ONE loader both the CLI and the
+ * programmatic entry route through, so every caller validates identically.
+ */
+export function parseThemeConfig(raw, sourcePath) {
+    const r = ThemeConfigSchema.safeParse(raw);
+    if (!r.success) {
+        throw new Error(`${basename(sourcePath)}: invalid theme config\n${z.prettifyError(r.error)}`);
+    }
+    return r.data;
+}
+/**
+ * Read, validate, and root a `theme.json` at `absPath` into a `CompilerConfig`.
+ * The single loader the CLI and programmatic callers share: file read/JSON
+ * failures fail fast with the path; structural failures go through
+ * `parseThemeConfig`. `rootDir` (the config's directory) is attached AFTER
+ * validation — it is not a JSON field.
+ */
+export function loadThemeConfig(absPath) {
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(absPath, "utf-8"));
+    }
+    catch {
+        throw new Error(`Config file not found or invalid JSON: ${absPath}`);
+    }
+    return { ...parseThemeConfig(raw, absPath), rootDir: dirname(absPath) };
+}