@cueframe/kernel 0.2.1 → 0.2.3

package/dist/_members/composition/fonts/bundledFaces.d.ts

@@ -0,0 +1,150 @@
+/**
+ * WHAT FONT FILES THIS BUILD ACTUALLY SHIPS, and the questions a refusal asks of them.
+ *
+ * The renderer draws a face only where bytes exist for that exact family, weight and style; it
+ * never lets the browser substitute a nearby file or slant an upright one. Everything that
+ * decision needs is here: the vendored and aliased families, the file-by-file weight declarations
+ * they were checked in with, the lookups over them, and the resolution of a CSS font STACK to the
+ * one bundled family (if any) it names.
+ *
+ * Split out of `fonts.ts` so the facts sit apart from the caption policy built on them
+ * (`fonts/captionFaces.ts`) — a move, not a rewrite. `../fonts.ts` re-exports both, so every
+ * existing `@cueframe/composition/fonts` import is unchanged.
+ */
+export declare const VENDORED_FONT_FAMILIES: readonly ["Inter", "Space Mono", "Montserrat", "Roboto", "Poppins", "Oswald", "Playfair Display", "Bebas Neue", "Instrument Serif", "National Park", "Bricolage Grotesque", "Schibsted Grotesk"];
+export type VendoredFontFamily = (typeof VENDORED_FONT_FAMILIES)[number];
+export declare const ALIASED_FONT_FAMILIES: readonly ["Georgia"];
+export type AliasedFontFamily = (typeof ALIASED_FONT_FAMILIES)[number];
+/** One bundled file, and the weights it actually carries. */
+export interface BundledFontFace {
+    /**
+     * The CSS `font-weight` descriptor the file is registered under: a single weight for a static
+     * face, or `"<lo> <hi>"` for a variable font's declared `wght` axis range.
+     */
+    readonly weight: string;
+    /** The `-<file>.woff2` suffix that carries it, i.e. `public/fonts/<slug>-<file>.woff2`. */
+    readonly file: "400" | "700";
+}
+/**
+ * The weights a caption run is drawn at when the style names none.
+ *
+ * DECLARED per family, not derived: there is no runtime nearest-weight search anywhere in this
+ * file. A family that ships 400 and 700 declares 400/700; a variable family that carries the
+ * house pair declares 600/800 so its look does not change. The invariant the table exists for is
+ * that every declared default has bytes behind it — `fonts.test.ts` asserts exactly that — so
+ * `{ fontFamily: "Poppins" }` alone names a face the render can draw.
+ */
+export interface CaptionFaceDefaults {
+    /** The ordinary run's weight. */
+    readonly base: number;
+    /** The weight an emphasised word is drawn at. */
+    readonly emphasis: number;
+}
+/** The files behind one bundled family. */
+export interface BundledFontFamilyFaces {
+    /**
+     * The `public/fonts` filename stem. It is the family lowercased with spaces hyphenated for every
+     * vendored family; an aliased family is the one case where the registered family name differs
+     * from the file stem (Georgia is served by the metric-compatible Gelasio binary).
+     */
+    readonly slug: string;
+    readonly faces: readonly BundledFontFace[];
+    /** What a caption drawn in this family weighs when the style leaves the weight unset. */
+    readonly captionDefaults: CaptionFaceDefaults;
+}
+/**
+ * What bytes actually ship with the render bundle, per family.
+ *
+ * This is the single source for the two facts every font gate needs before it may claim a face is
+ * reproducible: which weights a bundled or aliased family's file declares, and that no bundled or
+ * aliased family ships an italic file at all. Both gates read this one table — render-entry's
+ * loader (`packages/execution/render-entry/src/fonts.ts`) derives its face table and its
+ * `staticFile('fonts/<slug>-<file>.woff2')` URLs from it, and core's scene-shot sealing
+ * (`sealSceneShotFonts`) admits a bundled face by it — so the host-side seal and the page-side
+ * admission agree by construction rather than by two hand-kept copies.
+ *
+ * A declared weight range must not exceed what the file carries: outside it the browser
+ * synthesises the face, which is a silent substitution, not a render. `fonts.test.ts` in
+ * render-entry asserts every face here has bytes on disk and that no italic file exists, so these
+ * facts cannot drift away from the bytes.
+ */
+export declare const BUNDLED_FONT_FACES: Readonly<Record<VendoredFontFamily | AliasedFontFamily, BundledFontFamilyFaces>>;
+/**
+ * The only style a bundled or aliased family can be rendered in. There is no italic file in
+ * `public/fonts` for any of them, so an italic request against one has no bytes behind it: the
+ * browser would slant the upright face, which is neither the typeface the author asked for nor
+ * reproducible across engines. A real italic comes from a sealed brand font asset.
+ */
+export declare const BUNDLED_FONT_STYLE: "normal";
+/** The files behind a bundled or aliased family, or `undefined` when nothing ships for it. */
+export declare function bundledFontFamilyFaces(family: string): BundledFontFamilyFaces | undefined;
+/** True when a bundled file declares this weight, whether as a single value or a variable range. */
+export declare function bundledFaceCoversWeight(face: BundledFontFace, weight: number): boolean;
+/**
+ * Whether bytes ship for exactly this (family, weight, style). This is the whole bundled-face
+ * rule: the family must be bundled or aliased, the style must be upright because no italic file
+ * exists, and some file must declare the weight.
+ */
+export declare function bundledFontFaceExists(family: string, weight: number, style: "normal" | "italic"): boolean;
+/** The weights a bundled family covers, phrased for an error message ("400-900", "400, 700"). */
+export declare function describeBundledFontWeights(family: string): string;
+/** The field a refused (family, weight, style) belongs to. */
+export type UnrenderableFaceField = "fontFamily" | "fontWeight" | "fontStyle";
+/** What a render's sealed brand font manifest carries, as the two questions a refusal asks it. */
+export interface SealedFontManifestFacts {
+    /** Whether the manifest seals any face of this family. */
+    hasFamily(family: string): boolean;
+    /** Whether it seals this family at this weight, in any style. */
+    hasWeight(family: string, weight: number): boolean;
+}
+/**
+ * Which field an author has to change for a face that cannot be drawn.
+ *
+ * This is one decision with two callers that must agree to the letter. Host-side sealing
+ * (`sealSceneShotFonts` in `@cueframe/core`) reports `layers.N.<field>` when it refuses to seal a
+ * scene layer's face; the render page reports the same path when the same face is refused at
+ * admission — because a marker that reached the page unsealed, or a render input edited after the
+ * seal, must not be described differently from the same defect caught an hour earlier. The order
+ * below is sealing's order: sealed manifest, then bundled bytes, then the family's own coverage.
+ *
+ * `fontStyle` when the family has bytes but not in this style; `fontWeight` when the style is
+ * available but the weight is not; `fontFamily` when nothing anywhere ships the family.
+ */
+export declare function unrenderableFaceField(family: string, weight: number, style: "normal" | "italic", sealed: SealedFontManifestFacts): UnrenderableFaceField;
+/** `"Inter", 'Helvetica Neue', sans-serif` → the family names, unquoted and trimmed. */
+export declare function parseFontStack(value: string): string[];
+/**
+ * True when a stack names ONLY CSS generic families — `sans-serif`, `serif, system-ui`.
+ *
+ * A generic names a CATEGORY the engine picks from, never a file: no font bundle carries one and
+ * no brand kit can seal one, because the names are reserved. So a caption authored with such a
+ * stack has no admissible face at any weight, and the render page refuses it at its family
+ * (`render-entry/src/fonts.ts`, which admits `use.stack` against the sealed manifest).
+ *
+ * It is deliberately NOT one of `captionFaceIssues`' issues: those name a weight or a style that
+ * has no file, and this is a family that has no file at ANY weight, which is a different field and
+ * a different sentence. Surfaces that must agree with the page — the editor preview gate — ask
+ * this as well. An absent or empty stack is not generic-only: that is the built-in default stack,
+ * which leads with a bundled family.
+ */
+export declare function isGenericOnlyStack(stack: string | undefined | null): boolean;
+/**
+ * Which bundled family a font stack will actually render with.
+ *
+ * - `{ kind: "bundled" }` — the stack names bundled families (and CSS generics) only, so the face
+ *   must come from a file this table describes.
+ * - `{ kind: "default" }` — no stack at all, so the render falls back to a bundled face; which one
+ *   is not knowable here, but every one of them is upright.
+ * - `{ kind: "unknown" }` — the stack names a family that is not bundled. It can only render from
+ *   a brand font asset sealed for the render, whose faces a schema cannot see, so nothing about
+ *   its weights or styles can be decided at edit time.
+ */
+export type StackFontFamily = {
+    kind: "bundled";
+    family: string;
+} | {
+    kind: "default";
+} | {
+    kind: "unknown";
+};
+export declare function bundledFamilyForStack(stack: string | undefined | null): StackFontFamily;

package/dist/_members/composition/fonts/captionFaces.d.ts

@@ -0,0 +1,268 @@
+/**
+ * THE CAPTION FACE RULE: which faces a caption style causes the renderer to draw, whether or not
+ * it names them, and which of those have no file behind them.
+ *
+ * Built on the file facts in `./bundledFaces` and used by four surfaces that must agree — the
+ * primitive that draws captions, the render page that admits them, the composition and brand-kit
+ * validators, and the Studio designer that offers the choices. Every one of them reads the same
+ * resolver here, so a defaulted face is valid by construction and visible in the UI.
+ *
+ * Split out of `fonts.ts` — a move, not a rewrite. `../fonts.ts` re-exports it, so every existing
+ * `@cueframe/composition/fonts` import is unchanged.
+ */
+import { type CaptionFaceDefaults, type StackFontFamily } from "./bundledFaces.js";
+/** The caption-style fields whose face has to exist before the render will draw it. */
+export interface CaptionFaceFields {
+    fontFamily?: string;
+    fontWeight?: number;
+    emphasisFontFamily?: string;
+    emphasisFontWeight?: number;
+    emphasisFontStyle?: "normal" | "italic";
+}
+/**
+ * The face a caption run is drawn with when its style leaves the field unset.
+ *
+ * `fontFamily` is a STACK, not a family: it is what the primitive falls back to when a style names
+ * no font at all. `CAPTION_DEFAULT_FAMILY` below names the bundled family that stack actually
+ * draws from.
+ *
+ * The two weights here are the LAST resort — the pair used for a family whose files this module
+ * cannot see, i.e. a custom face sealed in the brand font manifest. A bundled or aliased family
+ * declares its own pair in `BUNDLED_FONT_FACES[family].captionDefaults`, because 600/800 is not a
+ * weight seven of the thirteen bundled families ship: judging a defaulted weight (which is right —
+ * the renderer draws no differently for having been left to its defaults) against a global pair
+ * turned the defaults into an accidental family allowlist.
+ */
+export declare const CAPTION_FACE_DEFAULTS: Readonly<{
+    readonly fontFamily: "Inter, 'Helvetica Neue', Helvetica, Arial, sans-serif";
+    readonly fontWeight: 600;
+    readonly emphasisFontWeight: 800;
+    readonly emphasisFontStyle: "normal";
+}>;
+/**
+ * The bundled family the default stack draws from.
+ *
+ * Declared, not searched: `CAPTION_FACE_DEFAULTS.fontFamily` leads with Inter and the render
+ * bundle always loads Inter, so Inter is the family a caption with no `fontFamily` is drawn in —
+ * the later entries in that stack are there for a browser that has no webfont at all.
+ * `fonts.test.ts` pins this to the head of that stack, so the two cannot drift apart.
+ */
+export declare const CAPTION_DEFAULT_FAMILY: "Inter";
+/**
+ * Which family a caption font stack is drawn in.
+ *
+ * The one difference from `bundledFamilyForStack` is the absent stack: a caption that names no
+ * family is not undecidable, it is drawn in the default stack's family. A stack of pure CSS
+ * generics stays undecidable — `sans-serif` is whatever the engine picks, which is exactly what
+ * nothing here may guess.
+ */
+export declare function captionStackFamily(stack: string | undefined | null): StackFontFamily;
+/** The weights a caption in this family is drawn at when the style names none. */
+export declare function captionDefaultWeights(resolved: StackFontFamily): CaptionFaceDefaults;
+/** One face a caption style will actually be drawn with, and the field that chose it. */
+export interface CaptionFaceUse {
+    /** `base` is the ordinary run; `emphasis` is the run an emphasised word is drawn with. */
+    readonly role: "base" | "emphasis";
+    /** The field an author changes to change this face. */
+    readonly field: keyof CaptionFaceFields;
+    /** The font stack this face is drawn from — the default stack when the style names none. */
+    readonly stack: string;
+    /** Which bundled family (if any) the stack resolves to. */
+    readonly resolved: StackFontFamily;
+    /** The weight this run is EFFECTIVELY drawn at, authored or declared. */
+    readonly weight: number;
+    readonly style: "normal" | "italic";
+    /** True when `weight`/`style` was declared rather than authored on the style. */
+    readonly fromDefault: boolean;
+}
+/** Both faces a caption style causes the renderer to draw, whether or not it names them. */
+export interface CaptionFaces {
+    readonly base: CaptionFaceUse;
+    readonly emphasis: CaptionFaceUse;
+}
+/**
+ * THE resolver: the faces a caption style is actually drawn with.
+ *
+ * Family stack → that family's declared facts → the declared defaults → the authored overrides,
+ * in that order, once. Every surface that needs to know what a caption weighs reads this and only
+ * this: the primitive draws these weights (`Captions.tsx`), the render page admits them
+ * (`assertCaptionFontsAdmitted`), the schema judges them (`captionFaceIssues`) and the caption
+ * designer displays them. Two copies of this resolution is how the page came to admit `Poppins
+ * 400` for a run the primitive drew at 800.
+ *
+ * The emphasis face is always resolved, even when the style names no emphasis field, because the
+ * primitive draws an emphasised word whether or not the style mentions one.
+ */
+export declare function resolveCaptionFaces(style: CaptionFaceFields): CaptionFaces;
+/**
+ * The DISTINCT faces a caption style causes the renderer to draw, defaults included.
+ *
+ * This is `resolveCaptionFaces` with the emphasis run dropped when it is byte-for-byte the base
+ * run: a style whose emphasis face equals its base face asks the render for one face, so admitting
+ * or reporting it twice would name a second face that does not exist. Everything else — including
+ * `{ fontFamily: "Poppins" }`, whose emphasis run is drawn at Poppins' declared 700 — yields both.
+ *
+ * This is the list the render page admits and the list the schema judges, so neither can consider
+ * a face the other does not.
+ */
+export declare function captionFaceUses(style: CaptionFaceFields): CaptionFaceUse[];
+/** The caption fields a face refusal can name. Every schema carrying a caption style declares
+ * all of them, so an issue always has a path to sit on; `brandKit.test.ts` and
+ * `composition.test.ts` assert that against the schema shapes. */
+export declare const CAPTION_FACE_ISSUE_FIELDS: readonly (keyof CaptionFaceFields)[];
+export interface CaptionFaceIssue {
+    readonly field: keyof CaptionFaceFields;
+    readonly message: string;
+    /** The face that cannot be drawn. Two edits refuse the same face iff this is equal. */
+    readonly face: {
+        readonly family: string;
+        readonly weight: number;
+        readonly style: "normal" | "italic";
+    };
+}
+/**
+ * The caption faces that cannot be drawn, with the field an author has to change.
+ *
+ * The renderer admits a face only where bytes exist for that exact family, weight and style, so an
+ * italic of a bundled family or a weight outside its file's declared range fails before capture.
+ * Deciding it here means the author learns at edit time, with a field path, instead of watching a
+ * render die. It is deliberately silent about a family that is not bundled: that face can only
+ * come from a brand font asset sealed for the render, and this schema cannot see the manifest.
+ *
+ * It judges `captionFaceUses`, so a defaulted weight or style counts exactly as an authored one
+ * does — the renderer draws no differently for having been left to its defaults.
+ */
+export declare function captionFaceIssues(style: CaptionFaceFields): CaptionFaceIssue[];
+/**
+ * The unrenderable faces an edit INTRODUCES.
+ *
+ * An edit boundary judges this rather than the whole result. A caption style saved before these
+ * rules existed carries faces with no bytes, and judging the merged style refused every control in
+ * the drawer — including the ones that would repair it — because the violation the edit was trying
+ * to fix was still there when the edit was judged. So the rule is the delta: an edit may not name
+ * a face the style did not already name, and an edit that leaves the violation set unchanged or
+ * smaller goes through. The pre-existing violation is reported where a project's other load-time
+ * defects are reported, not by refusing the repair.
+ *
+ * Identity is the FACE, not the field: swapping Poppins 800 for Bebas Neue 800 leaves one issue at
+ * `fontWeight` either way, but it is a different face with no bytes and is refused as new.
+ */
+export declare function introducedCaptionFaceIssues(base: CaptionFaceFields, next: CaptionFaceFields): CaptionFaceIssue[];
+/**
+ * The caption-face fields a MERGE has to carry, in the order a merge resolves them.
+ *
+ * Only these five decide a face. Everything else on a caption style — colour, plate, entrance —
+ * cannot make the renderer ask for a file that does not exist.
+ */
+export declare const CAPTION_FACE_MERGE_FIELDS: readonly (keyof CaptionFaceFields)[];
+/** One brand kit font slot, as much of it as the caption face rule reads. */
+export interface CaptionFamilyRef {
+    readonly family?: string | undefined;
+}
+/** A brand kit's font block. `heading` is required exactly as the kit schema requires it. */
+export interface CaptionKitFonts<T extends CaptionFamilyRef = CaptionFamilyRef> {
+    readonly heading: T;
+    readonly body?: T | undefined;
+    readonly caption?: T | undefined;
+}
+/** Which of a kit's three font slots supplies the caption face. */
+export type CaptionFontSlot = "caption" | "body" | "heading";
+/**
+ * THE caption font slot: the ref a kit's captions are drawn from.
+ *
+ * `resolveBrandKit` reads this and so does every gate that judges a kit, because the chain picks a
+ * REF and then reads that ref's family — not the first family among the three. An uploaded caption
+ * ref carrying no family name leaves the caption family unset even when the body slot has one, and
+ * a second copy of this chain is how a validator came to judge a family the projection never drew.
+ */
+export declare function captionFontSource<T extends CaptionFamilyRef>(fonts: CaptionKitFonts<T>): {
+    readonly ref: T;
+    readonly slot: CaptionFontSlot;
+};
+/** The family a kit's captions are drawn in, and the kit field that supplied it. */
+export interface EffectiveCaptionFamily {
+    /** Undefined when no slot names a family: the caption then falls back to the default stack. */
+    readonly family: string | undefined;
+    /** The kit path that chose it — `captionProfile.fontFamily` or `fonts.<slot>`. */
+    readonly path: string;
+}
+/** What a brand kit has to expose for the caption face rule to judge it. */
+export interface CaptionFaceKit {
+    readonly fonts: CaptionKitFonts;
+    readonly captionProfile?: CaptionFaceFields | null | undefined;
+}
+/**
+ * The family a kit's caption profile is EFFECTIVELY drawn in.
+ *
+ * A profile that names no `fontFamily` does not draw in the default stack: `resolveBrandKit` fills
+ * the caption family from the kit's own font slots, so the face the render draws is that family at
+ * the profile's weights. Judging the profile on its own defaulted the family to Inter and let a kit
+ * project two faces with no bytes behind them.
+ */
+export declare function effectiveCaptionFamily(kit: CaptionFaceKit): EffectiveCaptionFamily;
+/** A face refusal against a whole brand kit, at the kit field an author edits. */
+export interface BrandKitCaptionFaceIssue extends CaptionFaceIssue {
+    /** `captionProfile.<field>` when the profile authored the offending value, else `fonts.<slot>`. */
+    readonly path: string;
+}
+/**
+ * The faces a brand kit's caption profile causes the renderer to draw and cannot.
+ *
+ * The profile is judged at `effectiveCaptionFamily`, which is what `resolveBrandKit` projects, so
+ * `{ fonts: { caption: Poppins }, captionProfile: { fontWeight: 600 } }` is refused here rather
+ * than validating clean and dying at capture. A kit whose effective family ships the defaults
+ * passes with nothing authored: every bundled family declares a base and an emphasis weight it has
+ * files for.
+ */
+export declare function brandKitCaptionFaceIssues(kit: CaptionFaceKit): BrandKitCaptionFaceIssue[];
+/** The two authoring surfaces a merged caption face value can have come from. */
+export type CaptionFaceOrigin = "captions.style" | "brandKit.captionProfile";
+/** A face refusal against the merged style, at the surface the offending value came from. */
+export interface MergedCaptionFaceIssue extends CaptionFaceIssue {
+    readonly origin: CaptionFaceOrigin;
+    /** `<origin>.<field>` — the path an author edits to change this face. */
+    readonly path: string;
+}
+/**
+ * The caption style the renderer is actually handed: the kit's caption block over the
+ * composition's own style, field by field, exactly as render-input assembly merges them.
+ */
+export declare function mergeCaptionFaceFields(style: CaptionFaceFields | null | undefined, brandCaption: CaptionFaceFields | null | undefined): CaptionFaceFields;
+/**
+ * The faces the MERGE cannot draw, each at the surface that supplied the offending value.
+ *
+ * Neither half is decidable alone: a kit naming only a family and a composition naming only a
+ * weight each validate, and together they name Poppins 800, which has no file. This judges what
+ * the renderer is handed and points the author at the half they authored — `captions.style.<field>`
+ * or `brandKit.captionProfile.<field>`.
+ */
+export declare function mergedCaptionFaceIssues(style: CaptionFaceFields | null | undefined, brandCaption: CaptionFaceFields | null | undefined): MergedCaptionFaceIssue[];
+/**
+ * One line per refused face, prefixed with the path an author edits.
+ *
+ * `field` is typed as a plain string rather than `keyof CaptionFaceFields` so a caller may add an
+ * issue this module does not raise — the editor's preview gate refuses a pure generic CSS stack at
+ * `fontFamily`, which the page refuses too and which is not a face issue — without either casting
+ * or growing a second formatter. Every field this module itself produces is still a caption field.
+ */
+export declare function describeCaptionFaceIssues(issues: readonly {
+    field: string;
+    message: string;
+}[], pathPrefix?: string): string;
+/** The CSS weights a caption UI offers; a family narrows this to the ones it has files for. */
+export declare const CAPTION_WEIGHT_CHOICES: readonly number[];
+/**
+ * The weights an editing surface may offer for a caption font stack.
+ *
+ * A bundled family is narrowed to the weights its files declare — offering 500 for a family that
+ * ships 400 and 700 is offering a face the render will refuse. A stack that resolves to no bundled
+ * family (a custom brand face, or the built-in fallback) is not decidable here, so the full list
+ * stands and the sealed manifest decides at render time.
+ */
+export declare function captionWeightChoices(stack: string | undefined): readonly number[];
+/**
+ * The styles an editing surface may offer for a caption font stack. Every bundled and aliased
+ * family is upright-only, so italic is offered only for a stack whose face comes from the brand
+ * kit's sealed font manifest.
+ */
+export declare function captionStyleChoices(stack: string | undefined): readonly ("normal" | "italic")[];

package/dist/_members/composition/fonts.d.ts

@@ -1,6 +1,13 @@
-export declare const VENDORED_FONT_FAMILIES: readonly ["Inter", "Space Mono", "Montserrat", "Roboto", "Poppins", "Oswald", "Playfair Display", "Bebas Neue", "Instrument Serif", "National Park", "Bricolage Grotesque", "Schibsted Grotesk"];
-export type VendoredFontFamily = (typeof VENDORED_FONT_FAMILIES)[number];
-export declare const ALIASED_FONT_FAMILIES: readonly ["Georgia"];
+/**
+ * `@cueframe/composition/fonts`: the font surface, in three parts.
+ *
+ * `./fonts/bundledFaces` carries what files this build ships and the lookups over them;
+ * `./fonts/captionFaces` carries the caption face rule built on those facts. Both are re-exported
+ * here, so this module path stays the single import for all of it. What remains inline is the
+ * third part — deciding whether an arbitrary CSS font stack, anywhere in an authored document,
+ * names a family this build can draw at all.
+ */
+export * from "./fonts/bundledFaces.js";
+export * from "./fonts/captionFaces.js";
 export declare function isAvailableFontFamily(family: string): boolean;
-export declare function parseFontStack(value: string): string[];
 export declare function detectUnavailableFonts(value: unknown): string[];

package/dist/_members/composition/graphics-plan/schemas.d.ts

@@ -105,8 +105,8 @@ export declare const ElementRole: z.ZodEnum<{
 }>;
 export type ElementRole = z.infer<typeof ElementRole>;
 export declare const StyleRole: z.ZodEnum<{
-    heading: "heading";
     body: "body";
+    heading: "heading";
     accent: "accent";
     surface: "surface";
     "on-accent": "on-accent";
@@ -136,8 +136,8 @@ export declare const LayoutElement: z.ZodObject<{
         h: z.ZodNumber;
     }, z.core.$strip>;
     styleRole: z.ZodEnum<{
-        heading: "heading";
         body: "body";
+        heading: "heading";
         accent: "accent";
         surface: "surface";
         "on-accent": "on-accent";
@@ -186,8 +186,8 @@ export declare const LayoutPlan: z.ZodObject<{
             h: z.ZodNumber;
         }, z.core.$strip>;
         styleRole: z.ZodEnum<{
-            heading: "heading";
             body: "body";
+            heading: "heading";
             accent: "accent";
             surface: "surface";
             "on-accent": "on-accent";
@@ -425,8 +425,8 @@ export declare const GraphicsPlan: z.ZodObject<{
                 h: z.ZodNumber;
             }, z.core.$strip>;
             styleRole: z.ZodEnum<{
-                heading: "heading";
                 body: "body";
+                heading: "heading";
                 accent: "accent";
                 surface: "surface";
                 "on-accent": "on-accent";

package/dist/_members/composition/ops/types.d.ts

@@ -60,7 +60,7 @@ export interface TransitionConfig {
     [key: string]: unknown;
 }
 export interface LayoutConfig {
-    type: 'letterbox' | 'split-screen' | 'picture-in-picture' | 'photo-grid';
+    type: 'letterbox' | 'split-screen' | 'picture-in-picture' | 'photo-grid' | 'flex-layout';
     [key: string]: unknown;
 }
 export interface GlobalEffects {

package/dist/_members/composition/primitive-catalog/types.d.ts

@@ -20,6 +20,7 @@ export interface PrimitiveCatalogMeta {
     name: string;
     category: PrimitiveCategory;
     kind: PrimitiveKind;
+    graphics?: 'webgl';
     version: string;
     intent?: string;
     description?: string;

package/dist/_members/composition/projection/behind-readiness.d.ts

@@ -1,3 +1,6 @@
+/** The only packed co-view generation the current renderer may consume. */
+export declare const CURRENT_MATTE_BAKE_VERSION = "birefnet-portrait-coview-h264-v14-rvm-2026.08.27";
+export declare function isCurrentMatteBakeVersion(version: string | undefined): boolean;
 export interface MatteIntentLike {
     startSec: number;
     endSec: number;

package/dist/_members/composition/projection/brandKit.d.ts

@@ -23,6 +23,11 @@ export interface ResolvedBrandKit {
         primary: string;
         secondary: string;
         accent: string;
+        accentStrong: string;
+        accentSoft: string;
+        success: string;
+        warning: string;
+        danger: string;
         background: string;
         text: string;
         textMuted: string;
@@ -46,6 +51,7 @@ export interface ResolvedBrandKit {
         entranceStaggerMs?: number;
         exitMs?: number;
         fontFamily?: string;
+        fontWeight?: number;
         emphasisFontFamily?: string;
         emphasisScale?: number;
         emphasisFontWeight?: number;

package/dist/_members/composition/projection/composition-floor.d.ts

@@ -1,5 +1,5 @@
 export { apcaLc } from "../../brand-derivation/index.js";
-export declare const FLOOR_VERSION = "floor-v6-2026.06.09";
+export declare const FLOOR_VERSION = "floor-v7-2026.09.09";
 export interface Rect {
     x: number;
     y: number;
@@ -144,6 +144,7 @@ interface Blockers {
     faceKeepOut: Rect[];
     safeZones: Rect[];
 }
+export declare const CAPTION_BOTTOM_INSET = 0.06;
 export declare function placeInLegalArea(el: PlaceReq, b: Blockers): Rect | null;
 export declare function resolveCaptionRegion(input: {
     aspect: string;

package/dist/_members/composition/scene/animation.d.ts

@@ -0,0 +1,25 @@
+import type { SceneCameraV2, SceneChannelV2, SceneObjectV2, SceneRigV2, SceneShotSpecV2, SceneTransformV2 } from './schema.js';
+export type SceneMatrix4V2 = readonly [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+export type EvaluatedSceneObjectV2 = SceneObjectV2 & {
+    /** Product of every world ancestor and this object's local transform. Null for screen text. */
+    worldMatrix: SceneMatrix4V2 | null;
+    /** Product of every ancestor opacity and this object's evaluated local opacity. */
+    worldOpacity: number;
+    children?: EvaluatedSceneObjectV2[];
+};
+export interface EvaluatedSceneV2 {
+    u: number;
+    contentFrame: number;
+    camera: SceneCameraV2;
+    environment: SceneRigV2;
+    focus: SceneShotSpecV2['post']['focus'];
+    layers: EvaluatedSceneObjectV2[];
+}
+export declare function contentFrame(frame: number, durationInFrames: number): number;
+export declare function normalizedTime(frame: number, durationInFrames: number): number;
+/** CSS-compatible cubic bezier: solve x(u)=t, then return y(u). */
+export declare function cubicBezierEase(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+export declare function evaluateChannel(keyframes: SceneChannelV2['keyframes'], t: number): number;
+/** Three-native T * Rx * Ry * Rz * S, column-major. */
+export declare function sceneTransformMatrix(transform: SceneTransformV2): SceneMatrix4V2;
+export declare function evaluateScene(spec: SceneShotSpecV2, requestedFrame: number, durationInFrames: number): EvaluatedSceneV2;

package/dist/_members/composition/scene/budget.d.ts

@@ -0,0 +1,29 @@
+/** Pure Decision 5 allocation accounting shared by preparation and runtime admission. */
+import { MIB, SCENE_SURFACE_TEXTURE_BUDGET_BYTES, SCENE_CONTEXT_GL_BUDGET_BYTES, SCENE_RENDER_JOB_BUDGET_BYTES, SCENE_MAX_TRIANGLES } from './budgetPolicy.mjs';
+export { MIB, SCENE_SURFACE_TEXTURE_BUDGET_BYTES, SCENE_CONTEXT_GL_BUDGET_BYTES, SCENE_RENDER_JOB_BUDGET_BYTES, SCENE_MAX_TRIANGLES, };
+export declare const STUDIO_SHADOW_MAP_BUDGET = 4096;
+export declare const SCENE_TESSELLATION_VERSION = 1;
+export declare const SCENE_SLAB_BODY_TRIANGLES = 5484;
+export declare const SCENE_SLAB_CONTENT_FACE_TRIANGLES = 2;
+export declare const SCENE_SLAB_CONTENT_OFFSET = 0.6;
+export declare const SCENE_PRESET_TRIANGLES: Readonly<{
+    readonly laptop: 1954;
+    readonly phone: 3136;
+    readonly slab: 5486;
+    readonly page: 2;
+}>;
+export type ScenePreset = keyof typeof SCENE_PRESET_TRIANGLES;
+export type SceneTextureFormat = 'rgba8' | 'rgba16f' | 'rgba32f' | 'depth24';
+export interface SceneTextureAllocation {
+    width: number;
+    height: number;
+    format: SceneTextureFormat;
+    mipLevels: number;
+    faces?: number;
+    layers?: number;
+    samples?: number;
+}
+export declare function sceneFullMipLevels(width: number, height: number): number;
+export declare function sceneMipTexels(width: number, height: number, mipLevels: number): number;
+export declare function sceneTextureBytes(allocation: SceneTextureAllocation): number;
+export declare function sceneTriangleCount(presets: readonly ScenePreset[]): number;

package/dist/_members/composition/scene/budgetPolicy.d.mts

@@ -0,0 +1,13 @@
+export declare const MIB: number;
+export declare const SCENE_SURFACE_TEXTURE_BUDGET_BYTES: number;
+export declare const SCENE_CONTEXT_GL_BUDGET_BYTES: number;
+export declare const SCENE_RENDER_JOB_BUDGET_BYTES: number;
+export declare const SCENE_MAX_TRIANGLES: number;
+export declare const I0_ORIGINAL_BUDGET_FIXTURE: Readonly<{
+  face2xBytes: number;
+  face3xBytes: number;
+  generatedRigAndFocusBaselineBytes: number;
+  transitionOverlapBytes: number;
+  corrective2x: Readonly<{bakeScale: null; layoutWidth: number; layoutHeight: number}>;
+  corrective3x: Readonly<{bakeScale: 2; layoutWidth: number; layoutHeight: number}>;
+}>;