create-ailk 0.12.1 → 0.14.0

package/dist/design-home.js

@@ -0,0 +1,256 @@
+/**
+ * A design's home arc (#7743, spec
+ * docs/specs/7743-minimalism-b5-the-design-seeds-spec.md D1, D3, D4) — the
+ * one place a design decides a page's SECTIONS rather than only their looks,
+ * and only for the home page, and only while the home is still a placeholder.
+ *
+ * A design package may carry `home/<shape>.mdx`: a complete `HomePage` whose
+ * `sections:` value is the design's arc for that shape. `planDesignHome`
+ * replaces a site home's `sections:` value with it when the home's content
+ * fingerprint is a known placeholder (the shape's own home, or a shipped
+ * design's arc of it); any authored home is left alone.
+ *
+ * Pure apart from `readDesignHomeSeeds`/`designHomeSeeds`: every directory it
+ * reads is passed in (no `import.meta.url` — Jest's CJS transform).
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DesignPackageError } from "./design-package.js";
+import { locatePageSections, pageTypeOf, } from "./design-presets.js";
+import { RECOGNIZED_SHAPES } from "./parse-args.js";
+import { STARTER_DESIGNS, TemplateError } from "./template-manifest.js";
+/** Where a site's home page lives, site-relative. */
+export const HOME_PAGE_PATH = "content/en/HomePage/home.mdx";
+// ── D1: reading a design's seeds ───────────────────────────────────────────
+/** Flow punctuation: whitespace beside it is layout, never content. */
+const FLOW_PUNCTUATION = new Set(["{", "}", "[", "]", ",", ":"]);
+/**
+ * A raw flow value in a layout-free form: outside quoted strings, whitespace
+ * beside flow punctuation is removed and any other run (inside a plain
+ * scalar) becomes one space, and a comma before `]` or `}` is dropped.
+ * Quoted strings are kept byte-for-byte.
+ */
+function normalizeRaw(raw) {
+    let out = "";
+    let pendingSpace = false;
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        if (/\s/.test(ch)) {
+            pendingSpace = out !== "";
+            continue;
+        }
+        if (pendingSpace && !FLOW_PUNCTUATION.has(ch) && !FLOW_PUNCTUATION.has(out.at(-1)))
+            out += " ";
+        pendingSpace = false;
+        if (ch === '"' || ch === "'") {
+            let j = i + 1;
+            while (j < raw.length) {
+                if (ch === '"' && raw[j] === "\\")
+                    j += 2;
+                else if (raw[j] === ch && ch === "'" && raw[j + 1] === "'")
+                    j += 2;
+                else if (raw[j] === ch)
+                    break;
+                else
+                    j++;
+            }
+            out += raw.slice(i, j + 1);
+            i = j;
+        }
+        else if ((ch === "]" || ch === "}") && out.endsWith(",")) {
+            out = out.slice(0, -1) + ch;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+/** The raw value of a located section's `data` entry, or undefined. */
+function rawEntry(text, sections, index, key) {
+    const entry = sections[index]?.entries.find((e) => e.key === key);
+    return entry === undefined ? undefined : text.slice(entry.valueStart, entry.valueEnd);
+}
+/**
+ * Read and validate `<dir>/home/*` (D1). Refuses with a `DesignPackageError`
+ * naming the file, before any write: a basename that is not a recognized
+ * shape, a page whose `type` is not `HomePage`, `sections` that cannot be
+ * located (or are not in the flow form a carry can splice), a section type
+ * the catalog does not carry, or a `logoCloud` whose `logos` is not `[]`.
+ */
+export function readDesignHomeSeeds(dir, opts) {
+    const homeDir = join(dir, "home");
+    if (!existsSync(homeDir))
+        return [];
+    const seeds = [];
+    for (const name of readdirSync(homeDir).sort()) {
+        const file = join(homeDir, name);
+        const shape = name.replace(/\.mdx$/, "");
+        if (!name.endsWith(".mdx") || !RECOGNIZED_SHAPES.includes(shape)) {
+            throw new DesignPackageError(file, "home", `is not named after a recognized shape (expected <shape>.mdx, one of ${RECOGNIZED_SHAPES.join(", ")})`);
+        }
+        const text = readFileSync(file, "utf8");
+        let pageType;
+        let sections;
+        try {
+            pageType = pageTypeOf(text, file);
+            sections = locatePageSections(text, file);
+        }
+        catch (err) {
+            if (!(err instanceof TemplateError))
+                throw err;
+            throw new DesignPackageError(file, "sections", `cannot be located (${err.message})`);
+        }
+        if (pageType !== "HomePage") {
+            throw new DesignPackageError(file, "type", `must be "HomePage" (got ${JSON.stringify(pageType ?? null)})`);
+        }
+        if (sections === undefined || sections.some((s) => s.form !== "flow")) {
+            throw new DesignPackageError(file, "sections", "must be a flow sequence of sections");
+        }
+        const catalog = opts.catalog();
+        if (sections.filter((s) => s.type === "logoCloud").length > 1) {
+            throw new DesignPackageError(file, "sections", "carries more than one logoCloud — the arc has one proof slide");
+        }
+        sections.forEach((section, index) => {
+            if (!Object.prototype.hasOwnProperty.call(catalog, section.type)) {
+                throw new DesignPackageError(file, `sections[${index}].type`, `"${section.type}" is not a registered section type`);
+            }
+            if (section.type === "logoCloud") {
+                const logos = rawEntry(text, sections, index, "logos");
+                if (logos === undefined || normalizeRaw(logos) !== "[]") {
+                    throw new DesignPackageError(file, `sections[${index}].data.logos`, "must be [] — a design ships no logo; the home's own logos are carried into it");
+                }
+            }
+        });
+        seeds.push({ shape, file, text });
+    }
+    return seeds;
+}
+/**
+ * The seeds a resolved design uses (D1): its own `home/`, else — a
+ * byte-identical copy of a shipped design IS that design — the shipped
+ * design's, else none.
+ */
+export function designHomeSeeds(resolved, opts) {
+    if (existsSync(join(resolved.dir, "home")))
+        return readDesignHomeSeeds(resolved.dir, opts);
+    if (STARTER_DESIGNS.includes(resolved.recorded)) {
+        return readDesignHomeSeeds(join(opts.designsDir, resolved.recorded), opts);
+    }
+    return [];
+}
+/** Every shipped design's seeds (D3's placeholder set reads them all). */
+export function shippedHomeSeeds(opts) {
+    return STARTER_DESIGNS.flatMap((name) => readDesignHomeSeeds(join(opts.designsDir, name), opts));
+}
+/** The shape's own home: its shape tree's, else the overlay's (spec § 1.4). */
+export function shapeHomePath(shape, opts) {
+    const own = join(opts.siteTemplatesDir, "shapes", shape, ...HOME_PAGE_PATH.split("/"));
+    return existsSync(own) ? own : join(opts.templatesDir, ...HOME_PAGE_PATH.split("/"));
+}
+// ── D3: the content fingerprint ────────────────────────────────────────────
+function locate(text, file) {
+    const sections = locatePageSections(text, file);
+    if (sections === undefined)
+        throw new TemplateError(`${file}: sections — the page has none`);
+    return sections;
+}
+/**
+ * A home's content fingerprint (D3): per section in order, its type and its
+ * non-look `data` entries as `[key, normalized raw value]`, sorted by key.
+ * A reflow, a look-field change or a preset leaves it unchanged; ids, the
+ * title, the description and the body are not in it.
+ */
+export function fingerprint(text, catalog, file = "home.mdx") {
+    const sections = locate(text, file);
+    return JSON.stringify(sections.map((section) => {
+        const look = new Set(catalog[section.type]?.look ?? []);
+        const entries = section.entries
+            .filter((e) => !look.has(e.key))
+            .map((e) => [e.key, normalizeRaw(text.slice(e.valueStart, e.valueEnd))])
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        return [section.type, entries];
+    }));
+}
+/** `page` with its `sections:` value replaced by `value`; nothing else moves. */
+function spliceSections(page, value, file) {
+    const sections = locate(page, file);
+    return page.slice(0, sections.valueStart) + value + page.slice(sections.valueEnd);
+}
+// ── D4: the carry ──────────────────────────────────────────────────────────
+/**
+ * The seed's `sections:` value with D4's carry applied from `home`: a seed
+ * `logoCloud` (its `logos: []`) takes the raw `logos` of the home's first
+ * `logoCloud`, or is dropped when the home has none.
+ */
+export function applySeed(home, seed, file = "home.mdx") {
+    const seedSections = locate(seed.text, seed.file);
+    const homeSections = locate(home, file);
+    const homeCloud = homeSections.findIndex((s) => s.type === "logoCloud");
+    const homeLogos = homeCloud < 0 ? undefined : homeSections[homeCloud].entries.find((e) => e.key === "logos");
+    // From just after the key's `:`, so the value keeps the line break prettier gave it.
+    // Only a flow sequence can sit inside the seed's flow mapping; anything else is not carried.
+    const raw = homeLogos === undefined ? undefined : home.slice(home.lastIndexOf(":", homeLogos.valueStart) + 1, homeLogos.valueEnd);
+    const carried = raw !== undefined && raw.trimStart().startsWith("[") ? raw : undefined;
+    let text = seed.text;
+    // Right to left, so earlier spans stay valid (a seed holds at most one logoCloud, D1).
+    for (let index = seedSections.length - 1; index >= 0; index--) {
+        const section = seedSections[index];
+        if (section.type !== "logoCloud")
+            continue;
+        if (carried !== undefined) {
+            const logos = section.entries.find((e) => e.key === "logos");
+            text = text.slice(0, text.lastIndexOf(":", logos.valueStart) + 1) + carried + text.slice(logos.valueEnd);
+            continue;
+        }
+        const next = seedSections[index + 1];
+        const previous = seedSections[index - 1];
+        const [from, to] = next !== undefined
+            ? [section.start, next.start]
+            : previous !== undefined
+                ? [previous.end, section.end]
+                : [section.start, section.end];
+        text = text.slice(0, from) + text.slice(to);
+    }
+    const located = locate(text, seed.file);
+    return text.slice(located.valueStart, located.valueEnd);
+}
+// ── D3: the decision ───────────────────────────────────────────────────────
+/**
+ * Plan a site home under a design (D3). Writes nothing: `text` is the new
+ * home when the outcome is `seeded` or `restored`, and absent otherwise.
+ */
+export function planDesignHome(opts) {
+    const { current, shape, target, shapeHome, catalog } = opts;
+    if (current === undefined)
+        return { outcome: "no-home" };
+    if (shape === undefined)
+        return { outcome: "no-shape" };
+    let currentPrint;
+    try {
+        currentPrint = fingerprint(current, catalog, HOME_PAGE_PATH);
+    }
+    catch (err) {
+        // A home whose sections cannot be read is not a placeholder: never write it.
+        if (err instanceof TemplateError)
+            return { outcome: "authored" };
+        throw err;
+    }
+    const seeds = [...opts.shippedSeeds.filter((s) => s.shape === shape), ...(target !== undefined ? [target] : [])];
+    const placeholders = new Set([
+        fingerprint(shapeHome, catalog),
+        ...seeds.map((seed) => fingerprint(spliceSections(shapeHome, applySeed(shapeHome, seed), "shape home"), catalog)),
+    ]);
+    if (!placeholders.has(currentPrint))
+        return { outcome: "authored" };
+    const wanted = target !== undefined
+        ? applySeed(current, target, HOME_PAGE_PATH)
+        : (() => {
+            const own = locate(shapeHome, "shape home");
+            return shapeHome.slice(own.valueStart, own.valueEnd);
+        })();
+    const text = spliceSections(current, wanted, HOME_PAGE_PATH);
+    if (fingerprint(text, catalog) === currentPrint)
+        return { outcome: "unchanged" };
+    return { outcome: target !== undefined ? "seeded" : "restored", text };
+}

package/dist/design-package.d.ts

@@ -11,13 +11,31 @@ export type DesignColors = {
 } & {
     [K in DesignColorKeyOptional]?: string;
 };
-/** Typography role fields, D2's `⊆ {fontFamily, fontSize, fontWeight, lineHeight, letterSpacing}` (`fontSize` required). */
+/** The closed font-source enum (#7720 D1) — a Google Fonts family, self-hosted at build by next/font. */
+export declare const DESIGN_FONT_SOURCE_VALUES: readonly ["google"];
+/** Duplicated from site-config's `FONT_FAMILY_REGEX` (#7720 D1) — proven equal by test. */
+export declare const DESIGN_FONT_STACK_ENTRY_REGEX: RegExp;
+/**
+ * #7739 D1.3 — a type size a `typeScale: design` package compiles: a plain
+ * length in rem, px or em. Duplicated from site-config's `TYPE_SIZE_REGEX` —
+ * proven equal by test.
+ */
+export declare const DESIGN_TYPE_SIZE_REGEX: RegExp;
+/**
+ * Typography role fields, D2's `⊆ {fontFamily, fontSize, fontWeight, lineHeight, letterSpacing}`
+ * (`fontSize` required), plus #7720's `fontSource` (display/body only) and
+ * `lineHeightMobile` (display only), and #7739's `fontSizeMobile` (the three
+ * heading roles only) — each set only when declared.
+ */
 export interface DesignTypographyRole {
     fontFamily?: string;
     fontSize: string;
     fontWeight?: number;
     lineHeight?: number;
     letterSpacing?: string;
+    fontSource?: (typeof DESIGN_FONT_SOURCE_VALUES)[number];
+    lineHeightMobile?: number;
+    fontSizeMobile?: string;
 }
 /** Role names are open (D2). */
 export type DesignTypography = Record<string, DesignTypographyRole>;
@@ -29,12 +47,29 @@ export declare const DESIGN_CORNERS_VALUES: readonly ["rounded", "square"];
 export declare const DESIGN_EYEBROW_CASE_VALUES: readonly ["upper", "sentence"];
 export declare const DESIGN_PLACEHOLDERS_VALUES: readonly ["outline", "fill"];
 export declare const DESIGN_CHECKMARKS_VALUES: readonly ["circle", "plain"];
-/** D2's optional `treatments` group — the four `SiteThemeSchema` shape settings. */
+/** #7741 D7 — the button shape. */
+export declare const DESIGN_BUTTON_SHAPE_VALUES: readonly ["control", "pill"];
+export declare const DESIGN_DARK_INK_VALUES: readonly ["fg", "accent"];
+export declare const DESIGN_FIGURES_VALUES: readonly ["platform", "display"];
+/**
+ * #7739 D1 — whether the compile writes the design's own type roles into the
+ * theme. A compile instruction, not a runtime setting: never written into `theme:`.
+ */
+export declare const DESIGN_TYPE_SCALE_VALUES: readonly ["platform", "design"];
+/**
+ * D2's optional `treatments` group — the four `SiteThemeSchema` shape
+ * settings plus #7741's `buttonShape`, #7739's `darkInk` and `figures` (also runtime settings) and its
+ * `typeScale` compile instruction.
+ */
 export interface DesignTreatments {
     corners?: (typeof DESIGN_CORNERS_VALUES)[number];
     eyebrowCase?: (typeof DESIGN_EYEBROW_CASE_VALUES)[number];
     placeholders?: (typeof DESIGN_PLACEHOLDERS_VALUES)[number];
     checkmarks?: (typeof DESIGN_CHECKMARKS_VALUES)[number];
+    buttonShape?: (typeof DESIGN_BUTTON_SHAPE_VALUES)[number];
+    typeScale?: (typeof DESIGN_TYPE_SCALE_VALUES)[number];
+    darkInk?: (typeof DESIGN_DARK_INK_VALUES)[number];
+    figures?: (typeof DESIGN_FIGURES_VALUES)[number];
 }
 /** D2's optional `sections` group — carried verbatim; look-field validation is #6803's. */
 export type DesignSections = Record<string, Record<string, unknown>>;
@@ -72,6 +107,8 @@ export declare class DesignPackageError extends Error {
     readonly field: string;
     constructor(file: string, field: string, reason: string);
 }
+/** One stack entry, trimmed, with one matching pair of `'` or `"` removed. */
+export declare function unquoteFamily(entry: string): string;
 /**
  * Read and validate `<dir>/DESIGN.md`'s frontmatter into a typed
  * `DesignPackage` (D1/D2). Refuses — naming the file and the field — on any

package/dist/design-package.js

@@ -45,11 +45,30 @@ export const DESIGN_COLOR_KEYS_OPTIONAL = [
 ];
 /** Duplicated from `SiteThemeSchema`'s colour regex (D3) — proven equal by test. */
 export const DESIGN_COLOR_REGEX = /^(#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|rgb\(.+\)|rgba\(.+\)|hsl\(.+\)|hsla\(.+\)|var\(--[^)]+\))$/;
+/** The closed font-source enum (#7720 D1) — a Google Fonts family, self-hosted at build by next/font. */
+export const DESIGN_FONT_SOURCE_VALUES = ["google"];
+/** Duplicated from site-config's `FONT_FAMILY_REGEX` (#7720 D1) — proven equal by test. */
+export const DESIGN_FONT_STACK_ENTRY_REGEX = /^(?:[A-Za-z0-9 ._-]+|'[A-Za-z0-9 ._-]+'|"[A-Za-z0-9 ._-]+")$/;
+/**
+ * #7739 D1.3 — a type size a `typeScale: design` package compiles: a plain
+ * length in rem, px or em. Duplicated from site-config's `TYPE_SIZE_REGEX` —
+ * proven equal by test.
+ */
+export const DESIGN_TYPE_SIZE_REGEX = /^(?:\d+|\d*\.\d+)(?:rem|px|em)$/;
 /** Duplicated from `SiteThemeSchema`'s enums (D3) — proven equal by test. */
 export const DESIGN_CORNERS_VALUES = ["rounded", "square"];
 export const DESIGN_EYEBROW_CASE_VALUES = ["upper", "sentence"];
 export const DESIGN_PLACEHOLDERS_VALUES = ["outline", "fill"];
 export const DESIGN_CHECKMARKS_VALUES = ["circle", "plain"];
+/** #7741 D7 — the button shape. */
+export const DESIGN_BUTTON_SHAPE_VALUES = ["control", "pill"];
+export const DESIGN_DARK_INK_VALUES = ["fg", "accent"];
+export const DESIGN_FIGURES_VALUES = ["platform", "display"];
+/**
+ * #7739 D1 — whether the compile writes the design's own type roles into the
+ * theme. A compile instruction, not a runtime setting: never written into `theme:`.
+ */
+export const DESIGN_TYPE_SCALE_VALUES = ["platform", "design"];
 /** The closed copy-density enum (spec 6892 D4). */
 export const DESIGN_COPY_DENSITY_VALUES = ["standard", "sparse"];
 /**
@@ -184,8 +203,52 @@ function parseScalar(raw, lineNo, file) {
     }
     return parsePlainScalar(raw, lineNo, file);
 }
-/** Parse a block mapping starting at `pos.i`, whose keys sit at `indent`. */
-function parseMapping(lines, pos, indent, file) {
+/**
+ * The one dotted key path whose value may be a block sequence (#7719 D2) —
+ * the deck's ordered ground list. Every other `- ` line is refused as before.
+ */
+const SEQUENCE_PATHS = new Set(["layout.deckGrounds"]);
+/**
+ * Parse a block sequence of scalars whose `- ` items sit at `pos.i`'s indent
+ * (#7719 D2). Each item's text is read by `parseScalar`, with every refusal it
+ * makes; an empty item, a mapping-shaped item, a nested sequence and any line
+ * deeper than the items are refused — the forms YAML would read as something
+ * other than a list of scalars.
+ */
+function parseScalarSequence(lines, pos, file) {
+    const itemIndent = lines[pos.i].indent;
+    const items = [];
+    while (pos.i < lines.length && lines[pos.i].indent >= itemIndent) {
+        const line = lines[pos.i];
+        if (line.indent > itemIndent) {
+            refuseFrontmatter(file, line.lineNo, "a sequence item must be a single scalar — nested blocks are not supported");
+        }
+        if (line.content === "-") {
+            refuseFrontmatter(file, line.lineNo, "a sequence item has no value");
+        }
+        if (!line.content.startsWith("- ")) {
+            refuseFrontmatter(file, line.lineNo, `expected a "- " sequence item, got "${line.content}"`);
+        }
+        const raw = line.content.slice(2);
+        if (raw === "" || raw.startsWith(" ")) {
+            refuseFrontmatter(file, line.lineNo, 'expected a single space after "-"');
+        }
+        if (raw === "-" || raw.startsWith("- ") || raw === "?" || raw.startsWith("? ")) {
+            refuseFrontmatter(file, line.lineNo, "a sequence item must be a scalar — nested collections are not supported");
+        }
+        if (!/^["']/.test(raw) && raw.endsWith(":")) {
+            refuseFrontmatter(file, line.lineNo, "a sequence item must be a scalar — mappings are not supported");
+        }
+        items.push(parseScalar(raw, line.lineNo, file));
+        pos.i += 1;
+    }
+    return items;
+}
+/**
+ * Parse a block mapping starting at `pos.i`, whose keys sit at `indent`.
+ * `path` is the dotted key path of this mapping (`""` at the top level).
+ */
+function parseMapping(lines, pos, indent, file, path) {
     const result = {};
     while (pos.i < lines.length && lines[pos.i].indent === indent) {
         const line = lines[pos.i];
@@ -202,13 +265,21 @@ function parseMapping(lines, pos, indent, file) {
             refuseFrontmatter(file, line.lineNo, `duplicate key "${key}"`);
         }
         pos.i += 1;
+        const keyPath = path === "" ? key : `${path}.${key}`;
         if (rawRest === "") {
             const next = lines[pos.i];
+            if (SEQUENCE_PATHS.has(keyPath) &&
+                next !== undefined &&
+                next.indent === indent + 2 &&
+                (next.content === "-" || next.content.startsWith("- "))) {
+                result[key] = parseScalarSequence(lines, pos, file);
+                continue;
+            }
             if (next !== undefined && next.indent > indent) {
                 if (next.indent !== indent + 2) {
                     refuseFrontmatter(file, next.lineNo, `bad indentation — expected ${indent + 2} spaces, got ${next.indent}`);
                 }
-                result[key] = parseMapping(lines, pos, next.indent, file);
+                result[key] = parseMapping(lines, pos, next.indent, file, keyPath);
             }
             else {
                 refuseFrontmatter(file, line.lineNo, `"${key}" has an empty value`);
@@ -238,7 +309,7 @@ function parseFrontmatter(text, file) {
     }
     const lines = toSignificantLines(m[1] ?? "", file);
     const pos = { i: 0 };
-    const result = parseMapping(lines, pos, 0, file);
+    const result = parseMapping(lines, pos, 0, file, "");
     if (pos.i < lines.length) {
         const stray = lines[pos.i];
         refuseFrontmatter(file, stray.lineNo, "unexpected indentation at the top level");
@@ -281,7 +352,51 @@ function validateColors(raw, file) {
     }
     return result;
 }
-const TYPOGRAPHY_ROLE_KEYS = ["fontFamily", "fontSize", "fontWeight", "lineHeight", "letterSpacing"];
+const TYPOGRAPHY_ROLE_KEYS = [
+    "fontFamily",
+    "fontSize",
+    "fontWeight",
+    "lineHeight",
+    "letterSpacing",
+    "fontSource",
+    "lineHeightMobile",
+    "fontSizeMobile",
+];
+/** The roles with a phone size (#7739 D1.2). */
+const FONT_SIZE_MOBILE_ROLES = ["display", "heading-section", "heading-item"];
+/** The roles `typeScale: design` compiles (#7739 D1.3, D2.2). */
+const COMPILED_TYPE_ROLES = ["display", "heading-section", "heading-item", "body", "eyebrow"];
+/** The roles with a runtime font slot (`--font-display` / `--font-body`, #7720 D1). */
+const FONT_SOURCE_ROLES = ["display", "body"];
+/** A Google Fonts family name, as next/font/google exports it with spaces → `_`. */
+const GOOGLE_FAMILY_RE = /^[A-Za-z][A-Za-z0-9 ]*$/;
+/** One stack entry, trimmed, with one matching pair of `'` or `"` removed. */
+export function unquoteFamily(entry) {
+    const trimmed = entry.trim();
+    const m = /^(['"])(.*)\1$/.exec(trimmed);
+    return m ? m[2] : trimmed;
+}
+/**
+ * #7720 D1.2 — a `fontSource` names the role's first family as the face to
+ * load; the rest of the stack is written into CSS and TypeScript source as
+ * the fallback, so both are constrained here.
+ */
+function validateFontSource(role, file, roleName) {
+    const field = `typography.${roleName}.fontSource`;
+    if (!FONT_SOURCE_ROLES.includes(roleName)) {
+        refuse(file, field, "only the display and body roles reach a runtime font slot");
+    }
+    if (role.fontFamily === undefined) {
+        refuse(file, field, "needs fontFamily on the same role");
+    }
+    const [first = "", ...rest] = role.fontFamily.split(",");
+    if (!GOOGLE_FAMILY_RE.test(unquoteFamily(first))) {
+        refuse(file, field, "the first family must be a Google Fonts family name");
+    }
+    if (!rest.every((entry) => DESIGN_FONT_STACK_ENTRY_REGEX.test(entry.trim()))) {
+        refuse(file, field, "fallback entries must be bare or singly-quoted family names");
+    }
+}
 function validateTypographyRole(raw, file, role) {
     const obj = requireObject(raw, file, `typography.${role}`);
     for (const key of Object.keys(obj)) {
@@ -295,15 +410,24 @@ function validateTypographyRole(raw, file, role) {
     const result = { fontSize: "" };
     for (const [key, value] of Object.entries(obj)) {
         const field = `typography.${role}.${key}`;
-        if (key === "fontFamily" || key === "fontSize" || key === "letterSpacing") {
+        if (key === "fontFamily" ||
+            key === "fontSize" ||
+            key === "letterSpacing" ||
+            key === "fontSizeMobile") {
             if (typeof value !== "string")
                 refuse(file, field, "must be a string");
             if (key === "fontFamily")
                 result.fontFamily = value;
             else if (key === "fontSize")
                 result.fontSize = value;
-            else
+            else if (key === "letterSpacing")
                 result.letterSpacing = value;
+            else {
+                if (!FONT_SIZE_MOBILE_ROLES.includes(role)) {
+                    refuse(file, field, "only the display, heading-section and heading-item roles have a phone size");
+                }
+                result.fontSizeMobile = value;
+            }
         }
         else if (key === "fontWeight" || key === "lineHeight") {
             if (typeof value !== "number")
@@ -313,7 +437,32 @@ function validateTypographyRole(raw, file, role) {
             else
                 result.lineHeight = value;
         }
+        else if (key === "fontSource") {
+            if (typeof value !== "string" ||
+                !DESIGN_FONT_SOURCE_VALUES.includes(value)) {
+                refuse(file, field, `must be one of ${DESIGN_FONT_SOURCE_VALUES.join(", ")}`);
+            }
+            result.fontSource = value;
+        }
+        else if (key === "lineHeightMobile") {
+            if (typeof value !== "number")
+                refuse(file, field, "must be a number");
+            if (!(value > 0))
+                refuse(file, field, "must be greater than 0");
+            if (role !== "display")
+                refuse(file, field, "only the display role has a mobile line-height");
+            result.lineHeightMobile = value;
+        }
+    }
+    // The leading pair compiles into `theme:` (#7720 D2), whose schema takes
+    // only positive line-heights — refuse here, before a site reads it.
+    if (result.lineHeightMobile !== undefined &&
+        result.lineHeight !== undefined &&
+        !(result.lineHeight > 0)) {
+        refuse(file, `typography.${role}.lineHeight`, "must be greater than 0 when lineHeightMobile is declared");
     }
+    if (result.fontSource !== undefined)
+        validateFontSource(result, file, role);
     return result;
 }
 function validateTypography(raw, file) {
@@ -336,10 +485,21 @@ function validateStringMap(raw, file, field) {
     return result;
 }
 const LAYOUT_KEYS = ["nav", "footer", "announcementBanner", "home"];
+/** Every key a package's `layout` may carry — #7719 D3 adds the optional `deckGrounds` (a deck home only),
+ *  #7721 D1 the optional `innerPages`, #7740 D1 the optional `deckPresentation` (a deck home only),
+ *  #7742 D1 the optional `colorMode` and `chromeStyle`. */
+const ALLOWED_LAYOUT_KEYS = new Set([
+    ...LAYOUT_KEYS,
+    "deckGrounds",
+    "innerPages",
+    "deckPresentation",
+    "colorMode",
+    "chromeStyle",
+]);
 function validateLayout(raw, file) {
     const obj = requireObject(raw, file, "layout");
     for (const key of Object.keys(obj)) {
-        if (!LAYOUT_KEYS.includes(key)) {
+        if (!ALLOWED_LAYOUT_KEYS.has(key)) {
             refuse(file, `layout.${key}`, "is not a recognized layout key");
         }
     }
@@ -348,8 +508,9 @@ function validateLayout(raw, file) {
             refuse(file, `layout.${key}`, "is required");
         }
     }
+    let validated;
     try {
-        return validateTemplateLayout(obj, "design package");
+        validated = validateTemplateLayout(obj, "design package");
     }
     catch (error) {
         if (error instanceof TemplateLayoutError) {
@@ -358,12 +519,35 @@ function validateLayout(raw, file) {
         }
         throw error;
     }
+    // #7721 D1 — a read package holds `innerPages` only as "bare", the
+    // `ResolvedSiteChrome` shape; an explicit "default" is the absent key.
+    // #7740 D1 — and `deckPresentation` only as `true`.
+    // #7742 D1 — and `colorMode` only as "light", `chromeStyle` only as "minimal".
+    const { innerPages, deckPresentation, colorMode, chromeStyle, ...rest } = validated;
+    const layout = {
+        ...rest,
+        ...(innerPages === "bare" ? { innerPages } : {}),
+        ...(deckPresentation === true ? { deckPresentation } : {}),
+        ...(colorMode === "light" ? { colorMode } : {}),
+        ...(chromeStyle === "minimal" ? { chromeStyle } : {}),
+    };
+    if (layout.deckGrounds !== undefined && layout.home !== "deck") {
+        refuse(file, "layout.deckGrounds", "applies only to home: deck");
+    }
+    if (deckPresentation === true && layout.home !== "deck") {
+        refuse(file, "layout.deckPresentation", "applies only to home: deck");
+    }
+    return layout;
 }
 const TREATMENTS_ENUMS = {
     corners: DESIGN_CORNERS_VALUES,
     eyebrowCase: DESIGN_EYEBROW_CASE_VALUES,
     placeholders: DESIGN_PLACEHOLDERS_VALUES,
     checkmarks: DESIGN_CHECKMARKS_VALUES,
+    buttonShape: DESIGN_BUTTON_SHAPE_VALUES,
+    typeScale: DESIGN_TYPE_SCALE_VALUES,
+    darkInk: DESIGN_DARK_INK_VALUES,
+    figures: DESIGN_FIGURES_VALUES,
 };
 function validateTreatments(raw, file) {
     const obj = requireObject(raw, file, "treatments");
@@ -380,6 +564,33 @@ function validateTreatments(raw, file) {
     }
     return result;
 }
+/**
+ * #7739 D1.3 — under `typeScale: design` the five compiled roles' sizes and
+ * weights are written into an inline `<style>`, so each is constrained here,
+ * after both `typography` and `treatments` have been read. Without the dial
+ * these fields are carried as before and never compiled.
+ */
+function validateCompiledTypeScale(typography, file) {
+    for (const role of COMPILED_TYPE_ROLES) {
+        const def = typography[role];
+        if (def === undefined)
+            continue;
+        for (const key of ["fontSize", "fontSizeMobile"]) {
+            const value = def[key];
+            if (value !== undefined && !DESIGN_TYPE_SIZE_REGEX.test(value)) {
+                refuse(file, `typography.${role}.${key}`, "must be a length in rem, px or em");
+            }
+        }
+        const weight = def.fontWeight;
+        if (weight !== undefined && !(Number.isInteger(weight) && weight >= 1 && weight <= 1000)) {
+            refuse(file, `typography.${role}.fontWeight`, "must be an integer from 1 to 1000");
+        }
+        // The display and body leadings compile too, into a schema that takes only positive ones.
+        if ((role === "display" || role === "body") && def.lineHeight !== undefined && !(def.lineHeight > 0)) {
+            refuse(file, `typography.${role}.lineHeight`, "must be greater than 0");
+        }
+    }
+}
 function validateSections(raw, file) {
     const obj = requireObject(raw, file, "sections");
     const result = {};
@@ -448,6 +659,9 @@ function validatePackage(raw, file) {
     if ("treatments" in raw) {
         pkg.treatments = validateTreatments(raw.treatments, file);
     }
+    if (pkg.treatments?.typeScale === "design") {
+        validateCompiledTypeScale(pkg.typography, file);
+    }
     return pkg;
 }
 /**