mythik 0.0.1 → 0.1.0

package/dist/design/animation/validator.d.ts

@@ -0,0 +1,44 @@
+import type { ElementAnimations } from './types.js';
+import type { BlobInstance } from '../background/blobs/types.js';
+/**
+ * Hard cap on animations per trigger (array length). Exported for consumers
+ * that need to allocate per-trigger pools matching the validator (e.g. RN
+ * runners using `useSharedValueArray(HARD_PER_TRIGGER)`) — centralizing
+ * here prevents pool/validator drift when the cap changes.
+ */
+export declare const HARD_PER_TRIGGER = 6;
+export type AnimationValidationResult = {
+    warnings: string[];
+    errors: string[];
+};
+export declare function validateAnimationCaps(animations: ElementAnimations): AnimationValidationResult;
+/**
+ * Input surface for validateBackgroundCaps. Deliberately narrower than the
+ * full LayerBackground type — we only need counts and per-blob cap-relevant
+ * fields. Callers pass the relevant slice of their background config.
+ */
+export interface BackgroundValidationInput {
+    blobs?: readonly BlobInstance[];
+    /**
+     * Background layers. Only the length is examined; the `type` tag is kept
+     * in the type to keep the input surface self-documenting (it's always a
+     * LayerBackground.layers slice in practice).
+     */
+    layers?: ReadonlyArray<{
+        type: string;
+    }>;
+}
+/**
+ * Validate a background-layer spec against per-layer and per-blob caps.
+ *
+ * Threshold semantics: strictly-over (`>` not `>=`). `blobsSoft=8` means
+ * "up to 8 blobs is fine; 9+ warns"; `blobsHard=16` means "up to 16 is
+ * tolerable; 17+ errors". See file-header note on why this differs from
+ * validateAnimationCaps' `>=` convention.
+ *
+ * Motion-dimension hard cap (3) is effectively unreachable via a
+ * well-typed BlobInstance.motion (which admits only 3 keys) — kept for
+ * pattern symmetry and as a sentinel if a future dimension is added.
+ */
+export declare function validateBackgroundCaps(input: BackgroundValidationInput): AnimationValidationResult;
+//# sourceMappingURL=validator.d.ts.map

package/dist/design/animation/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/design/animation/validator.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,iBAAiB,EAAwD,MAAM,YAAY,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAiBjE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAIlC,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,iBAAiB,GAAG,yBAAyB,CA+C9F;AAID;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1C;AA0BD;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,yBAAyB,GAC/B,yBAAyB,CA+D3B"}

package/dist/design/animation/validator.js

@@ -0,0 +1,169 @@
+// Validator — soft/hard performance gates per master design spec.
+//
+// Two separate exported functions (same file, shared result shape):
+//
+//   - validateAnimationCaps: per-element animation caps
+//       animations per trigger (array length):  soft=3,  hard=6  (>= semantics)
+//       triggers with animations per element:   soft=5,  hard=7  (= all triggers)
+//       Also: web-only-recipe discoverability warnings.
+//
+//   - validateBackgroundCaps (Task 9): per-background-layer caps
+//       blobs per background:            soft=8,   hard=16    (>  semantics)
+//       layers per background:           soft=6,   hard=10    (>  semantics)
+//       custom-svg path length (chars):  soft=500, hard=2000  (>  semantics)
+//       motion dimensions per blob:      soft=2,   hard=3     (>  semantics)
+//
+// Note the threshold semantics asymmetry:
+//   validateAnimationCaps uses `length >= CAP` (at-or-over the cap triggers).
+//   validateBackgroundCaps uses `length >  CAP` (strictly above the cap
+//     triggers). The design spec tables for plan 2 vs plan 3 name the caps
+//     differently: plan 2's SOFT_PER_TRIGGER=3 means "at length 3, warn"
+//     (so length 2 is fine); plan 3's blobsSoft=8 means "up to 8 is fine,
+//     9+ warn" (so length 8 is at the cap, not over). Keeping both literal
+//     per their specs; the soft/hard field names document the boundary in
+//     each context.
+//
+// The caller decides whether to log warnings, throw on errors, or fail the
+// spec (e.g. `mythik validate` typically logs warnings and errors both).
+import { WEB_ONLY_RECIPES } from '../recipes/animations.js';
+function collectRecipeNames(value) {
+    const items = Array.isArray(value) ? value : [value];
+    const names = [];
+    for (const item of items) {
+        // AnimationRef and StateChangeAnimation both have an optional `recipe` field
+        const recipe = item.recipe;
+        if (typeof recipe === 'string')
+            names.push(recipe);
+    }
+    return names;
+}
+const SOFT_PER_TRIGGER = 3;
+/**
+ * Hard cap on animations per trigger (array length). Exported for consumers
+ * that need to allocate per-trigger pools matching the validator (e.g. RN
+ * runners using `useSharedValueArray(HARD_PER_TRIGGER)`) — centralizing
+ * here prevents pool/validator drift when the cap changes.
+ */
+export const HARD_PER_TRIGGER = 6;
+const SOFT_TRIGGERS = 5;
+const HARD_TRIGGERS = 7;
+export function validateAnimationCaps(animations) {
+    const warnings = [];
+    const errors = [];
+    const triggers = [
+        'mount', 'unmount', 'hover', 'focus', 'active', 'ambient', 'stateChange',
+    ];
+    let activeTriggerCount = 0;
+    for (const t of triggers) {
+        const val = animations[t];
+        if (val === undefined || val === null)
+            continue;
+        activeTriggerCount++;
+        const length = Array.isArray(val) ? val.length : 1;
+        if (length >= HARD_PER_TRIGGER) {
+            errors.push(`trigger '${t}' has ${length} animations — hard-cap (${HARD_PER_TRIGGER}) exceeded; split into multiple elements or compose into a single animation with more keyframes`);
+        }
+        else if (length >= SOFT_PER_TRIGGER) {
+            warnings.push(`trigger '${t}' has ${length} animations — soft-cap (${SOFT_PER_TRIGGER}) reached; review whether all are necessary`);
+        }
+        // Web-only recipe warning — silent no-op on RN until plan-3+ adds mapping.
+        for (const recipe of collectRecipeNames(val)) {
+            if (WEB_ONLY_RECIPES.has(recipe)) {
+                warnings.push(`trigger '${t}' uses web-only recipe '${recipe}' — no visual effect on React Native until per-platform shadow/filter mapping is added`);
+            }
+        }
+    }
+    if (activeTriggerCount >= HARD_TRIGGERS) {
+        errors.push(`element has ${activeTriggerCount} triggers with animations — hard-cap (${HARD_TRIGGERS}) exceeded; remove non-essential triggers`);
+    }
+    else if (activeTriggerCount >= SOFT_TRIGGERS) {
+        warnings.push(`element has ${activeTriggerCount} triggers with animations — soft-cap (${SOFT_TRIGGERS}) reached; consider consolidating`);
+    }
+    return { warnings, errors };
+}
+const BG_CAPS = {
+    blobsSoft: 8,
+    blobsHard: 16,
+    layersSoft: 6,
+    layersHard: 10,
+    customSvgPathSoft: 500,
+    customSvgPathHard: 2000,
+    motionDimsSoft: 2,
+    motionDimsHard: 3,
+};
+function countMotionDimensions(motion) {
+    if (!motion)
+        return 0;
+    // Explicit field checks (not `Object.values(motion).filter(Boolean)`)
+    // because the union admits only three keys — a literal check is both
+    // exhaustive and survives schema evolution (missing a new key here would
+    // need an intentional update, not silently undercount).
+    let n = 0;
+    if (motion.drift)
+        n++;
+    if (motion.rotate)
+        n++;
+    if (motion.scale)
+        n++;
+    return n;
+}
+/**
+ * Validate a background-layer spec against per-layer and per-blob caps.
+ *
+ * Threshold semantics: strictly-over (`>` not `>=`). `blobsSoft=8` means
+ * "up to 8 blobs is fine; 9+ warns"; `blobsHard=16` means "up to 16 is
+ * tolerable; 17+ errors". See file-header note on why this differs from
+ * validateAnimationCaps' `>=` convention.
+ *
+ * Motion-dimension hard cap (3) is effectively unreachable via a
+ * well-typed BlobInstance.motion (which admits only 3 keys) — kept for
+ * pattern symmetry and as a sentinel if a future dimension is added.
+ */
+export function validateBackgroundCaps(input) {
+    const warnings = [];
+    const errors = [];
+    const blobs = input.blobs ?? [];
+    if (blobs.length > BG_CAPS.blobsHard) {
+        errors.push(`blobs per background: ${blobs.length} exceeds hard-cap (${BG_CAPS.blobsHard}); split across multiple backgrounds or reduce count`);
+    }
+    else if (blobs.length > BG_CAPS.blobsSoft) {
+        warnings.push(`blobs per background: ${blobs.length} exceeds soft-cap (${BG_CAPS.blobsSoft}); review whether all are necessary`);
+    }
+    const layers = input.layers ?? [];
+    if (layers.length > BG_CAPS.layersHard) {
+        errors.push(`layers per background: ${layers.length} exceeds hard-cap (${BG_CAPS.layersHard}); consolidate layers or split across backgrounds`);
+    }
+    else if (layers.length > BG_CAPS.layersSoft) {
+        warnings.push(`layers per background: ${layers.length} exceeds soft-cap (${BG_CAPS.layersSoft}); review whether all are necessary`);
+    }
+    for (const blob of blobs) {
+        // custom-svg path length — only meaningful when the path came from a
+        // consumer. Curated shapes have their own catalog-sourced paths whose
+        // length is controlled by the framework, not the spec author.
+        if (blob.shape === 'custom-svg' && typeof blob.path === 'string') {
+            const len = blob.path.length;
+            if (len > BG_CAPS.customSvgPathHard) {
+                errors.push(`custom-svg path length: ${len} chars exceeds hard-cap (${BG_CAPS.customSvgPathHard}); simplify the path geometry`);
+            }
+            else if (len > BG_CAPS.customSvgPathSoft) {
+                warnings.push(`custom-svg path length: ${len} chars exceeds soft-cap (${BG_CAPS.customSvgPathSoft}); consider simplifying the path`);
+            }
+        }
+        const dims = countMotionDimensions(blob.motion);
+        // The hard-cap branch below is structurally unreachable via a
+        // well-typed BlobMotion (only three keys exist, so `dims` maxes at 3,
+        // equal to motionDimsHard; `>` requires strictly greater). Kept as a
+        // sentinel: if a future contributor adds a fourth motion dimension,
+        // bumping motionDimsHard here is the natural next step, and the
+        // path activates immediately.
+        /* c8 ignore next 4 — unreachable via well-typed input; sentinel branch */
+        if (dims > BG_CAPS.motionDimsHard) {
+            errors.push(`motion dimensions per blob: ${dims} exceeds hard-cap (${BG_CAPS.motionDimsHard}); remove non-essential motion`);
+        }
+        else if (dims > BG_CAPS.motionDimsSoft) {
+            warnings.push(`motion dimensions per blob: ${dims} exceeds soft-cap (${BG_CAPS.motionDimsSoft}); drift+rotate+scale together is visually heavy`);
+        }
+    }
+    return { warnings, errors };
+}
+//# sourceMappingURL=validator.js.map

package/dist/design/animation/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../../src/design/animation/validator.ts"],"names":[],"mappings":"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"}

package/dist/design/background/blobs/catalog.d.ts

@@ -0,0 +1,10 @@
+export type BlobShapeName = 'organic-1' | 'organic-2' | 'organic-3' | 'organic-4' | 'organic-5' | 'circle' | 'custom-svg';
+/** Names of catalog-backed shapes (excludes the user-provided `custom-svg`). */
+export type CuratedBlobName = Exclude<BlobShapeName, 'custom-svg'>;
+export interface BlobShapeDef {
+    name: BlobShapeName;
+    viewBox: string;
+    path: string;
+}
+export declare const BLOB_CATALOG: Record<CuratedBlobName, BlobShapeDef>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/design/background/blobs/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/design/background/blobs/catalog.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,aAAa,GACrB,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,QAAQ,GACR,YAAY,CAAC;AAEjB,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,YAAY,CAuC9D,CAAC"}

package/dist/design/background/blobs/catalog.js

@@ -0,0 +1,63 @@
+// Blob v2 — curated SVG shape catalog (plan 3 Task 5).
+//
+// Five hand-curated organic shapes + a perfect circle. `custom-svg` is a
+// sentinel value for the `BlobShapeName` union; it does NOT appear in this
+// catalog map — callers passing `shape: 'custom-svg'` must supply their own
+// path + viewBox (sanitized by resolveBlobLayer).
+//
+// Coordinate system: every curated shape uses the canonical `0 0 100 100`
+// viewBox so that `size` (px/%) scales predictably. Paths always close with
+// `Z` to guarantee fill behavior is well-defined regardless of the renderer.
+//
+// Aesthetic intent (informal — no literal copies of third-party assets):
+//   organic-1 → balanced rounded blob (four convex cubic segments)
+//   organic-2 → elongated diagonal blob (offset center of mass)
+//   organic-3 → asymmetric multi-lobe (all-cubic to avoid T-reflection cusps)
+//   organic-4 → horizontal flowing ribbon
+//   organic-5 → sharply asymmetric with one extended lobe
+//
+// Adding a new curated shape requires:
+//   1. Adding the member to `BlobShapeName` (union)
+//   2. Adding the catalog entry (viewBox + path)
+//   3. The type system enforces the map key matches `BlobShapeName` minus 'custom-svg'
+export const BLOB_CATALOG = {
+    'organic-1': {
+        name: 'organic-1',
+        viewBox: '0 0 100 100',
+        path: 'M50,10 C70,10 90,25 90,50 C90,70 75,90 55,90 C30,90 10,75 10,50 C10,28 28,10 50,10 Z',
+    },
+    'organic-2': {
+        name: 'organic-2',
+        viewBox: '0 0 100 100',
+        path: 'M20,25 C35,10 65,15 80,30 C90,45 85,65 70,80 C55,95 30,90 15,75 C5,55 10,40 20,25 Z',
+    },
+    // All-cubic path — avoids T-reflection cusp at the closure point that the
+    // previous Q+T variant risked producing. Asymmetric bounding box still
+    // yields a distinctive multi-lobe silhouette.
+    'organic-3': {
+        name: 'organic-3',
+        viewBox: '0 0 100 100',
+        path: 'M60,12 C82,18 92,36 84,58 C78,82 50,92 35,82 C18,72 12,50 22,34 C30,22 46,8 60,12 Z',
+    },
+    'organic-4': {
+        name: 'organic-4',
+        viewBox: '0 0 100 100',
+        path: 'M10,45 C25,25 45,35 55,50 C65,65 85,55 90,70 C75,90 45,85 30,75 C15,70 5,60 10,45 Z',
+    },
+    // Sharply asymmetric — one extended lower-right lobe reaching to x=95,
+    // compensated by an inset at upper-right (x=62). Intentionally reads as a
+    // distinct silhouette from organic-1 (which is near-convex and balanced).
+    'organic-5': {
+        name: 'organic-5',
+        viewBox: '0 0 100 100',
+        path: 'M18,20 C40,8 62,16 70,30 C58,42 70,58 95,68 C82,88 50,90 32,78 C12,66 5,42 18,20 Z',
+    },
+    // Single-subpath canonical circle. M moves to the leftmost point, two
+    // relative arcs each trace 180°; Z is meaningful (returns to M).
+    circle: {
+        name: 'circle',
+        viewBox: '0 0 100 100',
+        path: 'M5,50 a45,45 0 1,0 90,0 a45,45 0 1,0 -90,0 Z',
+    },
+};
+//# sourceMappingURL=catalog.js.map

package/dist/design/background/blobs/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../../../src/design/background/blobs/catalog.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,yEAAyE;AACzE,2EAA2E;AAC3E,4EAA4E;AAC5E,kDAAkD;AAClD,EAAE;AACF,0EAA0E;AAC1E,4EAA4E;AAC5E,6EAA6E;AAC7E,EAAE;AACF,yEAAyE;AACzE,mEAAmE;AACnE,gEAAgE;AAChE,8EAA8E;AAC9E,0CAA0C;AAC1C,0DAA0D;AAC1D,EAAE;AACF,uCAAuC;AACvC,oDAAoD;AACpD,iDAAiD;AACjD,uFAAuF;AAoBvF,MAAM,CAAC,MAAM,YAAY,GAA0C;IACjE,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,sFAAsF;KAC7F;IACD,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,qFAAqF;KAC5F;IACD,0EAA0E;IAC1E,uEAAuE;IACvE,8CAA8C;IAC9C,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,qFAAqF;KAC5F;IACD,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,qFAAqF;KAC5F;IACD,uEAAuE;IACvE,0EAA0E;IAC1E,0EAA0E;IAC1E,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,oFAAoF;KAC3F;IACD,sEAAsE;IACtE,iEAAiE;IACjE,MAAM,EAAE;QACN,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,aAAa;QACtB,IAAI,EAAE,8CAA8C;KACrD;CACF,CAAC"}

package/dist/design/background/blobs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './catalog.js';
+export * from './types.js';
+export { resolveBlobLayer } from './resolver.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/design/background/blobs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/design/background/blobs/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/dist/design/background/blobs/index.js

@@ -0,0 +1,5 @@
+// Blob v2 subsystem — public barrel.
+export * from './catalog.js';
+export * from './types.js';
+export { resolveBlobLayer } from './resolver.js';
+//# sourceMappingURL=index.js.map

package/dist/design/background/blobs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/design/background/blobs/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/dist/design/background/blobs/resolver.d.ts

@@ -0,0 +1,16 @@
+import type { BlobSpec, BlobV2Config } from './types.js';
+interface Palette {
+    primary: string;
+    accent: string;
+}
+/**
+ * Convert a BlobV2Config into an array of render-ready BlobSpec entries.
+ *
+ * Ordering: explicit-form blobs are emitted in the same order as the input
+ * array. Preset-form blobs are emitted in preset-defined order (Task 8).
+ *
+ * Ambiguous inputs ({ preset, blobs } both set): preset wins, dev warning.
+ */
+export declare function resolveBlobLayer(config: BlobV2Config, palette: Palette): BlobSpec[];
+export {};
+//# sourceMappingURL=resolver.d.ts.map

package/dist/design/background/blobs/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../../src/design/background/blobs/resolver.ts"],"names":[],"mappings":"AAoDA,OAAO,KAAK,EAMV,QAAQ,EACR,YAAY,EACb,MAAM,YAAY,CAAC;AASpB,UAAU,OAAO;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAqND;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,GACf,QAAQ,EAAE,CAuEZ"}

package/dist/design/background/blobs/resolver.js

@@ -0,0 +1,301 @@
+// Blob v2 — resolver (plan 3 Task 7 + 8).
+//
+// Pure function that converts a BlobV2Config into an array of BlobSpec ready
+// to render. Two input forms:
+//
+//   1. Explicit form (BlobV2Config.blobs[]): consumer declares each blob. The
+//      resolver applies defaults (opacity 1, blur 0), resolves palette
+//      keywords, looks up catalog shapes, and converts motion dimensions
+//      into ElementAnimations.ambient entries (Task 8).
+//
+//   2. Preset form (BlobV2Config.preset + palette + motion preset): framework
+//      picks the shape/position/size composition from a small curated
+//      registry. Motion preset identifiers ('drift-gentle'/'drift-fluid'/
+//      'drift-snappy'/'static') map to concrete BlobMotion values applied
+//      uniformly to every blob in the preset (Task 8).
+//
+// Ambiguous combinations ({ preset, blobs } both set): resolver prefers
+// `preset` and logs a dev warning. Documented in types.ts.
+//
+// Motion → ElementAnimations.ambient conversion (Task 8):
+//   Each of the three independent motion dimensions (drift / rotate / scale)
+//   becomes one InlineAnimation:
+//     - drift:  keyframes [0%/50%/100%] on translateX/Y; returns to origin via
+//               `direction: alternate` — symmetric (no visible snap-back).
+//     - rotate: keyframes [0%/100%] on rotate; alternate to avoid spinning.
+//     - scale:  keyframes [0%/100%] on scale;  alternate to breathe.
+//   All three use `iterations: 'infinite'` because blob motion is ambient
+//   (cosmetic, non-interactive, always on). When multiple dimensions are set
+//   we emit them as an array so the Layer 3 runner composes each on its own
+//   timeline. Single-dimension motion returns a scalar for ergonomics — the
+//   `AnimationRef | AnimationRef[]` union accepts both.
+//
+// Error policy (matches design spec "Error handling" table):
+//
+//   - `shape: 'custom-svg'` requires both `path` and `viewBox`. Dev: throws
+//     with field-specific message to surface the bug immediately. Prod:
+//     skips the malformed blob + console.warn — preserves app stability.
+//     Rationale: specs in prod come from the DB (should have passed
+//     validation); a crash would take the whole app down over one bad blob.
+//
+//   - Ambiguous { preset, blobs } both set: dev-only console.warn (no
+//     throw). Severity is lower than the custom-svg case because there's a
+//     defensible winner (preset), and no rendering is broken — just one
+//     of the two inputs is ignored. Contrast with useElementAnimations'
+//     mixed-key throw (Task 4): there, no defensible winner exists since
+//     trigger keys and context keys both carry meaning.
+//
+//   - Everything else is permissive: missing palette entries, out-of-range
+//     opacities, etc. are passed through unmodified; validator (Task 9)
+//     catches caps.
+import { BLOB_CATALOG } from './catalog.js';
+const IS_DEV = process.env.NODE_ENV !== 'production';
+function resolveColor(color, palette) {
+    if (color === 'primary')
+        return palette.primary;
+    if (color === 'accent')
+        return palette.accent;
+    return color;
+}
+/**
+ * Resolve a blob instance's shape to a complete BlobShapeDef.
+ *
+ * @returns BlobShapeDef on success.
+ * @returns null when the instance is malformed (custom-svg missing path or
+ *          viewBox) in production — caller should skip this blob. In dev,
+ *          throws instead to surface the malformation immediately.
+ */
+function resolveShape(instance) {
+    if (instance.shape === 'custom-svg') {
+        if (!instance.path) {
+            const msg = `resolveBlobLayer: shape='custom-svg' requires a non-empty path. ` +
+                `Got path=${JSON.stringify(instance.path)}.`;
+            if (IS_DEV)
+                throw new Error(msg);
+            // eslint-disable-next-line no-console
+            console.warn(msg);
+            return null;
+        }
+        if (!instance.viewBox) {
+            const msg = `resolveBlobLayer: shape='custom-svg' requires a non-empty viewBox. ` +
+                `Got viewBox=${JSON.stringify(instance.viewBox)}.`;
+            if (IS_DEV)
+                throw new Error(msg);
+            // eslint-disable-next-line no-console
+            console.warn(msg);
+            return null;
+        }
+        return {
+            name: 'custom-svg',
+            path: instance.path,
+            viewBox: instance.viewBox,
+        };
+    }
+    // Curated shape — catalog lookup is total over BlobShapeName minus
+    // 'custom-svg'. TS narrows `instance.shape` here.
+    return BLOB_CATALOG[instance.shape];
+}
+function resolveStyle(instance, palette) {
+    return {
+        position: instance.position,
+        size: instance.size,
+        rotation: instance.rotation,
+        color: resolveColor(instance.color, palette),
+        // `??` preserves explicit 0 (not treated as missing); 1 default matches
+        // "fully opaque" intuition. `?? 0` for blur aligns with "no blur by default".
+        opacity: instance.opacity ?? 1,
+        blur: instance.blur ?? 0,
+    };
+}
+// --- Motion → ElementAnimations.ambient conversion ------------------------
+//
+// Each dimension produces one InlineAnimation. All three use
+// `direction: 'alternate'` for contract uniformity, but the effect differs:
+//
+//   - drift: keyframes are already symmetric (0%→origin, 50%→max, 100%→origin).
+//     `alternate` reverses odd iterations; reversing a symmetric curve gives
+//     the same trajectory, so it's a no-op for drift *trajectory*. Kept for
+//     uniform contract across dimensions and to match the plan 2 reduced-
+//     motion semantics ("disable entirely" is the only binary switch needed).
+//
+//   - rotate + scale: 2-point keyframes (from → to). Without `alternate`,
+//     iteration 2 would snap back to `from` and jump to `to` again — visible
+//     flicker. `alternate` plays iteration 2 as `to → from` reversed, giving
+//     a smooth breathing/oscillation cycle.
+//
+// Perceived cycle duration:
+//   - drift: 1 × `duration` (full symmetric out-and-back in one iteration).
+//   - rotate/scale: 2 × `duration` (iteration 1 forward + iteration 2 reverse
+//     completes the visible cycle).
+//
+// This asymmetry is intentional: `duration` names "the time the animation's
+// own keyframe timeline takes", not "the visual cycle length". Consumers who
+// want comparable cadence across dimensions should halve rotate/scale
+// durations relative to drift.
+function driftToInline(d) {
+    return {
+        keyframes: [
+            { at: '0%', transform: { translateX: 0, translateY: 0 } },
+            { at: '50%', transform: { translateX: d.range.x, translateY: d.range.y } },
+            { at: '100%', transform: { translateX: 0, translateY: 0 } },
+        ],
+        duration: d.duration,
+        easing: d.easing ?? 'ease-in-out',
+        iterations: 'infinite',
+        direction: 'alternate',
+    };
+}
+function rotateToInline(r) {
+    return {
+        keyframes: [
+            { at: '0%', transform: { rotate: r.from } },
+            { at: '100%', transform: { rotate: r.to } },
+        ],
+        duration: r.duration,
+        easing: 'linear',
+        iterations: 'infinite',
+        direction: 'alternate',
+    };
+}
+function scaleToInline(s) {
+    return {
+        keyframes: [
+            { at: '0%', transform: { scale: s.from } },
+            { at: '100%', transform: { scale: s.to } },
+        ],
+        duration: s.duration,
+        easing: 'ease-in-out',
+        iterations: 'infinite',
+        direction: 'alternate',
+    };
+}
+/**
+ * Convert a BlobMotion (or undefined) to ElementAnimations with only the
+ * `ambient` trigger populated. Returns null when there is no motion to emit
+ * so the caller can set `BlobSpec.animations = null` directly.
+ *
+ * Emission order is stable: drift → rotate → scale. Single-dimension motion
+ * returns a scalar `AnimationRef` (not a 1-element array) — `AnimationRef |
+ * AnimationRef[]` accepts both, and scalar is the more ergonomic default.
+ */
+function motionToAnimations(motion) {
+    if (!motion)
+        return null;
+    const entries = [];
+    if (motion.drift)
+        entries.push(driftToInline(motion.drift));
+    if (motion.rotate)
+        entries.push(rotateToInline(motion.rotate));
+    if (motion.scale)
+        entries.push(scaleToInline(motion.scale));
+    if (entries.length === 0)
+        return null;
+    return { ambient: entries.length === 1 ? entries[0] : entries };
+}
+const PRESET_SEEDS = {
+    'organic-duo': [
+        { shape: 'organic-1', position: { x: '10%', y: '20%' }, size: { width: '420px', height: '360px' } },
+        { shape: 'organic-3', position: { x: '60%', y: '55%' }, size: { width: '380px', height: '320px' } },
+    ],
+    'organic-trio': [
+        { shape: 'organic-1', position: { x: '5%', y: '15%' }, size: { width: '400px', height: '340px' } },
+        { shape: 'organic-4', position: { x: '55%', y: '40%' }, size: { width: '360px', height: '300px' } },
+        { shape: 'organic-5', position: { x: '30%', y: '70%' }, size: { width: '340px', height: '280px' } },
+    ],
+    'circle-pair': [
+        { shape: 'circle', position: { x: '15%', y: '25%' }, size: { width: '320px', height: '320px' } },
+        { shape: 'circle', position: { x: '65%', y: '60%' }, size: { width: '280px', height: '280px' } },
+    ],
+};
+// Motion presets — curated triples of (duration, range, easing). Design
+// intent per preset:
+//   - drift-gentle: slow, small amplitude, default ease-in-out (organic feel).
+//     Ambient background, does not pull attention.
+//   - drift-fluid:  medium-fast, wider amplitude, default ease-in-out.
+//     Lively but still organic (Stripe/Linear aesthetic).
+//   - drift-snappy: fast, medium amplitude, `linear` easing (mechanical/
+//     constant-velocity feel). Contrasts the gentle/fluid organic curves.
+// drift-gentle and drift-fluid deliberately omit `easing` to inherit the
+// ease-in-out default; drift-snappy overrides with linear.
+const PRESET_MOTION = {
+    'drift-gentle': { drift: { duration: '28s', range: { x: 4, y: 3 } } },
+    'drift-fluid': { drift: { duration: '20s', range: { x: 8, y: 5 } } },
+    'drift-snappy': { drift: { duration: '14s', range: { x: 6, y: 4 }, easing: 'linear' } },
+};
+function resolvePresetMotion(preset) {
+    if (!preset || preset === 'static')
+        return undefined;
+    return PRESET_MOTION[preset];
+}
+/**
+ * Convert a BlobV2Config into an array of render-ready BlobSpec entries.
+ *
+ * Ordering: explicit-form blobs are emitted in the same order as the input
+ * array. Preset-form blobs are emitted in preset-defined order (Task 8).
+ *
+ * Ambiguous inputs ({ preset, blobs } both set): preset wins, dev warning.
+ */
+export function resolveBlobLayer(config, palette) {
+    // Preset form takes precedence when both are set. Dev warns on ambiguity.
+    if (config.preset !== undefined) {
+        if (IS_DEV &&
+            config.blobs !== undefined &&
+            config.blobs.length > 0) {
+            // eslint-disable-next-line no-console
+            console.warn("resolveBlobLayer: both 'preset' and 'blobs' are set; preset takes precedence and blobs are ignored. " +
+                'Remove one to silence this warning.');
+        }
+        const seeds = PRESET_SEEDS[config.preset];
+        const paletteNames = config.palette ?? ['primary'];
+        // Defensive: `paletteNames` is typed non-empty in spirit but a consumer
+        // could pass an empty array at runtime — fall back to ['primary'] so
+        // modulo arithmetic below stays sound (n % 0 = NaN). Dev-warn because
+        // `palette: []` is almost always a bug (consumer meant to omit the
+        // field entirely); silent fallback would hide it. Severity matches the
+        // existing ambiguous {preset,blobs} dev-warn above — defensible winner,
+        // no rendering broken.
+        if (IS_DEV && paletteNames.length === 0) {
+            // eslint-disable-next-line no-console
+            console.warn("resolveBlobLayer: preset 'palette' is an empty array; falling back to ['primary']. " +
+                'Omit the field or pass at least one palette keyword to silence.');
+        }
+        const safePaletteNames = paletteNames.length > 0 ? paletteNames : ['primary'];
+        const motion = resolvePresetMotion(config.motion);
+        const animations = motionToAnimations(motion);
+        return seeds.map((seed, i) => {
+            const colorName = safePaletteNames[i % safePaletteNames.length];
+            const instance = {
+                ...seed,
+                color: colorName,
+                opacity: config.opacity,
+            };
+            // Preset seeds are curated — PresetSeed's shape type excludes
+            // 'custom-svg' so catalog lookup is total. Going direct avoids the
+            // `BlobShapeDef | null` union of resolveShape (which is needed only
+            // for the explicit `blobs[]` path where custom-svg is allowed).
+            const shape = BLOB_CATALOG[seed.shape];
+            return {
+                shape,
+                style: resolveStyle(instance, palette),
+                animations,
+            };
+        });
+    }
+    // Explicit form
+    if (!config.blobs || config.blobs.length === 0) {
+        return [];
+    }
+    const specs = [];
+    for (const instance of config.blobs) {
+        const shape = resolveShape(instance);
+        if (shape === null)
+            continue; // prod-mode skip for malformed custom-svg
+        specs.push({
+            shape,
+            style: resolveStyle(instance, palette),
+            animations: motionToAnimations(instance.motion),
+        });
+    }
+    return specs;
+}
+//# sourceMappingURL=resolver.js.map