@ggui-ai/project-config 0.16.0 → 0.17.0

package/dist/theme.d.ts

@@ -326,6 +326,135 @@ export declare const ThemeDocumentV2: z.ZodObject<{
             }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    typeScale: z.ZodOptional<z.ZodObject<{
+        display: z.ZodOptional<z.ZodObject<{
+            size: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            weight: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"fontWeight">;
+                $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tracking: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            leading: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"number">;
+                $value: z.ZodNumber;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        h1: z.ZodOptional<z.ZodObject<{
+            size: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            weight: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"fontWeight">;
+                $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tracking: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            leading: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"number">;
+                $value: z.ZodNumber;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        h2: z.ZodOptional<z.ZodObject<{
+            size: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            weight: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"fontWeight">;
+                $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tracking: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            leading: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"number">;
+                $value: z.ZodNumber;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        body: z.ZodOptional<z.ZodObject<{
+            size: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            weight: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"fontWeight">;
+                $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tracking: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            leading: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"number">;
+                $value: z.ZodNumber;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        label: z.ZodOptional<z.ZodObject<{
+            size: z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            weight: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"fontWeight">;
+                $value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            tracking: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"dimension">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            leading: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"number">;
+                $value: z.ZodNumber;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    rhythm: z.ZodOptional<z.ZodObject<{
+        base: z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        section: z.ZodOptional<z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        inset: z.ZodOptional<z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     motion: z.ZodOptional<z.ZodObject<{
         transition: z.ZodRecord<z.ZodString, z.ZodObject<{
             $type: z.ZodLiteral<"transition">;
@@ -341,6 +470,64 @@ export declare const ThemeDocumentV2: z.ZodObject<{
             $value: z.ZodString;
             $description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        duration: z.ZodOptional<z.ZodObject<{
+            fast: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"duration">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            base: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"duration">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            slow: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodLiteral<"duration">;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        easing: z.ZodOptional<z.ZodObject<{
+            standard: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodString;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            emphasized: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodString;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            exit: z.ZodOptional<z.ZodObject<{
+                $type: z.ZodString;
+                $value: z.ZodString;
+                $description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        reduce: z.ZodOptional<z.ZodEnum<{
+            ignore: "ignore";
+            respect: "respect";
+        }>>;
+    }, z.core.$strict>>;
+    scrim: z.ZodOptional<z.ZodObject<{
+        tone: z.ZodUnion<readonly [z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>, z.ZodObject<{
+            $type: z.ZodLiteral<"color">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        opacity: z.ZodObject<{
+            $type: z.ZodLiteral<"number">;
+            $value: z.ZodNumber;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        blur: z.ZodObject<{
+            $type: z.ZodLiteral<"dimension">;
+            $value: z.ZodString;
+            $description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
     }, z.core.$strict>>;
     accessibility: z.ZodOptional<z.ZodObject<{
         focusRing: z.ZodOptional<z.ZodObject<{

package/dist/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../src/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,wBAAwB,CAAC;AA0PnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6C1B,CAAC;AAEH,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,eAAe,CAAC,SAAS,CAAC,CAE9C;AAYD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,CAmDpE"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../src/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,wBAAwB,CAAC;AAqYnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8D1B,CAAC;AAEH,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,iDAAiD;AACjD,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,eAAe,CAAC,SAAS,CAAC,CAE9C;AAYD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,CAmDpE"}

package/dist/theme.js

@@ -38,6 +38,7 @@
  * keys fail parse, the same discipline as `ggui.json`.
  */
 import { z } from 'zod';
+import { fontFaceDeclarationSchema } from '@ggui-ai/protocol';
 import { lightTheme } from '@ggui-ai/design/themes';
 // ─── Token leaves ────────────────────────────────────────────────────
 /** A CSS color string. `$value` is not structurally validated (hex,
@@ -115,27 +116,6 @@ const StringToken = z.strictObject({
     $value: z.string().min(1),
     $description: z.string().optional(),
 });
-/** A declared font face (ggui#987 §5): `src` MUST be `https:` with a
- *  well-formed host — the same rule the design package asserts. */
-const FontFaceDeclarationSchema = z.strictObject({
-    family: z.string().min(1).refine((f) => !/[\r\n]/.test(f), 'family must be one line'),
-    src: z
-        .string()
-        .min(1)
-        .refine((src) => {
-        let url;
-        try {
-            url = new URL(src);
-        }
-        catch {
-            return false;
-        }
-        return url.protocol === 'https:' && /^[a-z0-9.-]+$/i.test(url.hostname) && url.hostname.includes('.');
-    }, 'src must be an https: URL with a well-formed host'),
-    weight: z.union([z.string().min(1), z.number().int().min(1).max(1000)]).optional(),
-    style: z.string().min(1).optional(),
-    display: z.string().min(1).optional(),
-});
 // ─── Groups ──────────────────────────────────────────────────────────
 /**
  * A "palette" group — a record of color tokens keyed by scale step
@@ -205,7 +185,8 @@ const FontGroup = z.strictObject({
 });
 /** Declared font faces (ggui#987 §5). */
 const TypographyGroup = z.strictObject({
-    faces: z.array(FontFaceDeclarationSchema).optional(),
+    /** The ONE face grammar — `@ggui-ai/protocol`'s `fontFaceDeclarationSchema` (ggui#1093): the document door and the AppTheme wire's `fonts` validate identically. */
+    faces: z.array(fontFaceDeclarationSchema).optional(),
 });
 /**
  * Shape group — `radius` + `shadow`. Moved here from the previous
@@ -222,9 +203,155 @@ const ShapeGroup = z.strictObject({
  * (optional). Durations and easings are not ladders any more: they ride
  * each transition's own value.
  */
+/**
+ * The HOST DESIGN LANGUAGE's document members (ggui#1093 P1b, #1075 Track C (a);
+ * grammar co-signed with rnd 2026-09-15). These are DOCUMENT tokens, never wire
+ * members: they reach the card through `deriveThemeVariables` → the overlay,
+ * which stays the ONE projection (`docs/principles/mcp-apps-compliance.md`).
+ * Every group is OPTIONAL and absent ⇒ the document parses exactly as before
+ * (INVARIANT 1: no declaration, byte-identical output).
+ */
+/**
+ * One type role. `size` is required; `leading` is a RATIO (`NumberToken`) and
+ * never a length — the projection writes `line-height: <ratio>`, which survives
+ * a size change, while a length leading breaks the moment the role's size moves.
+ */
+const TypeScaleRole = z.strictObject({
+    size: DimensionToken,
+    weight: FontWeightToken.optional(),
+    tracking: DimensionToken.optional(),
+    leading: NumberToken.optional(),
+});
+/**
+ * PRECEDENCE, and the ONE sentence that governs every member in this group
+ * (ggui#1093 R1, ruled with rnd 2026-09-16): **a host-design-language member
+ * overrides the base document's corresponding ladder.** A stated `typeScale`
+ * role beats the `font.ramp` stop that would have generated it; a stated
+ * `rhythm.base` beats the `spacing` stops it re-derives. Those two read as
+ * opposite directions (role over scale, scale over rungs) and are not: in
+ * both, the member the HOST measured wins over the ladder ggui supplied.
+ *
+ * The asymmetry that makes the sentence necessary: a `typeScale` role IS a
+ * rung, so it wins its own stop and leaves the others to the ramp — a harvest
+ * that measured only `h1` and `body` must not blank the rest. A `rhythm.base`
+ * is a statement about the SCALE, and every real document already carries
+ * spacing stops (the base theme supplies them), so "stated stop wins" would
+ * make the member inert on every document a harvest can produce.
+ *
+ * Nothing is lost by it: a document needing one bespoke step states no
+ * rhythm, and an app needing one pinned value has `AppTheme.cssVariables`,
+ * which overrides the whole projection at the overlay layer.
+ *
+ * CONTRACTED AHEAD OF THEIR CONSUMERS — read this before assuming a stated
+ * member changes a pixel. A member may be contracted before its consumer
+ * exists; a VARIABLE may not enter the consumed-token manifest before its
+ * consumer exists (a name nothing reads is coverage debt, not a feature).
+ * Today that makes three of these members STATED, STORED and NOT YET
+ * VISIBLE: the role-named type families and `scrim` arrive with their
+ * consumers (ggui#1075 Track C (b), ggui#1083), and `motion` with
+ * **ggui#1106** — the card's motion is build-time constants in the
+ * primitives, so no `--ggui-motion-*` variable exists to project onto yet
+ * (the manifest carries 122 tokens and none of them is motion). A writer
+ * may declare all of them now, which is the point of contracting first;
+ * nobody should read the contract as shipping the behaviour.
+ */
+/** The five type roles; `display` is the poster-scale role a host page leads with. */
+const TypeScaleGroup = z.strictObject({
+    display: TypeScaleRole.optional(),
+    h1: TypeScaleRole.optional(),
+    h2: TypeScaleRole.optional(),
+    body: TypeScaleRole.optional(),
+    label: TypeScaleRole.optional(),
+});
+/**
+ * The spacing base a rhythm re-derives its scale from: a positive length in
+ * `px` (2–16) or `rem` / `em` (0.125–1, the same range at a 16px root). Other
+ * units and `calc()` are refused at the door — a base the reader cannot
+ * multiply is not a base.
+ */
+const RHYTHM_BASE_RE = /^(\d+(?:\.\d+)?)(px|rem|em)$/;
+function isRhythmBase(value) {
+    const m = RHYTHM_BASE_RE.exec(value);
+    if (m === null)
+        return false;
+    const n = Number(m[1]);
+    return m[2] === 'px' ? n >= 2 && n <= 16 : n >= 0.125 && n <= 1;
+}
+const RhythmBaseToken = DimensionToken.refine((t) => isRhythmBase(t.$value), 'rhythm.base must be a length in px (2–16) or rem/em (0.125–1)');
+/** `base` re-derives the spacing scale; `section` and `inset` are named steps. */
+const RhythmGroup = z.strictObject({
+    base: RhythmBaseToken,
+    section: DimensionToken.optional(),
+    inset: DimensionToken.optional(),
+});
+/** The CSS easing keywords a document may name. */
+const CSS_EASING_KEYWORDS = new Set(['linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out', 'step-start', 'step-end']);
+const CUBIC_BEZIER_RE = /^cubic-bezier\(\s*-?\d*\.?\d+\s*(?:,\s*-?\d*\.?\d+\s*){3}\)$/;
+const STEPS_RE = /^steps\(\s*\d+\s*(?:,\s*(?:jump-start|jump-end|jump-none|jump-both|start|end)\s*)?\)$/;
+/**
+ * An easing a projection can emit verbatim: a CSS keyword, a well-formed
+ * `cubic-bezier(a,b,c,d)`, or `steps(n[, position])`. Validated HERE so no
+ * reader has to clamp a string it cannot trust.
+ */
+function isCssEasing(value) {
+    return CSS_EASING_KEYWORDS.has(value) || CUBIC_BEZIER_RE.test(value) || STEPS_RE.test(value);
+}
+const EasingToken = z.strictObject({
+    $type: z.string().min(1),
+    $value: z.string().min(1).refine(isCssEasing, 'easing must be a CSS keyword, cubic-bezier(a,b,c,d) or steps(n[, position])'),
+    $description: z.string().optional(),
+});
+/**
+ * The per-app motion TEMPO OVERRIDE (ggui#1093 P1c; reverses the layer-1
+ * retirement of the theming spec §2.3, co-signed with rnd 2026-09-16).
+ *
+ * Layer-1 keeps the motion SCALE — the durations and easings the design
+ * system ships, which every card gets by default and no app may redefine
+ * wholesale. What a document may state is a BOUNDED tempo override, for a
+ * card that has to sit inside someone else's site: exactly the standing
+ * `palette` has (per-app forever, without that making colour "not
+ * layer-1"). The retired FREE-MAP ladders stay refused — three duration
+ * steps and three easing roles are admitted, and nothing else.
+ */
+const MotionDurationGroup = z.strictObject({
+    fast: DurationToken.optional(),
+    base: DurationToken.optional(),
+    slow: DurationToken.optional(),
+});
+const MotionEasingGroup = z.strictObject({
+    standard: EasingToken.optional(),
+    emphasized: EasingToken.optional(),
+    exit: EasingToken.optional(),
+});
+/**
+ * The scrim a host page's ground shows through (ggui#1083): `tone` is a word
+ * (`light` / `dark`) or a stated colour token, `opacity` a 0..1 ratio, `blur` a
+ * length. Absent ⇒ the completion derives it from the ground pair, so a
+ * builder who declares nothing still gets a scrim that matches their page.
+ */
+const ScrimGroup = z.strictObject({
+    tone: z.union([z.enum(['light', 'dark']), ColorToken]),
+    opacity: NumberToken.refine((t) => t.$value >= 0 && t.$value <= 1, 'scrim.opacity must be a ratio between 0 and 1'),
+    blur: DimensionToken,
+});
 const MotionGroup = z.strictObject({
     transition: z.record(z.string(), TransitionToken),
     keyframes: z.record(z.string(), StringToken).optional(),
+    /** Per-app tempo override — three steps, bounded (ggui#1093 P1c). */
+    duration: MotionDurationGroup.optional(),
+    /** Per-app easing override — three roles, each value validated at the door (ggui#1093 P1c). */
+    easing: MotionEasingGroup.optional(),
+    /**
+     * What the composer does under `prefers-reduced-motion: reduce`.
+     *
+     * Two defaults that must never be read as disagreeing (rnd, ggui#1093
+     * P1c): the DOOR does not stamp a value — absent stays absent, so the
+     * document never carries something its author did not write — and the
+     * COMPOSER's default is `respect`: it emits the reduced-motion rule
+     * unless a document explicitly says `ignore`. Absence therefore means
+     * "respect" downstream, without the wire inventing it.
+     */
+    reduce: z.enum(['respect', 'ignore']).optional(),
 });
 const AccessibilityGroup = z.strictObject({
     focusRing: z
@@ -305,9 +432,23 @@ export const ThemeDocumentV2 = z.strictObject({
     typography: TypographyGroup.optional(),
     /** Shape tokens — `radius` + `shadow`. Required. */
     shape: ShapeGroup,
-    /** Motion tokens — `duration` + `transition` (required sub-records),
-     *  `easing` + `keyframes` (optional sub-records). Optional. */
+    /** The five type ROLES of the host's design language (ggui#1093 P1b):
+     *  display / h1 / h2 / body / label, each `size` + optional weight,
+     *  tracking and a RATIO leading. Role-based, beside `font.ramp`'s
+     *  size-stop ladder — the projection reads a role when it is stated and
+     *  falls to the ramp when it is not. Optional. */
+    typeScale: TypeScaleGroup.optional(),
+    /** The host's spacing rhythm (ggui#1093 P1b): `base` re-derives the scale,
+     *  `section` / `inset` are named steps. Optional. */
+    rhythm: RhythmGroup.optional(),
+    /** Motion tokens — `transition` (required sub-record), `keyframes`, and
+     *  the bounded per-app TEMPO OVERRIDE (ggui#1093 P1c): `duration`
+     *  (fast/base/slow), `easing` (standard/emphasized/exit) and `reduce`.
+     *  The motion SCALE stays layer-1; the free-map ladders stay refused. */
     motion: MotionGroup.optional(),
+    /** The scrim between the host page's ground and the card (ggui#1093 P1b,
+     *  ggui#1083). Absent ⇒ derived from the ground pair. Optional. */
+    scrim: ScrimGroup.optional(),
     /** Accessibility tokens (focus ring, reduced motion, high contrast).
      *  Optional. */
     accessibility: AccessibilityGroup.optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/project-config",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Schema and loader for `ggui.json` — the portable app/agent manifest for the ggui protocol. Vendor-neutral. Consumed by the `ggui` CLI and any host that reconstitutes an agent from the manifest.",
   "keywords": [
     "ggui",
@@ -33,8 +33,8 @@
   "dependencies": {
     "tinyglobby": "^0.2.16",
     "zod": "^4.3.6",
-    "@ggui-ai/design": "0.16.0",
-    "@ggui-ai/protocol": "0.16.0"
+    "@ggui-ai/design": "0.17.0",
+    "@ggui-ai/protocol": "0.17.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",