kuinetic 0.1.0

package/dist/types/effects/catalog/interaction-shared.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Pure math for the pointer-tracking half of section I (`tilt-3d`, `tilt-parallax`, and the
+ * `cursor-*` family) — kept separate from DOM/timer wiring so the position → transform arithmetic
+ * is assertable without a browser, the same separation `text-shared.ts` uses for its state
+ * machines.
+ */
+export interface TiltAngles {
+    rotateX: number;
+    rotateY: number;
+}
+/** A pointer position relative to an element's own top-left corner, in pixels. */
+export interface LocalPoint {
+    x: number;
+    y: number;
+}
+/** An element's own content box size, in pixels. */
+export interface ElementSize {
+    width: number;
+    height: number;
+}
+/**
+ * Convert a pointer position within an element into a two-axis tilt, for `tilt-3d`.
+ *
+ * X drives `rotateY` (moving right tilts the far edge away) and Y drives `rotateX`, inverted, so
+ * hovering the top of the card tilts it back rather than forward — the direction a physical card
+ * would rotate if pushed at that point.
+ *
+ * @param point - Pointer position relative to the element's own top-left corner.
+ * @param size - Element's own content box size.
+ * @param maxAngleDeg - Rotation at the element's edge, in degrees.
+ * @returns The rotation to apply on each axis.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function tiltAngles(point: LocalPoint, size: ElementSize, maxAngleDeg: number): TiltAngles;
+/**
+ * Convert a pointer position within an element into a translate offset, for `tilt-parallax`'s
+ * per-layer depth effect. The caller multiplies the result by each layer's own depth factor.
+ *
+ * @param point - Pointer position relative to the element's own top-left corner.
+ * @param size - Element's own content box size.
+ * @param strengthPx - Translation at the element's edge, in pixels, for a depth of 1.
+ * @returns The base offset to scale by each layer's depth.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function parallaxOffset(point: LocalPoint, size: ElementSize, strengthPx: number): LocalPoint;
+/**
+ * Whether the environment can express a genuine hover — a touchscreen cannot, and treating a tap
+ * as a hover leaves an element visibly "stuck" in its hovered state with no pointer to leave it.
+ *
+ * @param win - Window to query; injected so tests can supply a fake `matchMedia`.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function supportsFineHover(win: Window): boolean;

package/dist/types/effects/catalog/interaction.d.ts

@@ -0,0 +1,22 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export declare const HOVER_PRIMITIVES: Primitive[];
+export declare const HOVER_PRESETS: Preset[];
+export declare const CONTINUOUS_BORDER_PRIMITIVES: Primitive[];
+export declare const CONTINUOUS_BORDER_PRESETS: Preset[];
+export declare const POINTER_PRIMITIVES: Primitive[];
+export declare const POINTER_PRESETS: Preset[];
+export declare const INTERACTION_PRIMITIVES: Primitive[];
+export declare const INTERACTION_PRESETS: Preset[];
+/**
+ * Register the hover and pointer catalog (section I).
+ *
+ * A standalone top-level registration, the same shape as `registerGestures`/`registerThreeD`, so
+ * wiring it into `createRegistry()` never has to touch the shared `catalog/index.ts` aggregator.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in registered primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerInteraction(registry: Registry): Registry;

package/dist/types/effects/catalog/media.d.ts

@@ -0,0 +1,13 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export declare const MEDIA_PRIMITIVES: Primitive[];
+export declare const MEDIA_PRESETS: Preset[];
+/**
+ * Register catalog section G (media & images) into a registry.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in registered primitives and presets; O(1) extra space.
+ * @overallScore 100
+ */
+export declare function registerMedia(registry: Registry): Registry;

package/dist/types/effects/catalog/numbers-shared.d.ts

@@ -0,0 +1,103 @@
+import type { Cleanup } from '../../core/types.js';
+/** Formats `count` can render its tweened value in. */
+export type CountFormat = 'number' | 'currency' | 'percent' | 'compact';
+export interface CountFormatOptions {
+    format: CountFormat;
+    decimals: number;
+    currency: string;
+}
+export interface CountLayers {
+    /** `aria-hidden` node the ticking display writes to on every frame. */
+    decorative: HTMLElement;
+    /**
+     * Visually-hidden twin. The caller must write this exactly once, on completion — never
+     * mid-tick — so a screen reader is told the final value and nothing in between.
+     */
+    srOnly: HTMLElement;
+    /** Remove both layers, restoring the element to plain text of whatever the SR layer last held. */
+    restore: Cleanup;
+}
+/**
+ * Replace an element's content with an `aria-hidden` ticking display plus a visually-hidden twin,
+ * both empty until the caller populates them, so a counter's mid-flight text is never read aloud
+ * and its `aria-live` region changes exactly once.
+ *
+ * @param el - Element whose content is being taken over. Assumed to hold no meaningful children.
+ * @param doc - Document to create nodes in, rather than the ambient global.
+ * @returns The decorative node to tick, the SR-only node to finalize once, and a cleanup.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function installCountLayers(el: Element, doc: Document): CountLayers;
+/**
+ * Ease a linear 0–1 ratio for a count tween. Counters read as mechanical on a linear ramp; cubic
+ * ease-out gives the settle a physical "spinning down" character without a spring's overshoot,
+ * which would put a currency counter briefly past its final total.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function easeOutCubic(t: number): number;
+/**
+ * Interpolate between `from` and `to` at an already-eased ratio.
+ *
+ * @param t - Eased progress, 0–1. Not clamped here — `easeOutCubic` already clamps its input.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function tweenValue(t: number, from: number, to: number): number;
+/**
+ * Resolve an author's validated `EffectTiming.easing` to a JS evaluator a tween can call per tick.
+ *
+ * `easeOutCubic` is both the historical no-easing-authored default and the fallback for a value
+ * this cannot map: `steps()`/`linear()` functions, `step-start`/`step-end`, `spring` (a keyframed
+ * `linear()` easing, not a bezier), or any keyword outside the table above. Falling back silently
+ * would leave an author's explicit easing quietly ignored a second time — the exact bug this
+ * function exists to close — so every unmapped-but-authored value warns once instead.
+ *
+ * @param warn - Diagnostic sink, called once for an easing this cannot map.
+ * @complexity O(1) time and space beyond the returned evaluator's own bounded solve.
+ * @overallScore 100
+ */
+export declare function resolveEasing(easing: string | undefined, warn: (message: string) => void): (t: number) => number;
+/**
+ * Format a tweened numeric value for display, sharing one formatter shape across the four
+ * text-rendered count presets rather than each hand-rolling its own string building.
+ *
+ * @param value - Current tweened value.
+ * @param options - Which display family to use, decimal precision, and currency code.
+ * @returns The formatted string for this frame.
+ * @complexity O(1) time and space (bounded by `Intl.NumberFormat`'s own cost).
+ * @overallScore 100
+ */
+export declare function formatCount(value: number, options: CountFormatOptions): string;
+/**
+ * Render a non-negative integer as a fixed-width digit string, so an odometer's column count
+ * never changes mid-count — only the digits inside each column do.
+ *
+ * @param value - Non-negative integer to render.
+ * @param width - Minimum digit count; shorter values are left-padded with zeros.
+ * @complexity O(w) time and space in the output width.
+ * @overallScore 100
+ */
+export declare function paddedDigits(value: number, width: number): string;
+/**
+ * Insert thousands separators into a fixed-width digit string, grouping from the right.
+ *
+ * @complexity O(n) time and space in digit count.
+ * @overallScore 100
+ */
+export declare function groupDigits(digits: string): string;
+/**
+ * Split a grouped digit string into its digit characters and the separators between them, so the
+ * odometer can roll digits in place while leaving separators static.
+ *
+ * @param grouped - A grouped digit string, e.g. "12,480".
+ * @returns One token per character, tagged as a rolling digit or a static separator.
+ * @complexity O(n) time and space in string length.
+ * @overallScore 100
+ */
+export declare function odometerTokens(grouped: string): {
+    char: string;
+    digit: boolean;
+}[];

package/dist/types/effects/catalog/numbers.d.ts

@@ -0,0 +1,31 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export interface NumberTween {
+    from: number;
+    to: number;
+    durationMs: number;
+    /** Time before the ramp starts. Author `delay`, same as every other timed JS primitive. */
+    delayMs: number;
+    /** Author `easing`, already resolved to a JS evaluator — `resolveEasing`'s fallback if none. */
+    easing: (t: number) => number;
+    onTick: (value: number, done: boolean) => void;
+}
+export declare const COUNT_PRIMITIVES: Primitive[];
+export declare const COUNT_PRESETS: Preset[];
+export declare const METER_PRIMITIVES: Primitive[];
+export declare const METER_PRESETS: Preset[];
+export declare const NUMBERS_PRIMITIVES: Primitive[];
+export declare const NUMBERS_PRESETS: Preset[];
+/**
+ * Register the numbers and data-viz catalog (section F).
+ *
+ * A standalone top-level registration, the same shape as `registerGestures`/`registerThreeD`,
+ * rather than folded into `registerCatalog` — that keeps this module wireable into
+ * `createRegistry()` without touching the shared `catalog/index.ts` aggregator.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in registered primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerNumbers(registry: Registry): Registry;

package/dist/types/effects/catalog/shared.d.ts

@@ -0,0 +1,3 @@
+/** Re-exported for same-directory catalog siblings; the canonical definition lives in `effects/shared.ts` — neutral ground for every CSS-keyframe category, not just `catalog/`. */
+export { cssPrimitive } from '../shared.js';
+export type { CssPrimitiveOptions } from '../shared.js';

package/dist/types/effects/catalog/text-shared.d.ts

@@ -0,0 +1,180 @@
+import type { Cleanup, EffectParams } from '../../core/types.js';
+/** How `split-text` breaks a string into decorative pieces. */
+export type SplitUnit = 'chars' | 'words' | 'lines';
+export interface SplitLayers {
+    /** `aria-hidden` container the caller populates with decorative markup or text. */
+    decorative: HTMLElement;
+    /** The element's text at the moment splitting began. */
+    originalText: string;
+    /** Remove both layers and put the original text back, selectable and unabridged. */
+    restore: Cleanup;
+}
+/**
+ * Replace an element's text with an `aria-hidden` decorative layer plus a visually-hidden twin
+ * holding the real text, so exactly one reading representation is ever exposed to assistive tech
+ * — the decorative layer is free to sit mid-scramble, mid-type, or split into spans without a
+ * screen reader ever seeing an incomplete or garbled read of the content.
+ *
+ * @param el - Element whose text is being taken over. Assumed to hold plain text (no children) —
+ *   every DOM-surgery primitive in this module shares that constraint.
+ * @param doc - Document to create nodes in, rather than the ambient global, so callers can point
+ *   this at a test document.
+ * @returns The decorative layer to populate, the captured text, and a cleanup.
+ * @complexity O(1) time and space beyond the caller's own population work.
+ * @overallScore 100
+ */
+export declare function installSplitLayers(el: Element, doc: Document): SplitLayers;
+/**
+ * Grapheme clusters, not UTF-16 code units — an emoji, a flag, or a base letter plus combining
+ * mark stays one unit instead of being torn across two "characters".
+ *
+ * @complexity O(n) time in text length; O(n) space for the returned array.
+ * @overallScore 100
+ */
+export declare function segmentGraphemes(text: string): string[];
+/**
+ * Forward validated timing params onto a synthetic container, so the `--kui-i` × `--kui-stagger`
+ * delay formula in text.css can read them by inheritance.
+ *
+ * A JS-rendered primitive's per-primitive namespaced `cssProperty` (see `registry.ts`) only
+ * governs what `resolveParams` writes onto the *authored* element for CSS-tier effects — nothing
+ * here reads that. These are plain, self-chosen custom properties on a container this module
+ * created and owns outright, populated straight from the validated `EffectParams` reader.
+ *
+ * Segment timing wins over the same-named parameters: `split-words 2s 1s linear` and
+ * `split-words duration:2s delay:1s ease:linear` are two spellings of one intent, and the
+ * positional one is the spelling `play()` emits, so it cannot be the one that gets dropped.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function applyStaggerVars(el: HTMLElement, params: EffectParams): void;
+/**
+ * Milliseconds per tick for a stepped effect.
+ *
+ * A `step:` parameter names one tick; an authored duration names the *whole* effect, so it divides
+ * across the ticks the effect needs. That is the only reading that makes `typewriter 2s` mean the
+ * same thing as `fade-up 2s` — both take two seconds — rather than two seconds per character.
+ *
+ * @param params - Reader carrying both the `step` parameter and the segment's timing.
+ * @param ticks - How many ticks the effect will take to complete.
+ * @param fallback - The primitive's own per-tick default.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function stepMsFor(params: EffectParams, ticks: number, fallback: number): number;
+/**
+ * Total time before every staggered `.kui-split-item` has finished its reveal keyframe: the last
+ * item's `--kui-i * --kui-stagger` delay (text.css), plus its own duration. `prepareSplitText`
+ * needs this as a plain number to know when `finished` may resolve — nothing else in this file
+ * derives it, so it is expressed here once rather than re-parsed at the call site.
+ *
+ * @param itemCount - Staggered item count; zero when there was nothing to split, in which case
+ *   nothing animates and the effect is already over.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function splitRevealFinishMs(params: EffectParams, itemCount: number): number;
+export interface StepRunOptions {
+    /** Milliseconds before the first tick. */
+    delayMs: number;
+    /** Milliseconds between ticks. */
+    stepMs: number;
+    /** One frame of work. Returns `true` when there is nothing left to do. */
+    tick(): boolean;
+}
+export interface StepRun {
+    /**
+     * Resolves once a tick reports it is done, or once `stop()` runs. A looping effect never
+     * reports done, so its promise never resolves — which is exactly right, and matches what an
+     * infinite CSS animation's `Animation.finished` does.
+     */
+    finished: Promise<void>;
+    stop(): void;
+}
+/**
+ * Run `tick` on an interval after an optional delay, and report when it is genuinely over.
+ *
+ * The delay is the whole point of the leading timeout: a JS-rendered effect had no way to honour
+ * an authored delay at all, because it never participates in the CSS `animation-delay` that the
+ * same attribute already means for every other effect.
+ *
+ * @param win - Timer source, injected so tests can drive it with fake timers.
+ * @param options - Delay, interval, and the work itself.
+ * @complexity O(1) time and space beyond the caller's own per-tick work.
+ * @overallScore 100
+ */
+export declare function createStepRunner(win: Window, options: StepRunOptions): StepRun;
+/**
+ * Split text into one span per grapheme cluster, leaving whitespace graphemes as plain text nodes.
+ *
+ * A `display: inline-block` span whose only content is a single space renders at zero width — the
+ * lone space is both the first and last "character" of that box's own formatting context, so CSS
+ * whitespace collapsing trims it away entirely. Every word ran together until this skipped
+ * wrapping the space itself, the same way `appendWordSpans` already leaves inter-word whitespace
+ * unwrapped.
+ *
+ * @complexity O(n) time and space in grapheme count.
+ * @overallScore 100
+ */
+export declare function appendCharSpans(container: Element, doc: Document, text: string): HTMLElement[];
+/**
+ * Split text into one span per word, leaving the whitespace and punctuation between them as plain
+ * text nodes so natural line-wrapping and spacing survive untouched.
+ *
+ * @complexity O(n) time and space in segment count.
+ * @overallScore 100
+ */
+export declare function appendWordSpans(container: Element, doc: Document, text: string): HTMLElement[];
+/**
+ * Split text into one span per visual line.
+ *
+ * Lines are not a text property — they only exist after wrapping — so this measures word spans
+ * already laid out in the live DOM, then regroups their nodes (words and the whitespace between
+ * them) into per-line containers.
+ *
+ * @complexity O(n) time and space in word-span count.
+ * @overallScore 100
+ */
+export declare function appendLineSpans(container: Element, doc: Document, text: string): HTMLElement[];
+/**
+ * Split text by the requested unit.
+ *
+ * @complexity O(n) time and space in text length, dominated by the chosen unit's own cost.
+ * @overallScore 100
+ */
+export declare function appendSpansFor(unit: SplitUnit, container: Element, doc: Document, text: string): HTMLElement[];
+export interface TypeState {
+    index: number;
+    deleting: boolean;
+}
+export interface TypeStep extends TypeState {
+    done: boolean;
+}
+/**
+ * Advance a typewriter one tick: typing forward, then — when looping — deleting back to zero
+ * before typing again. Pure so the state machine is assertable without any timer or DOM.
+ *
+ * @param state - Current position and direction.
+ * @param total - Grapheme count of the full string.
+ * @param loop - Whether to reverse at the end instead of stopping.
+ * @returns The next state, plus whether the effect has nothing left to do.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function nextTypeState(state: TypeState, total: number, loop: boolean): TypeStep;
+/** Charsets the scramble family cycles through while a character is still unresolved. */
+export declare const SCRAMBLE_CHARSETS: Record<string, string>;
+/**
+ * Render one frame of a scramble/decode/glitch resolve: graphemes before `resolved` show their
+ * real value, the rest render as a random charset character. Whitespace is never scrambled, so
+ * word boundaries stay legible mid-resolve.
+ *
+ * @param graphemes - The target text, already grapheme-segmented.
+ * @param resolved - Count of graphemes (from the start) considered final.
+ * @param charset - Characters to draw unresolved positions from.
+ * @param random - Source of randomness, injected so the frame is reproducible in tests.
+ * @complexity O(n) time and space in grapheme count.
+ * @overallScore 100
+ */
+export declare function scrambledFrame(graphemes: string[], resolved: number, charset: string, random: () => number): string;

package/dist/types/effects/catalog/text.d.ts

@@ -0,0 +1,17 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export declare const TEXT_CSS_PRIMITIVES: Primitive[];
+export declare const TEXT_CSS_PRESETS: Preset[];
+export declare const TEXT_JS_PRIMITIVES: Primitive[];
+export declare const TEXT_JS_PRESETS: Preset[];
+export declare const TEXT_PRIMITIVES: Primitive[];
+export declare const TEXT_PRESETS: Preset[];
+/**
+ * Register catalog section D (text & typography) into a registry.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in registered primitives and presets; O(1) extra space.
+ * @overallScore 100
+ */
+export declare function registerText(registry: Registry): Registry;

package/dist/types/effects/forms/index.d.ts

@@ -0,0 +1,14 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export * from './primitives.js';
+export declare const FORMS_PRIMITIVES: Primitive[];
+export declare const FORMS_PRESETS: Preset[];
+/**
+ * Register the forms catalog.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerForms(registry: Registry): Registry;

package/dist/types/effects/forms/primitives.d.ts

@@ -0,0 +1,32 @@
+import type { Primitive } from '../../core/types.js';
+export declare const NATIVE_STATE_PRIMITIVE: Primitive;
+export declare const FOCUS_RING_PRIMITIVE: Primitive;
+export declare const VALIDATE_SHAKE_PRIMITIVE: Primitive;
+export declare const VALIDATE_CHECK_PRIMITIVE: Primitive;
+/**
+ * Score a password's strength on length and character variety — a rough, dependency-free
+ * heuristic; real strength scoring (zxcvbn and friends) is out of scope for a demo primitive.
+ *
+ * @complexity O(n) time in value length; O(1) space.
+ * @overallScore 100
+ */
+export declare function computeStrength(value: string): number;
+export declare const STRENGTH_METER_PRIMITIVE: Primitive;
+export declare const RANGE_FILL_PRIMITIVE: Primitive;
+/**
+ * Advance a step index, wrapping back to 0 — pure, so the wrap rule is assertable without a DOM.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function nextStep(step: number, total: number): number;
+export declare const STEP_PROGRESS_PRIMITIVE: Primitive;
+export type SubmitStage = 'idle' | 'loading' | 'done';
+/**
+ * Advance the submit flow one stage: idle -> loading -> done -> idle.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function nextSubmitStage(stage: SubmitStage): SubmitStage;
+export declare const SUBMIT_FLOW_PRIMITIVE: Primitive;

package/dist/types/effects/gestures/index.d.ts

@@ -0,0 +1,19 @@
+import type { Preset } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export { GESTURE_PRIMITIVES } from './primitives.js';
+/**
+ * Gesture names. Twelve names over four primitives.
+ *
+ * The drag family differs only in where a release goes: back to origin (elastic), onward with
+ * momentum (throwable), or nowhere (plain drag). That is one primitive with two booleans.
+ */
+export declare const GESTURE_PRESETS: Preset[];
+/**
+ * Register the gesture catalog.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerGestures(registry: Registry): Registry;

package/dist/types/effects/gestures/primitives.d.ts

@@ -0,0 +1,2 @@
+import type { Primitive } from '../../core/types.js';
+export declare const GESTURE_PRIMITIVES: Primitive[];

package/dist/types/effects/index.d.ts

@@ -0,0 +1,19 @@
+import { Registry } from '../core/registry.js';
+export { PRIMITIVES, PRESETS, COMBOS, registerCore } from './catalog/core.js';
+export { registerGestures } from './gestures/index.js';
+export { registerLayout } from './layout/index.js';
+export { registerScrollMechanics } from './scroll-mechanics/index.js';
+export { registerSvg } from './svg/index.js';
+export { registerThreeD } from './three-d/index.js';
+export { registerCatalog } from './catalog/index.js';
+/**
+ * A registry with the full catalog registered.
+ *
+ * Packages register separately so a consumer paying attention to payload can take only what they
+ * use — `registerCore` alone is entirely CSS-rendered and ships no scroll orchestration at all.
+ *
+ * @returns A populated registry.
+ * @complexity O(n) time in the total number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function createRegistry(): Registry;

package/dist/types/effects/layout/index.d.ts

@@ -0,0 +1,12 @@
+import type { Registry } from '../../core/registry.js';
+export { LAYOUT_PRIMITIVES } from './primitives.js';
+export { LAYOUT_PRESETS } from './presets.js';
+/**
+ * Register the layout/FLIP catalog.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerLayout(registry: Registry): Registry;

package/dist/types/effects/layout/presets.d.ts

@@ -0,0 +1,9 @@
+import type { Preset } from '../../core/types.js';
+/**
+ * Layout-transition names. Nine names over three primitives.
+ *
+ * The four `flip-*` names are the same primitive: what differs is why the children moved, and the
+ * engine neither knows nor needs to. They exist as separate names because authors think in terms
+ * of "I filtered a list", not "I mutated a child list".
+ */
+export declare const LAYOUT_PRESETS: Preset[];

package/dist/types/effects/layout/primitives.d.ts

@@ -0,0 +1,2 @@
+import type { Primitive } from '../../core/types.js';
+export declare const LAYOUT_PRIMITIVES: Primitive[];

package/dist/types/effects/navigation/index.d.ts

@@ -0,0 +1,30 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+/**
+ * Navigation effects (catalog section M).
+ *
+ * Boundary, same as section H's FLIP group: these animate a menu, header, or drawer *you*
+ * control. None of them own `aria-expanded`, focus trapping, roving tabindex, or Escape-to-close
+ * — that is an accessible-menu-component's job, not an animation primitive's. An author wires the
+ * open/closed state (a class, an attribute, a framework) and triggers playback; this module only
+ * ever supplies the motion.
+ *
+ * Three of the eight names — `header-shrink`, `header-hide-on-scroll`, `back-to-top-fade` — react
+ * to raw scroll position rather than a trigger, so they share one small helper over the same
+ * `ctx.scheduler`/`ctx.rootFor` primitives every scroll-mechanics effect already uses.
+ */
+export declare const NAV_CSS_PRIMITIVES: Primitive[];
+export declare const NAV_CSS_PRESETS: Preset[];
+export declare const NAV_JS_PRIMITIVES: Primitive[];
+export declare const NAV_JS_PRESETS: Preset[];
+export declare const NAVIGATION_PRIMITIVES: Primitive[];
+export declare const NAVIGATION_PRESETS: Preset[];
+/**
+ * Register the navigation catalog.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerNavigation(registry: Registry): Registry;

package/dist/types/effects/scroll-mechanics/index.d.ts

@@ -0,0 +1,14 @@
+import type { Registry } from '../../core/registry.js';
+export { SCROLL_PRIMITIVES } from './primitives.js';
+export { SCROLL_PRESETS } from './presets.js';
+export { domGeometry, progressFrom, trackProgress } from './tracker.js';
+export type { ElementGeometry, Measurer, TrackOptions } from './tracker.js';
+/**
+ * Register the scroll-mechanics catalog.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ * @overallScore 100
+ */
+export declare function registerScrollMechanics(registry: Registry): Registry;

package/dist/types/effects/scroll-mechanics/presets.d.ts

@@ -0,0 +1,6 @@
+import type { Preset } from '../../core/types.js';
+/**
+ * Scroll-mechanics names. Eleven names over six primitives — the same alias-table shape the
+ * entrance matrix uses, so adding a variant stays a data change.
+ */
+export declare const SCROLL_PRESETS: Preset[];

package/dist/types/effects/scroll-mechanics/primitives.d.ts

@@ -0,0 +1,2 @@
+import type { Primitive } from '../../core/types.js';
+export declare const SCROLL_PRIMITIVES: Primitive[];