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

package/dist/value-types/complex.js

@@ -0,0 +1,155 @@
+// Complex/compound value types (SPEC-VALUE-TYPES §3, REQ-VALUETYPE-007/008). Tokenize a compound string
+// (borderRadius, box-shadow, transform lists) into an ordered list of typed slots (number+unit or color)
+// plus the literal separators between them, mix positionally, and recompose using the TARGET's separators.
+// Host-agnostic (REQ-VALUETYPE-011). Native TIGHTENS motion-dom: exact-count shape compatibility (motion
+// allows origin.count >= target.count), a per-slot unit-identity check (motion folds units into its split
+// template and silently re-applies the target's), and a loud throw where motion warns + snaps
+// (mixImmediate). motion carries bare numbers + a unit-bearing split; Native carries number+unit slots +
+// unit-free separators — the recompose STRING is byte-identical either way.
+import { KNOWN_UNITS } from "./constants.js";
+import { mixColor, parseColor, transformColor } from "./color.js";
+import { mixNumeric } from "./numeric.js";
+// Longest-match-first token recognizers (REQ-VALUETYPE-007). Sticky (`y`) so each is anchored at the
+// cursor. The hex branch grabs the WHOLE `#…` alphanumeric run (not a fixed 3/4/6/8 length) so a
+// malformed hex like `#12` or `#1234567` is captured in full and handed to parseColor, which throws
+// (REQ-VALUETYPE-008) — rather than the old fixed-length regex silently matching the `#123456` prefix and
+// leaving a stray `7` to tokenize as a bogus number. A bare `#` (no alnum after) is caught by an explicit
+// guard in the scan loop.
+const COLOR_TOKEN_RE = /#[0-9a-z]+|(?:rgba?|hsla?)\([^)]*\)/iy;
+const NUMBER_TOKEN_RE = /[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/iy;
+const VAR_TOKEN_RE = /var\(\s*--[^)]*\)/iy;
+// A color-function SIGIL (`rgb(`/`rgba(`/`hsl(`/`hsla(`). Non-sticky, tested against the remaining slice:
+// if a sigil is present but COLOR_TOKEN_RE could not consume a complete function, the function is
+// unclosed/malformed and must fail loud rather than silently tokenizing its interior numbers.
+const COLOR_SIGIL_RE = /^(?:rgba?|hsla?)\(/i;
+function matchStickyAt(re, raw, at) {
+    re.lastIndex = at;
+    const m = re.exec(raw);
+    return m !== null && m.index === at ? m[0] : null;
+}
+// A number token plus an optional trailing KNOWN unit. A non-KNOWN suffix (e.g. `em`) is left in the
+// template, matching motion — REQ-VALUETYPE-004's unit check only governs the units this subsystem owns.
+function matchNumberAt(raw, at) {
+    const numStr = matchStickyAt(NUMBER_TOKEN_RE, raw, at);
+    if (numStr === null)
+        return null;
+    const rest = raw.slice(at + numStr.length);
+    let unit = '';
+    for (const u of KNOWN_UNITS) {
+        if (rest.startsWith(u)) {
+            unit = u;
+            break;
+        }
+    }
+    return { value: Number.parseFloat(numStr), unit, length: numStr.length + unit.length };
+}
+export function parseComplex(raw) {
+    const slots = [];
+    const template = [];
+    let cursor = 0;
+    let literalStart = 0;
+    while (cursor < raw.length) {
+        // var() is web-only (REQ-VALUETYPE-007): on the native runtime it fails loud at parse, never silently
+        // becomes a literal.
+        if (matchStickyAt(VAR_TOKEN_RE, raw, cursor) !== null) {
+            throw new Error(`CSS variable tokens are web-only and cannot be parsed on the native runtime: ${JSON.stringify(raw)}`);
+        }
+        // color BEFORE number (longest-match-first): rgba(…) wins over the bare `0` at its opening paren.
+        const color = matchStickyAt(COLOR_TOKEN_RE, raw, cursor);
+        if (color !== null) {
+            template.push(raw.slice(literalStart, cursor));
+            slots.push({ kind: 'color', value: parseColor(color) });
+            cursor += color.length;
+            literalStart = cursor;
+            continue;
+        }
+        const num = matchNumberAt(raw, cursor);
+        if (num !== null) {
+            template.push(raw.slice(literalStart, cursor));
+            slots.push({ kind: 'number', value: num.value, unit: num.unit });
+            cursor += num.length;
+            literalStart = cursor;
+            continue;
+        }
+        // A color SIGIL the color branch could not accept — a bare/malformed `#`, or an unclosed/malformed
+        // `rgb()`/`hsl()` — is a malformed color, never literal template filler: fail loud (REQ-VALUETYPE-008)
+        // so it can never silently split into a `#`/`rgb(` literal plus bogus downstream numbers. An unknown
+        // keyword WITHOUT a sigil (`solid`, `inset`, `rgbicon`) stays a legitimate literal.
+        if (raw.charAt(cursor) === '#' || COLOR_SIGIL_RE.test(raw.slice(cursor))) {
+            throw new Error(`Malformed color token at index ${cursor} in complex value ${JSON.stringify(raw)}`);
+        }
+        cursor++;
+    }
+    template.push(raw.slice(literalStart));
+    if (slots.length === 0) {
+        throw new Error(`No animatable tokens (number/color) in complex value ${JSON.stringify(raw)}`);
+    }
+    return { slots, template };
+}
+// motion's mixComplex recompose runs each interpolated number through `sanitize` (round to 5 decimals) —
+// note this is a DIVERGENCE from motion's STANDALONE number/unit transform, which is raw (see numeric.ts).
+// Native mirrors motion per-path for byte-parity: raw standalone (transformNumeric), sanitized in complex.
+function sanitize(v) {
+    return Math.round(v * 1e5) / 1e5;
+}
+function transformSlot(slot) {
+    if (slot.kind === 'color')
+        return transformColor(slot.value);
+    const v = sanitize(slot.value);
+    return slot.unit === '' ? String(v) : `${v}${slot.unit}`;
+}
+export function transformComplex(v) {
+    let out = v.template[0] ?? '';
+    for (let i = 0; i < v.slots.length; i++) {
+        const slot = v.slots[i];
+        if (slot === undefined)
+            continue; // unreachable: i < slots.length
+        out += transformSlot(slot) + (v.template[i + 1] ?? '');
+    }
+    return out;
+}
+function countByKind(v) {
+    let number = 0;
+    let color = 0;
+    for (const s of v.slots) {
+        if (s.kind === 'color')
+            color++;
+        else
+            number++;
+    }
+    return { number, color };
+}
+// Exact-count shape compatibility (REQ-VALUETYPE-007): motion mixes when origin.count >= target.count and
+// snaps the excess; Native requires the counts to match exactly and fails loud otherwise.
+function assertShapeCompatible(from, to) {
+    const cf = countByKind(from);
+    const ct = countByKind(to);
+    if (cf.number !== ct.number || cf.color !== ct.color) {
+        throw new Error(`Complex values are shape-incompatible: origin ${JSON.stringify(transformComplex(from))} has ` +
+            `${cf.number} number(s)/${cf.color} color(s), target ${JSON.stringify(transformComplex(to))} has ` +
+            `${ct.number} number(s)/${ct.color} color(s) — counts must match exactly`);
+    }
+}
+// Positionally mix each slot: numbers via mixNumeric (which enforces the per-slot unit-identity check,
+// REQ-VALUETYPE-004), colors via the gamma-aware mixColor. Recompose with the TARGET's template
+// (REQ-VALUETYPE-007). A same-count but positional type mismatch (number vs color at a slot) is a loud
+// failure (REQ-VALUETYPE-008).
+export function mixComplex(from, to, progress) {
+    assertShapeCompatible(from, to);
+    const slots = to.slots.map((toSlot, i) => {
+        const fromSlot = from.slots[i];
+        if (fromSlot === undefined) {
+            throw new Error(`Missing origin slot ${i} for complex mix`); // unreachable after shape check
+        }
+        if (fromSlot.kind === 'number' && toSlot.kind === 'number') {
+            const mixed = mixNumeric({ value: fromSlot.value, unit: fromSlot.unit }, { value: toSlot.value, unit: toSlot.unit }, progress);
+            return { kind: 'number', value: mixed.value, unit: mixed.unit };
+        }
+        if (fromSlot.kind === 'color' && toSlot.kind === 'color') {
+            return { kind: 'color', value: mixColor(fromSlot.value, toSlot.value, progress) };
+        }
+        throw new Error(`Type mismatch at slot ${i}: origin is ${fromSlot.kind}, target is ${toSlot.kind} — ` +
+            `${JSON.stringify(transformComplex(from))} vs ${JSON.stringify(transformComplex(to))}`);
+    });
+    return { slots, template: to.template };
+}

package/dist/value-types/constants.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_UNITS = exports.EPS_COLOR_CHANNEL = exports.EPS_UNITLESS = exports.EPS_ANGLE = exports.EPS_LENGTH = void 0;
+// Ratified normalization floors (SPEC-VALUE-TYPES §5), adopted VERBATIM from REQ-SUBSET-016 so this
+// subsystem's internal golden-vector floor and the cross-engine comparator's floor never drift apart as
+// two independently-set numbers. Never widened to force a red assertion green.
+exports.EPS_LENGTH = 0.5; // length-unit-equivalent (px, vw, vh)
+exports.EPS_ANGLE = 1e-3; // deg (and the `rad` extension)
+exports.EPS_UNITLESS = 1e-4; // plain numbers, %
+exports.EPS_COLOR_CHANNEL = 1 / 255; // per-channel RGBA (Milestone 2)
+// The unit tokens this subsystem recognizes (REQ-VALUETYPE-002). `px`/`%`/`deg`/`vw`/`vh` mirror
+// motion-dom's unit value types; `rad` is a Native-only extension for React Native's radian `rotate`
+// (no motion counterpart — its web mapping is degrees-conversion in the shim, not here). Listed
+// longest-first so suffix detection is unambiguous even if a future unit is a suffix of another.
+exports.KNOWN_UNITS = ['deg', 'rad', 'px', 'vw', 'vh', '%'];

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

@@ -0,0 +1,6 @@
+export declare const EPS_LENGTH = 0.5;
+export declare const EPS_ANGLE = 0.001;
+export declare const EPS_UNITLESS = 0.0001;
+export declare const EPS_COLOR_CHANNEL: number;
+export declare const KNOWN_UNITS: readonly ["deg", "rad", "px", "vw", "vh", "%"];
+export type KnownUnit = (typeof KNOWN_UNITS)[number];

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

@@ -0,0 +1,6 @@
+export declare const EPS_LENGTH = 0.5;
+export declare const EPS_ANGLE = 0.001;
+export declare const EPS_UNITLESS = 0.0001;
+export declare const EPS_COLOR_CHANNEL: number;
+export declare const KNOWN_UNITS: readonly ["deg", "rad", "px", "vw", "vh", "%"];
+export type KnownUnit = (typeof KNOWN_UNITS)[number];

package/dist/value-types/constants.js

@@ -0,0 +1,12 @@
+// Ratified normalization floors (SPEC-VALUE-TYPES §5), adopted VERBATIM from REQ-SUBSET-016 so this
+// subsystem's internal golden-vector floor and the cross-engine comparator's floor never drift apart as
+// two independently-set numbers. Never widened to force a red assertion green.
+export const EPS_LENGTH = 0.5; // length-unit-equivalent (px, vw, vh)
+export const EPS_ANGLE = 1e-3; // deg (and the `rad` extension)
+export const EPS_UNITLESS = 1e-4; // plain numbers, %
+export const EPS_COLOR_CHANNEL = 1 / 255; // per-channel RGBA (Milestone 2)
+// The unit tokens this subsystem recognizes (REQ-VALUETYPE-002). `px`/`%`/`deg`/`vw`/`vh` mirror
+// motion-dom's unit value types; `rad` is a Native-only extension for React Native's radian `rotate`
+// (no motion counterpart — its web mapping is degrees-conversion in the shim, not here). Listed
+// longest-first so suffix detection is unambiguous even if a future unit is a suffix of another.
+export const KNOWN_UNITS = ['deg', 'rad', 'px', 'vw', 'vh', '%'];

package/dist/value-types/discrete.cjs

@@ -0,0 +1,62 @@
+"use strict";
+// The DISCRETE keyword family (T23 B; pin motion-dom mix/visibility.ts and mix/complex.ts):
+// single-keyword zero-token strings — CSS keywords like display/visibility values — that are not
+// auto/calc/numeric/color.
+//
+// The pin answers this family through TWO paths, and which one it takes is not a property of the
+// keywords alone (H3, REQ-VALUETYPE-015):
+//
+//   1. `mixVisibility` — taken only when an endpoint is in {none, hidden} AND its COUNTERPART has
+//      zero interpolable values. That is the step law: an invisible ORIGIN shows the target once
+//      p > 0, an invisible TARGET holds the origin until p >= 1, and the origin arm is checked
+//      first, so a both-invisible pair takes it.
+//   2. Otherwise `mixComplex`'s ordinary path, where `canInterpolate` holds and the transformer is
+//      built from the TARGET. With zero target slots it has nothing to substitute, so it publishes
+//      the target as a CONSTANT — at every progress, in or out of range.
+//
+// A both-visible pair takes (2). It is a constant, NOT a step: at p <= 0 it already reads the
+// target, which is what separates it from `mixImmediate` and from either visibility arm. Native
+// refused this pair until H3; refusing it was native being stricter than the pin, which the
+// fidelity doctrine does not permit.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVISIBLE_DISCRETE_VALUES = void 0;
+exports.isDiscreteKeyword = isDiscreteKeyword;
+exports.mixDiscrete = mixDiscrete;
+exports.transformDiscrete = transformDiscrete;
+// The pin set (mix/visibility.ts invisibleValues), exactly.
+exports.INVISIBLE_DISCRETE_VALUES = new Set(['none', 'hidden']);
+const DISCRETE_KEYWORD_PATTERN = /^[a-zA-Z-]+$/;
+// A single-keyword shape. Callers order this AFTER auto/calc/numeric/color detection — the
+// pattern alone would also match 'auto' and named colors, whose families win by parse order.
+function isDiscreteKeyword(raw) {
+    return DISCRETE_KEYWORD_PATTERN.test(raw);
+}
+// The pin's two paths, in its own branch order. The visibility arms come first and the ORIGIN arm
+// before the TARGET arm, exactly like `mixVisibility`, so a both-invisible pair takes the origin
+// arm. Progress arrives unclamped; the pin compares p <= 0 / p >= 1.
+//
+// Both endpoints visible falls through to the zero-slot constant. Every discrete keyword has zero
+// interpolable slots by construction (`isDiscreteKeyword` is a single bare keyword), so the
+// target's transformer can only ever be the target itself — there is no progress at which this
+// answers anything else, and no clamping to do.
+function mixDiscrete(from, to, progress) {
+    // Both endpoints must actually BE discrete keywords. The arms below are total over that family,
+    // so without this an out-of-family endpoint would fall through the visibility arms and be
+    // returned silently — the class of quiet acceptance this engine refuses everywhere. The seam one
+    // level up (parseValue → mix) already refuses cross-family pairs, so this guards the EXPORTED
+    // symbol against a direct call rather than any product path. A plain Error: an unknown shape is
+    // an authoring error at a boundary that has already typed its own refusals.
+    if (!isDiscreteKeyword(from) || !isDiscreteKeyword(to)) {
+        throw new Error(`mixDiscrete: both endpoints must be discrete keywords — got "${from}" → "${to}"`);
+    }
+    if (exports.INVISIBLE_DISCRETE_VALUES.has(from)) {
+        return progress <= 0 ? from : to;
+    }
+    if (exports.INVISIBLE_DISCRETE_VALUES.has(to)) {
+        return progress >= 1 ? to : from;
+    }
+    return to;
+}
+function transformDiscrete(value) {
+    return value;
+}

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

@@ -0,0 +1,4 @@
+export declare const INVISIBLE_DISCRETE_VALUES: ReadonlySet<string>;
+export declare function isDiscreteKeyword(raw: string): boolean;
+export declare function mixDiscrete(from: string, to: string, progress: number): string;
+export declare function transformDiscrete(value: string): string;

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

@@ -0,0 +1,4 @@
+export declare const INVISIBLE_DISCRETE_VALUES: ReadonlySet<string>;
+export declare function isDiscreteKeyword(raw: string): boolean;
+export declare function mixDiscrete(from: string, to: string, progress: number): string;
+export declare function transformDiscrete(value: string): string;

package/dist/value-types/discrete.js

@@ -0,0 +1,56 @@
+// The DISCRETE keyword family (T23 B; pin motion-dom mix/visibility.ts and mix/complex.ts):
+// single-keyword zero-token strings — CSS keywords like display/visibility values — that are not
+// auto/calc/numeric/color.
+//
+// The pin answers this family through TWO paths, and which one it takes is not a property of the
+// keywords alone (H3, REQ-VALUETYPE-015):
+//
+//   1. `mixVisibility` — taken only when an endpoint is in {none, hidden} AND its COUNTERPART has
+//      zero interpolable values. That is the step law: an invisible ORIGIN shows the target once
+//      p > 0, an invisible TARGET holds the origin until p >= 1, and the origin arm is checked
+//      first, so a both-invisible pair takes it.
+//   2. Otherwise `mixComplex`'s ordinary path, where `canInterpolate` holds and the transformer is
+//      built from the TARGET. With zero target slots it has nothing to substitute, so it publishes
+//      the target as a CONSTANT — at every progress, in or out of range.
+//
+// A both-visible pair takes (2). It is a constant, NOT a step: at p <= 0 it already reads the
+// target, which is what separates it from `mixImmediate` and from either visibility arm. Native
+// refused this pair until H3; refusing it was native being stricter than the pin, which the
+// fidelity doctrine does not permit.
+// The pin set (mix/visibility.ts invisibleValues), exactly.
+export const INVISIBLE_DISCRETE_VALUES = new Set(['none', 'hidden']);
+const DISCRETE_KEYWORD_PATTERN = /^[a-zA-Z-]+$/;
+// A single-keyword shape. Callers order this AFTER auto/calc/numeric/color detection — the
+// pattern alone would also match 'auto' and named colors, whose families win by parse order.
+export function isDiscreteKeyword(raw) {
+    return DISCRETE_KEYWORD_PATTERN.test(raw);
+}
+// The pin's two paths, in its own branch order. The visibility arms come first and the ORIGIN arm
+// before the TARGET arm, exactly like `mixVisibility`, so a both-invisible pair takes the origin
+// arm. Progress arrives unclamped; the pin compares p <= 0 / p >= 1.
+//
+// Both endpoints visible falls through to the zero-slot constant. Every discrete keyword has zero
+// interpolable slots by construction (`isDiscreteKeyword` is a single bare keyword), so the
+// target's transformer can only ever be the target itself — there is no progress at which this
+// answers anything else, and no clamping to do.
+export function mixDiscrete(from, to, progress) {
+    // Both endpoints must actually BE discrete keywords. The arms below are total over that family,
+    // so without this an out-of-family endpoint would fall through the visibility arms and be
+    // returned silently — the class of quiet acceptance this engine refuses everywhere. The seam one
+    // level up (parseValue → mix) already refuses cross-family pairs, so this guards the EXPORTED
+    // symbol against a direct call rather than any product path. A plain Error: an unknown shape is
+    // an authoring error at a boundary that has already typed its own refusals.
+    if (!isDiscreteKeyword(from) || !isDiscreteKeyword(to)) {
+        throw new Error(`mixDiscrete: both endpoints must be discrete keywords — got "${from}" → "${to}"`);
+    }
+    if (INVISIBLE_DISCRETE_VALUES.has(from)) {
+        return progress <= 0 ? from : to;
+    }
+    if (INVISIBLE_DISCRETE_VALUES.has(to)) {
+        return progress >= 1 ? to : from;
+    }
+    return to;
+}
+export function transformDiscrete(value) {
+    return value;
+}

package/dist/value-types/index.cjs

@@ -0,0 +1,59 @@
+"use strict";
+// Public surface of the SPEC-VALUE-TYPES subsystem: the unified mix() seam plus the per-family
+// parse/transform/mix functions and their typed value shapes. Host-agnostic (REQ-VALUETYPE-011) — drivers
+// (native + web shim) depend on this; it depends on no host. Re-exported additively from the core index.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLengthToPx = exports.POSITIONAL_LENGTH_AXES = exports.parseLengthTarget = exports.needsLengthMeasureResolve = exports.MeasureResolveContextError = exports.isPositionalLengthAxis = exports.isLengthTarget = exports.isCalc = exports.isAuto = exports.transformValue = exports.parseValue = exports.mix = exports.transformDiscrete = exports.mixDiscrete = exports.isDiscreteKeyword = exports.transformComplex = exports.parseComplex = exports.mixComplex = exports.NAMED_COLORS = exports.transformColor = exports.parseColor = exports.mixColor = exports.isColor = exports.transformNumeric = exports.parseNumeric = exports.mixNumeric = exports.isNumeric = exports.KNOWN_UNITS = exports.EPS_UNITLESS = exports.EPS_LENGTH = exports.EPS_COLOR_CHANNEL = exports.EPS_ANGLE = void 0;
+var constants_1 = require("./constants.cjs");
+Object.defineProperty(exports, "EPS_ANGLE", { enumerable: true, get: function () { return constants_1.EPS_ANGLE; } });
+Object.defineProperty(exports, "EPS_COLOR_CHANNEL", { enumerable: true, get: function () { return constants_1.EPS_COLOR_CHANNEL; } });
+Object.defineProperty(exports, "EPS_LENGTH", { enumerable: true, get: function () { return constants_1.EPS_LENGTH; } });
+Object.defineProperty(exports, "EPS_UNITLESS", { enumerable: true, get: function () { return constants_1.EPS_UNITLESS; } });
+Object.defineProperty(exports, "KNOWN_UNITS", { enumerable: true, get: function () { return constants_1.KNOWN_UNITS; } });
+// The verdict-shaped parse forms are CORE-INTERNAL (M3 r8 major 4a5b686f1f5f / r9 major
+// 9245b65f280e): the ratified VALUE-TYPES public seam enumerates the throwing parse APIs
+// only — internal consumers import the verdicts from the modules directly, and
+// publicSurface.test.ts pins their absence from this barrel.
+var numeric_1 = require("./numeric.cjs");
+Object.defineProperty(exports, "isNumeric", { enumerable: true, get: function () { return numeric_1.isNumeric; } });
+Object.defineProperty(exports, "mixNumeric", { enumerable: true, get: function () { return numeric_1.mixNumeric; } });
+Object.defineProperty(exports, "parseNumeric", { enumerable: true, get: function () { return numeric_1.parseNumeric; } });
+Object.defineProperty(exports, "transformNumeric", { enumerable: true, get: function () { return numeric_1.transformNumeric; } });
+var color_1 = require("./color.cjs");
+Object.defineProperty(exports, "isColor", { enumerable: true, get: function () { return color_1.isColor; } });
+Object.defineProperty(exports, "mixColor", { enumerable: true, get: function () { return color_1.mixColor; } });
+Object.defineProperty(exports, "parseColor", { enumerable: true, get: function () { return color_1.parseColor; } });
+Object.defineProperty(exports, "transformColor", { enumerable: true, get: function () { return color_1.transformColor; } });
+var named_colors_1 = require("./named-colors.cjs");
+Object.defineProperty(exports, "NAMED_COLORS", { enumerable: true, get: function () { return named_colors_1.NAMED_COLORS; } });
+var complex_1 = require("./complex.cjs");
+Object.defineProperty(exports, "mixComplex", { enumerable: true, get: function () { return complex_1.mixComplex; } });
+Object.defineProperty(exports, "parseComplex", { enumerable: true, get: function () { return complex_1.parseComplex; } });
+Object.defineProperty(exports, "transformComplex", { enumerable: true, get: function () { return complex_1.transformComplex; } });
+// T23 B: the discrete keyword family's shape guard + mix/transform join the seam surface (the
+// native projection parity test + the native controller's discrete lane consume them); the
+// invisible-set constant stays module-internal per this barrel's own law until a consumer
+// ratifies it.
+var discrete_1 = require("./discrete.cjs");
+Object.defineProperty(exports, "isDiscreteKeyword", { enumerable: true, get: function () { return discrete_1.isDiscreteKeyword; } });
+Object.defineProperty(exports, "mixDiscrete", { enumerable: true, get: function () { return discrete_1.mixDiscrete; } });
+Object.defineProperty(exports, "transformDiscrete", { enumerable: true, get: function () { return discrete_1.transformDiscrete; } });
+var mix_1 = require("./mix.cjs");
+Object.defineProperty(exports, "mix", { enumerable: true, get: function () { return mix_1.mix; } });
+Object.defineProperty(exports, "parseValue", { enumerable: true, get: function () { return mix_1.parseValue; } });
+Object.defineProperty(exports, "transformValue", { enumerable: true, get: function () { return mix_1.transformValue; } });
+// R13 value-breadth (REQ-VALUETYPE-013/014): positional measure-resolve pure seam.
+// Throwing + type public surface only — verdict helpers stay module-internal (same law as
+// parseNumericVerdict): internal consumers import from `./measure-resolve` directly, and the
+// key-aware executable-matrix WALKER (a string|null refusal — verdict-shaped by this barrel's
+// own law, review ab7c5370fc5a) rides the internal-driver seam, never this barrel.
+var measure_resolve_1 = require("./measure-resolve.cjs");
+Object.defineProperty(exports, "isAuto", { enumerable: true, get: function () { return measure_resolve_1.isAuto; } });
+Object.defineProperty(exports, "isCalc", { enumerable: true, get: function () { return measure_resolve_1.isCalc; } });
+Object.defineProperty(exports, "isLengthTarget", { enumerable: true, get: function () { return measure_resolve_1.isLengthTarget; } });
+Object.defineProperty(exports, "isPositionalLengthAxis", { enumerable: true, get: function () { return measure_resolve_1.isPositionalLengthAxis; } });
+Object.defineProperty(exports, "MeasureResolveContextError", { enumerable: true, get: function () { return measure_resolve_1.MeasureResolveContextError; } });
+Object.defineProperty(exports, "needsLengthMeasureResolve", { enumerable: true, get: function () { return measure_resolve_1.needsLengthMeasureResolve; } });
+Object.defineProperty(exports, "parseLengthTarget", { enumerable: true, get: function () { return measure_resolve_1.parseLengthTarget; } });
+Object.defineProperty(exports, "POSITIONAL_LENGTH_AXES", { enumerable: true, get: function () { return measure_resolve_1.POSITIONAL_LENGTH_AXES; } });
+Object.defineProperty(exports, "resolveLengthToPx", { enumerable: true, get: function () { return measure_resolve_1.resolveLengthToPx; } });

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

@@ -0,0 +1,14 @@
+export { EPS_ANGLE, EPS_COLOR_CHANNEL, EPS_LENGTH, EPS_UNITLESS, KNOWN_UNITS } from "./constants.cjs";
+export type { KnownUnit } from "./constants.cjs";
+export { isNumeric, mixNumeric, parseNumeric, transformNumeric } from "./numeric.cjs";
+export type { NumericValue } from "./numeric.cjs";
+export { isColor, mixColor, parseColor, transformColor } from "./color.cjs";
+export type { RGBA } from "./color.cjs";
+export { NAMED_COLORS } from "./named-colors.cjs";
+export { mixComplex, parseComplex, transformComplex } from "./complex.cjs";
+export type { ComplexValue, Slot } from "./complex.cjs";
+export { isDiscreteKeyword, mixDiscrete, transformDiscrete } from "./discrete.cjs";
+export { mix, parseValue, transformValue } from "./mix.cjs";
+export type { TypedValue } from "./mix.cjs";
+export { isAuto, isCalc, isLengthTarget, isPositionalLengthAxis, MeasureResolveContextError, needsLengthMeasureResolve, parseLengthTarget, POSITIONAL_LENGTH_AXES, resolveLengthToPx, } from "./measure-resolve.cjs";
+export type { LengthLayoutContext, MeasureResolveContextReason, ParsedLengthTarget, PositionalLengthAxis, } from "./measure-resolve.cjs";

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

@@ -0,0 +1,14 @@
+export { EPS_ANGLE, EPS_COLOR_CHANNEL, EPS_LENGTH, EPS_UNITLESS, KNOWN_UNITS } from "./constants.js";
+export type { KnownUnit } from "./constants.js";
+export { isNumeric, mixNumeric, parseNumeric, transformNumeric } from "./numeric.js";
+export type { NumericValue } from "./numeric.js";
+export { isColor, mixColor, parseColor, transformColor } from "./color.js";
+export type { RGBA } from "./color.js";
+export { NAMED_COLORS } from "./named-colors.js";
+export { mixComplex, parseComplex, transformComplex } from "./complex.js";
+export type { ComplexValue, Slot } from "./complex.js";
+export { isDiscreteKeyword, mixDiscrete, transformDiscrete } from "./discrete.js";
+export { mix, parseValue, transformValue } from "./mix.js";
+export type { TypedValue } from "./mix.js";
+export { isAuto, isCalc, isLengthTarget, isPositionalLengthAxis, MeasureResolveContextError, needsLengthMeasureResolve, parseLengthTarget, POSITIONAL_LENGTH_AXES, resolveLengthToPx, } from "./measure-resolve.js";
+export type { LengthLayoutContext, MeasureResolveContextReason, ParsedLengthTarget, PositionalLengthAxis, } from "./measure-resolve.js";

package/dist/value-types/index.js

@@ -0,0 +1,24 @@
+// Public surface of the SPEC-VALUE-TYPES subsystem: the unified mix() seam plus the per-family
+// parse/transform/mix functions and their typed value shapes. Host-agnostic (REQ-VALUETYPE-011) — drivers
+// (native + web shim) depend on this; it depends on no host. Re-exported additively from the core index.
+export { EPS_ANGLE, EPS_COLOR_CHANNEL, EPS_LENGTH, EPS_UNITLESS, KNOWN_UNITS } from "./constants.js";
+// The verdict-shaped parse forms are CORE-INTERNAL (M3 r8 major 4a5b686f1f5f / r9 major
+// 9245b65f280e): the ratified VALUE-TYPES public seam enumerates the throwing parse APIs
+// only — internal consumers import the verdicts from the modules directly, and
+// publicSurface.test.ts pins their absence from this barrel.
+export { isNumeric, mixNumeric, parseNumeric, transformNumeric } from "./numeric.js";
+export { isColor, mixColor, parseColor, transformColor } from "./color.js";
+export { NAMED_COLORS } from "./named-colors.js";
+export { mixComplex, parseComplex, transformComplex } from "./complex.js";
+// T23 B: the discrete keyword family's shape guard + mix/transform join the seam surface (the
+// native projection parity test + the native controller's discrete lane consume them); the
+// invisible-set constant stays module-internal per this barrel's own law until a consumer
+// ratifies it.
+export { isDiscreteKeyword, mixDiscrete, transformDiscrete } from "./discrete.js";
+export { mix, parseValue, transformValue } from "./mix.js";
+// R13 value-breadth (REQ-VALUETYPE-013/014): positional measure-resolve pure seam.
+// Throwing + type public surface only — verdict helpers stay module-internal (same law as
+// parseNumericVerdict): internal consumers import from `./measure-resolve` directly, and the
+// key-aware executable-matrix WALKER (a string|null refusal — verdict-shaped by this barrel's
+// own law, review ab7c5370fc5a) rides the internal-driver seam, never this barrel.
+export { isAuto, isCalc, isLengthTarget, isPositionalLengthAxis, MeasureResolveContextError, needsLengthMeasureResolve, parseLengthTarget, POSITIONAL_LENGTH_AXES, resolveLengthToPx, } from "./measure-resolve.js";