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

package/dist/inertia.js

@@ -0,0 +1,212 @@
+'worklet';
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// Two-phase inertia generator (SPEC-GESTURE REQ-GESTURE-016/-023/-027, R16 packet): a pure
+// closed-form exponential-decay evaluator with a latched boundary spring, pinned verbatim to
+// motion-dom@12.42.2 `inertia()` under the drag-layer invocation
+// (VisualElementDragControls.startAnimation: timeConstant 750, power 0.8, restDelta 1,
+// restSpeed 10, elastic-conditional bounce pairs). Host-agnostic (REQ-CORE-003): imports nothing
+// from motion/react. Parity is proven by golden traces in inertia.test.ts.
+//
+// Pin semantics (motion-dom inertia.ts, replicated exactly):
+//   amplitude = power · velocity        (px — the time constant absorbs the unit)
+//   target    = origin + amplitude      (free-drag: no modifyTarget)
+//   value(t)  = target − amplitude·e^(−t/timeConstant)
+//   done      = |amplitude·e^(−t/timeConstant)| ≤ restDelta  (value snaps to target)
+// Every sample, if the value lies outside [min, max] — INCLUDING a snapped out-of-bounds target —
+// the generator permanently switches to a spring from that value toward the violated bound,
+// seeded with the decay velocity at the crossing instant (stiffness/damping = bounce params).
+// An out-of-bounds origin latches the boundary spring at t=0 (the past-bound release,
+// REQ-GESTURE-016). The decay's initial velocity is amplitude/timeConstant, NOT the seeded
+// velocity — this is the pin's curve, and the goldens hold it.
+// spring.ts's rest-threshold constants (REQ-SPRING-003/-011), pinned to the same motion
+// springDefaults source: the under/critical latch used to defer to springGenerator for this
+// resolution, so the repair reproduces it verbatim — scale switch at |Δ| < 5, granular
+// 0.01/0.005, default 2/0.5, zero-as-absent (`||`, never `??`).
+const BOUNDARY_GRANULAR_SCALE = 5;
+const BOUNDARY_REST_SPEED = { default: 2, granular: 0.01 };
+const BOUNDARY_REST_DELTA = { default: 0.5, granular: 0.005 };
+/**
+ * Build an inertia `GeneratorFactory` from pinned physics. The seed supplies the origin (`from`)
+ * and the release velocity (`velocity`, px/s — dragMomentum=false hands 0, the pin's
+ * `velocity: dragMomentum ? v : 0`).
+ */
+// alloc-ok: lifecycle-edge — the factory binds physics once per animate command; per-frame work
+// is sample() below. The boundary spring's coefficients latch into one preallocated
+// BoundarySpringState (packet §6: no closure, sample record, generator object, or
+// springGenerator factory at the crossing); sample() itself allocates nothing.
+export function inertiaGenerator(physics) {
+    const { power, timeConstant, bounceStiffness, bounceDamping, restDelta, restSpeed } = physics;
+    const min = physics.min;
+    const max = physics.max;
+    return (seed) => {
+        const amplitude = power * seed.velocity;
+        const target = seed.from + amplitude;
+        const decayDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
+        const decayValue = (t) => target + decayDelta(t);
+        // Analytic decay velocity (px/s): d/dt[target − amplitude·e^(−t/tc)] = amplitude/tc·e^(−t/tc) px/ms.
+        const decayVelocity = (t) => (amplitude / timeConstant) * Math.exp(-t / timeConstant) * 1000;
+        const outOfBounds = (v) => {
+            if (min !== undefined && v < min)
+                return min;
+            if (max !== undefined && v > max)
+                return max;
+            return undefined;
+        };
+        // Boundary-spring latch (the pin's timeReachedBoundary + spring, created on first OOB sample).
+        let crossingT;
+        // One preallocated state per generator — reset at the latch, sampled in place per frame.
+        const boundaryState = {
+            bound: 0,
+            from: seed.from,
+            velocity: 0,
+            initialDelta: 0,
+            initialVelocity: 0,
+            restSpeed,
+            restDelta,
+            wd: 0,
+            a: 0,
+            sinCoeff: 0,
+            cosCoeff: 0,
+            c: 0,
+            sinhCoeff: 0,
+            coshCoeff: 0,
+        };
+        // The pin's overdamped branch with its sinh/cosh exponent cap (motion-dom spring.ts:340-374,
+        // the #1207 mechanism — `Math.min(dampedAngularFreq*t, 300)`). Cross-engine parity: the pin
+        // uses the capped form for EVERY overdamped boundary spring (bounceZ > 1), so this generator
+        // does the same — the capped form is the pin's own formula, fp behavior included. Selecting
+        // it only when the cap engages within one frame diverges for intermediate overdamped pairs
+        // (review r3 major 1: bounceStiffness 10000/damping 30000 caps at ~20ms; core's cap-free
+        // solver stays unsettled past 200ms where the pin settles at 70ms). Under/critically-damped
+        // pairs (bounceZ ≤ 1) stay on core's solver — the pin's own branches there are the same
+        // cap-free math (golden regime continuity).
+        const bounceOmega0 = Math.sqrt(bounceStiffness / 1) / 1000; // rad/ms (mass 1)
+        const bounceZ = bounceDamping / (2 * Math.sqrt(bounceStiffness * 1));
+        const bounceDampedFreq = bounceZ > 1 ? bounceOmega0 * Math.sqrt(bounceZ * bounceZ - 1) : 0;
+        // Write target/origin/velocity and the primitive coefficients for the latched regime —
+        // spring.ts's exact closed forms for under/critical (including its REQ-SPRING-011 scale
+        // thresholds and pinned zero-as-absent || fallback) and the pin's capped overdamped branch
+        // (raw physics thresholds, as at HEAD). Runs at the initial or mid-flight latch only.
+        function resetBoundarySpringState(bound, from, velocity, state) {
+            state.bound = bound;
+            state.from = from;
+            state.velocity = velocity;
+            const delta = bound - from; // px (pin: initialDelta = target − origin)
+            const v0 = -velocity / 1000; // px/ms (pin: −millisecondsToSeconds; spring.ts REQ-SPRING-008)
+            state.initialDelta = delta;
+            state.initialVelocity = v0;
+            if (bounceZ > 1) {
+                state.restSpeed = restSpeed;
+                state.restDelta = restDelta;
+                const P = (v0 + bounceZ * bounceOmega0 * delta) / bounceDampedFreq;
+                state.sinhCoeff = bounceZ * bounceOmega0 * P - delta * bounceDampedFreq;
+                state.coshCoeff = bounceZ * bounceOmega0 * delta - P * bounceDampedFreq;
+                return;
+            }
+            // Under/critical latch — springGenerator's exact threshold resolution (scale defaults,
+            // granular switch, zero-as-absent) for the same { restDelta, restSpeed } settle input.
+            const granular = Math.abs(delta) < BOUNDARY_GRANULAR_SCALE;
+            state.restSpeed =
+                restSpeed || (granular ? BOUNDARY_REST_SPEED.granular : BOUNDARY_REST_SPEED.default);
+            state.restDelta =
+                restDelta || (granular ? BOUNDARY_REST_DELTA.granular : BOUNDARY_REST_DELTA.default);
+            if (bounceZ < 1) {
+                const wd = bounceOmega0 * Math.sqrt(1 - bounceZ * bounceZ);
+                const a = (v0 + bounceZ * bounceOmega0 * delta) / wd;
+                state.wd = wd;
+                state.a = a;
+                state.sinCoeff = bounceZ * bounceOmega0 * a + delta * wd;
+                state.cosCoeff = bounceZ * bounceOmega0 * delta - a * wd;
+            }
+            else {
+                state.c = v0 + bounceOmega0 * delta;
+            }
+        }
+        // Sample the latched boundary spring in place: underdamped, critical, and the pin's
+        // capped-overdamped branch — the exact spring.ts/capped-form math, no allocation.
+        function sampleBoundarySpringInto(elapsedMs, state, out) {
+            if (bounceZ > 1) {
+                const f = Math.min(bounceDampedFreq * elapsedMs, 300);
+                const envelope = Math.exp(-bounceZ * bounceOmega0 * elapsedMs);
+                const current = state.bound -
+                    (envelope *
+                        ((state.initialVelocity + bounceZ * bounceOmega0 * state.initialDelta) * Math.sinh(f) +
+                            bounceDampedFreq * state.initialDelta * Math.cosh(f))) /
+                        bounceDampedFreq;
+                const velocityNow = envelope * (state.sinhCoeff * Math.sinh(f) + state.coshCoeff * Math.cosh(f)) * 1000;
+                const done = Math.abs(velocityNow) <= state.restSpeed &&
+                    Math.abs(state.bound - current) <= state.restDelta;
+                out.value = done ? state.bound : current;
+                out.velocity = velocityNow;
+                out.done = done;
+                return;
+            }
+            let current;
+            let velocityPerMs;
+            if (bounceZ < 1) {
+                const env = Math.exp(-bounceZ * bounceOmega0 * elapsedMs);
+                current =
+                    state.bound -
+                        env *
+                            (state.a * Math.sin(state.wd * elapsedMs) +
+                                state.initialDelta * Math.cos(state.wd * elapsedMs));
+                velocityPerMs =
+                    env *
+                        (state.sinCoeff * Math.sin(state.wd * elapsedMs) +
+                            state.cosCoeff * Math.cos(state.wd * elapsedMs));
+            }
+            else {
+                current =
+                    state.bound -
+                        Math.exp(-bounceOmega0 * elapsedMs) * (state.initialDelta + state.c * elapsedMs);
+                velocityPerMs =
+                    Math.exp(-bounceOmega0 * elapsedMs) *
+                        (bounceOmega0 * state.c * elapsedMs - state.initialVelocity);
+            }
+            const velocity = velocityPerMs * 1000; // → px/s (REQ-SPRING-008)
+            const done = Math.abs(velocity) <= state.restSpeed && Math.abs(state.bound - current) <= state.restDelta;
+            out.value = done ? state.bound : current;
+            out.velocity = velocity;
+            out.done = done;
+        }
+        function latchBoundaryInto(bound, value, t, state) {
+            crossingT = t;
+            // The pin's seed (motion-dom getGeneratorVelocity at the latch): the 5ms backward
+            // finite-diff of the DECAY curve — which degenerates to 0 at t=0 (empty window), so an
+            // out-of-bounds origin springs from rest, never from the analytic decay velocity.
+            const prevT = Math.max(t - 5, 0);
+            const dt = t - prevT;
+            const seedVelocity = dt === 0 ? 0 : ((value - decayValue(prevT)) / dt) * 1000;
+            resetBoundarySpringState(bound, value, seedVelocity, state);
+        }
+        // The pin's checkCatchBoundary(0): an out-of-bounds origin springs from t=0.
+        const initialBound = outOfBounds(seed.from);
+        if (initialBound !== undefined)
+            latchBoundaryInto(initialBound, seed.from, 0, boundaryState);
+        const record = { value: seed.from, velocity: seed.velocity, done: false };
+        return {
+            sample(elapsedMs) {
+                if (crossingT !== undefined && elapsedMs >= crossingT) {
+                    sampleBoundarySpringInto(elapsedMs - crossingT, boundaryState, record);
+                    return record;
+                }
+                const delta = decayDelta(elapsedMs);
+                const decayDone = Math.abs(delta) <= restDelta;
+                const value = decayDone ? target : decayValue(elapsedMs);
+                const velocity = decayVelocity(elapsedMs);
+                // OOB check on the POST-friction value — the pin checks after applyFriction, so a decay
+                // that settles past the wall (out-of-bounds target) still engages the boundary spring.
+                const bound = outOfBounds(value);
+                if (bound !== undefined) {
+                    latchBoundaryInto(bound, value, elapsedMs, boundaryState);
+                    sampleBoundarySpringInto(0, boundaryState, record);
+                    return record;
+                }
+                record.value = value;
+                record.velocity = decayDone ? 0 : velocity;
+                record.done = decayDone;
+                return record;
+            },
+        };
+    };
+}

package/dist/instant.cjs

@@ -0,0 +1,66 @@
+"use strict";
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// U7a + transition-default-selection F5 — the INSTANT lane (the pin's makeAnimationInstant,
+// motion-dom@12.42.2 animation/interfaces/motion-value.ts:89-98,122-136). The pin's guard is
+// `type === false || (duration === 0 && !repeatDelay)` — TYPE-INDEPENDENT, so a zero authored
+// duration routes here exactly like the authored `{ type: false }` form; a repeatDelay-bearing
+// bag is exempt and keeps its generator (the zero-length timing base takes this same SHAPE at the
+// drivers, so the fold's plays hold the seed at t ≤ 0 and commit the final keyframe past it).
+// The pin SKIPS animation creation entirely and commits the final keyframe via `frame.update(() => {
+// onUpdate(finalKeyframe); onComplete() })` — next-frame, NEVER synchronously — and a nonzero
+// authored `delay` is HONORED (the pin zeroes delay only for the GLOBAL instantAnimations flag,
+// 7b's window — never for the authored form). In this repo's driver architecture every trajectory
+// is a `Generator` sampled by accumulated elapsed time, so the instant lane is the degenerate
+// one: it holds the seed value at t ≤ 0 (the command applies; nothing has committed yet) and
+// commits the final keyframe, done, at the first tick past it. The shared `delayGenerator`
+// rebase wraps it like any other trajectory, which is what honors the authored delay. No
+// spring/timing/keyframes resolution ever runs for this lane. Host-agnostic (REQ-CORE-003):
+// relative imports only.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantFinalKeyframe = instantFinalKeyframe;
+exports.instantGenerator = instantGenerator;
+/**
+ * The final keyframe of an instant target — the pin's `getFinalKeyframe`: a scalar rests at
+ * itself; a keyframe array rests at its LAST non-null element (validation guarantees one exists
+ * for an array target — a null FIRST element is the from-current form, R8-F2). Fail-loud on a
+ * target with no numeric terminal, never a silent 0 (the uiTerminalTarget law).
+ */
+// alloc-ok: lifecycle-edge — terminal-keyframe resolution at command time, never per frame.
+function instantFinalKeyframe(to) {
+    if (typeof to === 'number')
+        return to;
+    for (let index = to.length - 1; index >= 0; index--) {
+        const value = to[index];
+        if (value !== null && value !== undefined)
+            return value;
+    }
+    throw new Error('an instant transition needs a numeric terminal keyframe (REQ-API-033).');
+}
+/**
+ * The instant "trajectory": no generator math runs. `sample(0)` is the seed value, NOT done —
+ * the driver's command edge seeds committed from it, so the value does not move at command time
+ * (the pin's frame.update deferral). The first sample past zero commits the final keyframe and
+ * reports done, so the commit, the onUpdate marshal, and the settle edge all land on the
+ * driver's next update tick. Velocity is always 0 — there is no motion to measure.
+ */
+// alloc-ok: lifecycle-edge — generator construction at command time; the one reused sample
+// record is built here, never per frame (REQ-DRIVER-021).
+function instantGenerator(target) {
+    return (seed) => {
+        const out = { value: seed.from, velocity: 0, done: false };
+        return {
+            sample(elapsedMs) {
+                if (elapsedMs <= 0) {
+                    out.value = seed.from;
+                    out.velocity = 0;
+                    out.done = false;
+                    return out;
+                }
+                out.value = target;
+                out.velocity = 0;
+                out.done = true;
+                return out;
+            },
+        };
+    };
+}

package/dist/instant.d.cts

@@ -0,0 +1,16 @@
+import type { GeneratorFactory } from "./types.cjs";
+/**
+ * The final keyframe of an instant target — the pin's `getFinalKeyframe`: a scalar rests at
+ * itself; a keyframe array rests at its LAST non-null element (validation guarantees one exists
+ * for an array target — a null FIRST element is the from-current form, R8-F2). Fail-loud on a
+ * target with no numeric terminal, never a silent 0 (the uiTerminalTarget law).
+ */
+export declare function instantFinalKeyframe(to: number | readonly (number | null)[]): number;
+/**
+ * The instant "trajectory": no generator math runs. `sample(0)` is the seed value, NOT done —
+ * the driver's command edge seeds committed from it, so the value does not move at command time
+ * (the pin's frame.update deferral). The first sample past zero commits the final keyframe and
+ * reports done, so the commit, the onUpdate marshal, and the settle edge all land on the
+ * driver's next update tick. Velocity is always 0 — there is no motion to measure.
+ */
+export declare function instantGenerator(target: number): GeneratorFactory;

package/dist/instant.d.ts

@@ -0,0 +1,16 @@
+import type { GeneratorFactory } from "./types.js";
+/**
+ * The final keyframe of an instant target — the pin's `getFinalKeyframe`: a scalar rests at
+ * itself; a keyframe array rests at its LAST non-null element (validation guarantees one exists
+ * for an array target — a null FIRST element is the from-current form, R8-F2). Fail-loud on a
+ * target with no numeric terminal, never a silent 0 (the uiTerminalTarget law).
+ */
+export declare function instantFinalKeyframe(to: number | readonly (number | null)[]): number;
+/**
+ * The instant "trajectory": no generator math runs. `sample(0)` is the seed value, NOT done —
+ * the driver's command edge seeds committed from it, so the value does not move at command time
+ * (the pin's frame.update deferral). The first sample past zero commits the final keyframe and
+ * reports done, so the commit, the onUpdate marshal, and the settle edge all land on the
+ * driver's next update tick. Velocity is always 0 — there is no motion to measure.
+ */
+export declare function instantGenerator(target: number): GeneratorFactory;

package/dist/instant.js

@@ -0,0 +1,63 @@
+'worklet';
+// @frame-path — executes inside the UI-runtime frame step; allocation-gated (REQ-DRIVER-021).
+// U7a + transition-default-selection F5 — the INSTANT lane (the pin's makeAnimationInstant,
+// motion-dom@12.42.2 animation/interfaces/motion-value.ts:89-98,122-136). The pin's guard is
+// `type === false || (duration === 0 && !repeatDelay)` — TYPE-INDEPENDENT, so a zero authored
+// duration routes here exactly like the authored `{ type: false }` form; a repeatDelay-bearing
+// bag is exempt and keeps its generator (the zero-length timing base takes this same SHAPE at the
+// drivers, so the fold's plays hold the seed at t ≤ 0 and commit the final keyframe past it).
+// The pin SKIPS animation creation entirely and commits the final keyframe via `frame.update(() => {
+// onUpdate(finalKeyframe); onComplete() })` — next-frame, NEVER synchronously — and a nonzero
+// authored `delay` is HONORED (the pin zeroes delay only for the GLOBAL instantAnimations flag,
+// 7b's window — never for the authored form). In this repo's driver architecture every trajectory
+// is a `Generator` sampled by accumulated elapsed time, so the instant lane is the degenerate
+// one: it holds the seed value at t ≤ 0 (the command applies; nothing has committed yet) and
+// commits the final keyframe, done, at the first tick past it. The shared `delayGenerator`
+// rebase wraps it like any other trajectory, which is what honors the authored delay. No
+// spring/timing/keyframes resolution ever runs for this lane. Host-agnostic (REQ-CORE-003):
+// relative imports only.
+/**
+ * The final keyframe of an instant target — the pin's `getFinalKeyframe`: a scalar rests at
+ * itself; a keyframe array rests at its LAST non-null element (validation guarantees one exists
+ * for an array target — a null FIRST element is the from-current form, R8-F2). Fail-loud on a
+ * target with no numeric terminal, never a silent 0 (the uiTerminalTarget law).
+ */
+// alloc-ok: lifecycle-edge — terminal-keyframe resolution at command time, never per frame.
+export function instantFinalKeyframe(to) {
+    if (typeof to === 'number')
+        return to;
+    for (let index = to.length - 1; index >= 0; index--) {
+        const value = to[index];
+        if (value !== null && value !== undefined)
+            return value;
+    }
+    throw new Error('an instant transition needs a numeric terminal keyframe (REQ-API-033).');
+}
+/**
+ * The instant "trajectory": no generator math runs. `sample(0)` is the seed value, NOT done —
+ * the driver's command edge seeds committed from it, so the value does not move at command time
+ * (the pin's frame.update deferral). The first sample past zero commits the final keyframe and
+ * reports done, so the commit, the onUpdate marshal, and the settle edge all land on the
+ * driver's next update tick. Velocity is always 0 — there is no motion to measure.
+ */
+// alloc-ok: lifecycle-edge — generator construction at command time; the one reused sample
+// record is built here, never per frame (REQ-DRIVER-021).
+export function instantGenerator(target) {
+    return (seed) => {
+        const out = { value: seed.from, velocity: 0, done: false };
+        return {
+            sample(elapsedMs) {
+                if (elapsedMs <= 0) {
+                    out.value = seed.from;
+                    out.velocity = 0;
+                    out.done = false;
+                    return out;
+                }
+                out.value = target;
+                out.velocity = 0;
+                out.done = true;
+                return out;
+            },
+        };
+    };
+}

package/dist/internal-driver.cjs

@@ -0,0 +1,81 @@
+"use strict";
+// Internal cross-package seam for native driver implementations (REQ-DRIVER-030). This is deliberately
+// absent from the package root: application consumers keep the simple Driver.command(raw) protocol,
+// while concrete backends can implement only the immutable prepared-command shape.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialExternalAnimationLedgerState = exports.ExternalAnimationLedgerUnimplementedError = exports.ExternalAnimationLedgerInvariantError = exports.EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED = exports.EXTERNAL_ANIMATION_LEDGER_INVARIANT = exports.createExternalAnimationLedger = exports.MotionValueDriverPortUnimplementedError = exports.MotionValueDriverPortInvariantError = exports.MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED = exports.MOTION_VALUE_DRIVER_PORT_INVARIANT = exports.isDirectPublicNumericMotionValue = exports.createMotionValueDriverPort = exports.createLocalFrameEventPort = exports.createDirectPublicMotionValue = exports.REPEAT_REFUSAL_NAME = exports.REPEAT_REFUSAL_KEY = exports.repeatRefusalMessage = exports.iterationMeasurementLane = exports.isRepeatFoldRefusalIdentity = exports.isRepeatFoldRefusal = exports.executableLengthValueRefusal = exports.toTimingLaneConfig = exports.isTimingLaneTransition = exports.isDurationZeroInstantTransition = exports.resolveTransitionForKey = exports.normalizeTransitionEaseAlias = exports.effectiveTransitionEase = exports.keyframeSegmentEase = exports.keyframeOffsetAt = exports.keyframeTransitionRefusal = exports.keyframeTimingRefusal = exports.initialTargetRefusal = exports.resolveVariantDefinitionResult = exports.capturedArrayDescription = exports.captureBoundedArray = exports.instantGenerator = exports.instantFinalKeyframe = exports.sampleArcPoint = exports.isNativeArcPath = exports.applyPathProgressInto = exports.applyPathProgress = exports.prepareDriverCommand = exports.adaptPreparedDriver = void 0;
+var prepare_1 = require("./driver/prepare.cjs");
+Object.defineProperty(exports, "adaptPreparedDriver", { enumerable: true, get: function () { return prepare_1.adaptPreparedDriver; } });
+Object.defineProperty(exports, "prepareDriverCommand", { enumerable: true, get: function () { return prepare_1.prepareDriverCommand; } });
+// U8 (REQ-API-059): UI sampler + brand predicate — backend/controller only. `applyPathProgressInto`
+// is the frame-path form (REQ-DRIVER-021): caller-owned sample/scratch slots, no per-frame records.
+var motion_arc_1 = require("./motion-arc.cjs");
+Object.defineProperty(exports, "applyPathProgress", { enumerable: true, get: function () { return motion_arc_1.applyPathProgress; } });
+Object.defineProperty(exports, "applyPathProgressInto", { enumerable: true, get: function () { return motion_arc_1.applyPathProgressInto; } });
+Object.defineProperty(exports, "isNativeArcPath", { enumerable: true, get: function () { return motion_arc_1.isNativeArcPath; } });
+Object.defineProperty(exports, "sampleArcPoint", { enumerable: true, get: function () { return motion_arc_1.sampleArcPoint; } });
+// U7a's authored `{ type: false }` instant lane (the pin's makeAnimationInstant): backend-only,
+// never the package root.
+var instant_1 = require("./instant.cjs");
+Object.defineProperty(exports, "instantFinalKeyframe", { enumerable: true, get: function () { return instant_1.instantFinalKeyframe; } });
+Object.defineProperty(exports, "instantGenerator", { enumerable: true, get: function () { return instant_1.instantGenerator; } });
+var boundedArray_1 = require("./component/boundedArray.cjs");
+Object.defineProperty(exports, "captureBoundedArray", { enumerable: true, get: function () { return boundedArray_1.captureBoundedArray; } });
+Object.defineProperty(exports, "capturedArrayDescription", { enumerable: true, get: function () { return boundedArray_1.capturedArrayDescription; } });
+var variants_1 = require("./component/variants.cjs");
+Object.defineProperty(exports, "resolveVariantDefinitionResult", { enumerable: true, get: function () { return variants_1.resolveVariantDefinitionResult; } });
+var keyframeTiming_1 = require("./driver/keyframeTiming.cjs");
+Object.defineProperty(exports, "initialTargetRefusal", { enumerable: true, get: function () { return keyframeTiming_1.initialTargetRefusal; } });
+Object.defineProperty(exports, "keyframeTimingRefusal", { enumerable: true, get: function () { return keyframeTiming_1.keyframeTimingRefusal; } });
+Object.defineProperty(exports, "keyframeTransitionRefusal", { enumerable: true, get: function () { return keyframeTiming_1.keyframeTransitionRefusal; } });
+var keyframeTimingConfig_1 = require("./driver/keyframeTimingConfig.cjs");
+Object.defineProperty(exports, "keyframeOffsetAt", { enumerable: true, get: function () { return keyframeTimingConfig_1.keyframeOffsetAt; } });
+Object.defineProperty(exports, "keyframeSegmentEase", { enumerable: true, get: function () { return keyframeTimingConfig_1.keyframeSegmentEase; } });
+// Family-2 host implementation helpers — not consumer public API (00i0nt).
+var transition_1 = require("./component/transition.cjs");
+Object.defineProperty(exports, "effectiveTransitionEase", { enumerable: true, get: function () { return transition_1.effectiveTransitionEase; } });
+Object.defineProperty(exports, "normalizeTransitionEaseAlias", { enumerable: true, get: function () { return transition_1.normalizeTransitionEaseAlias; } });
+Object.defineProperty(exports, "resolveTransitionForKey", { enumerable: true, get: function () { return transition_1.resolveTransitionForKey; } });
+// REQ-TIMING-006 + transition-default-selection F1/F5/F6: the generator-selection predicates
+// (duration-only untyped; duration-zero instant; the F6 timing lane adding the ease-only untyped
+// form) + the ONE timing-lane config with the pin's easeOut base — backend seams only (both
+// drivers, validation), never the package root.
+var transition_2 = require("./component/transition.cjs");
+Object.defineProperty(exports, "isDurationZeroInstantTransition", { enumerable: true, get: function () { return transition_2.isDurationZeroInstantTransition; } });
+Object.defineProperty(exports, "isTimingLaneTransition", { enumerable: true, get: function () { return transition_2.isTimingLaneTransition; } });
+Object.defineProperty(exports, "toTimingLaneConfig", { enumerable: true, get: function () { return transition_2.toTimingLaneConfig; } });
+// The ONE key-aware executable length matrix (review 91d41675d511): verdict-shaped (string|null)
+// and therefore INTERNAL-only by the value-types barrel's own law (review ab7c5370fc5a) —
+// native supplying boundaries (variants, gesture state, style bases) import it from this seam.
+var measure_resolve_1 = require("./value-types/measure-resolve.cjs");
+Object.defineProperty(exports, "executableLengthValueRefusal", { enumerable: true, get: function () { return measure_resolve_1.executableLengthValueRefusal; } });
+// T18-a: the fold's backend protocol — the ONE iteration-measurement lane rule both backends call
+// (three parallel copies of it drifted across four review rounds), and the refusal identity they
+// must present identically. Backend-only by the same law as the prepared-command shape above:
+// an application consumer never measures a fold or builds its refusal.
+var repeat_1 = require("./repeat.cjs");
+Object.defineProperty(exports, "isRepeatFoldRefusal", { enumerable: true, get: function () { return repeat_1.isRepeatFoldRefusal; } });
+Object.defineProperty(exports, "isRepeatFoldRefusalIdentity", { enumerable: true, get: function () { return repeat_1.isRepeatFoldRefusalIdentity; } });
+Object.defineProperty(exports, "iterationMeasurementLane", { enumerable: true, get: function () { return repeat_1.iterationMeasurementLane; } });
+Object.defineProperty(exports, "repeatRefusalMessage", { enumerable: true, get: function () { return repeat_1.repeatRefusalMessage; } });
+Object.defineProperty(exports, "REPEAT_REFUSAL_KEY", { enumerable: true, get: function () { return repeat_1.REPEAT_REFUSAL_KEY; } });
+Object.defineProperty(exports, "REPEAT_REFUSAL_NAME", { enumerable: true, get: function () { return repeat_1.REPEAT_REFUSAL_NAME; } });
+// Identity-global direct numeric MotionValue channel (REQ-VALUE-014/015): private CORE capability,
+// transported-sample/cache port, and external execution/target-batch ledger. These seams are staged
+// behind explicit typed refusals for the row-2 TDD red and never enter the consumer root.
+var motion_value_driver_port_1 = require("./motion-value-driver-port.cjs");
+Object.defineProperty(exports, "createDirectPublicMotionValue", { enumerable: true, get: function () { return motion_value_driver_port_1.createDirectPublicMotionValue; } });
+Object.defineProperty(exports, "createLocalFrameEventPort", { enumerable: true, get: function () { return motion_value_driver_port_1.createLocalFrameEventPort; } });
+Object.defineProperty(exports, "createMotionValueDriverPort", { enumerable: true, get: function () { return motion_value_driver_port_1.createMotionValueDriverPort; } });
+Object.defineProperty(exports, "isDirectPublicNumericMotionValue", { enumerable: true, get: function () { return motion_value_driver_port_1.isDirectPublicNumericMotionValue; } });
+Object.defineProperty(exports, "MOTION_VALUE_DRIVER_PORT_INVARIANT", { enumerable: true, get: function () { return motion_value_driver_port_1.MOTION_VALUE_DRIVER_PORT_INVARIANT; } });
+Object.defineProperty(exports, "MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED", { enumerable: true, get: function () { return motion_value_driver_port_1.MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED; } });
+Object.defineProperty(exports, "MotionValueDriverPortInvariantError", { enumerable: true, get: function () { return motion_value_driver_port_1.MotionValueDriverPortInvariantError; } });
+Object.defineProperty(exports, "MotionValueDriverPortUnimplementedError", { enumerable: true, get: function () { return motion_value_driver_port_1.MotionValueDriverPortUnimplementedError; } });
+var external_animation_ledger_1 = require("./external-animation-ledger.cjs");
+Object.defineProperty(exports, "createExternalAnimationLedger", { enumerable: true, get: function () { return external_animation_ledger_1.createExternalAnimationLedger; } });
+Object.defineProperty(exports, "EXTERNAL_ANIMATION_LEDGER_INVARIANT", { enumerable: true, get: function () { return external_animation_ledger_1.EXTERNAL_ANIMATION_LEDGER_INVARIANT; } });
+Object.defineProperty(exports, "EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED", { enumerable: true, get: function () { return external_animation_ledger_1.EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED; } });
+Object.defineProperty(exports, "ExternalAnimationLedgerInvariantError", { enumerable: true, get: function () { return external_animation_ledger_1.ExternalAnimationLedgerInvariantError; } });
+Object.defineProperty(exports, "ExternalAnimationLedgerUnimplementedError", { enumerable: true, get: function () { return external_animation_ledger_1.ExternalAnimationLedgerUnimplementedError; } });
+Object.defineProperty(exports, "initialExternalAnimationLedgerState", { enumerable: true, get: function () { return external_animation_ledger_1.initialExternalAnimationLedgerState; } });

package/dist/internal-driver.d.cts

@@ -0,0 +1,19 @@
+export { adaptPreparedDriver, prepareDriverCommand } from "./driver/prepare.cjs";
+export { applyPathProgress, applyPathProgressInto, isNativeArcPath, sampleArcPoint, } from "./motion-arc.cjs";
+export type { ArcScratch, NativeArcPath, PathChannelGeometry, PathProgressSample, } from "./motion-arc.cjs";
+export { instantFinalKeyframe, instantGenerator } from "./instant.cjs";
+export { captureBoundedArray, capturedArrayDescription } from "./component/boundedArray.cjs";
+export type { BoundedArrayCapture } from "./component/boundedArray.cjs";
+export { resolveVariantDefinitionResult } from "./component/variants.cjs";
+export { initialTargetRefusal, keyframeTimingRefusal, keyframeTransitionRefusal, } from "./driver/keyframeTiming.cjs";
+export { keyframeOffsetAt, keyframeSegmentEase } from "./driver/keyframeTimingConfig.cjs";
+export { effectiveTransitionEase, normalizeTransitionEaseAlias, resolveTransitionForKey, } from "./component/transition.cjs";
+export { isDurationZeroInstantTransition, isTimingLaneTransition, toTimingLaneConfig, } from "./component/transition.cjs";
+export { executableLengthValueRefusal } from "./value-types/measure-resolve.cjs";
+export type { PreparedDriver, PreparedDriverCommand, PreparedPropTarget } from "./driver/types.cjs";
+export { isRepeatFoldRefusal, isRepeatFoldRefusalIdentity, iterationMeasurementLane, repeatRefusalMessage, REPEAT_REFUSAL_KEY, REPEAT_REFUSAL_NAME, } from "./repeat.cjs";
+export type { IterationMeasurementLane } from "./repeat.cjs";
+export { createDirectPublicMotionValue, createLocalFrameEventPort, createMotionValueDriverPort, isDirectPublicNumericMotionValue, MOTION_VALUE_DRIVER_PORT_INVARIANT, MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED, MotionValueDriverPortInvariantError, MotionValueDriverPortUnimplementedError, } from "./motion-value-driver-port.cjs";
+export type { CachedNumericHistory, CollectorSilentMotionValueRawSnapshot, CreateLocalFrameEventPortOptions, CreateMotionValueDriverPortOptions, DirectMotionValueOperation, DirectMotionValueOperationReceipt, DirectPublicInitializerProvenance, LocalFrameEventPort, LocalFrameEventPortObservation, LocalFrameEventPortState, MotionValueDriverBindingEligibility, MotionValueDriverCreation, MotionValueDriverPort, MotionValueDriverPortInvariant, MotionValueDriverPortObservation, MotionValueDriverPortOperation, MotionValueDriverPortState, MotionValueLifecycleTerminalEvent, MotionValuePublicControlSlotInstallation, MotionValuePublicControlSlotReceipt, MotionValuePublicControlSlotState, MotionValueTerminalCandidateCacheGuard, PrimitiveMotionValueSnapshot, PrimitiveNumericHistory, PrimitiveTransitionEvent, SynchronousSnapshotAdoption, TransportedExecutionGeneratorSample, TransportedMotionValueSample, TransportedSampleApplication, TransportedSampleOrigin, TransportedSampleIrreversibleSubphase, TransportedSampleProgressEntry, TransportedSampleProgressState, TransportedSampleProgressWriter, TransportedTaskCallbackKind, TransportedTerminalApplication, TokenlessCallbackReplaySuppression, TokenlessMotionValueTaskKind, } from "./motion-value-driver-port.cjs";
+export { createExternalAnimationLedger, EXTERNAL_ANIMATION_LEDGER_INVARIANT, EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED, ExternalAnimationLedgerInvariantError, ExternalAnimationLedgerUnimplementedError, initialExternalAnimationLedgerState, } from "./external-animation-ledger.cjs";
+export type { CreateExternalAnimationLedgerOptions, ExternalAnimationExecutionState, ExternalAnimationIdentityAuthorityState, ExternalAnimationIdentityObservation, ExternalAnimationLedger, ExternalAnimationLedgerEffect, ExternalAnimationLedgerEvent, ExternalAnimationLedgerInvariant, ExternalAnimationLedgerObservation, ExternalAnimationLedgerOperation, ExternalAnimationLedgerState, ExternalAnimationLedgerTransition, ExternalAnimationTargetBatchAuthorityState, IdentityTargetBatchDependencyEvent, IdentityTargetBatchDependencyEventOutboxEntry, PendingFrameActivityRetention, PrivateControlTargetBatchDependencySource, PublicIdentityTargetBatchDependencySource, PublicControlSlotState, TargetBatchAuthoredCarrier, TargetBatchActivityState, TargetBatchDependencyEvent, TargetBatchDependencyAcknowledgement, TargetBatchDependencyReference, TargetBatchDependencySource, TargetBatchDependencyState, } from "./external-animation-ledger.cjs";

package/dist/internal-driver.d.ts

@@ -0,0 +1,19 @@
+export { adaptPreparedDriver, prepareDriverCommand } from "./driver/prepare.js";
+export { applyPathProgress, applyPathProgressInto, isNativeArcPath, sampleArcPoint, } from "./motion-arc.js";
+export type { ArcScratch, NativeArcPath, PathChannelGeometry, PathProgressSample, } from "./motion-arc.js";
+export { instantFinalKeyframe, instantGenerator } from "./instant.js";
+export { captureBoundedArray, capturedArrayDescription } from "./component/boundedArray.js";
+export type { BoundedArrayCapture } from "./component/boundedArray.js";
+export { resolveVariantDefinitionResult } from "./component/variants.js";
+export { initialTargetRefusal, keyframeTimingRefusal, keyframeTransitionRefusal, } from "./driver/keyframeTiming.js";
+export { keyframeOffsetAt, keyframeSegmentEase } from "./driver/keyframeTimingConfig.js";
+export { effectiveTransitionEase, normalizeTransitionEaseAlias, resolveTransitionForKey, } from "./component/transition.js";
+export { isDurationZeroInstantTransition, isTimingLaneTransition, toTimingLaneConfig, } from "./component/transition.js";
+export { executableLengthValueRefusal } from "./value-types/measure-resolve.js";
+export type { PreparedDriver, PreparedDriverCommand, PreparedPropTarget } from "./driver/types.js";
+export { isRepeatFoldRefusal, isRepeatFoldRefusalIdentity, iterationMeasurementLane, repeatRefusalMessage, REPEAT_REFUSAL_KEY, REPEAT_REFUSAL_NAME, } from "./repeat.js";
+export type { IterationMeasurementLane } from "./repeat.js";
+export { createDirectPublicMotionValue, createLocalFrameEventPort, createMotionValueDriverPort, isDirectPublicNumericMotionValue, MOTION_VALUE_DRIVER_PORT_INVARIANT, MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED, MotionValueDriverPortInvariantError, MotionValueDriverPortUnimplementedError, } from "./motion-value-driver-port.js";
+export type { CachedNumericHistory, CollectorSilentMotionValueRawSnapshot, CreateLocalFrameEventPortOptions, CreateMotionValueDriverPortOptions, DirectMotionValueOperation, DirectMotionValueOperationReceipt, DirectPublicInitializerProvenance, LocalFrameEventPort, LocalFrameEventPortObservation, LocalFrameEventPortState, MotionValueDriverBindingEligibility, MotionValueDriverCreation, MotionValueDriverPort, MotionValueDriverPortInvariant, MotionValueDriverPortObservation, MotionValueDriverPortOperation, MotionValueDriverPortState, MotionValueLifecycleTerminalEvent, MotionValuePublicControlSlotInstallation, MotionValuePublicControlSlotReceipt, MotionValuePublicControlSlotState, MotionValueTerminalCandidateCacheGuard, PrimitiveMotionValueSnapshot, PrimitiveNumericHistory, PrimitiveTransitionEvent, SynchronousSnapshotAdoption, TransportedExecutionGeneratorSample, TransportedMotionValueSample, TransportedSampleApplication, TransportedSampleOrigin, TransportedSampleIrreversibleSubphase, TransportedSampleProgressEntry, TransportedSampleProgressState, TransportedSampleProgressWriter, TransportedTaskCallbackKind, TransportedTerminalApplication, TokenlessCallbackReplaySuppression, TokenlessMotionValueTaskKind, } from "./motion-value-driver-port.js";
+export { createExternalAnimationLedger, EXTERNAL_ANIMATION_LEDGER_INVARIANT, EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED, ExternalAnimationLedgerInvariantError, ExternalAnimationLedgerUnimplementedError, initialExternalAnimationLedgerState, } from "./external-animation-ledger.js";
+export type { CreateExternalAnimationLedgerOptions, ExternalAnimationExecutionState, ExternalAnimationIdentityAuthorityState, ExternalAnimationIdentityObservation, ExternalAnimationLedger, ExternalAnimationLedgerEffect, ExternalAnimationLedgerEvent, ExternalAnimationLedgerInvariant, ExternalAnimationLedgerObservation, ExternalAnimationLedgerOperation, ExternalAnimationLedgerState, ExternalAnimationLedgerTransition, ExternalAnimationTargetBatchAuthorityState, IdentityTargetBatchDependencyEvent, IdentityTargetBatchDependencyEventOutboxEntry, PendingFrameActivityRetention, PrivateControlTargetBatchDependencySource, PublicIdentityTargetBatchDependencySource, PublicControlSlotState, TargetBatchAuthoredCarrier, TargetBatchActivityState, TargetBatchDependencyEvent, TargetBatchDependencyAcknowledgement, TargetBatchDependencyReference, TargetBatchDependencySource, TargetBatchDependencyState, } from "./external-animation-ledger.js";

package/dist/internal-driver.js

@@ -0,0 +1,35 @@
+// Internal cross-package seam for native driver implementations (REQ-DRIVER-030). This is deliberately
+// absent from the package root: application consumers keep the simple Driver.command(raw) protocol,
+// while concrete backends can implement only the immutable prepared-command shape.
+export { adaptPreparedDriver, prepareDriverCommand } from "./driver/prepare.js";
+// U8 (REQ-API-059): UI sampler + brand predicate — backend/controller only. `applyPathProgressInto`
+// is the frame-path form (REQ-DRIVER-021): caller-owned sample/scratch slots, no per-frame records.
+export { applyPathProgress, applyPathProgressInto, isNativeArcPath, sampleArcPoint, } from "./motion-arc.js";
+// U7a's authored `{ type: false }` instant lane (the pin's makeAnimationInstant): backend-only,
+// never the package root.
+export { instantFinalKeyframe, instantGenerator } from "./instant.js";
+export { captureBoundedArray, capturedArrayDescription } from "./component/boundedArray.js";
+export { resolveVariantDefinitionResult } from "./component/variants.js";
+export { initialTargetRefusal, keyframeTimingRefusal, keyframeTransitionRefusal, } from "./driver/keyframeTiming.js";
+export { keyframeOffsetAt, keyframeSegmentEase } from "./driver/keyframeTimingConfig.js";
+// Family-2 host implementation helpers — not consumer public API (00i0nt).
+export { effectiveTransitionEase, normalizeTransitionEaseAlias, resolveTransitionForKey, } from "./component/transition.js";
+// REQ-TIMING-006 + transition-default-selection F1/F5/F6: the generator-selection predicates
+// (duration-only untyped; duration-zero instant; the F6 timing lane adding the ease-only untyped
+// form) + the ONE timing-lane config with the pin's easeOut base — backend seams only (both
+// drivers, validation), never the package root.
+export { isDurationZeroInstantTransition, isTimingLaneTransition, toTimingLaneConfig, } from "./component/transition.js";
+// The ONE key-aware executable length matrix (review 91d41675d511): verdict-shaped (string|null)
+// and therefore INTERNAL-only by the value-types barrel's own law (review ab7c5370fc5a) —
+// native supplying boundaries (variants, gesture state, style bases) import it from this seam.
+export { executableLengthValueRefusal } from "./value-types/measure-resolve.js";
+// T18-a: the fold's backend protocol — the ONE iteration-measurement lane rule both backends call
+// (three parallel copies of it drifted across four review rounds), and the refusal identity they
+// must present identically. Backend-only by the same law as the prepared-command shape above:
+// an application consumer never measures a fold or builds its refusal.
+export { isRepeatFoldRefusal, isRepeatFoldRefusalIdentity, iterationMeasurementLane, repeatRefusalMessage, REPEAT_REFUSAL_KEY, REPEAT_REFUSAL_NAME, } from "./repeat.js";
+// Identity-global direct numeric MotionValue channel (REQ-VALUE-014/015): private CORE capability,
+// transported-sample/cache port, and external execution/target-batch ledger. These seams are staged
+// behind explicit typed refusals for the row-2 TDD red and never enter the consumer root.
+export { createDirectPublicMotionValue, createLocalFrameEventPort, createMotionValueDriverPort, isDirectPublicNumericMotionValue, MOTION_VALUE_DRIVER_PORT_INVARIANT, MOTION_VALUE_DRIVER_PORT_UNIMPLEMENTED, MotionValueDriverPortInvariantError, MotionValueDriverPortUnimplementedError, } from "./motion-value-driver-port.js";
+export { createExternalAnimationLedger, EXTERNAL_ANIMATION_LEDGER_INVARIANT, EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED, ExternalAnimationLedgerInvariantError, ExternalAnimationLedgerUnimplementedError, initialExternalAnimationLedgerState, } from "./external-animation-ledger.js";