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

package/dist/value-types/named-colors.js

@@ -0,0 +1,58 @@
+// CSS Color Module Level 4 named colors → canonical RGBA (REQ-VALUETYPE-005). Authored from the CSS
+// spec, NOT motion-dom (which has no named-color table — `color.parse("red")` returns garbage; on web it
+// delegates named colors to the DOM) and NOT the DOM/react-native, so the SAME raw string resolves to the
+// SAME RGBA on both engines with no host in the loop. `transparent` is the CSS keyword for rgba(0,0,0,0).
+// This is a curated common subset (the 16 CSS Level-2 keywords + `transparent` + frequent extended
+// keywords); full-L4 completeness is the vetoable open decision (SPEC-VALUE-TYPES §8). Keys are lowercase;
+// the lookup lowercases its input.
+const opaque = (red, green, blue) => ({ red, green, blue, alpha: 1 });
+export const NAMED_COLORS = {
+    transparent: { red: 0, green: 0, blue: 0, alpha: 0 },
+    // CSS Level 2 (basic) keywords
+    black: opaque(0, 0, 0),
+    silver: opaque(192, 192, 192),
+    gray: opaque(128, 128, 128),
+    white: opaque(255, 255, 255),
+    maroon: opaque(128, 0, 0),
+    red: opaque(255, 0, 0),
+    purple: opaque(128, 0, 128),
+    fuchsia: opaque(255, 0, 255),
+    green: opaque(0, 128, 0),
+    lime: opaque(0, 255, 0),
+    olive: opaque(128, 128, 0),
+    yellow: opaque(255, 255, 0),
+    navy: opaque(0, 0, 128),
+    blue: opaque(0, 0, 255),
+    teal: opaque(0, 128, 128),
+    aqua: opaque(0, 255, 255),
+    // Frequent extended keywords + spelling aliases
+    cyan: opaque(0, 255, 255), // alias of aqua
+    magenta: opaque(255, 0, 255), // alias of fuchsia
+    grey: opaque(128, 128, 128), // alias of gray
+    orange: opaque(255, 165, 0),
+    pink: opaque(255, 192, 203),
+    brown: opaque(165, 42, 42),
+    gold: opaque(255, 215, 0),
+    indigo: opaque(75, 0, 130),
+    violet: opaque(238, 130, 238),
+    darkgray: opaque(169, 169, 169),
+    darkgrey: opaque(169, 169, 169),
+    lightgray: opaque(211, 211, 211),
+    lightgrey: opaque(211, 211, 211),
+    dimgray: opaque(105, 105, 105),
+    slategray: opaque(112, 128, 144),
+    whitesmoke: opaque(245, 245, 245),
+    lightblue: opaque(173, 216, 230),
+    darkblue: opaque(0, 0, 139),
+    lightgreen: opaque(144, 238, 144),
+    darkgreen: opaque(0, 100, 0),
+    coral: opaque(255, 127, 80),
+    salmon: opaque(250, 128, 114),
+    tomato: opaque(255, 99, 71),
+    crimson: opaque(220, 20, 60),
+    skyblue: opaque(135, 206, 235),
+    steelblue: opaque(70, 130, 180),
+    turquoise: opaque(64, 224, 208),
+    beige: opaque(245, 245, 220),
+    ivory: opaque(255, 255, 240),
+};

package/dist/value-types/numeric.cjs

@@ -0,0 +1,86 @@
+"use strict";
+// Numeric + unit value types (SPEC-VALUE-TYPES §3, REQ-VALUETYPE-001/002/003/004). Pure parse/transform/
+// mix over plain numbers and single-unit-suffixed numbers. Host-agnostic (REQ-VALUETYPE-011): no DOM, no
+// react-native, no locale formatting. motion-dom carries no unit in its typed value and applies NO
+// unit-identity check; this subsystem CARRIES the unit and fails loud on a mismatch — the INTENTIONAL,
+// scenario-backed divergence (REQ-VALUETYPE-004).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumericVerdict = parseNumericVerdict;
+exports.parseNumeric = parseNumeric;
+exports.isNumeric = isNumeric;
+exports.transformNumeric = transformNumeric;
+exports.mixNumeric = mixNumeric;
+const constants_1 = require("./constants.cjs");
+// A strict numeric token: optional sign, integer/fraction (or bare fraction), optional exponent.
+// `parseFloat` is lenient (`"10abc" -> 10`); this gate rejects trailing garbage so a malformed value is a
+// loud failure (REQ-VALUETYPE-008), never a silent truncation.
+const NUMBER_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+function parseNumericVerdict(raw) {
+    if (typeof raw === 'number') {
+        if (!Number.isFinite(raw)) {
+            return { parsed: null, refusal: `Cannot parse non-finite numeric value: ${raw}` };
+        }
+        return { parsed: { value: raw, unit: '' }, refusal: null };
+    }
+    const s = raw.trim();
+    // REQ-VALUETYPE-002: a single value has no interior whitespace (splits on whitespace to length 1).
+    if (s.length === 0 || /\s/.test(s)) {
+        return {
+            parsed: null,
+            refusal: `Cannot parse ${JSON.stringify(raw)} as a single numeric/unit value (empty or interior whitespace)`,
+        };
+    }
+    for (const unit of constants_1.KNOWN_UNITS) {
+        if (s.length > unit.length && s.endsWith(unit)) {
+            const prefix = s.slice(0, s.length - unit.length);
+            if (NUMBER_RE.test(prefix)) {
+                return { parsed: { value: Number.parseFloat(prefix), unit }, refusal: null };
+            }
+            return {
+                parsed: null,
+                refusal: `Cannot parse ${JSON.stringify(raw)}: ${JSON.stringify(prefix)} is not a valid number before unit "${unit}"`,
+            };
+        }
+    }
+    if (NUMBER_RE.test(s))
+        return { parsed: { value: Number.parseFloat(s), unit: '' }, refusal: null };
+    return { parsed: null, refusal: `Cannot parse ${JSON.stringify(raw)} as a numeric or unit value` };
+}
+// Parse a raw string (or number) into a decomposed {value, unit}. Throws on unparseable input, interior
+// whitespace, or a malformed numeric prefix (REQ-VALUETYPE-008) — no silent coercion.
+function parseNumeric(raw) {
+    const verdict = parseNumericVerdict(raw);
+    if (verdict.refusal !== null)
+        throw new Error(verdict.refusal);
+    return verdict.parsed;
+}
+// Family predicate for the dispatcher (mix.ts): does the whole raw string decompose as a single
+// number/unit value? Mirrors parseNumeric's acceptance without throwing — no interior whitespace, an
+// optional trailing KNOWN unit, a strict numeric prefix.
+function isNumeric(raw) {
+    const s = raw.trim();
+    if (s.length === 0 || /\s/.test(s))
+        return false;
+    for (const unit of constants_1.KNOWN_UNITS) {
+        if (s.length > unit.length && s.endsWith(unit)) {
+            return NUMBER_RE.test(s.slice(0, s.length - unit.length));
+        }
+    }
+    return NUMBER_RE.test(s);
+}
+// Project a typed value back to its committed form: a plain number transforms as the IDENTITY (returns
+// the number, not a string, REQ-VALUETYPE-001); a unit value re-appends its suffix.
+function transformNumeric(v) {
+    if (v.unit === '')
+        return v.value;
+    return `${v.value}${v.unit}`;
+}
+// Interpolate `origin + (target − origin)·progress` (REQ-VALUETYPE-003, motion's mixNumber), but only
+// when the units are identical — a mismatch throws naming both raw values + units (REQ-VALUETYPE-004).
+function mixNumeric(from, to, progress) {
+    if (from.unit !== to.unit) {
+        throw new Error(`Cannot interpolate mismatched units: "${transformNumeric(from)}" (unit "${from.unit || 'none'}") ` +
+            `against "${transformNumeric(to)}" (unit "${to.unit || 'none'}")`);
+    }
+    return { value: from.value + (to.value - from.value) * progress, unit: from.unit };
+}

package/dist/value-types/numeric.d.cts

@@ -0,0 +1,16 @@
+export interface NumericValue {
+    readonly value: number;
+    readonly unit: string;
+}
+export type NumericParseVerdict = {
+    readonly parsed: NumericValue;
+    readonly refusal: null;
+} | {
+    readonly parsed: null;
+    readonly refusal: string;
+};
+export declare function parseNumericVerdict(raw: string | number): NumericParseVerdict;
+export declare function parseNumeric(raw: string | number): NumericValue;
+export declare function isNumeric(raw: string): boolean;
+export declare function transformNumeric(v: NumericValue): string | number;
+export declare function mixNumeric(from: NumericValue, to: NumericValue, progress: number): NumericValue;

package/dist/value-types/numeric.d.ts

@@ -0,0 +1,16 @@
+export interface NumericValue {
+    readonly value: number;
+    readonly unit: string;
+}
+export type NumericParseVerdict = {
+    readonly parsed: NumericValue;
+    readonly refusal: null;
+} | {
+    readonly parsed: null;
+    readonly refusal: string;
+};
+export declare function parseNumericVerdict(raw: string | number): NumericParseVerdict;
+export declare function parseNumeric(raw: string | number): NumericValue;
+export declare function isNumeric(raw: string): boolean;
+export declare function transformNumeric(v: NumericValue): string | number;
+export declare function mixNumeric(from: NumericValue, to: NumericValue, progress: number): NumericValue;

package/dist/value-types/numeric.js

@@ -0,0 +1,79 @@
+// Numeric + unit value types (SPEC-VALUE-TYPES §3, REQ-VALUETYPE-001/002/003/004). Pure parse/transform/
+// mix over plain numbers and single-unit-suffixed numbers. Host-agnostic (REQ-VALUETYPE-011): no DOM, no
+// react-native, no locale formatting. motion-dom carries no unit in its typed value and applies NO
+// unit-identity check; this subsystem CARRIES the unit and fails loud on a mismatch — the INTENTIONAL,
+// scenario-backed divergence (REQ-VALUETYPE-004).
+import { KNOWN_UNITS } from "./constants.js";
+// A strict numeric token: optional sign, integer/fraction (or bare fraction), optional exponent.
+// `parseFloat` is lenient (`"10abc" -> 10`); this gate rejects trailing garbage so a malformed value is a
+// loud failure (REQ-VALUETYPE-008), never a silent truncation.
+const NUMBER_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+export function parseNumericVerdict(raw) {
+    if (typeof raw === 'number') {
+        if (!Number.isFinite(raw)) {
+            return { parsed: null, refusal: `Cannot parse non-finite numeric value: ${raw}` };
+        }
+        return { parsed: { value: raw, unit: '' }, refusal: null };
+    }
+    const s = raw.trim();
+    // REQ-VALUETYPE-002: a single value has no interior whitespace (splits on whitespace to length 1).
+    if (s.length === 0 || /\s/.test(s)) {
+        return {
+            parsed: null,
+            refusal: `Cannot parse ${JSON.stringify(raw)} as a single numeric/unit value (empty or interior whitespace)`,
+        };
+    }
+    for (const unit of KNOWN_UNITS) {
+        if (s.length > unit.length && s.endsWith(unit)) {
+            const prefix = s.slice(0, s.length - unit.length);
+            if (NUMBER_RE.test(prefix)) {
+                return { parsed: { value: Number.parseFloat(prefix), unit }, refusal: null };
+            }
+            return {
+                parsed: null,
+                refusal: `Cannot parse ${JSON.stringify(raw)}: ${JSON.stringify(prefix)} is not a valid number before unit "${unit}"`,
+            };
+        }
+    }
+    if (NUMBER_RE.test(s))
+        return { parsed: { value: Number.parseFloat(s), unit: '' }, refusal: null };
+    return { parsed: null, refusal: `Cannot parse ${JSON.stringify(raw)} as a numeric or unit value` };
+}
+// Parse a raw string (or number) into a decomposed {value, unit}. Throws on unparseable input, interior
+// whitespace, or a malformed numeric prefix (REQ-VALUETYPE-008) — no silent coercion.
+export function parseNumeric(raw) {
+    const verdict = parseNumericVerdict(raw);
+    if (verdict.refusal !== null)
+        throw new Error(verdict.refusal);
+    return verdict.parsed;
+}
+// Family predicate for the dispatcher (mix.ts): does the whole raw string decompose as a single
+// number/unit value? Mirrors parseNumeric's acceptance without throwing — no interior whitespace, an
+// optional trailing KNOWN unit, a strict numeric prefix.
+export function isNumeric(raw) {
+    const s = raw.trim();
+    if (s.length === 0 || /\s/.test(s))
+        return false;
+    for (const unit of KNOWN_UNITS) {
+        if (s.length > unit.length && s.endsWith(unit)) {
+            return NUMBER_RE.test(s.slice(0, s.length - unit.length));
+        }
+    }
+    return NUMBER_RE.test(s);
+}
+// Project a typed value back to its committed form: a plain number transforms as the IDENTITY (returns
+// the number, not a string, REQ-VALUETYPE-001); a unit value re-appends its suffix.
+export function transformNumeric(v) {
+    if (v.unit === '')
+        return v.value;
+    return `${v.value}${v.unit}`;
+}
+// Interpolate `origin + (target − origin)·progress` (REQ-VALUETYPE-003, motion's mixNumber), but only
+// when the units are identical — a mismatch throws naming both raw values + units (REQ-VALUETYPE-004).
+export function mixNumeric(from, to, progress) {
+    if (from.unit !== to.unit) {
+        throw new Error(`Cannot interpolate mismatched units: "${transformNumeric(from)}" (unit "${from.unit || 'none'}") ` +
+            `against "${transformNumeric(to)}" (unit "${to.unit || 'none'}")`);
+    }
+    return { value: from.value + (to.value - from.value) * progress, unit: from.unit };
+}

package/dist/worklet-layout/config/constants.js

@@ -0,0 +1,39 @@
+'worklet';
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// Pinned motion-graph constants. Adopted from `motion@12.42.2` (see
+// `specs/OPEN-DECISIONS.md` §D resolutions log) and PROVEN equal to that pinned oracle by the M1b
+// conformance suite — these literals are a starting seed, not hand-authored ground truth. Never
+// widen an epsilon here to make a test pass (test-integrity); fix the code or ratify the constant.
+/**
+ * CORE-only velocity staleness window (ms). Governs `MotionValue.getVelocity` and the animation
+ * cold-start velocity seed. It does NOT govern the gesture path — that consumes platform release
+ * velocity (§D/§G). A value sample older than this reads velocity `0`.
+ */
+export const MAX_VELOCITY_DELTA_MS = 30;
+/**
+ * Per-frame elapsed-time ceiling (ms). Guards the graph against a large jump after backgrounding
+ * (REQ-CLOCK-003). Flagged for human confirmation. ~2.4 frames at 60Hz.
+ */
+export const DT_CLAMP_MS = 40;
+// Rest thresholds — adopted from Motion; the exact numerics and their conformance pin are owned by
+// SPEC-SPRING. Present here only so CORE has one source; SPRING tightens them.
+export const REST_DELTA = 0.01;
+export const REST_SPEED = 2;
+/** Granular rest-threshold discontinuity at `|target − origin| < 5` (Motion). */
+export const GRANULAR_THRESHOLD = 5;
+// Named epsilons — config, not literals in assertions. Nominal seeds from SPEC-CORE §5; final
+// values ratified with SPEC-SPRING and tightened against the pinned oracle in M1b.
+/** Velocity equality tolerance (units/sec). */
+export const EPS_VELOCITY = 1;
+/** Trajectory / dt-robustness tolerance (value units). */
+export const EPS_TRAJ = 0.5;
+/** Settle is exact to the frame. */
+export const EPS_SETTLE_FRAME = 0;
+/**
+ * The settle law's shared horizon (r12 4f6e2d1b8a70 / r13 minor 1d6f4b8a2e90 — ONE
+ * authority): validateTransition requires every accepted trajectory to be DONE by this
+ * instant (~285 millennia), and stepProp's precision-freeze termination samples the settled
+ * state at max(elapsed, this horizon). The pairing is what guarantees an accepted config
+ * reaches its settled value on every stepping cadence; the two consumers must never diverge.
+ */
+export const SETTLE_HORIZON_MS = 2 ** 53;

package/dist/worklet-layout/layout/constants.js

@@ -0,0 +1,11 @@
+'worklet';
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// SPEC-LAYOUT §4a pinned tolerances. Stated once, shared across the projection math, composition, and the
+// session. Position/scale epsilons gate identity-at-settle + counter-scale; the velocity epsilon gates
+// retarget C1 continuity (M4). These are invariant tolerances, not feel parameters — they do not widen.
+/** Position/edge coincidence tolerance (px): ends-at-host-layout, parent-relative coherence, C0 seam. */
+export const EPSILON_POS = 0.5;
+/** Child-size tolerance (fraction): a counter-scaled child stays within 1% of its intrinsic size. */
+export const EPSILON_SCALE = 0.01;
+/** Retarget velocity-continuity tolerance (px/s): the C1 seam when a layout change arrives mid-projection. */
+export const EPSILON_VEL = 1;