@cueframe/kernel 0.2.2 → 0.2.4

package/dist/_members/mcp/generated/sceneContract.d.ts

@@ -0,0 +1,155 @@
+/**
+ * AUTO-GENERATED — do not edit by hand.
+ *
+ * Sources: packages/composition/src/scene/generated/schema.json (the canonical SceneShotSpecV2
+ * JSON schema, itself generated from packages/composition/src/scene/schema.ts), the agent-facing
+ * description vendored with it at api/openapi.json#/components/schemas/SceneShotSpecV2, and
+ * SCENE_SHOT_EXAMPLES from packages/composition/src/scene/examples.ts.
+ * Generator: packages/mcp/scripts/generate-scene-contract.ts
+ * Re-run: `pnpm generate:api-consumers` from the repo root.
+ *
+ * `@cueframe/mcp` cannot depend on `@cueframe/composition`, so the scene contract is copied here
+ * rather than imported — by a generator, gated by `pnpm check:api-consumer-drift`, so the copy
+ * cannot drift silently. The schema below is the canonical document byte-for-byte, plus the
+ * `description` annotation the public contract carries for it; nothing is weakened or restated.
+ */
+/** The canonical SceneShotSpecV2 JSON schema, served verbatim at `cueframe://scene-shot`. */
+export declare const SCENE_SHOT_SCHEMA: Readonly<Record<string, unknown>>;
+/** Agent-facing prose kept outside the canonical schema document. */
+export declare const SCENE_SHOT_SCHEMA_DESCRIPTION = "A version-2 scene shot: a self-contained 3D world-object shot that scene.add / scene.update materializes into an ordinary component clip. The shot owns its layers, camera, lighting, backdrop and normalized local animation; the composition owns start, duration, ordering, cuts and transitions. Coordinates are REFERENCE PIXELS: origin at frame centre, +X right, +Y down, +Z toward the viewer. referenceSize must have the SAME aspect ratio as the composition format; mismatch fails instead of cropping. At equal aspect ratio the shot scales uniformly by outputWidth/referenceWidth. A segment's easing belongs to the keyframe it ARRIVES at; the first keyframe has no easing. Authoring limits: 32 layers, 4 devices, 16 distinct image slots, 256 keyframes per channel, 2048 keyframes per shot. Version 2 supports nested groups, procedural slab/page/phone/laptop objects, screen- and world-space text, admitted image/component/video surfaces, fixed photographic and generated studio environments, transparent/solid/linear/radial backdrops, constraints, focus, grain and vignette. Raw HTML, custom shader props, imported GLB models, arbitrary external HDR environments, skeletal animation and physics are refused with an exact field path.";
+/** What each shot in the published example demonstrates, per clip. */
+export declare const SCENE_SHOT_EXAMPLE_SHOTS: readonly [{
+    readonly clipId: "shot-world-objects";
+    readonly exampleId: "world-objects";
+    readonly title: "World objects";
+    readonly summary: "Nested satin card and fitted page.";
+    readonly slots: readonly ["page"];
+}];
+/**
+ * A complete `apply_composition` body: one slab-heavy nested world-object shot on a dedicated
+ * scene track, followed by a revision that changes its admitted page asset and duration. The
+ * `scene` payload is the canonical example verbatim.
+ */
+export declare const SCENE_SHOT_WORLD_OBJECT_BODY: {
+    readonly ops: readonly [{
+        readonly type: "scene.add";
+        readonly clipId: "shot-world-objects";
+        readonly newTrack: true;
+        readonly startTime: 0;
+        readonly duration: 6;
+        readonly scene: {
+            readonly version: 2;
+            readonly referenceSize: {
+                readonly width: 1920;
+                readonly height: 1080;
+            };
+            readonly environment: {
+                readonly kind: "photographic-studio-v1";
+            };
+            readonly backdrop: {
+                readonly kind: "solid";
+                readonly color: "$brand:colors.background";
+            };
+            readonly layers: readonly [{
+                readonly kind: "group";
+                readonly id: "cards";
+                readonly transform: {
+                    readonly position: readonly [0, 0, 0];
+                    readonly rotation: readonly [0, 0, 0];
+                    readonly scale: 1;
+                };
+                readonly opacity: 1;
+                readonly children: readonly [{
+                    readonly kind: "slab";
+                    readonly id: "hero";
+                    readonly transform: {
+                        readonly position: readonly [0, 0, 0];
+                        readonly rotation: readonly [0, 0, 0];
+                        readonly scale: 1;
+                    };
+                    readonly opacity: 1;
+                    readonly width: 720;
+                    readonly height: 900;
+                    readonly thickness: 32;
+                    readonly cornerRadius: 32;
+                    readonly edgeRadius: 15;
+                    readonly finish: "satin";
+                    readonly surfaces: {
+                        readonly front: {
+                            readonly source: "component";
+                            readonly component: {
+                                readonly version: 1;
+                                readonly componentId: "hero-card";
+                                readonly sourceVersionId: "0000000000000000000000000000000000000000000000000000000000000000";
+                            };
+                            readonly captureFrame: 12;
+                            readonly layout: {
+                                readonly width: 720;
+                                readonly height: 900;
+                            };
+                        };
+                    };
+                }, {
+                    readonly kind: "page";
+                    readonly id: "page";
+                    readonly transform: {
+                        readonly position: readonly [760, 0, -20];
+                        readonly rotation: readonly [0, 0, 0];
+                        readonly scale: 1;
+                    };
+                    readonly opacity: 1;
+                    readonly width: 640;
+                    readonly height: 800;
+                    readonly fit: "contain";
+                    readonly transparency: "straight";
+                    readonly depthWrite: true;
+                    readonly backface: "hidden";
+                    readonly surfaces: {
+                        readonly content: {
+                            readonly source: "image";
+                            readonly assetSlot: "page";
+                        };
+                    };
+                }];
+            }];
+            readonly animation: readonly [{
+                readonly target: {
+                    readonly kind: "layer";
+                    readonly layerId: "cards";
+                };
+                readonly property: "rotationY";
+                readonly keyframes: readonly [{
+                    readonly at: 0;
+                    readonly value: 0;
+                }, {
+                    readonly at: 1;
+                    readonly value: 18.84955592153876;
+                    readonly easing: {
+                        readonly kind: "linear";
+                    };
+                }];
+            }];
+            readonly post: {
+                readonly grain: 0;
+                readonly vignette: 0;
+                readonly focus: null;
+            };
+            readonly constraints: readonly [];
+            readonly camera: {
+                readonly position: readonly [0, 0, 1483.6378065054962];
+                readonly rotation: readonly [0, 0, 0];
+                readonly fov: 0.6981317007977318;
+            };
+        };
+        readonly assets: {
+            readonly page: "<landingPageScreenshotMediaId>";
+        };
+    }, {
+        readonly type: "scene.update";
+        readonly clipId: "shot-world-objects";
+        readonly duration: 7;
+        readonly assets: {
+            readonly page: "<updatedLandingPageScreenshotMediaId>";
+        };
+    }];
+};

package/dist/_members/mcp/sceneShot.d.ts

@@ -0,0 +1,38 @@
+export declare const SCENE_SHOT_RESOURCE_URI = "cueframe://scene-shot";
+export declare const SCENE_SHOT_RESOURCE_DESCRIPTION: string;
+/** The V2 capability envelope, stated as the two lists an agent has to act on. */
+export declare const SCENE_SHOT_LIMITS: {
+    readonly supported: readonly ["nested groups and procedural slab, page, phone and laptop world objects", "admitted PNG/JPEG/WebP images, captured components and frame-addressed video surfaces", "procedural phone and laptop devices, with a laptop open angle in [0,180] degrees", "typed text in screen space or world space, with per-run colours for two-colour type", "one camera and either generated studio lighting or the fixed photographic studio environment", "a transparent, solid, linear-gradient or radial-gradient backdrop", "world-space focus, grain and vignette", "JSON numeric animation channels over camera, layer transform/opacity, laptop openAngle, environment intensity and focus"];
+    readonly notSupportedInV2: readonly ["raw HTML in a shot — a page is an ADMITTED SCREENSHOT; live HTML is never rasterized or injected", "custom shader props — no shader source enters through the scene spec", "imported models (GLB and friends) — devices are procedural only", "arbitrary external HDR environments — use the admitted fixed photographic rig or generated studio", "skeletal animation and physics", "animating topology, asset bindings, text content, font properties, device kind or colours — those are static within a shot; author a revised spec instead", "source trim/slip of generated animation — a resized clip resamples the same normalized channels"];
+    readonly authoringLimits: {
+        readonly layers: 32;
+        readonly devices: 4;
+        readonly distinctImageSlots: 16;
+        readonly keyframesPerChannel: 256;
+        readonly keyframesPerShot: 2048;
+        readonly note: "Oversized resources are refused with a path and a corrective message; nothing is silently resized to fit a budget.";
+    };
+};
+/** The behaviours agents most often get wrong, each phrased as the rule that fails the request. */
+export declare const SCENE_SHOT_RULES: {
+    readonly imageFormats: string;
+    readonly referenceAspect: string;
+    readonly screenVersusWorldText: string;
+    readonly lightingAndColour: string;
+    readonly timelineOwnership: string;
+    readonly animationEasing: string;
+    readonly focusIsPerPixelDepth: string;
+    readonly globalEffectScopeGap: string;
+    readonly catalogDiscovery: string;
+    readonly brandTokens: string;
+    readonly failures: string;
+};
+/**
+ * Every `$brand:` token the scene schema admits, grouped by family, read straight out of the
+ * SERVED schema's enums — i.e. out of the canonical `scene/schema.json` this resource carries.
+ * Never hand-listed: the composition contract's exported token constants are the source, and they
+ * reach here through schema.ts → schema.json → the generated copy in `./generated/sceneContract`.
+ */
+export declare function sceneBrandTokens(schema: unknown): Record<string, string[]>;
+/** The full discovery document served at `cueframe://scene-shot`. */
+export declare function sceneShotContract(): Record<string, unknown>;

package/dist/_members/mcp/sceneShotExample.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The canonical world-object scene example an agent can copy, plus the prose that explains where its
+ * placeholder media ids come from.
+ *
+ * NOTHING HERE IS HAND-INLINED. Both `scene` payloads are the canonical `SCENE_SHOT_EXAMPLES`
+ * specs published by `@cueframe/composition/scene`, copied verbatim into
+ * `./generated/sceneContract.js` by `packages/mcp/scripts/generate-scene-contract.ts` and gated by
+ * `pnpm check:api-consumer-drift`. `@cueframe/mcp` cannot depend on `@cueframe/composition`, so a
+ * copy is unavoidable; a *generated* copy cannot drift silently the way an inlined one can.
+ *
+ * Two tests hold the copy to the contract from both sides:
+ * `packages/authoring/src/scene/discoveryExample.test.ts` — the package that CAN import
+ * composition — parses every spec with `parseSceneShotSpecV2`, checks it against the generated
+ * `@cueframe/composition/scene/schema.json`, and asserts it still deep-equals the canonical
+ * example; `packages/mcp/src/sceneShot.test.ts` re-parses the whole batch through the GENERATED
+ * `applyCompositionBody` zod, i.e. the exact schema this server puts on the wire.
+ *
+ * To refresh after a contract change: run `pnpm generate:api-consumers`.
+ */
+export { SCENE_SHOT_EXAMPLE_SHOTS, SCENE_SHOT_WORLD_OBJECT_BODY, } from './generated/sceneContract.js';
+/** Where the placeholder media ids in the example come from. */
+export declare const SCENE_SHOT_ASSET_PROVENANCE: string;

package/dist/_members/media-model/api.d.ts

@@ -174,6 +174,7 @@ export declare const MediaItem: z.ZodObject<{
         video: "video";
         audio: "audio";
         image: "image";
+        data: "data";
     }>;
     filename: z.ZodString;
     mimeType: z.ZodString;

package/dist/_members/media-model/media-kind.d.ts

@@ -1,4 +1,4 @@
-export type MediaKind = "video" | "audio" | "image" | "opaque";
+export type MediaKind = "video" | "audio" | "image" | "data" | "opaque";
 export declare const IMAGE_CONTENT_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
 export declare const ALLOWED_CONTENT_TYPES: readonly ["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"];
 export type AllowedContentType = (typeof ALLOWED_CONTENT_TYPES)[number];

package/dist/_members/media-model/testing/mediaStoreContract.d.ts

@@ -1,4 +1,4 @@
-export type ContractPoolKind = 'video' | 'audio' | 'image';
+export type ContractPoolKind = 'video' | 'audio' | 'image' | 'data';
 export interface ContractPoolItem {
     id: string;
     name: string;

package/dist/_members/primitives/effects/index.d.ts

@@ -7,6 +7,7 @@ export { Particles } from './particles/index.js';
 export { PulsingIndicator } from './pulsing-indicator/index.js';
 export { SpotlightCard } from './spotlight-card/index.js';
 export { SpringPopIn } from './spring-pop-in/index.js';
+export { StageCameraEffect, laneDepths } from './stage-camera/index.js';
 export { SuccessConfetti } from './success-confetti/index.js';
 export { Vignette } from './vignette/index.js';
 export declare const catalog: Catalog;

package/dist/_members/primitives/effects/stage-camera/config.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PrimitiveMeta } from '../../lib/types.js';
+declare const paramsSchema: z.ZodObject<{
+    move: z.ZodDefault<z.ZodEnum<{
+        static: "static";
+        "dolly-in": "dolly-in";
+        "dolly-out": "dolly-out";
+        drift: "drift";
+        "tilt-reveal": "tilt-reveal";
+        orbit: "orbit";
+    }>>;
+    fov: z.ZodDefault<z.ZodNumber>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    easing: z.ZodDefault<z.ZodEnum<{
+        emphasis: "emphasis";
+        playful: "playful";
+        none: "none";
+        exit: "exit";
+        entrance: "entrance";
+        cross: "cross";
+        drama: "drama";
+    }>>;
+    from: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        z: z.ZodOptional<z.ZodNumber>;
+        rotX: z.ZodOptional<z.ZodNumber>;
+        rotY: z.ZodOptional<z.ZodNumber>;
+        rotZ: z.ZodOptional<z.ZodNumber>;
+        fov: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    to: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        z: z.ZodOptional<z.ZodNumber>;
+        rotX: z.ZodOptional<z.ZodNumber>;
+        rotY: z.ZodOptional<z.ZodNumber>;
+        rotZ: z.ZodOptional<z.ZodNumber>;
+        fov: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    focus: z.ZodOptional<z.ZodObject<{
+        z: z.ZodNumber;
+        range: z.ZodNumber;
+        maxBlur: z.ZodNumber;
+    }, z.core.$strip>>;
+    layerDepth: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+type Params = z.infer<typeof paramsSchema>;
+export declare const config: PrimitiveMeta<Params>;
+export {};

package/dist/_members/primitives/effects/stage-camera/index.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { type CameraMove, type FocusSpec, type StageCamera } from '../../../animate/index.js';
+import { type EasingIntent } from '../../lib/easings.js';
+export interface StageCameraEffectProps {
+    move?: CameraMove;
+    fov?: number;
+    amount?: number;
+    easing?: EasingIntent;
+    from?: Partial<StageCamera>;
+    to?: Partial<StageCamera>;
+    focus?: FocusSpec;
+    layerDepth?: number;
+    /** Wrap protocol (render-entry WrapEffects). */
+    active?: boolean;
+    effectFrame?: number;
+    effectDurationInFrames?: number;
+    style?: React.CSSProperties;
+    /** Stage size; defaults to the video frame. */
+    width?: number;
+    height?: number;
+    children?: React.ReactNode;
+}
+/** z for each child: tagged lanes are spaced by `layerDepth`, the front-most lane at 0. */
+export declare function laneDepths(children: React.ReactNode, layerDepth: number): number[];
+/**
+ * Uniform scale that cancels the perspective foreshortening of a lane at depth `z`: a layer
+ * there projects at `P / (P - z)`, so `(P - z) / P` restores the size it would have at z=0.
+ * Lanes therefore stay full-bleed at the rest camera and parallax only when the camera moves.
+ */
+export declare function laneScale(z: number, fov: number, height: number): number;
+export declare const StageCameraEffect: React.FC<StageCameraEffectProps>;

package/dist/_members/primitives/layouts/flex-layout/config.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { PrimitiveMeta } from '../../lib/types.js';
+declare const paramsSchema: z.ZodObject<{
+    direction: z.ZodDefault<z.ZodEnum<{
+        column: "column";
+        row: "row";
+    }>>;
+    gap: z.ZodDefault<z.ZodNumber>;
+    padding: z.ZodDefault<z.ZodNumber>;
+    tracks: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        split: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            weight: z.ZodNumber;
+            basis: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            shrink: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        weight: z.ZodNumber;
+        basis: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        shrink: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        weight: z.ZodNumber;
+        basis: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        shrink: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>>;
+    tracksEnd: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        split: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            weight: z.ZodNumber;
+            basis: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            shrink: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        weight: z.ZodNumber;
+        basis: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        shrink: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        weight: z.ZodNumber;
+        basis: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        shrink: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>>;
+    fits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        mode: z.ZodEnum<{
+            position: "position";
+            stretch: "stretch";
+            contain: "contain";
+            cover: "cover";
+            scale: "scale";
+            matte: "matte";
+        }>;
+        aspect: z.ZodOptional<z.ZodNumber>;
+        size: z.ZodOptional<z.ZodObject<{
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>>;
+        anchor: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>>;
+    outline: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$loose>;
+type Params = z.infer<typeof paramsSchema>;
+export declare const config: PrimitiveMeta<Params>;
+export {};

package/dist/_members/primitives/layouts/flex-layout/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { type FlexLayoutProps } from '../../../animate/index.js';
+export { buildTree, unionTracks, weightsAt, type FlexTrack, type FlexTrackSpec, type FlexLayoutProps, } from '../../../animate/index.js';
+export declare const FlexLayout: React.FC<FlexLayoutProps>;

package/dist/_members/primitives/layouts/index.d.ts

@@ -1,5 +1,6 @@
 import type { Catalog } from '../lib/types.js';
 export { ChatToPreviewLayout } from './chat-to-preview-layout/index.js';
+export { FlexLayout } from './flex-layout/index.js';
 export { InfiniteBentoPan } from './infinite-bento-pan/index.js';
 export { Letterbox } from './letterbox/index.js';
 export { PhotoGrid } from './photo-grid/index.js';

package/dist/_members/primitives/layouts/picture-in-picture/config.d.ts

@@ -3,8 +3,8 @@ import type { PrimitiveMeta } from '../../lib/types.js';
 declare const paramsSchema: z.ZodObject<{
     position: z.ZodDefault<z.ZodEnum<{
         "top-left": "top-left";
-        "top-right": "top-right";
         "bottom-left": "bottom-left";
+        "top-right": "top-right";
         "bottom-right": "bottom-right";
     }>>;
     size: z.ZodDefault<z.ZodNumber>;

package/dist/_members/primitives/lib/frameScale.d.ts

@@ -0,0 +1,4 @@
+/** Pixel values in this catalog were authored against a 1280-wide frame. */
+export declare const FRAME_BASELINE_WIDTH = 1280;
+export declare function frameScale(width: number, baseline?: number): number;
+export declare function useFrameScale(baseline?: number): number;

package/dist/_members/primitives/lib/index.d.ts

@@ -1,6 +1,7 @@
 export type { PrimitiveMeta, PrimitiveCategory, PrimitiveKind, Mood, Example, TokenBinding, PrimitivePreview as PrimitivePreviewMeta, Catalog, } from './types.js';
 export { SOFT, OUT_EXPO, OUT_BACK, OUT_CUBIC, IN_OUT_CUBIC, IN_OUT_QUART, IN_QUART, LINEAR, STEP, EASING_BY_INTENT, type EasingIntent, } from './easings.js';
 export { pick, range, gauss, SeededPRNG } from './seeded-random.js';
+export { frameScale, useFrameScale, FRAME_BASELINE_WIDTH } from './frameScale.js';
 export { resolveTokenValue, applyBrandCascade, resolveParams, isContrastCritical, CONTRAST_CRITICAL_PATHS, ALLOWED_BRAND_PATHS, FROZEN_CORE_PATHS, TIER2B_EXTENSION_PATHS, lintBrandPath, } from './tokens.js';
 export { NEUTRAL_RAMP } from '../../brand-derivation/constants.js';
 export { zodToJsonSchemaFor, zodToDefaults, zodToControls, type ControlConfig, type ControlType, } from './schema.js';

package/dist/_members/primitives/lib/palette.d.ts

@@ -1,33 +1,33 @@
-export declare const BG_DEEP = "#0f0b07";
-export declare const BG = "#14100c";
-export declare const SURFACE = "#1c1611";
-export declare const SURFACE_HI = "#241d16";
-export declare const BORDER = "#2e2620";
-export declare const BORDER_SOFT = "rgba(244,236,224,0.10)";
-export declare const BORDER_STRONG = "#3a3128";
-export declare const TEXT_HI = "#f4ece0";
-export declare const TEXT = "#e4dccf";
-export declare const TEXT_MUTED = "#b8a894";
-export declare const TEXT_FAINT = "#7a6f63";
-export declare const ACCENT = "#f2913c";
-export declare const ACCENT_STRONG = "#e8782b";
-export declare const ACCENT_DEEP = "#b0501c";
-export declare const ACCENT_SOFT = "#ffb38e";
-export declare const SUCCESS = "#7fae7a";
-export declare const SUCCESS_SOFT = "#a7c8a1";
-export declare const DANGER = "#d1685e";
-export declare const WARNING = "#e0a355";
-export declare const BLUE = "#7b93b0";
-export declare const VIOLET = "#9b8bb0";
-export declare const TEAL = "#5fa5a0";
-export declare const SERIES: readonly ["#f2913c", "#5fa5a0", "#7b93b0", "#9b8bb0", "#7fae7a", "#e0a355"];
-export declare const SYN_TEXT = "#e4dccf";
-export declare const SYN_COMMENT = "#7a6f63";
-export declare const SYN_KEYWORD = "#c99ac0";
-export declare const SYN_STRING = "#9cb887";
-export declare const SYN_NUMBER = "#dcae6a";
-export declare const SYN_FN = "#e8934f";
-export declare const SYN_PROP = "#7fa8b0";
+export declare const BG_DEEP = "#050507";
+export declare const BG = "#0b0b0e";
+export declare const SURFACE = "#141418";
+export declare const SURFACE_HI = "#1b1b1f";
+export declare const BORDER = "#26262e";
+export declare const BORDER_SOFT = "rgba(255,255,255,0.08)";
+export declare const BORDER_STRONG = "#34343e";
+export declare const TEXT_HI = "#F5F5F7";
+export declare const TEXT = "#e4e4e9";
+export declare const TEXT_MUTED = "#9b9ba6";
+export declare const TEXT_FAINT = "#62626d";
+export declare const ACCENT = "#6f7dff";
+export declare const ACCENT_STRONG = "#5566f2";
+export declare const ACCENT_DEEP = "#3d4ac7";
+export declare const ACCENT_SOFT = "#a7b0ff";
+export declare const SUCCESS = "#5ec48a";
+export declare const SUCCESS_SOFT = "#9ddcb8";
+export declare const DANGER = "#ef6a5e";
+export declare const WARNING = "#e9b84a";
+export declare const BLUE = "#6aa6ff";
+export declare const VIOLET = "#a48cff";
+export declare const TEAL = "#4fc8c4";
+export declare const SERIES: readonly ["#6f7dff", "#4fc8c4", "#6aa6ff", "#a48cff", "#5ec48a", "#e9b84a"];
+export declare const SYN_TEXT = "#e4e4e9";
+export declare const SYN_COMMENT = "#62626d";
+export declare const SYN_KEYWORD = "#c792ea";
+export declare const SYN_STRING = "#9ece6a";
+export declare const SYN_NUMBER = "#f0b46a";
+export declare const SYN_FN = "#82aaff";
+export declare const SYN_PROP = "#7dcfff";
 export declare const MAC_RED = "#ff5f57";
 export declare const MAC_YELLOW = "#febc2e";
 export declare const MAC_GREEN = "#28c840";

package/dist/_members/primitives/lib/text/contrast.d.ts

@@ -2,7 +2,8 @@ export interface ContrastResult {
     textColor: string;
     textShadow: string;
 }
-export declare const FLOOR_TEXT = "#F7F2EA";
+/** The house text floor. Derived so it can never drift from the palette's primary text colour. */
+export declare const FLOOR_TEXT = "#F5F5F7";
 export declare const FLOOR_SHADOW = "0 1px 6px rgba(0,0,0,0.55)";
 export declare function resolveContrast(opts?: {
     brandTextOnMedia?: string;

package/dist/_members/primitives/lib/text/spec.d.ts

@@ -1,11 +1,3 @@
-export interface TextTypography {
-    fontFamily: string;
-    fontSizePct: number;
-    fontWeight: number;
-    fontStyle?: 'normal' | 'italic';
-    letterSpacing?: number;
-    textTransform?: 'none' | 'uppercase' | 'capitalize';
-}
 export interface TextRecolor {
     from: string;
     to: string;

package/dist/_members/primitives/lib/types.d.ts

@@ -32,6 +32,8 @@ export interface PrimitiveMeta<P = any> {
     kind: PrimitiveKind;
     version: string;
     effectPlacement?: 'wrap' | 'overlay';
+    /** Rendering capability the primitive needs beyond DOM. The render lane picks a GL backend from it. */
+    graphics?: 'webgl';
     intent: string;
     description: string;
     useWhen: string;

package/dist/_members/primitives/scenes/device-showcase/config.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { PrimitiveMeta } from '../../lib/types.js';
+declare const paramsSchema: z.ZodObject<{
+    device: z.ZodDefault<z.ZodEnum<{
+        laptop: "laptop";
+        phone: "phone";
+    }>>;
+    screenSrc: z.ZodOptional<z.ZodString>;
+    move: z.ZodDefault<z.ZodEnum<{
+        static: "static";
+        "dolly-in": "dolly-in";
+        "dolly-out": "dolly-out";
+        drift: "drift";
+        "tilt-reveal": "tilt-reveal";
+        orbit: "orbit";
+    }>>;
+    fov: z.ZodDefault<z.ZodNumber>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    easing: z.ZodDefault<z.ZodEnum<{
+        emphasis: "emphasis";
+        playful: "playful";
+        none: "none";
+        exit: "exit";
+        entrance: "entrance";
+        cross: "cross";
+        drama: "drama";
+    }>>;
+    finish: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodString>;
+    accentColor: z.ZodDefault<z.ZodString>;
+    openAngle: z.ZodDefault<z.ZodNumber>;
+    lighting: z.ZodDefault<z.ZodEnum<{
+        soft: "soft";
+        key: "key";
+        rim: "rim";
+    }>>;
+    speed: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+type Params = z.infer<typeof paramsSchema>;
+export declare const config: PrimitiveMeta<Params>;
+export {};

package/dist/_members/primitives/scenes/device-showcase/index.d.ts

@@ -0,0 +1,36 @@
+import { type CameraMove, type DeviceKind } from '../../../animate/index.js';
+import { type EasingIntent } from '../../lib/easings.js';
+export interface DeviceShowcaseProps {
+    device?: 'laptop' | 'phone';
+    screenSrc?: string;
+    move?: CameraMove;
+    fov?: number;
+    amount?: number;
+    easing?: EasingIntent;
+    finish?: string;
+    background?: string;
+    accentColor?: string;
+    openAngle?: number;
+    lighting?: 'soft' | 'key' | 'rim';
+    speed?: number;
+}
+/** Body width of the device in px: the laptop reads as a hero, the phone as an object in space. */
+export declare function deviceBodyWidth(kind: DeviceKind, frameWidth: number): number;
+/** Y offset of the device group in px. The laptop rides a touch high so the open lid centres. */
+export declare function deviceGroupY(kind: DeviceKind, frameHeight: number): number;
+/**
+ * Height of StudioRig's shadow floor: the device's own bottom edge.
+ *
+ * It has to come from the device's geometry, never from the frame height. The device is sized off
+ * the frame *width*, so a height-derived floor drifts the moment the aspect is not 16:9 — 365px of
+ * float for the laptop at 9:16, 585px for the phone — and a floating floor slides the contact
+ * shadow out from under the device and into the open frame as a detached band. That is exactly the
+ * unlit-placeholder tell this scene exists to kill.
+ *
+ * The laptop's underside comes from `laptopLayout`, the one statement of that layout, which the
+ * mesh and the scene renderer also read: this used to be a hand-copy of the same arithmetic, and a
+ * change to the mesh would have moved the device off this floor without a word. The phone's shell
+ * is centred on the group, so its underside is simply -h/2.
+ */
+export declare function deviceFloorY(kind: DeviceKind, frameWidth: number, frameHeight: number): number;
+export declare function DeviceShowcase({ device, screenSrc, move, fov, amount, easing, finish, background, accentColor, openAngle, lighting, speed, }: DeviceShowcaseProps): import("react").JSX.Element;

package/dist/_members/primitives/scenes/hero-device-assemble/config.d.ts

@@ -6,6 +6,7 @@ declare const paramsSchema: z.ZodObject<{
         laptop: "laptop";
         phone: "phone";
     }>>;
+    screenSrc: z.ZodOptional<z.ZodString>;
     accentColor: z.ZodDefault<z.ZodString>;
     speed: z.ZodDefault<z.ZodNumber>;
     className: z.ZodOptional<z.ZodString>;