@haiyue/extensions 0.1.0

package/dist/chunks/AnimationStateMachineController-BIcAh-sT.js

@@ -0,0 +1,1438 @@
+const EPSILON = 1e-9;
+const TWO_PI = Math.PI * 2;
+/**
+ * Evaluates direct child weights for a compiled 1D blend tree. Values outside
+ * the authored threshold range clamp to the nearest endpoint.
+ */
+function evaluateAnimation3DBlend1DWeights(motion, value, out = new Float64Array(motion.children.length)) {
+    requireOutputSize(out, motion.children.length);
+    out.fill(0);
+    const children = motion.children;
+    if (children.length === 1 || value <= children[0].threshold) {
+        out[0] = 1;
+        return out;
+    }
+    const lastIndex = children.length - 1;
+    if (value >= children[lastIndex].threshold) {
+        out[lastIndex] = 1;
+        return out;
+    }
+    let low = 0;
+    let high = lastIndex;
+    while (low + 1 < high) {
+        const middle = (low + high) >>> 1;
+        if (value < children[middle].threshold)
+            high = middle;
+        else
+            low = middle;
+    }
+    const start = children[low].threshold;
+    const end = children[high].threshold;
+    const alpha = (value - start) / (end - start);
+    out[low] = 1 - alpha;
+    out[high] = alpha;
+    return out;
+}
+/**
+ * Evaluates direct child weights for a compiled 2D blend tree.
+ *
+ * Cartesian trees use a deterministic containing simplex after projecting
+ * outside samples to the convex hull. Directional trees interpolate the two
+ * surrounding authored directions and then interpolate/clamp radially.
+ */
+function evaluateAnimation3DBlend2DWeights(motion, x, y, out = new Float64Array(motion.children.length)) {
+    requireOutputSize(out, motion.children.length);
+    out.fill(0);
+    if (motion.children.length === 1) {
+        out[0] = 1;
+        return out;
+    }
+    return motion.algorithm === 'directional'
+        ? evaluateDirectional(motion, x, y, out)
+        : evaluateCartesian(motion, x, y, out);
+}
+function evaluateCartesian(motion, x, y, out) {
+    const children = motion.children;
+    const exact = findExactPoint(motion, x, y);
+    if (exact >= 0) {
+        out[exact] = 1;
+        return out;
+    }
+    const hull = convexHull(motion);
+    const point = clampToHull(motion, hull, x, y);
+    const clampedExact = findExactPoint(motion, point[0], point[1]);
+    if (clampedExact >= 0) {
+        out[clampedExact] = 1;
+        return out;
+    }
+    let bestArea = Infinity;
+    let bestIndices = null;
+    let bestWeights = null;
+    for (let first = 0; first < children.length - 2; first++) {
+        for (let second = first + 1; second < children.length - 1; second++) {
+            for (let third = second + 1; third < children.length; third++) {
+                const a = children[first].position;
+                const b = children[second].position;
+                const c = children[third].position;
+                const signedDoubleArea = cross(a, b, c);
+                const area = Math.abs(signedDoubleArea);
+                if (area <= EPSILON)
+                    continue;
+                const weights = barycentric(point, a, b, c, signedDoubleArea);
+                if (weights[0] < -EPSILON
+                    || weights[1] < -EPSILON
+                    || weights[2] < -EPSILON)
+                    continue;
+                if (area < bestArea - EPSILON
+                    || (Math.abs(area - bestArea) <= EPSILON
+                        && lexicographicallyBefore([first, second, third], bestIndices))) {
+                    bestArea = area;
+                    bestIndices = [first, second, third];
+                    bestWeights = weights;
+                }
+            }
+        }
+    }
+    if (bestIndices && bestWeights) {
+        out[bestIndices[0]] = clamp01(bestWeights[0]);
+        out[bestIndices[1]] = clamp01(bestWeights[1]);
+        out[bestIndices[2]] = clamp01(bestWeights[2]);
+        normalize(out);
+        return out;
+    }
+    // Collinear input (or a numerically degenerate hull): clamp to the closest
+    // authored segment with declaration order as the final tie breaker.
+    let bestDistance = Infinity;
+    let bestLength = Infinity;
+    let bestFirst = 0;
+    let bestSecond = 1;
+    let bestAlpha = 0;
+    for (let first = 0; first < children.length - 1; first++) {
+        for (let second = first + 1; second < children.length; second++) {
+            const projection = closestPointOnSegment(point[0], point[1], children[first].position, children[second].position);
+            const dx = projection[0] - point[0];
+            const dy = projection[1] - point[1];
+            const distance = dx * dx + dy * dy;
+            const segmentDx = children[second].position[0] - children[first].position[0];
+            const segmentDy = children[second].position[1] - children[first].position[1];
+            const length = segmentDx * segmentDx + segmentDy * segmentDy;
+            if (distance < bestDistance - EPSILON
+                || (Math.abs(distance - bestDistance) <= EPSILON
+                    && length < bestLength - EPSILON)) {
+                bestDistance = distance;
+                bestLength = length;
+                bestFirst = first;
+                bestSecond = second;
+                bestAlpha = projection[2];
+            }
+        }
+    }
+    out[bestFirst] = 1 - bestAlpha;
+    out[bestSecond] = bestAlpha;
+    return out;
+}
+function evaluateDirectional(motion, x, y, out) {
+    const exact = findExactPoint(motion, x, y);
+    if (exact >= 0) {
+        out[exact] = 1;
+        return out;
+    }
+    const radius = Math.hypot(x, y);
+    const originIndices = [];
+    const directionalEntries = [];
+    motion.children.forEach((child, index) => {
+        const childRadius = Math.hypot(child.position[0], child.position[1]);
+        if (childRadius <= EPSILON) {
+            originIndices.push(index);
+        }
+        else {
+            directionalEntries.push({
+                angle: normalizeAngle(Math.atan2(child.position[1], child.position[0])),
+                radius: childRadius,
+                index,
+            });
+        }
+    });
+    if (radius <= EPSILON) {
+        out[originIndices[0] ?? directionalEntries[0].index] = 1;
+        return out;
+    }
+    if (directionalEntries.length === 0) {
+        out[originIndices[0]] = 1;
+        return out;
+    }
+    directionalEntries.sort((left, right) => left.angle - right.angle
+        || left.radius - right.radius
+        || left.index - right.index);
+    const groups = [];
+    directionalEntries.forEach(entry => {
+        const previous = groups[groups.length - 1];
+        if (previous && Math.abs(previous.angle - entry.angle) <= EPSILON) {
+            groups[groups.length - 1] = {
+                angle: previous.angle,
+                entries: Object.freeze([...previous.entries, {
+                        index: entry.index,
+                        radius: entry.radius,
+                    }]),
+            };
+        }
+        else {
+            groups.push({
+                angle: entry.angle,
+                entries: Object.freeze([{
+                        index: entry.index,
+                        radius: entry.radius,
+                    }]),
+            });
+        }
+    });
+    const queryAngle = normalizeAngle(Math.atan2(y, x));
+    let leftGroupIndex = groups.length - 1;
+    let rightGroupIndex = 0;
+    let angularAlpha = 0;
+    for (let index = 0; index < groups.length; index++) {
+        const left = groups[index];
+        const rightIndex = (index + 1) % groups.length;
+        const right = groups[rightIndex];
+        const leftAngle = left.angle;
+        const rightAngle = rightIndex === 0 ? right.angle + TWO_PI : right.angle;
+        const adjustedQuery = queryAngle < leftAngle ? queryAngle + TWO_PI : queryAngle;
+        if (adjustedQuery >= leftAngle - EPSILON && adjustedQuery <= rightAngle + EPSILON) {
+            leftGroupIndex = index;
+            rightGroupIndex = rightIndex;
+            angularAlpha = groups.length === 1
+                ? 0
+                : clamp01((adjustedQuery - leftAngle) / (rightAngle - leftAngle));
+            break;
+        }
+    }
+    const originIndex = originIndices[0] ?? -1;
+    accumulateRadial(groups[leftGroupIndex], radius, 1 - angularAlpha, originIndex, out);
+    if (rightGroupIndex !== leftGroupIndex) {
+        accumulateRadial(groups[rightGroupIndex], radius, angularAlpha, originIndex, out);
+    }
+    normalize(out);
+    return out;
+}
+function accumulateRadial(group, radius, angularWeight, originIndex, out) {
+    if (angularWeight <= EPSILON)
+        return;
+    const entries = group.entries;
+    const first = entries[0];
+    if (radius <= first.radius) {
+        if (originIndex >= 0) {
+            const alpha = clamp01(radius / first.radius);
+            out[originIndex] = (out[originIndex] ?? 0) + angularWeight * (1 - alpha);
+            out[first.index] = (out[first.index] ?? 0) + angularWeight * alpha;
+        }
+        else {
+            out[first.index] = (out[first.index] ?? 0) + angularWeight;
+        }
+        return;
+    }
+    const last = entries[entries.length - 1];
+    if (radius >= last.radius) {
+        out[last.index] = (out[last.index] ?? 0) + angularWeight;
+        return;
+    }
+    for (let index = 0; index < entries.length - 1; index++) {
+        const start = entries[index];
+        const end = entries[index + 1];
+        if (radius <= end.radius) {
+            const alpha = (radius - start.radius) / (end.radius - start.radius);
+            out[start.index] = (out[start.index] ?? 0) + angularWeight * (1 - alpha);
+            out[end.index] = (out[end.index] ?? 0) + angularWeight * alpha;
+            return;
+        }
+    }
+}
+function convexHull(motion) {
+    const sorted = motion.children.map((child, index) => ({
+        index,
+        x: child.position[0],
+        y: child.position[1],
+    })).sort((left, right) => left.x - right.x || left.y - right.y || left.index - right.index);
+    if (sorted.length <= 2)
+        return sorted.map(entry => entry.index);
+    const lower = [];
+    for (const entry of sorted) {
+        while (lower.length >= 2
+            && crossEntries(lower[lower.length - 2], lower[lower.length - 1], entry) <= EPSILON)
+            lower.pop();
+        lower.push(entry);
+    }
+    const upper = [];
+    for (let index = sorted.length - 1; index >= 0; index--) {
+        const entry = sorted[index];
+        while (upper.length >= 2
+            && crossEntries(upper[upper.length - 2], upper[upper.length - 1], entry) <= EPSILON)
+            upper.pop();
+        upper.push(entry);
+    }
+    lower.pop();
+    upper.pop();
+    const result = [...lower, ...upper].map(entry => entry.index);
+    return result.length === 0 ? [sorted[0].index] : result;
+}
+function clampToHull(motion, hull, x, y) {
+    if (hull.length === 1)
+        return motion.children[hull[0]].position;
+    if (hull.length === 2) {
+        const projection = closestPointOnSegment(x, y, motion.children[hull[0]].position, motion.children[hull[1]].position);
+        return [projection[0], projection[1]];
+    }
+    let inside = true;
+    for (let index = 0; index < hull.length; index++) {
+        const start = motion.children[hull[index]].position;
+        const end = motion.children[hull[(index + 1) % hull.length]].position;
+        if ((end[0] - start[0]) * (y - start[1]) - (end[1] - start[1]) * (x - start[0]) < -EPSILON) {
+            inside = false;
+            break;
+        }
+    }
+    if (inside)
+        return [x, y];
+    let bestX = x;
+    let bestY = y;
+    let bestDistance = Infinity;
+    for (let index = 0; index < hull.length; index++) {
+        const projection = closestPointOnSegment(x, y, motion.children[hull[index]].position, motion.children[hull[(index + 1) % hull.length]].position);
+        const dx = projection[0] - x;
+        const dy = projection[1] - y;
+        const distance = dx * dx + dy * dy;
+        if (distance < bestDistance - EPSILON) {
+            bestDistance = distance;
+            bestX = projection[0];
+            bestY = projection[1];
+        }
+    }
+    return [bestX, bestY];
+}
+function closestPointOnSegment(x, y, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const denominator = dx * dx + dy * dy;
+    const alpha = denominator <= EPSILON
+        ? 0
+        : clamp01(((x - start[0]) * dx + (y - start[1]) * dy) / denominator);
+    return [start[0] + dx * alpha, start[1] + dy * alpha, alpha];
+}
+function barycentric(point, a, b, c, signedDoubleArea) {
+    const first = ((b[0] - point[0]) * (c[1] - point[1])
+        - (b[1] - point[1]) * (c[0] - point[0])) / signedDoubleArea;
+    const second = ((c[0] - point[0]) * (a[1] - point[1])
+        - (c[1] - point[1]) * (a[0] - point[0])) / signedDoubleArea;
+    return [first, second, 1 - first - second];
+}
+function findExactPoint(motion, x, y) {
+    for (let index = 0; index < motion.children.length; index++) {
+        const position = motion.children[index].position;
+        if (Math.abs(position[0] - x) <= EPSILON && Math.abs(position[1] - y) <= EPSILON) {
+            return index;
+        }
+    }
+    return -1;
+}
+function cross(a, b, c) {
+    return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+function crossEntries(a, b, c) {
+    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+function lexicographicallyBefore(candidate, current) {
+    if (!current)
+        return true;
+    return candidate[0] < current[0]
+        || (candidate[0] === current[0] && candidate[1] < current[1])
+        || (candidate[0] === current[0]
+            && candidate[1] === current[1]
+            && candidate[2] < current[2]);
+}
+function normalize(out) {
+    let total = 0;
+    for (const value of out)
+        total += value;
+    if (total <= EPSILON)
+        return;
+    for (let index = 0; index < out.length; index++)
+        out[index] = out[index] / total;
+}
+function normalizeAngle(angle) {
+    return angle < 0 ? angle + TWO_PI : angle;
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function requireOutputSize(out, size) {
+    if (out.length < size) {
+        throw new RangeError(`Blend weight output requires ${size} entries; received ${out.length}.`);
+    }
+}
+
+class AnimationStateMachineValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid animation state-machine definition (${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}).`);
+        this.name = 'AnimationStateMachineValidationError';
+        this.issues = Object.freeze([...issues]);
+    }
+}
+const INTERRUPTION_VALUES = [
+    'none',
+    'source',
+    'destination',
+    'source-then-destination',
+    'destination-then-source',
+];
+function validateAnimationStateMachineDefinition(definition) {
+    const issues = [];
+    const parameterByName = new Map();
+    const context = {
+        issues,
+        parameterByName,
+        motionStack: new Set(),
+    };
+    if (definition.format !== 'haiyue-animation-state-machine@1'
+        && definition.format !== 'haiyue-animation3d-state-machine@1') {
+        issue(context, 'invalid-value', 'format', 'Unsupported state-machine format.');
+    }
+    validateNonEmptyString(context, definition.id, 'id');
+    validateNonEmptyString(context, definition.name, 'name');
+    definition.parameters.forEach((parameter, parameterIndex) => {
+        const path = `parameters[${parameterIndex}]`;
+        validateNonEmptyString(context, parameter.name, `${path}.name`);
+        if (parameterByName.has(parameter.name)) {
+            issue(context, 'duplicate-id', `${path}.name`, `Duplicate parameter name "${parameter.name}".`);
+        }
+        else {
+            parameterByName.set(parameter.name, parameter);
+        }
+        if (parameter.type === 'float') {
+            validateFinite(context, parameter.defaultValue, `${path}.defaultValue`);
+        }
+        else if (parameter.type === 'integer') {
+            if (!Number.isSafeInteger(parameter.defaultValue)) {
+                issue(context, 'invalid-value', `${path}.defaultValue`, 'Integer parameter defaults must be safe integers.');
+            }
+        }
+        else if (parameter.type === 'boolean') {
+            if (typeof parameter.defaultValue !== 'boolean') {
+                issue(context, 'invalid-value', `${path}.defaultValue`, 'Boolean parameter defaults must be boolean.');
+            }
+        }
+        else if (parameter.type === 'trigger') ;
+        else {
+            issue(context, 'invalid-value', `${path}.type`, 'Unknown parameter type.');
+        }
+    });
+    const layerIds = new Set();
+    definition.layers.forEach((layer, layerIndex) => {
+        const layerPath = `layers[${layerIndex}]`;
+        validateNonEmptyString(context, layer.id, `${layerPath}.id`);
+        validateNonEmptyString(context, layer.name, `${layerPath}.name`);
+        if (layerIds.has(layer.id)) {
+            issue(context, 'duplicate-id', `${layerPath}.id`, `Duplicate layer id "${layer.id}".`);
+        }
+        layerIds.add(layer.id);
+        validateUnitWeight(context, layer.weight ?? 1, `${layerPath}.weight`);
+        if (layer.blendMode !== undefined
+            && layer.blendMode !== 'override'
+            && layer.blendMode !== 'additive') {
+            issue(context, 'invalid-value', `${layerPath}.blendMode`, 'Unknown layer blend mode.');
+        }
+        const stateIds = new Set();
+        layer.states.forEach((state, stateIndex) => {
+            const statePath = `${layerPath}.states[${stateIndex}]`;
+            validateNonEmptyString(context, state.id, `${statePath}.id`);
+            validateNonEmptyString(context, state.name, `${statePath}.name`);
+            if (stateIds.has(state.id)) {
+                issue(context, 'duplicate-id', `${statePath}.id`, `Duplicate state id "${state.id}".`);
+            }
+            stateIds.add(state.id);
+            validateFinite(context, state.speed ?? 1, `${statePath}.speed`);
+            if (state.loop !== undefined
+                && state.loop !== 'once'
+                && state.loop !== 'repeat'
+                && state.loop !== 'ping-pong') {
+                issue(context, 'invalid-value', `${statePath}.loop`, 'Unknown state loop mode.');
+            }
+            if (state.speedParameter !== undefined) {
+                validateNumericParameter(context, state.speedParameter, `${statePath}.speedParameter`);
+            }
+            validateMotion(context, state.motion, `${statePath}.motion`);
+        });
+        if (!stateIds.has(layer.initialStateId)) {
+            issue(context, 'missing-reference', `${layerPath}.initialStateId`, `Initial state "${layer.initialStateId}" does not exist in this layer.`);
+        }
+        const transitionIds = new Set();
+        layer.transitions.forEach((transition, transitionIndex) => {
+            const transitionPath = `${layerPath}.transitions[${transitionIndex}]`;
+            validateNonEmptyString(context, transition.id, `${transitionPath}.id`);
+            if (transitionIds.has(transition.id)) {
+                issue(context, 'duplicate-id', `${transitionPath}.id`, `Duplicate transition id "${transition.id}".`);
+            }
+            transitionIds.add(transition.id);
+            if (transition.from !== '*' && !stateIds.has(transition.from)) {
+                issue(context, 'missing-reference', `${transitionPath}.from`, `Source state "${transition.from}" does not exist in this layer.`);
+            }
+            if (!stateIds.has(transition.to)) {
+                issue(context, 'missing-reference', `${transitionPath}.to`, `Destination state "${transition.to}" does not exist in this layer.`);
+            }
+            validateNonNegativeFinite(context, transition.duration, `${transitionPath}.duration`);
+            if (transition.hasExitTime !== undefined
+                && typeof transition.hasExitTime !== 'boolean') {
+                issue(context, 'invalid-value', `${transitionPath}.hasExitTime`, 'hasExitTime must be boolean.');
+            }
+            if (transition.hasExitTime === true && transition.exitTime === undefined) {
+                issue(context, 'invalid-value', `${transitionPath}.exitTime`, 'exitTime is required when hasExitTime is true.');
+            }
+            if (transition.exitTime !== undefined) {
+                validateNonNegativeFinite(context, transition.exitTime, `${transitionPath}.exitTime`);
+            }
+            if (transition.destinationOffset !== undefined) {
+                validateNonNegativeFinite(context, transition.destinationOffset, `${transitionPath}.destinationOffset`);
+            }
+            if (transition.interruption !== undefined
+                && !INTERRUPTION_VALUES.includes(transition.interruption)) {
+                issue(context, 'invalid-value', `${transitionPath}.interruption`, 'Unknown transition interruption strategy.');
+            }
+            transition.conditions.forEach((condition, conditionIndex) => {
+                validateCondition(context, condition, `${transitionPath}.conditions[${conditionIndex}]`);
+            });
+        });
+    });
+    return Object.freeze(issues);
+}
+function compileAnimationStateMachineDefinition(definition) {
+    const issues = validateAnimationStateMachineDefinition(definition);
+    if (issues.length > 0)
+        throw new AnimationStateMachineValidationError(issues);
+    const parameterIndexByName = new Map();
+    const parameters = definition.parameters.map((parameter, index) => {
+        parameterIndexByName.set(parameter.name, index);
+        return Object.freeze({
+            index,
+            name: parameter.name,
+            type: parameter.type,
+            defaultValue: parameter.type === 'trigger'
+                ? 0
+                : parameter.type === 'boolean'
+                    ? (parameter.defaultValue ? 1 : 0)
+                    : parameter.defaultValue,
+        });
+    });
+    const layerIndexById = new Map();
+    const layers = definition.layers.map((layer, layerIndex) => {
+        layerIndexById.set(layer.id, layerIndex);
+        const stateIndexById = new Map();
+        layer.states.forEach((state, stateIndex) => stateIndexById.set(state.id, stateIndex));
+        const states = layer.states.map((state, stateIndex) => Object.freeze({
+            index: stateIndex,
+            id: state.id,
+            name: state.name,
+            motion: compileMotion(state.motion, parameterIndexByName),
+            speed: state.speed ?? 1,
+            speedParameterIndex: state.speedParameter === undefined
+                ? -1
+                : parameterIndexByName.get(state.speedParameter),
+            loop: state.loop ?? 'repeat',
+        }));
+        const transitions = layer.transitions.map((transition, transitionIndex) => {
+            const conditions = transition.conditions.map(condition => compileCondition(condition, parameterIndexByName));
+            const triggerParameterIndices = conditions
+                .filter(condition => condition.operator === 'triggered')
+                .map(condition => condition.parameterIndex);
+            return Object.freeze({
+                index: transitionIndex,
+                id: transition.id,
+                fromStateIndex: transition.from === '*'
+                    ? -1
+                    : stateIndexById.get(transition.from),
+                toStateIndex: stateIndexById.get(transition.to),
+                conditions: Object.freeze(conditions),
+                triggerParameterIndices: Object.freeze(triggerParameterIndices),
+                duration: transition.duration,
+                hasExitTime: transition.hasExitTime ?? false,
+                exitTime: transition.exitTime ?? 0,
+                destinationOffset: transition.destinationOffset ?? 0,
+                interruption: transition.interruption ?? 'none',
+            });
+        });
+        return Object.freeze({
+            index: layerIndex,
+            id: layer.id,
+            name: layer.name,
+            initialStateIndex: stateIndexById.get(layer.initialStateId),
+            states: Object.freeze(states),
+            transitions: Object.freeze(transitions),
+            blendMode: layer.blendMode ?? 'override',
+            weight: layer.weight ?? 1,
+            mask: compileMask(layer.mask),
+            stateIndexById,
+        });
+    });
+    return Object.freeze({
+        format: 'haiyue-animation-state-machine-compiled@1',
+        id: definition.id,
+        name: definition.name,
+        parameters: Object.freeze(parameters),
+        layers: Object.freeze(layers),
+        parameterIndexByName,
+        layerIndexById,
+    });
+}
+const validateAnimation3DStateMachineDefinition = validateAnimationStateMachineDefinition;
+const compileAnimation3DStateMachineDefinition = compileAnimationStateMachineDefinition;
+function validateMotion(context, motion, path) {
+    if (typeof motion !== 'object' || motion === null) {
+        issue(context, 'invalid-value', path, 'Motion must be an object.');
+        return;
+    }
+    if (context.motionStack.has(motion)) {
+        issue(context, 'recursive-motion', path, 'Recursive motion cycle detected.');
+        return;
+    }
+    context.motionStack.add(motion);
+    if (motion.kind === 'clip') {
+        validateNonEmptyString(context, motion.clipId, `${path}.clipId`);
+    }
+    else if (motion.kind === 'blend-1d') {
+        validateNumericParameter(context, motion.parameter, `${path}.parameter`);
+        if (motion.children.length === 0) {
+            issue(context, 'empty-blend-tree', `${path}.children`, '1D blend tree cannot be empty.');
+        }
+        let previousThreshold = -Infinity;
+        motion.children.forEach((child, childIndex) => {
+            const childPath = `${path}.children[${childIndex}]`;
+            validateFinite(context, child.threshold, `${childPath}.threshold`);
+            if (childIndex > 0 && child.threshold <= previousThreshold) {
+                issue(context, 'invalid-thresholds', `${childPath}.threshold`, child.threshold === previousThreshold
+                    ? '1D blend thresholds must be unique.'
+                    : '1D blend thresholds must be strictly increasing.');
+            }
+            previousThreshold = child.threshold;
+            validateMotion(context, child.motion, `${childPath}.motion`);
+        });
+    }
+    else if (motion.kind === 'blend-2d') {
+        validateNumericParameter(context, motion.parameterX, `${path}.parameterX`);
+        validateNumericParameter(context, motion.parameterY, `${path}.parameterY`);
+        if (motion.algorithm !== 'cartesian' && motion.algorithm !== 'directional') {
+            issue(context, 'invalid-value', `${path}.algorithm`, 'Unknown 2D blend algorithm.');
+        }
+        if (motion.children.length === 0) {
+            issue(context, 'empty-blend-tree', `${path}.children`, '2D blend tree cannot be empty.');
+        }
+        const positions = new Set();
+        motion.children.forEach((child, childIndex) => {
+            const childPath = `${path}.children[${childIndex}]`;
+            const x = child.position[0];
+            const y = child.position[1];
+            validateFinite(context, x, `${childPath}.position[0]`);
+            validateFinite(context, y, `${childPath}.position[1]`);
+            const key = `${x}\u0000${y}`;
+            if (positions.has(key)) {
+                issue(context, 'invalid-value', `${childPath}.position`, '2D blend child positions must be unique.');
+            }
+            positions.add(key);
+            validateMotion(context, child.motion, `${childPath}.motion`);
+        });
+    }
+    else {
+        issue(context, 'invalid-value', `${path}.kind`, 'Unknown motion kind.');
+    }
+    context.motionStack.delete(motion);
+}
+function validateCondition(context, condition, path) {
+    const parameter = context.parameterByName.get(condition.parameter);
+    if (!parameter) {
+        issue(context, 'missing-reference', `${path}.parameter`, `Parameter "${condition.parameter}" does not exist.`);
+        return;
+    }
+    const operator = condition.operator;
+    if (parameter.type === 'float' || parameter.type === 'integer') {
+        const valid = operator === 'greater'
+            || operator === 'greater-or-equal'
+            || operator === 'less'
+            || operator === 'less-or-equal'
+            || operator === 'equal'
+            || operator === 'not-equal';
+        if (!valid) {
+            issue(context, 'invalid-operator', `${path}.operator`, `Operator "${operator}" is invalid for ${parameter.type} parameters.`);
+            return;
+        }
+        const value = 'value' in condition ? condition.value : undefined;
+        if (typeof value !== 'number'
+            || !Number.isFinite(value)
+            || (parameter.type === 'integer' && !Number.isSafeInteger(value))) {
+            issue(context, 'parameter-type-mismatch', `${path}.value`, parameter.type === 'integer'
+                ? 'Integer conditions require a safe integer value.'
+                : 'Float conditions require a finite numeric value.');
+        }
+        return;
+    }
+    if (parameter.type === 'boolean') {
+        if (operator !== 'equal'
+            && operator !== 'not-equal'
+            && operator !== 'is-true'
+            && operator !== 'is-false') {
+            issue(context, 'invalid-operator', `${path}.operator`, `Operator "${operator}" is invalid for boolean parameters.`);
+            return;
+        }
+        if ((operator === 'equal' || operator === 'not-equal')
+            && (!('value' in condition) || typeof condition.value !== 'boolean')) {
+            issue(context, 'parameter-type-mismatch', `${path}.value`, 'Boolean equality conditions require a boolean value.');
+        }
+        return;
+    }
+    if (operator !== 'triggered') {
+        issue(context, 'invalid-operator', `${path}.operator`, `Operator "${operator}" is invalid for trigger parameters.`);
+    }
+}
+function validateNumericParameter(context, parameterName, path) {
+    const parameter = context.parameterByName.get(parameterName);
+    if (!parameter) {
+        issue(context, 'missing-reference', path, `Parameter "${parameterName}" does not exist.`);
+    }
+    else if (parameter.type !== 'float' && parameter.type !== 'integer') {
+        issue(context, 'parameter-type-mismatch', path, `Parameter "${parameterName}" must be float or integer.`);
+    }
+}
+function compileMotion(motion, parameterIndexByName) {
+    if (motion.kind === 'clip') {
+        return Object.freeze({ kind: 'clip', clipId: motion.clipId });
+    }
+    if (motion.kind === 'blend-1d') {
+        return Object.freeze({
+            kind: 'blend-1d',
+            parameterIndex: parameterIndexByName.get(motion.parameter),
+            children: Object.freeze(motion.children.map(child => Object.freeze({
+                threshold: child.threshold,
+                motion: compileMotion(child.motion, parameterIndexByName),
+            }))),
+        });
+    }
+    return Object.freeze({
+        kind: 'blend-2d',
+        algorithm: motion.algorithm,
+        parameterXIndex: parameterIndexByName.get(motion.parameterX),
+        parameterYIndex: parameterIndexByName.get(motion.parameterY),
+        children: Object.freeze(motion.children.map((child, declarationIndex) => Object.freeze({
+            position: Object.freeze([child.position[0], child.position[1]]),
+            motion: compileMotion(child.motion, parameterIndexByName),
+            declarationIndex,
+        }))),
+    });
+}
+function compileCondition(condition, parameterIndexByName) {
+    const rawValue = 'value' in condition ? condition.value : 0;
+    return Object.freeze({
+        parameterIndex: parameterIndexByName.get(condition.parameter),
+        operator: condition.operator,
+        value: typeof rawValue === 'boolean' ? (rawValue ? 1 : 0) : rawValue,
+    });
+}
+function compileMask(mask) {
+    if (!mask)
+        return null;
+    return Object.freeze({
+        ...(mask.include === undefined
+            ? {}
+            : { include: Object.freeze([...mask.include]) }),
+        ...(mask.exclude === undefined
+            ? {}
+            : { exclude: Object.freeze([...mask.exclude]) }),
+    });
+}
+function validateNonEmptyString(context, value, path) {
+    if (typeof value !== 'string' || value.length === 0) {
+        issue(context, 'invalid-value', path, 'Expected a non-empty string.');
+    }
+}
+function validateFinite(context, value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        issue(context, 'invalid-value', path, 'Expected a finite number.');
+    }
+}
+function validateNonNegativeFinite(context, value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        issue(context, 'invalid-value', path, 'Expected a finite number greater than or equal to zero.');
+    }
+}
+function validateUnitWeight(context, value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+        issue(context, 'invalid-value', path, 'Layer weight must be a finite number in [0, 1].');
+    }
+}
+function issue(context, code, path, message) {
+    context.issues.push(Object.freeze({ code, path, message }));
+}
+
+const TIME_EPSILON = 1e-9;
+const DEFAULT_MAX_TRANSITIONS_PER_UPDATE = 128;
+const CONTROLLER_UPDATE_TRANSACTION = Symbol('AnimationStateMachineController.updateTransaction');
+/**
+ * Deterministic, mixer-agnostic runtime controller for a compiled definition.
+ * All string resolution happens in the compiler or at setter/query boundaries.
+ */
+class Animation3DStateMachineController {
+    compiled;
+    port;
+    maxTransitionsPerUpdate;
+    lastUpdateTransitionCount = 0;
+    transitionLimitReached = false;
+    _parameterValues;
+    _transactionParameterValues;
+    _layers = [];
+    _layerTransactionCheckpoints = [];
+    _transactionLastUpdateTransitionCount = 0;
+    _transactionLimitReached = false;
+    _transactionActive = false;
+    _status = 'active';
+    constructor(compiled, port, options = {}) {
+        const maxTransitions = options.maxTransitionsPerUpdate ?? DEFAULT_MAX_TRANSITIONS_PER_UPDATE;
+        if (!Number.isSafeInteger(maxTransitions) || maxTransitions <= 0) {
+            throw new RangeError('maxTransitionsPerUpdate must be a positive safe integer.');
+        }
+        this.compiled = compiled;
+        this.port = port;
+        this.maxTransitionsPerUpdate = maxTransitions;
+        this._parameterValues = new Float64Array(compiled.parameters.length);
+        this._transactionParameterValues = new Float64Array(compiled.parameters.length);
+        this._restoreParameterDefaults();
+        try {
+            for (const layer of compiled.layers) {
+                const current = this._createPlayback(layer, layer.states[layer.initialStateIndex], 0);
+                this._layers.push({ definition: layer, current, transition: null });
+            }
+            this._synchronizeAllLayers();
+        }
+        catch (error) {
+            this._destroyAllLayers();
+            this._status = 'destroyed';
+            throw error;
+        }
+    }
+    get status() {
+        return this._status;
+    }
+    get layerSnapshots() {
+        return Object.freeze(this._layers.map(layer => this._snapshotLayer(layer)));
+    }
+    getLayerSnapshot(layerId) {
+        const layerIndex = this.compiled.layerIndexById.get(layerId);
+        if (layerIndex === undefined)
+            throw new ReferenceError(`Unknown layer "${layerId}".`);
+        const runtime = this._layers[layerIndex];
+        if (!runtime)
+            throw new Error('State-machine controller is destroyed.');
+        return this._snapshotLayer(runtime);
+    }
+    setFloat(name, value) {
+        if (!Number.isFinite(value))
+            throw new RangeError('Float parameters must be finite.');
+        this._setTypedParameter(name, 'float', value);
+        return this;
+    }
+    setInteger(name, value) {
+        if (!Number.isSafeInteger(value)) {
+            throw new RangeError('Integer parameters must be safe integers.');
+        }
+        this._setTypedParameter(name, 'integer', value);
+        return this;
+    }
+    setBoolean(name, value) {
+        if (typeof value !== 'boolean')
+            throw new TypeError('Boolean parameters require a boolean.');
+        this._setTypedParameter(name, 'boolean', value ? 1 : 0);
+        return this;
+    }
+    setTrigger(name) {
+        this._setTypedParameter(name, 'trigger', 1);
+        return this;
+    }
+    resetTrigger(name) {
+        this._setTypedParameter(name, 'trigger', 0);
+        return this;
+    }
+    getParameter(name) {
+        const parameter = this._resolveParameter(name);
+        const value = this._parameterValues[parameter.index];
+        return parameter.type === 'boolean' || parameter.type === 'trigger'
+            ? value !== 0
+            : value;
+    }
+    update(deltaSeconds) {
+        this[CONTROLLER_UPDATE_TRANSACTION](deltaSeconds);
+        return this;
+    }
+    /** @internal Keeps controller and transactional mixer ports atomic through final pose evaluation. */
+    [CONTROLLER_UPDATE_TRANSACTION](deltaSeconds, beforeUpdate, complete) {
+        this._requireActive();
+        if (!Number.isFinite(deltaSeconds) || deltaSeconds < 0) {
+            throw new RangeError('State-machine deltaSeconds must be finite and non-negative.');
+        }
+        if (this._transactionActive) {
+            throw new Error('State-machine controller update transaction is already active.');
+        }
+        const transactionalPort = resolveTransactionalPort(this.port);
+        this._captureUpdateTransaction();
+        this._transactionActive = true;
+        let portTransactionActive = false;
+        try {
+            if (transactionalPort) {
+                transactionalPort.beginControllerTransaction();
+                portTransactionActive = true;
+            }
+            beforeUpdate?.();
+            this.lastUpdateTransitionCount = 0;
+            this.transitionLimitReached = false;
+            for (const layer of this._layers)
+                this._updateLayer(layer, deltaSeconds);
+            const result = complete?.();
+            transactionalPort?.commitControllerTransaction();
+            portTransactionActive = false;
+            this._transactionActive = false;
+            return result;
+        }
+        catch (error) {
+            this._restoreUpdateTransaction();
+            this._transactionActive = false;
+            if (portTransactionActive) {
+                try {
+                    transactionalPort.rollbackControllerTransaction();
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], 'State-machine update and rollback both failed.');
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Restores defaults and initial states. Repeated reset calls are safe and
+     * leave the same observable controller state.
+     */
+    reset() {
+        if (this._status === 'destroyed')
+            return this;
+        this._destroyAllLayers();
+        this._restoreParameterDefaults();
+        this.lastUpdateTransitionCount = 0;
+        this.transitionLimitReached = false;
+        for (const layer of this.compiled.layers) {
+            const current = this._createPlayback(layer, layer.states[layer.initialStateIndex], 0);
+            this._layers.push({ definition: layer, current, transition: null });
+        }
+        this._synchronizeAllLayers();
+        return this;
+    }
+    /** Stops and releases all port actions. Idempotent. */
+    destroy() {
+        if (this._status === 'destroyed')
+            return;
+        this._destroyAllLayers();
+        this._status = 'destroyed';
+    }
+    _updateLayer(layer, deltaSeconds) {
+        let remaining = deltaSeconds;
+        let layerTransitionCount = 0;
+        let inspectImmediateTransitions = true;
+        while (remaining > TIME_EPSILON || inspectImmediateTransitions) {
+            inspectImmediateTransitions = false;
+            if (layerTransitionCount >= this.maxTransitionsPerUpdate) {
+                this.transitionLimitReached = true;
+                this._advanceWithoutTransitions(layer, remaining);
+                remaining = 0;
+                break;
+            }
+            if (layer.transition) {
+                const interruption = this._findInterruption(layer);
+                if (interruption) {
+                    this._interruptTransition(layer, interruption);
+                    layerTransitionCount++;
+                    this.lastUpdateTransitionCount++;
+                    inspectImmediateTransitions = true;
+                    continue;
+                }
+                const active = layer.transition;
+                const timeToCompletion = Math.max(0, active.definition.duration - active.elapsed);
+                if (timeToCompletion <= TIME_EPSILON) {
+                    this._completeTransition(layer);
+                    inspectImmediateTransitions = true;
+                    continue;
+                }
+                if (remaining <= TIME_EPSILON)
+                    break;
+                const step = Math.min(remaining, timeToCompletion);
+                this._advancePlayback(active.source, step);
+                this._advancePlayback(active.destination, step);
+                active.elapsed = Math.min(active.definition.duration, active.elapsed + step);
+                remaining = Math.max(0, remaining - step);
+                this._synchronizeLayer(layer);
+                if (active.elapsed + TIME_EPSILON >= active.definition.duration
+                    && layer.transition === active) {
+                    this._completeTransition(layer);
+                    inspectImmediateTransitions = true;
+                }
+                continue;
+            }
+            const candidate = this._findEligibleTransition(layer.definition, layer.current, -1);
+            if (candidate) {
+                this._startTransition(layer, layer.current, candidate);
+                layerTransitionCount++;
+                this.lastUpdateTransitionCount++;
+                inspectImmediateTransitions = true;
+                continue;
+            }
+            if (remaining <= TIME_EPSILON)
+                break;
+            const wait = this._timeUntilNextExitTransition(layer);
+            const step = Number.isFinite(wait)
+                ? Math.min(remaining, Math.max(wait, TIME_EPSILON))
+                : remaining;
+            this._advancePlayback(layer.current, step);
+            remaining = Math.max(0, remaining - step);
+            this._synchronizeLayer(layer);
+            if (Number.isFinite(wait) && step + TIME_EPSILON >= wait) {
+                inspectImmediateTransitions = true;
+            }
+        }
+        this._synchronizeLayer(layer);
+    }
+    _captureUpdateTransaction() {
+        this._transactionParameterValues.set(this._parameterValues);
+        this._transactionLastUpdateTransitionCount = this.lastUpdateTransitionCount;
+        this._transactionLimitReached = this.transitionLimitReached;
+        for (let index = 0; index < this._layers.length; index++) {
+            const layer = this._layers[index];
+            const transition = layer.transition;
+            let checkpoint = this._layerTransactionCheckpoints[index];
+            if (!checkpoint) {
+                checkpoint = {
+                    current: layer.current,
+                    transition,
+                    currentTime: 0,
+                    sourceTime: 0,
+                    destinationTime: 0,
+                    transitionElapsed: 0,
+                };
+                this._layerTransactionCheckpoints.push(checkpoint);
+            }
+            checkpoint.current = layer.current;
+            checkpoint.transition = transition;
+            checkpoint.currentTime = layer.current.time;
+            checkpoint.sourceTime = transition?.source.time ?? 0;
+            checkpoint.destinationTime = transition?.destination.time ?? 0;
+            checkpoint.transitionElapsed = transition?.elapsed ?? 0;
+        }
+    }
+    _restoreUpdateTransaction() {
+        this._parameterValues.set(this._transactionParameterValues);
+        this.lastUpdateTransitionCount = this._transactionLastUpdateTransitionCount;
+        this.transitionLimitReached = this._transactionLimitReached;
+        for (let index = 0; index < this._layers.length; index++) {
+            const layer = this._layers[index];
+            const checkpoint = this._layerTransactionCheckpoints[index];
+            layer.current = checkpoint.current;
+            layer.transition = checkpoint.transition;
+            checkpoint.current.time = checkpoint.currentTime;
+            if (checkpoint.transition) {
+                checkpoint.transition.source.time = checkpoint.sourceTime;
+                checkpoint.transition.destination.time = checkpoint.destinationTime;
+                checkpoint.transition.elapsed = checkpoint.transitionElapsed;
+            }
+        }
+    }
+    _findEligibleTransition(layer, playback, excludedTransitionIndex) {
+        for (const transition of layer.transitions) {
+            if (transition.index === excludedTransitionIndex)
+                continue;
+            if (transition.fromStateIndex !== -1
+                && transition.fromStateIndex !== playback.state.index)
+                continue;
+            if (!this._conditionsPass(transition.conditions))
+                continue;
+            if (transition.hasExitTime
+                && !this._exitTimeReached(playback, transition.exitTime))
+                continue;
+            return transition;
+        }
+        return null;
+    }
+    _findInterruption(layer) {
+        const active = layer.transition;
+        const strategy = active.definition.interruption;
+        if (strategy === 'none')
+            return null;
+        const source = () => {
+            const transition = this._findEligibleTransition(layer.definition, active.source, active.definition.index);
+            return transition ? { transition, anchor: active.source } : null;
+        };
+        const destination = () => {
+            const transition = this._findEligibleTransition(layer.definition, active.destination, active.definition.index);
+            return transition ? { transition, anchor: active.destination } : null;
+        };
+        if (strategy === 'source')
+            return source();
+        if (strategy === 'destination')
+            return destination();
+        if (strategy === 'source-then-destination')
+            return source() ?? destination();
+        return destination() ?? source();
+    }
+    _startTransition(layer, source, transition) {
+        const destinationState = layer.definition.states[transition.toStateIndex];
+        const destination = this._createPlayback(layer.definition, destinationState, transition.destinationOffset);
+        // Consume only after destination action creation succeeds and the
+        // transition can actually become active.
+        this._consumeTriggers(transition);
+        const active = {
+            definition: transition,
+            source,
+            destination,
+            elapsed: 0,
+        };
+        layer.transition = active;
+        this._fadePlayback(source, 0, transition.duration);
+        this._fadePlayback(destination, layer.definition.weight, transition.duration);
+        this._synchronizeLayer(layer);
+        if (transition.duration <= TIME_EPSILON)
+            this._completeTransition(layer);
+    }
+    _interruptTransition(layer, candidate) {
+        const active = layer.transition;
+        const discarded = candidate.anchor === active.source
+            ? active.destination
+            : active.source;
+        this._destroyPlayback(discarded);
+        layer.current = candidate.anchor;
+        layer.transition = null;
+        this._startTransition(layer, candidate.anchor, candidate.transition);
+    }
+    _completeTransition(layer) {
+        const active = layer.transition;
+        if (!active)
+            return;
+        this._destroyPlayback(active.source);
+        layer.current = active.destination;
+        layer.transition = null;
+        this._synchronizeLayer(layer);
+    }
+    _timeUntilNextExitTransition(layer) {
+        let earliest = Infinity;
+        for (const transition of layer.definition.transitions) {
+            if (transition.fromStateIndex !== -1
+                && transition.fromStateIndex !== layer.current.state.index)
+                continue;
+            if (!transition.hasExitTime || !this._conditionsPass(transition.conditions))
+                continue;
+            earliest = Math.min(earliest, this._timeUntilExit(layer.current, transition.exitTime));
+        }
+        return earliest;
+    }
+    _exitTimeReached(playback, exitTime) {
+        const duration = this._playbackDuration(playback);
+        if (duration <= TIME_EPSILON)
+            return true;
+        const normalizedTime = playback.time / duration;
+        if (playback.state.loop === 'once' || exitTime >= 1) {
+            return normalizedTime + TIME_EPSILON >= exitTime;
+        }
+        const cycleTime = normalizedTime - Math.floor(normalizedTime);
+        return cycleTime + TIME_EPSILON >= exitTime;
+    }
+    _timeUntilExit(playback, exitTime) {
+        if (this._exitTimeReached(playback, exitTime))
+            return 0;
+        const duration = this._playbackDuration(playback);
+        if (duration <= TIME_EPSILON)
+            return 0;
+        const speed = this._playbackSpeed(playback);
+        if (speed <= TIME_EPSILON)
+            return Infinity;
+        const normalizedTime = playback.time / duration;
+        let targetNormalized;
+        if (playback.state.loop === 'once' || exitTime >= 1) {
+            targetNormalized = exitTime;
+        }
+        else {
+            targetNormalized = Math.floor(normalizedTime) + exitTime;
+            if (targetNormalized <= normalizedTime + TIME_EPSILON)
+                targetNormalized += 1;
+        }
+        return Math.max(0, (targetNormalized * duration - playback.time) / speed);
+    }
+    _conditionsPass(conditions) {
+        for (const condition of conditions) {
+            const actual = this._parameterValues[condition.parameterIndex];
+            const expected = condition.value;
+            if (condition.operator === 'greater' && !(actual > expected))
+                return false;
+            if (condition.operator === 'greater-or-equal'
+                && !(actual >= expected))
+                return false;
+            if (condition.operator === 'less' && !(actual < expected))
+                return false;
+            if (condition.operator === 'less-or-equal'
+                && !(actual <= expected))
+                return false;
+            if (condition.operator === 'equal' && actual !== expected)
+                return false;
+            if (condition.operator === 'not-equal' && actual === expected)
+                return false;
+            if (condition.operator === 'is-true' && actual === 0)
+                return false;
+            if (condition.operator === 'is-false' && actual !== 0)
+                return false;
+            if (condition.operator === 'triggered' && actual === 0)
+                return false;
+        }
+        return true;
+    }
+    _consumeTriggers(transition) {
+        for (const parameterIndex of transition.triggerParameterIndices) {
+            this._parameterValues[parameterIndex] = 0;
+        }
+    }
+    _createPlayback(layer, state, normalizedOffset) {
+        const createdActions = [];
+        try {
+            const motion = this._createRuntimeMotion(layer, state, state.motion, createdActions);
+            const playback = { state, motion, time: 0 };
+            playback.time = normalizedOffset * this._playbackDuration(playback);
+            this._forEachAction(motion, action => {
+                this.port.setWeight(action, 0);
+                this.port.setTime(action, playback.time);
+                this.port.setTimeScale(action, this._playbackSpeed(playback));
+                this.port.play(action);
+            });
+            return playback;
+        }
+        catch (error) {
+            for (let index = createdActions.length - 1; index >= 0; index--) {
+                const action = createdActions[index];
+                this.port.stop(action);
+                this.port.destroyAction(action);
+            }
+            throw error;
+        }
+    }
+    _createRuntimeMotion(layer, state, motion, createdActions) {
+        if (motion.kind === 'clip') {
+            const action = this.port.createAction(motion.clipId, {
+                layerId: layer.id,
+                stateId: state.id,
+                loop: state.loop,
+                blendMode: layer.blendMode,
+                mask: layer.mask,
+            });
+            if (!Number.isFinite(action.duration) || action.duration < 0) {
+                throw new RangeError(`Mixer port returned an invalid duration for clip "${motion.clipId}".`);
+            }
+            createdActions.push(action);
+            return { kind: 'clip', action };
+        }
+        const children = motion.children.map(child => this._createRuntimeMotion(layer, state, child.motion, createdActions));
+        return motion.kind === 'blend-1d'
+            ? {
+                kind: 'blend-1d',
+                motion,
+                children,
+                weights: new Float64Array(children.length),
+            }
+            : {
+                kind: 'blend-2d',
+                motion,
+                children,
+                weights: new Float64Array(children.length),
+            };
+    }
+    _advancePlayback(playback, deltaSeconds) {
+        playback.time += deltaSeconds * this._playbackSpeed(playback);
+    }
+    _advanceWithoutTransitions(layer, deltaSeconds) {
+        if (deltaSeconds <= TIME_EPSILON)
+            return;
+        const active = layer.transition;
+        if (!active) {
+            this._advancePlayback(layer.current, deltaSeconds);
+            this._synchronizeLayer(layer);
+            return;
+        }
+        const timeToCompletion = Math.max(0, active.definition.duration - active.elapsed);
+        const transitionStep = Math.min(deltaSeconds, timeToCompletion);
+        this._advancePlayback(active.source, transitionStep);
+        this._advancePlayback(active.destination, transitionStep);
+        active.elapsed += transitionStep;
+        const afterCompletion = deltaSeconds - transitionStep;
+        if (active.elapsed + TIME_EPSILON >= active.definition.duration) {
+            this._completeTransition(layer);
+            if (afterCompletion > TIME_EPSILON) {
+                this._advancePlayback(layer.current, afterCompletion);
+            }
+        }
+        this._synchronizeLayer(layer);
+    }
+    _synchronizeAllLayers() {
+        for (const layer of this._layers)
+            this._synchronizeLayer(layer);
+    }
+    _synchronizeLayer(layer) {
+        const active = layer.transition;
+        if (!active) {
+            this._applyPlayback(layer.current, layer.definition.weight);
+            return;
+        }
+        const progress = active.definition.duration <= TIME_EPSILON
+            ? 1
+            : Math.max(0, Math.min(1, active.elapsed / active.definition.duration));
+        this._applyPlayback(active.source, layer.definition.weight * (1 - progress));
+        this._applyPlayback(active.destination, layer.definition.weight * progress);
+    }
+    _applyPlayback(playback, parentWeight) {
+        const speed = this._playbackSpeed(playback);
+        this._applyMotion(playback.motion, parentWeight, playback.time, speed);
+    }
+    _applyMotion(motion, parentWeight, time, timeScale) {
+        if (motion.kind === 'clip') {
+            this.port.setWeight(motion.action, parentWeight);
+            this.port.setTime(motion.action, time);
+            this.port.setTimeScale(motion.action, timeScale);
+            return;
+        }
+        this._evaluateDirectWeights(motion);
+        for (let index = 0; index < motion.children.length; index++) {
+            this._applyMotion(motion.children[index], parentWeight * motion.weights[index], time, timeScale);
+        }
+    }
+    _playbackDuration(playback) {
+        return this._motionDuration(playback.motion);
+    }
+    _motionDuration(motion) {
+        if (motion.kind === 'clip')
+            return motion.action.duration;
+        this._evaluateDirectWeights(motion);
+        let duration = 0;
+        for (let index = 0; index < motion.children.length; index++) {
+            duration += motion.weights[index] * this._motionDuration(motion.children[index]);
+        }
+        return duration;
+    }
+    _playbackSpeed(playback) {
+        const parameterScale = playback.state.speedParameterIndex < 0
+            ? 1
+            : this._parameterValues[playback.state.speedParameterIndex];
+        return playback.state.speed * parameterScale;
+    }
+    _evaluateDirectWeights(motion) {
+        if (motion.kind === 'blend-1d') {
+            evaluateAnimation3DBlend1DWeights(motion.motion, this._parameterValues[motion.motion.parameterIndex], motion.weights);
+        }
+        else {
+            evaluateAnimation3DBlend2DWeights(motion.motion, this._parameterValues[motion.motion.parameterXIndex], this._parameterValues[motion.motion.parameterYIndex], motion.weights);
+        }
+    }
+    _fadePlayback(playback, targetParentWeight, durationSeconds) {
+        this._fadeMotion(playback.motion, targetParentWeight, durationSeconds);
+    }
+    _fadeMotion(motion, parentWeight, durationSeconds) {
+        if (motion.kind === 'clip') {
+            this.port.fade(motion.action, parentWeight, durationSeconds);
+            return;
+        }
+        this._evaluateDirectWeights(motion);
+        for (let index = 0; index < motion.children.length; index++) {
+            this._fadeMotion(motion.children[index], parentWeight * motion.weights[index], durationSeconds);
+        }
+    }
+    _destroyPlayback(playback) {
+        this._forEachAction(playback.motion, action => {
+            this.port.stop(action);
+            this.port.destroyAction(action);
+        });
+    }
+    _destroyAllLayers() {
+        for (const layer of this._layers) {
+            if (layer.transition) {
+                this._destroyPlayback(layer.transition.source);
+                this._destroyPlayback(layer.transition.destination);
+            }
+            else {
+                this._destroyPlayback(layer.current);
+            }
+        }
+        this._layers.length = 0;
+    }
+    _forEachAction(motion, visitor) {
+        if (motion.kind === 'clip') {
+            visitor(motion.action);
+            return;
+        }
+        for (const child of motion.children)
+            this._forEachAction(child, visitor);
+    }
+    _snapshotLayer(layer) {
+        const active = layer.transition;
+        return Object.freeze({
+            layerId: layer.definition.id,
+            currentStateId: active?.source.state.id ?? layer.current.state.id,
+            currentTime: active?.source.time ?? layer.current.time,
+            transitionId: active?.definition.id ?? null,
+            sourceStateId: active?.source.state.id ?? null,
+            destinationStateId: active?.destination.state.id ?? null,
+            transitionProgress: active
+                ? (active.definition.duration <= TIME_EPSILON
+                    ? 1
+                    : Math.max(0, Math.min(1, active.elapsed / active.definition.duration)))
+                : 0,
+        });
+    }
+    _setTypedParameter(name, expectedType, value) {
+        this._requireActive();
+        const parameter = this._resolveParameter(name);
+        if (parameter.type !== expectedType) {
+            throw new TypeError(`Parameter "${name}" is ${parameter.type}, not ${expectedType}.`);
+        }
+        this._parameterValues[parameter.index] = value;
+    }
+    _resolveParameter(name) {
+        const parameterIndex = this.compiled.parameterIndexByName.get(name);
+        if (parameterIndex === undefined)
+            throw new ReferenceError(`Unknown parameter "${name}".`);
+        return this.compiled.parameters[parameterIndex];
+    }
+    _restoreParameterDefaults() {
+        for (const parameter of this.compiled.parameters) {
+            this._parameterValues[parameter.index] = parameter.defaultValue;
+        }
+    }
+    _requireActive() {
+        if (this._status === 'destroyed') {
+            throw new Error('Animation3D state-machine controller is destroyed.');
+        }
+    }
+}
+/**
+ * @internal Extends one controller update transaction through caller-owned
+ * pose evaluation. It is intentionally not re-exported from package entries.
+ */
+function runAnimationStateMachineControllerUpdateTransaction(controller, deltaSeconds, beforeUpdate, complete) {
+    return controller[CONTROLLER_UPDATE_TRANSACTION](deltaSeconds, beforeUpdate, complete);
+}
+function resolveTransactionalPort(port) {
+    const candidate = port;
+    const hasBegin = typeof candidate.beginControllerTransaction === 'function';
+    const hasCommit = typeof candidate.commitControllerTransaction === 'function';
+    const hasRollback = typeof candidate.rollbackControllerTransaction === 'function';
+    const implemented = Number(hasBegin) + Number(hasCommit) + Number(hasRollback);
+    if (implemented === 0)
+        return null;
+    if (implemented !== 3) {
+        throw new TypeError('A transactional state-machine mixer port must implement begin, commit, and rollback.');
+    }
+    return candidate;
+}
+
+export { Animation3DStateMachineController as A, AnimationStateMachineValidationError as a, compileAnimation3DStateMachineDefinition as b, compileAnimationStateMachineDefinition as c, validateAnimation3DStateMachineDefinition as d, runAnimationStateMachineControllerUpdateTransaction as r, validateAnimationStateMachineDefinition as v };
+//# sourceMappingURL=AnimationStateMachineController-BIcAh-sT.js.map