@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/subset/normalize.js

@@ -0,0 +1,85 @@
+// SPEC-UNIVERSAL-SUBSET §3 — the per-value-type normalizer + epsilon floors (REQ-SUBSET-016). Reduces an
+// engine-native encoding (RN unitless dp number, web `px`/`deg`/`rad` string, any color syntax) to ONE
+// comparable value per value type so the cross-engine comparator compares like for like. It DELEGATES to
+// VALUE-TYPES for every parse and for the epsilon floors — there is exactly one parser and one set of
+// floors in the codebase (REQ-SUBSET-016 "adopted verbatim"); this file re-declares neither.
+import { EPS_ANGLE, EPS_COLOR_CHANNEL, EPS_LENGTH, EPS_UNITLESS } from "../value-types/index.js";
+import { parseColorVerdict } from "../value-types/color.js";
+import { parseNumericVerdict } from "../value-types/numeric.js";
+const DEG_PER_RAD = 180 / Math.PI;
+// The units each numeric value type may carry and still reduce to ONE comparable value. `''` is the
+// engine-native unitless encoding (RN dp for length, a bare scalar for unitless, degrees for angle).
+// length is px + dp ONLY — vw/vh/% are viewport-/parent-relative and NOT px-comparable without a layout
+// context (they are excluded from the guaranteed subset, REQ-SUBSET-011/§8); an angle unit on a length
+// (or vice versa) is a category error. Anything outside the set fails loud rather than being silently
+// reduced to a bare number that would make incompatible encodings compare equal (REQ-SUBSET-016).
+const COMPATIBLE_UNITS = {
+    length: new Set(['', 'px']),
+    unitless: new Set(['']),
+    angle: new Set(['', 'deg', 'rad']),
+};
+const refuseNormalize = (message) => ({
+    value: null,
+    refusal: new Error(message),
+});
+function scalarVerdict(kind, engineValue) {
+    if (typeof engineValue === 'number')
+        return { value: engineValue, refusal: null };
+    const parsed = parseNumericVerdict(engineValue);
+    if (parsed.refusal !== null)
+        return refuseNormalize(parsed.refusal);
+    const { value, unit } = parsed.parsed;
+    if (!COMPATIBLE_UNITS[kind].has(unit)) {
+        const allowed = [...COMPATIBLE_UNITS[kind]].map((u) => u || '<unitless>').join(', ');
+        return refuseNormalize(`Incompatible unit '${unit}' for a ${kind} value ${JSON.stringify(engineValue)}: it cannot be ` +
+            `normalized as ${kind} (compatible units: ${allowed}).`);
+    }
+    return { value: kind === 'angle' && unit === 'rad' ? value * DEG_PER_RAD : value, refusal: null };
+}
+export function normalizeCapabilityVerdict(entry, engineValue) {
+    switch (entry.valueType) {
+        case 'length':
+        case 'unitless':
+        case 'angle':
+            return scalarVerdict(entry.valueType, engineValue);
+        case 'rgba': {
+            const parsed = parseColorVerdict(String(engineValue));
+            return parsed.refusal !== null
+                ? refuseNormalize(parsed.refusal)
+                : { value: parsed.parsed, refusal: null };
+        }
+        case 'complex':
+        case 'gesture':
+        case 'discrete':
+            // Web-only compositor effects (complex), gestures, and discrete keywords (T23 B — compared
+            // by exact keyword equality, never a normalized scalar) have no cross-engine numeric value to
+            // compare — asking for one is a caller error, not a silent zero. Fail loud (REQ-SUBSET-014 ethos).
+            return refuseNormalize(`Capability '${entry.keys[0]}' (valueType '${entry.valueType}') has no cross-engine ` +
+                `normalized value — it is not a comparable animated scalar/color.`);
+    }
+    return refuseNormalize(`unreachable valueType`);
+}
+export function normalizeCapability(entry, engineValue) {
+    const verdict = normalizeCapabilityVerdict(entry, engineValue);
+    if (verdict.refusal !== null)
+        throw verdict.refusal;
+    return verdict.value;
+}
+// The comparison epsilon FLOOR for a value type, imported verbatim from VALUE-TYPES (REQ-SUBSET-016).
+// complex/gesture have no comparison tolerance — requesting one is a loud failure, not a default.
+export function epsilonFor(valueType) {
+    switch (valueType) {
+        case 'length':
+            return EPS_LENGTH;
+        case 'unitless':
+            return EPS_UNITLESS;
+        case 'angle':
+            return EPS_ANGLE;
+        case 'rgba':
+            return EPS_COLOR_CHANNEL;
+        case 'complex':
+        case 'gesture':
+        case 'discrete':
+            throw new Error(`valueType '${valueType}' has no comparison epsilon — it is not a cross-engine numeric value.`);
+    }
+}

package/dist/subset/registry.cjs

@@ -0,0 +1,259 @@
+"use strict";
+// SPEC-UNIVERSAL-SUBSET §3 — the single frozen, machine-readable universal-subset registry
+// (REQ-SUBSET-010). It is the SOLE source of subset membership: app code, the native runtime, the web
+// shim, and the conformance runner all read this one object; no engine carries a private list. Lives in
+// `core` with ZERO host dependencies (structural isolation gate) — the host-aware Motion-seam canary
+// (REQ-SUBSET-015) and authoring gate (REQ-SUBSET-018) read this registry from `packages/conformance`.
+//
+// Each entry declares every REQ-SUBSET-010 field. Schema completions beyond the spec's illustrative
+// enums, flagged as vetoable (see .rl decision log): the `webEffect` CLASS carries web-only compositor
+// effects (filter/clipPath/boxShadow/gradients) that fit none of transform|opacity|color|layoutProp|
+// gesture; the `gesture` VALUE-TYPE and `complex` VALUE-TYPE fill §5.1's "enum-valid valueType on every
+// entry" for gesture and web-effect entries respectively. Membership + marking follow REQ-SUBSET-011
+// (properties), -012 (gestures), -013 (platform-specific), -015 (web path), -017 (native mapping).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIVERSAL_SUBSET = void 0;
+// --- entry builders (keep the tables below declarative) --------------------------------------------
+// A universal transform maps to one RN transform-array token and takes the accelerated web path
+// (Motion folds every transform into the composite `transform` string it accelerates via WAAPI).
+function transform(key, token, valueType) {
+    return {
+        keys: [key],
+        class: 'transform',
+        universality: 'universal',
+        shipping: 'shipped', // the animate pipeline drives every transform today
+        referenceDisposition: 'portable-shipped',
+        valueType,
+        webEnginePath: 'accelerated',
+        nativeMapping: token,
+    };
+}
+// A universal non-transform property maps to the identically-named RN style field. Opacity is the lone
+// accelerated non-transform; colors + layout props take Motion's JS path (REQ-SUBSET-015).
+function styleProp(key, cls, valueType, webEnginePath) {
+    return {
+        keys: [key],
+        class: cls,
+        universality: 'universal',
+        shipping: 'shipped', // opacity/colors/layout props all animate today
+        referenceDisposition: 'portable-shipped',
+        valueType,
+        webEnginePath,
+        nativeMapping: key,
+    };
+}
+// A web-only compositor effect: no faithful native mapping (RN has no per-layer filter/clip/shadow
+// parity), so `unsupported` — but it still records its Motion web path so the canary stays exact and a
+// native use fails loud (REQ-SUBSET-013/-014).
+function webEffect(key, webEnginePath) {
+    return {
+        keys: [key],
+        class: 'webEffect',
+        universality: 'web-only',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'complex',
+        webEnginePath,
+        nativeMapping: 'unsupported',
+    };
+}
+const RAW_ENTRIES = [
+    // Transforms (REQ-SUBSET-011) — accelerated; each folds into the composite `transform`.
+    transform('x', 'translateX', 'length'),
+    transform('y', 'translateY', 'length'),
+    transform('scale', 'scale', 'unitless'),
+    transform('scaleX', 'scaleX', 'unitless'),
+    transform('scaleY', 'scaleY', 'unitless'),
+    transform('rotate', 'rotate', 'angle'),
+    transform('rotateX', 'rotateX', 'angle'),
+    transform('rotateY', 'rotateY', 'angle'),
+    transform('skewX', 'skewX', 'angle'),
+    transform('skewY', 'skewY', 'angle'),
+    transform('perspective', 'perspective', 'length'),
+    // Opacity (REQ-SUBSET-011) — the one accelerated non-transform.
+    styleProp('opacity', 'opacity', 'unitless', 'accelerated'),
+    // Colors (REQ-SUBSET-011) — JS path (Motion's `background-color` acceleration is disabled at pin).
+    styleProp('backgroundColor', 'color', 'rgba', 'js'),
+    styleProp('color', 'color', 'rgba', 'js'),
+    styleProp('borderColor', 'color', 'rgba', 'js'),
+    // Layout props to explicit numeric targets (REQ-SUBSET-011) — JS path, length value type.
+    styleProp('width', 'layoutProp', 'length', 'js'),
+    styleProp('height', 'layoutProp', 'length', 'js'),
+    styleProp('top', 'layoutProp', 'length', 'js'),
+    styleProp('right', 'layoutProp', 'length', 'js'),
+    styleProp('bottom', 'layoutProp', 'length', 'js'),
+    styleProp('left', 'layoutProp', 'length', 'js'),
+    styleProp('borderRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopLeftRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopRightRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomLeftRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomRightRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderRightWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderLeftWidth', 'layoutProp', 'length', 'js'),
+    styleProp('margin', 'layoutProp', 'length', 'js'),
+    styleProp('marginTop', 'layoutProp', 'length', 'js'),
+    styleProp('marginRight', 'layoutProp', 'length', 'js'),
+    styleProp('marginBottom', 'layoutProp', 'length', 'js'),
+    styleProp('marginLeft', 'layoutProp', 'length', 'js'),
+    styleProp('padding', 'layoutProp', 'length', 'js'),
+    styleProp('paddingTop', 'layoutProp', 'length', 'js'),
+    styleProp('paddingRight', 'layoutProp', 'length', 'js'),
+    styleProp('paddingBottom', 'layoutProp', 'length', 'js'),
+    styleProp('paddingLeft', 'layoutProp', 'length', 'js'),
+    // Discrete keywords (REQ-SUBSET-011 amendment; mix law REQ-VALUETYPE-015) — JS path; a pair
+    // takes the pin's mixVisibility step when an endpoint is invisible ({none, hidden}) and its
+    // counterpart has zero values, and otherwise publishes the TARGET as a constant. `display`
+    // maps to the identically-named RN style field (RN vocabulary flex↔none; web block is a port
+    // adaptation). `visibility` has NO RN style field: it commits as the ratified composed override
+    // (charter Decision 15 — hidden = effective opacity 0 overriding animated opacity +
+    // pointerEvents 'none'), recorded as a marker token since no faithful single field exists.
+    styleProp('display', 'discrete', 'discrete', 'js'),
+    {
+        keys: ['visibility'],
+        class: 'discrete',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'discrete',
+        webEnginePath: 'js',
+        nativeMapping: 'composed:opacity+pointerEvents',
+    },
+    // Universal gestures (REQ-SUBSET-012) — the RECOGNIZERS are the universal gesture intersection;
+    // recognition detail owned by the gesture sub-SPEC, membership owned here. JS-thread event
+    // capabilities, not accelerated values. `universality` = host membership; `shipping` = subset
+    // availability today (the two axes, review r4 bd59a7c). The gesture-STATE TARGET props
+    // (`whileTap`/`whileDrag`) are SEPARATE deferred entries below — the BRIEF puts them "outside the
+    // subset" (BRIEF.md:139), which the machine-readable `shipping: 'deferred'` now records; they are
+    // NOT lumped with the shipped recognizer.
+    //
+    // Pan/drag RECOGNIZER — SHIPPED on the public surface as of FLAG 5a (`drag`, `onDrag*`).
+    // R15 D1 (REQ-API-041) widened it: both-axes `drag={true}` and `dragPropagation` (Motion's
+    // global nested-drag lock) ship on both entries; the axis-scope record lives in
+    // SPEC-UNIVERSAL-SUBSET § gestures.
+    // R15 D3 (REQ-API-043): `dragControls` / `dragListener` ship with the pan recognizer
+    // (imperative hub + element-originated start gate).
+    {
+        keys: [
+            'drag',
+            'dragPropagation',
+            'dragControls',
+            'dragListener',
+            'onMeasureDragConstraints',
+            'onDrag',
+            'onDragStart',
+            'onDragEnd',
+        ],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:pan',
+    },
+    // Press/tap RECOGNIZER callbacks — SHIPPED as of R5 (REQ-API-030,
+    // specs/R5-TAP-BUILD-PACKET.md): the pinned MotionNodeTapHandlers trio on both entries.
+    {
+        keys: ['onTap', 'onTapStart', 'onTapCancel'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:tap',
+    },
+    // Gesture-STATE TARGET props (`whileTap`/`whileDrag`) — SHIPPED at R6 (REQ-API-031), OBJECT
+    // form: the priority-overlay law over the shipped recognizers. The LABEL (variant) form
+    // remains R7's at the runtime gates on both engines; `shipping` records the object surface.
+    // Separate entries because they map to different recognizers.
+    {
+        keys: ['whileTap'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:tap',
+    },
+    {
+        keys: ['whileDrag'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:pan',
+    },
+    // Web-only compositor effects (REQ-SUBSET-013). filter/clipPath ARE accelerated in Motion (canary),
+    // boxShadow + CSS gradients are not. All unsupported natively, deferred (outside the universal Target).
+    webEffect('filter', 'accelerated'),
+    webEffect('clipPath', 'accelerated'),
+    webEffect('boxShadow', 'js'),
+    webEffect('backgroundImage', 'js'),
+    // Pointer-gated interactions (REQ-SUBSET-013) — hover/focus are pointer/keyboard concepts absent on
+    // touch-only hosts; unsupported natively, fail loud there (REQ-SUBSET-014). Deferred (no rung).
+    {
+        keys: ['whileHover', 'onHoverStart', 'onHoverEnd'],
+        class: 'gesture',
+        universality: 'pointer-gated',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'unsupported',
+    },
+    {
+        keys: ['whileFocus'],
+        class: 'gesture',
+        universality: 'pointer-gated',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'unsupported',
+    },
+];
+// Deep-freeze: each entry + its keys array + the entries array are frozen so no consumer can mutate the
+// shared source of truth (REQ-SUBSET-010 invariant, §5.1). The lookup Map is module-private and derived,
+// so it is not part of the frozen public surface.
+const entries = Object.freeze(RAW_ENTRIES.map((e) => Object.freeze({ ...e, keys: Object.freeze([...e.keys]) })));
+const byKey = new Map();
+for (const e of entries)
+    for (const k of e.keys)
+        byKey.set(k, e);
+exports.UNIVERSAL_SUBSET = Object.freeze({
+    entries,
+    // Membership lookup by any single prop key (a gesture's cluster keys all resolve to its entry).
+    get(key) {
+        return byKey.get(key);
+    },
+    has(key) {
+        return byKey.has(key);
+    },
+    byUniversality(universality) {
+        return entries.filter((e) => e.universality === universality);
+    },
+    // The accelerated set at Motion's token granularity (REQ-SUBSET-015): every transform-class entry
+    // collapses to the single `transform` token; opacity + the web-only accelerated effects appear as
+    // themselves. This is compared for EXACT equality against motion-dom's live `acceleratedValues` by the
+    // Milestone-4 conformance canary — a superset/subset match would silently mis-route the oracle.
+    acceleratedKeys() {
+        const out = new Set();
+        for (const e of entries) {
+            if (e.webEnginePath !== 'accelerated')
+                continue;
+            if (e.class === 'transform')
+                out.add('transform');
+            else
+                for (const k of e.keys)
+                    out.add(k);
+        }
+        return out;
+    },
+});

package/dist/subset/registry.d.cts

@@ -0,0 +1,25 @@
+export type CapabilityClass = 'transform' | 'opacity' | 'color' | 'layoutProp' | 'discrete' | 'gesture' | 'webEffect';
+export type Universality = 'universal' | 'web-only' | 'pointer-gated' | 'native-extension';
+export type ShippingStatus = 'shipped' | 'deferred';
+export type ReferenceDisposition = 'portable-shipped' | 'portable-deferred' | 'intrinsic-web' | 'extension' | 'waived-divergence';
+export type WebEnginePath = 'accelerated' | 'js';
+export type ValueType = 'length' | 'unitless' | 'angle' | 'rgba' | 'complex' | 'discrete' | 'gesture';
+export interface CapabilityEntry {
+    readonly keys: readonly string[];
+    readonly class: CapabilityClass;
+    readonly universality: Universality;
+    readonly shipping: ShippingStatus;
+    readonly referenceDisposition: ReferenceDisposition;
+    readonly valueType: ValueType;
+    readonly webEnginePath: WebEnginePath;
+    readonly nativeMapping: string;
+    readonly debtId?: string;
+    readonly waiverId?: string;
+}
+export declare const UNIVERSAL_SUBSET: Readonly<{
+    entries: readonly CapabilityEntry[];
+    get(key: string): CapabilityEntry | undefined;
+    has(key: string): boolean;
+    byUniversality(universality: Universality): readonly CapabilityEntry[];
+    acceleratedKeys(): ReadonlySet<string>;
+}>;

package/dist/subset/registry.d.ts

@@ -0,0 +1,25 @@
+export type CapabilityClass = 'transform' | 'opacity' | 'color' | 'layoutProp' | 'discrete' | 'gesture' | 'webEffect';
+export type Universality = 'universal' | 'web-only' | 'pointer-gated' | 'native-extension';
+export type ShippingStatus = 'shipped' | 'deferred';
+export type ReferenceDisposition = 'portable-shipped' | 'portable-deferred' | 'intrinsic-web' | 'extension' | 'waived-divergence';
+export type WebEnginePath = 'accelerated' | 'js';
+export type ValueType = 'length' | 'unitless' | 'angle' | 'rgba' | 'complex' | 'discrete' | 'gesture';
+export interface CapabilityEntry {
+    readonly keys: readonly string[];
+    readonly class: CapabilityClass;
+    readonly universality: Universality;
+    readonly shipping: ShippingStatus;
+    readonly referenceDisposition: ReferenceDisposition;
+    readonly valueType: ValueType;
+    readonly webEnginePath: WebEnginePath;
+    readonly nativeMapping: string;
+    readonly debtId?: string;
+    readonly waiverId?: string;
+}
+export declare const UNIVERSAL_SUBSET: Readonly<{
+    entries: readonly CapabilityEntry[];
+    get(key: string): CapabilityEntry | undefined;
+    has(key: string): boolean;
+    byUniversality(universality: Universality): readonly CapabilityEntry[];
+    acceleratedKeys(): ReadonlySet<string>;
+}>;

package/dist/subset/registry.js

@@ -0,0 +1,256 @@
+// SPEC-UNIVERSAL-SUBSET §3 — the single frozen, machine-readable universal-subset registry
+// (REQ-SUBSET-010). It is the SOLE source of subset membership: app code, the native runtime, the web
+// shim, and the conformance runner all read this one object; no engine carries a private list. Lives in
+// `core` with ZERO host dependencies (structural isolation gate) — the host-aware Motion-seam canary
+// (REQ-SUBSET-015) and authoring gate (REQ-SUBSET-018) read this registry from `packages/conformance`.
+//
+// Each entry declares every REQ-SUBSET-010 field. Schema completions beyond the spec's illustrative
+// enums, flagged as vetoable (see .rl decision log): the `webEffect` CLASS carries web-only compositor
+// effects (filter/clipPath/boxShadow/gradients) that fit none of transform|opacity|color|layoutProp|
+// gesture; the `gesture` VALUE-TYPE and `complex` VALUE-TYPE fill §5.1's "enum-valid valueType on every
+// entry" for gesture and web-effect entries respectively. Membership + marking follow REQ-SUBSET-011
+// (properties), -012 (gestures), -013 (platform-specific), -015 (web path), -017 (native mapping).
+// --- entry builders (keep the tables below declarative) --------------------------------------------
+// A universal transform maps to one RN transform-array token and takes the accelerated web path
+// (Motion folds every transform into the composite `transform` string it accelerates via WAAPI).
+function transform(key, token, valueType) {
+    return {
+        keys: [key],
+        class: 'transform',
+        universality: 'universal',
+        shipping: 'shipped', // the animate pipeline drives every transform today
+        referenceDisposition: 'portable-shipped',
+        valueType,
+        webEnginePath: 'accelerated',
+        nativeMapping: token,
+    };
+}
+// A universal non-transform property maps to the identically-named RN style field. Opacity is the lone
+// accelerated non-transform; colors + layout props take Motion's JS path (REQ-SUBSET-015).
+function styleProp(key, cls, valueType, webEnginePath) {
+    return {
+        keys: [key],
+        class: cls,
+        universality: 'universal',
+        shipping: 'shipped', // opacity/colors/layout props all animate today
+        referenceDisposition: 'portable-shipped',
+        valueType,
+        webEnginePath,
+        nativeMapping: key,
+    };
+}
+// A web-only compositor effect: no faithful native mapping (RN has no per-layer filter/clip/shadow
+// parity), so `unsupported` — but it still records its Motion web path so the canary stays exact and a
+// native use fails loud (REQ-SUBSET-013/-014).
+function webEffect(key, webEnginePath) {
+    return {
+        keys: [key],
+        class: 'webEffect',
+        universality: 'web-only',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'complex',
+        webEnginePath,
+        nativeMapping: 'unsupported',
+    };
+}
+const RAW_ENTRIES = [
+    // Transforms (REQ-SUBSET-011) — accelerated; each folds into the composite `transform`.
+    transform('x', 'translateX', 'length'),
+    transform('y', 'translateY', 'length'),
+    transform('scale', 'scale', 'unitless'),
+    transform('scaleX', 'scaleX', 'unitless'),
+    transform('scaleY', 'scaleY', 'unitless'),
+    transform('rotate', 'rotate', 'angle'),
+    transform('rotateX', 'rotateX', 'angle'),
+    transform('rotateY', 'rotateY', 'angle'),
+    transform('skewX', 'skewX', 'angle'),
+    transform('skewY', 'skewY', 'angle'),
+    transform('perspective', 'perspective', 'length'),
+    // Opacity (REQ-SUBSET-011) — the one accelerated non-transform.
+    styleProp('opacity', 'opacity', 'unitless', 'accelerated'),
+    // Colors (REQ-SUBSET-011) — JS path (Motion's `background-color` acceleration is disabled at pin).
+    styleProp('backgroundColor', 'color', 'rgba', 'js'),
+    styleProp('color', 'color', 'rgba', 'js'),
+    styleProp('borderColor', 'color', 'rgba', 'js'),
+    // Layout props to explicit numeric targets (REQ-SUBSET-011) — JS path, length value type.
+    styleProp('width', 'layoutProp', 'length', 'js'),
+    styleProp('height', 'layoutProp', 'length', 'js'),
+    styleProp('top', 'layoutProp', 'length', 'js'),
+    styleProp('right', 'layoutProp', 'length', 'js'),
+    styleProp('bottom', 'layoutProp', 'length', 'js'),
+    styleProp('left', 'layoutProp', 'length', 'js'),
+    styleProp('borderRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopLeftRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopRightRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomLeftRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomRightRadius', 'layoutProp', 'length', 'js'),
+    styleProp('borderWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderTopWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderRightWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderBottomWidth', 'layoutProp', 'length', 'js'),
+    styleProp('borderLeftWidth', 'layoutProp', 'length', 'js'),
+    styleProp('margin', 'layoutProp', 'length', 'js'),
+    styleProp('marginTop', 'layoutProp', 'length', 'js'),
+    styleProp('marginRight', 'layoutProp', 'length', 'js'),
+    styleProp('marginBottom', 'layoutProp', 'length', 'js'),
+    styleProp('marginLeft', 'layoutProp', 'length', 'js'),
+    styleProp('padding', 'layoutProp', 'length', 'js'),
+    styleProp('paddingTop', 'layoutProp', 'length', 'js'),
+    styleProp('paddingRight', 'layoutProp', 'length', 'js'),
+    styleProp('paddingBottom', 'layoutProp', 'length', 'js'),
+    styleProp('paddingLeft', 'layoutProp', 'length', 'js'),
+    // Discrete keywords (REQ-SUBSET-011 amendment; mix law REQ-VALUETYPE-015) — JS path; a pair
+    // takes the pin's mixVisibility step when an endpoint is invisible ({none, hidden}) and its
+    // counterpart has zero values, and otherwise publishes the TARGET as a constant. `display`
+    // maps to the identically-named RN style field (RN vocabulary flex↔none; web block is a port
+    // adaptation). `visibility` has NO RN style field: it commits as the ratified composed override
+    // (charter Decision 15 — hidden = effective opacity 0 overriding animated opacity +
+    // pointerEvents 'none'), recorded as a marker token since no faithful single field exists.
+    styleProp('display', 'discrete', 'discrete', 'js'),
+    {
+        keys: ['visibility'],
+        class: 'discrete',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'discrete',
+        webEnginePath: 'js',
+        nativeMapping: 'composed:opacity+pointerEvents',
+    },
+    // Universal gestures (REQ-SUBSET-012) — the RECOGNIZERS are the universal gesture intersection;
+    // recognition detail owned by the gesture sub-SPEC, membership owned here. JS-thread event
+    // capabilities, not accelerated values. `universality` = host membership; `shipping` = subset
+    // availability today (the two axes, review r4 bd59a7c). The gesture-STATE TARGET props
+    // (`whileTap`/`whileDrag`) are SEPARATE deferred entries below — the BRIEF puts them "outside the
+    // subset" (BRIEF.md:139), which the machine-readable `shipping: 'deferred'` now records; they are
+    // NOT lumped with the shipped recognizer.
+    //
+    // Pan/drag RECOGNIZER — SHIPPED on the public surface as of FLAG 5a (`drag`, `onDrag*`).
+    // R15 D1 (REQ-API-041) widened it: both-axes `drag={true}` and `dragPropagation` (Motion's
+    // global nested-drag lock) ship on both entries; the axis-scope record lives in
+    // SPEC-UNIVERSAL-SUBSET § gestures.
+    // R15 D3 (REQ-API-043): `dragControls` / `dragListener` ship with the pan recognizer
+    // (imperative hub + element-originated start gate).
+    {
+        keys: [
+            'drag',
+            'dragPropagation',
+            'dragControls',
+            'dragListener',
+            'onMeasureDragConstraints',
+            'onDrag',
+            'onDragStart',
+            'onDragEnd',
+        ],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:pan',
+    },
+    // Press/tap RECOGNIZER callbacks — SHIPPED as of R5 (REQ-API-030,
+    // specs/R5-TAP-BUILD-PACKET.md): the pinned MotionNodeTapHandlers trio on both entries.
+    {
+        keys: ['onTap', 'onTapStart', 'onTapCancel'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:tap',
+    },
+    // Gesture-STATE TARGET props (`whileTap`/`whileDrag`) — SHIPPED at R6 (REQ-API-031), OBJECT
+    // form: the priority-overlay law over the shipped recognizers. The LABEL (variant) form
+    // remains R7's at the runtime gates on both engines; `shipping` records the object surface.
+    // Separate entries because they map to different recognizers.
+    {
+        keys: ['whileTap'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:tap',
+    },
+    {
+        keys: ['whileDrag'],
+        class: 'gesture',
+        universality: 'universal',
+        shipping: 'shipped',
+        referenceDisposition: 'portable-shipped',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'gesture:pan',
+    },
+    // Web-only compositor effects (REQ-SUBSET-013). filter/clipPath ARE accelerated in Motion (canary),
+    // boxShadow + CSS gradients are not. All unsupported natively, deferred (outside the universal Target).
+    webEffect('filter', 'accelerated'),
+    webEffect('clipPath', 'accelerated'),
+    webEffect('boxShadow', 'js'),
+    webEffect('backgroundImage', 'js'),
+    // Pointer-gated interactions (REQ-SUBSET-013) — hover/focus are pointer/keyboard concepts absent on
+    // touch-only hosts; unsupported natively, fail loud there (REQ-SUBSET-014). Deferred (no rung).
+    {
+        keys: ['whileHover', 'onHoverStart', 'onHoverEnd'],
+        class: 'gesture',
+        universality: 'pointer-gated',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'unsupported',
+    },
+    {
+        keys: ['whileFocus'],
+        class: 'gesture',
+        universality: 'pointer-gated',
+        shipping: 'deferred',
+        referenceDisposition: 'intrinsic-web',
+        valueType: 'gesture',
+        webEnginePath: 'js',
+        nativeMapping: 'unsupported',
+    },
+];
+// Deep-freeze: each entry + its keys array + the entries array are frozen so no consumer can mutate the
+// shared source of truth (REQ-SUBSET-010 invariant, §5.1). The lookup Map is module-private and derived,
+// so it is not part of the frozen public surface.
+const entries = Object.freeze(RAW_ENTRIES.map((e) => Object.freeze({ ...e, keys: Object.freeze([...e.keys]) })));
+const byKey = new Map();
+for (const e of entries)
+    for (const k of e.keys)
+        byKey.set(k, e);
+export const UNIVERSAL_SUBSET = Object.freeze({
+    entries,
+    // Membership lookup by any single prop key (a gesture's cluster keys all resolve to its entry).
+    get(key) {
+        return byKey.get(key);
+    },
+    has(key) {
+        return byKey.has(key);
+    },
+    byUniversality(universality) {
+        return entries.filter((e) => e.universality === universality);
+    },
+    // The accelerated set at Motion's token granularity (REQ-SUBSET-015): every transform-class entry
+    // collapses to the single `transform` token; opacity + the web-only accelerated effects appear as
+    // themselves. This is compared for EXACT equality against motion-dom's live `acceleratedValues` by the
+    // Milestone-4 conformance canary — a superset/subset match would silently mis-route the oracle.
+    acceleratedKeys() {
+        const out = new Set();
+        for (const e of entries) {
+            if (e.webEnginePath !== 'accelerated')
+                continue;
+            if (e.class === 'transform')
+                out.add('transform');
+            else
+                for (const k of e.keys)
+                    out.add(k);
+        }
+        return out;
+    },
+});