kuinetic 0.1.3 → 0.2.0

package/dist/types/core/unquoted-selectors.d.ts

@@ -0,0 +1,53 @@
+import type { EffectSpec } from './types.js';
+import type { Registry } from './registry.js';
+/**
+ * Owned by phase 9b — catching the classic `target:` typo: `pop target:.a, .b` reads as three
+ * effect segments (`pop`, `.a`, `.b`), not one effect with a two-part selector, because a comma
+ * separates *segments* everywhere else in the grammar and `target:` is the one place a selector
+ * can legitimately contain one. An author who forgets the quotes (`target:'.a, .b'`) gets a stray
+ * segment named `.a` that is not a registered effect and looks exactly like a selector — this
+ * module finds that shape and 9b's diagnostics surface it via `data-kui-unmatched`.
+ */
+/** One stray segment that looks like a continuation of the previous segment's `target:` selector. */
+export interface UnquotedSelector {
+    /** The previous segment's `target:` value, as authored. */
+    previous: string;
+    /** The stray segment's name — the text between commas that isn't a registered effect. */
+    segment: string;
+}
+/**
+ * Find segments whose first token is not a registered effect name, that look like a selector
+ * fragment (start with `.`, `#`, `[`, `*`, `:`, or contain `>`, `~`, `+`), and whose *previous*
+ * segment carries a `target:` token — the shape an unquoted, comma-containing selector leaves
+ * behind once `parse.ts` has already split it on the comma.
+ *
+ * Pure: it only reads `specs` and `registry`, and never changes how anything is parsed or
+ * compiled — the fix is a warning, not a silent re-join, because re-joining would have to guess
+ * where the selector was supposed to end.
+ *
+ * Known limitation: only catches a stray segment whose *first token* looks like a selector.
+ * `pop target:.a, li > a` splits into a stray segment `li > a` whose first token is `li` — a
+ * plausible effect name — so it is not flagged, even though `>` later in the segment is still a
+ * combinator. Detecting that shape would mean scanning every segment for a `target:`-less
+ * combinator, not just the one right after a `target:`-bearing segment, which is out of scope
+ * here: this pass only looks at the segment immediately following one that carries `target:`.
+ *
+ * @param specs - The document's parsed effect segments, in authored order. Pre-lift: `target:`
+ *   still lives in `spec.params.target` rather than having been pulled onto a separate field.
+ * @param registry - Where a segment's first token is looked up to decide if it names a real
+ *   effect.
+ * @returns Every suspect segment found, in authored order.
+ * @complexity O(n) time in `specs.length`, each iteration doing an O(1) registry lookup; O(f)
+ *   space in the number of findings.
+ * @overallScore 100
+ */
+export declare function findUnquotedSelectors(specs: EffectSpec[], registry: Registry): UnquotedSelector[];
+/**
+ * Render one {@link UnquotedSelector} finding as a warning string, naming both halves of the fix:
+ * quote the previous segment's selector so the whole comma list is one `target:` value.
+ *
+ * @param found - One finding from {@link findUnquotedSelectors}.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function unquotedSelectorWarning(found: UnquotedSelector): string;

package/dist/types/effects/carousel/drag.d.ts

@@ -0,0 +1,80 @@
+import type { PrepareContext } from '../../core/effect-context.js';
+import type { Cleanup } from '../../core/types.js';
+export interface RingDragRequest {
+    el: Element;
+    ctx: PrepareContext;
+    /** `grab:false` still installs the keyboard half — that is accessibility, not decoration. */
+    enabled: boolean;
+    /** Pointer pixels per place on the ring. */
+    travelPx: number;
+    /** How many places the ring has *now*; asked per gesture, never captured. */
+    total(): number;
+    /** The ring's current continuous position, in places. */
+    positionOf(): number;
+    /** Move the ring to a continuous position and re-render. */
+    moveTo(position: number): void;
+    /** Publish or clear the dragging state the stylesheet suspends its transition on. */
+    setDragging(dragging: boolean): void;
+}
+/**
+ * Where a release coasts to, before snapping.
+ *
+ * Velocity is in pixels per second and the ring is measured in places, so the projection is
+ * `velocity / travel * seconds` — one conversion, in one place, in the unit the index uses.
+ *
+ * Capped, and the cap is not politeness. Uncapped, a hard flick on a phone (velocities of several
+ * thousand pixels per second are ordinary) projects a dozen places, and a ring that spins a dozen
+ * cards from one flick has stopped being a control and become a slot machine: the visitor cannot
+ * predict where it lands, so they cannot aim, so they flick again. Four places is far enough that a
+ * deliberate throw clearly differs from a nudge and close enough that the destination stays
+ * legible.
+ *
+ * Pure and exported so both halves — the conversion and the cap — are assertable without a pointer.
+ *
+ * @param position - Where the ring is at release, in places.
+ * @param velocityPxPerSec - Signed pointer velocity along the drag axis.
+ * @param travelPx - Pixels per place.
+ * @returns The un-snapped position the ring is heading for.
+ * @complexity O(1) time and space.
+ */
+export declare function projectRelease(position: number, velocityPxPerSec: number, travelPx: number): number;
+/**
+ * Which place a released ring settles on.
+ *
+ * Separate from {@link projectRelease} because they answer different questions and only one of them
+ * has an opinion: projection is physics, snapping is the contract that a ring always comes to rest
+ * facing a card. Splitting them is also what makes "a flick of exactly half a place still commits"
+ * testable without synthesising a gesture.
+ *
+ * `+ 0` is not decoration. `Math.round(-0.4)` is `-0`, and a ring settled at "minus place zero" is
+ * not a place — it is the same place spelled in a way that half of JavaScript disagrees with
+ * itself about. `-0 === 0` is true, so most arithmetic hides it; `Object.is(-0, 0)` is false, which
+ * is what `toBe` compares with, and `[-0].toString()` and `JSON.stringify(-0)` disagree with each
+ * other too. Adding zero normalises the sign at the one place a negative zero can be produced,
+ * rather than leaving every caller and every serialisation to find out for itself.
+ *
+ * @param projected - The coasting destination, in places.
+ * @returns The nearest whole place, never negative zero.
+ * @complexity O(1) time and space.
+ */
+export declare function snapTo(projected: number): number;
+/**
+ * Bring a settled position onto `[0, total)`.
+ *
+ * A ring has no ends, so nothing about the geometry needs this — `--kui-offset` is computed modulo
+ * the count and `render` rebases the published position on the live step every time. What needs it
+ * is arithmetic hygiene over a long session: `position` accumulates every drag ever made, and a
+ * number in the millions loses the fractional precision the sub-step rotation is carried in. Doing
+ * it at rest rather than mid-drag keeps the drag itself monotonic, so a gesture never jumps because
+ * it happened to cross the seam.
+ *
+ * @complexity O(1) time and space.
+ */
+export declare function wrapPlace(place: number, total: number): number;
+/**
+ * Install the grab and the keyboard on a ring.
+ *
+ * @returns Teardown for every listener and attribute this installs.
+ * @complexity O(1) per pointer event and per key; O(1) space.
+ */
+export declare function createRingDrag(request: RingDragRequest): Cleanup;

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

@@ -0,0 +1,149 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+/**
+ * Whether a slot at this ring angle has its own plane turned away from the camera.
+ *
+ * Pure and exported so the rule is assertable without a DOM or a layout. The angle is the slot's
+ * signed place on the ring in degrees, already including the live-step drift.
+ *
+ * `>=` rather than `>` at exactly a quarter turn: a slot edge-on to the camera has zero projected
+ * width, so it can only ever swallow a click that was aimed at something else. Calling it "back" is
+ * the answer that costs nothing and removes the boundary case from the hit-testing question.
+ *
+ * @param angleDeg - Signed degrees from the camera-facing position.
+ * @returns `'back'` when the slot's face points away, `'front'` otherwise.
+ * @complexity O(1) time and space.
+ */
+export declare function faceAt(angleDeg: number): 'front' | 'back';
+/**
+ * Bring an angle onto `(-180, 180]`, the range where "how far from facing me" is a magnitude.
+ *
+ * Without it a slot at `+350deg` — which is 10 degrees from front — reads as further from the
+ * camera than one at `+100deg`, and the whole back half of a large ring is mislabelled.
+ *
+ * @complexity O(1) time and space.
+ */
+export declare function normaliseDegrees(angleDeg: number): number;
+/**
+ * Where the ring's continuous position rounds to, and how far past it the ring currently sits.
+ *
+ * The pair the stylesheet needs and the reason both tokens are published rather than one: the
+ * integer decides which slot is *live* (and therefore what `--kui-offset` means for every other
+ * slot), and the remainder is the sub-step rotation on top of it. Re-snapping the integer whenever
+ * the remainder passes a half step is what keeps the remainder inside ±0.5, so the ring never has
+ * to travel back across the whole strip to wrap from the last slide to the first — the same
+ * property `circularOffset` gives the discrete case.
+ *
+ * @param position - Continuous ring position, in places. May be negative or beyond the count.
+ * @param total - How many places the ring has.
+ * @returns The live integer step, wrapped into range, and the signed remainder in `[-0.5, 0.5)`.
+ * @complexity O(1) time and space.
+ */
+export declare function snapPosition(position: number, total: number): {
+    step: number;
+    drift: number;
+};
+/**
+ * An authored `<angle>` as a number of degrees.
+ *
+ * `params.ts` accepts every CSS angle unit and normalises only the bare/`d` spellings to `deg`, so
+ * a value reaching here can legitimately be `0.05turn` or `1.2rad`. The stylesheet does not care —
+ * it hands the token straight to `rotateY()` — but this file computes with it (to decide which
+ * slots face away), and a `Number('0.05turn')` is `NaN`.
+ *
+ * Falls back rather than throwing on an unrecognised unit for the reason every reader in this
+ * library does: the value has already been validated, so an unfamiliar spelling here means this
+ * function is behind `params.ts`, and a ring that spreads over the default arc is a better answer
+ * than one that throws during `prepare`.
+ *
+ * @param value - A validated CSS angle.
+ * @param fallbackDeg - Used when the unit is not one this function converts.
+ * @returns Degrees.
+ * @complexity O(n) time in value length; O(1) space.
+ */
+export declare function degreesOf(value: string, fallbackDeg: number): number;
+/**
+ * The ring primitive.
+ *
+ * `renderer: 'javascript'` and two channels together are the honest declaration: this file paints
+ * nothing itself — it publishes numbers — but `carousel.css` does, and both of the things it writes
+ * have to be declared or the conflict detector waves through a composition that silently loses one
+ * effect's output.
+ *
+ * `skew` is this catalog's name for "claims the whole `transform` shorthand" (see `CHANNEL.skew` in
+ * `core/types.ts`), which `carousel.css` writes on the elements this effect drives. The shorthand is
+ * unavoidable here: three-dimensional placement needs `rotateX`/`rotateY`/`translateZ` composed in a
+ * fixed order, and `rotate:`/`translate:` as individual properties are applied in the order the spec
+ * fixes, which is the reverse of the one this geometry needs.
+ *
+ * `discrete` is `display`, and it is here for exactly the reason `card-toggle` declares it
+ * (`effects/three-d/index.ts`): the unconditional host rule pins `display: grid` so every slot
+ * starts from the same cell instead of flowing down the page as block siblings. That has nothing to
+ * do with `catalog/discrete.ts`'s show/hide use of the same property, but `display` is tracked as
+ * one channel whatever value is written into it — the point of the channel model is the physical
+ * property, not the intent — so a ring composed with an `@starting-style` open/close effect is now
+ * correctly reported as a collision rather than quietly letting one of the two win.
+ *
+ * `reducedMotion: 'shorten'`, not `'disable'`, for exactly the reason `step-progress` carries the
+ * same note: under `disable` the animator never activates the instance, so no index is published,
+ * no slot is marked, and the arrows do nothing. A visitor who asked for less motion would get a
+ * dead widget rather than a calm one. Reduced motion suppresses the *travel* between places — which
+ * `base.css`'s policy layer already does to the transition `carousel.css` declares — never the
+ * function.
+ */
+export declare const SPATIAL_RING_PRIMITIVE: Primitive;
+export declare const CAROUSEL_PRIMITIVES: Primitive[];
+/**
+ * Convex and concave are two names, not one parameter with two values.
+ *
+ * They are one sign in the maths — `translateZ(+r)` puts the camera outside the ring,
+ * `translateZ(-r)` puts it at the centre — and everything else about them differs. Outside, the far
+ * half of the ring is content: smaller, dimmer, and part of the composition, and a full 360-degree
+ * spread is right. Inside, the far half is *behind your head*, so a full spread hides most of the
+ * deck and the sensible default is a slice; the cards nearest the edges of that slice are the ones
+ * that need culling; and "next" moves the world past a fixed viewer rather than turning an object
+ * in front of one.
+ *
+ * A `curve:` keyword would have made all of that one name's problem to explain, with half its
+ * documentation prefixed by "unless". Two names each get their own defaults, their own rules in
+ * `carousel.css`, and their own paragraph.
+ *
+ * `requiresOwnSubtree` on all of them: every rule in `carousel.css` past the host rule reaches the
+ * slots, so a `target:` that relocated `data-kui-fx` onto one slot would leave those selectors
+ * looking for grandchildren nobody authored. (The primitive declares a `target` parameter of its
+ * own, so `compile.ts` never consults the flag — but `test/css-requires-own-subtree.test.ts`
+ * re-derives the reaching set from the stylesheet and does, and the fact it records is true.)
+ *
+ * `phase: 'idle'` on all of them too, and for the same reason `target` does not change the answer:
+ * `channelsFor`/`findConflicts` (`core/channels.ts`) reason about the channels *this preset
+ * declares* on the host it is authored on (`CHANNEL.skew` and `'discrete'`, from
+ * `SPATIAL_RING_PRIMITIVE`), not about which element in the subtree physically paints them — the
+ * compiler has no notion of "the primitive's own target moved the real work three nodes down," and
+ * does not need one here, because `requiresOwnSubtree` already keeps this preset off of anything
+ * `target:` could relocate.
+ *
+ * The phase question itself is the same one `scroll-mechanics/presets.ts` answers at length:
+ * `prepareSpatialRing` calls `render()` unconditionally during `prepare` — before any drag, before
+ * any control click — which stamps `data-kui-step`/`--kui-step-position`/the per-slot face
+ * attributes immediately, and the primitive's `defaultActivation` is `'load'`. So, like the scroll
+ * primitives and unlike `gestures/index.ts`'s `draggable` (silent until `pointerdown`), a ring never
+ * has a quiescent stretch for an entrance to release into — it claims `skew`/`discrete` from the
+ * first frame and holds them, drag or no drag, until `destroy()`. That is `EffectPhase`'s `idle`:
+ * "runs unbounded, so it never yields the channel at all." It buys nothing new by itself —
+ * `INDEPENDENT_PHASES` exempts only `entrance|state` and `exit|state`, so `idle` still collides with
+ * everything including another `idle`, which is correct: `carousel-3d, flip-in-x` really would fight
+ * over the `transform` shorthand (`CHANNEL.skew`) for the ring's whole lifetime, and there is no
+ * turn-taking to model. It replaces "nothing is known" with the actual, checked fact.
+ *
+ * None of the four declares `transitions`: nothing here renders through a CSS `transition:` on the
+ * host box for `phaseOf` to derive `state` from — the ring is `renderer: 'javascript'` throughout.
+ */
+export declare const CAROUSEL_PRESETS: Preset[];
+/**
+ * Register the spatial carousel.
+ *
+ * @param registry - Registry to populate.
+ * @returns The same registry, for chaining.
+ * @complexity O(n) time in the number of primitives and presets.
+ */
+export declare function registerCarousel(registry: Registry): Registry;

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

@@ -0,0 +1,152 @@
+import type { PrepareContext } from '../../core/effect-context.js';
+import type { Cleanup } from '../../core/types.js';
+/**
+ * Whether an authored `src` names a video platform's web page instead of a media file.
+ *
+ * @complexity O(n) time in value length; O(1) space.
+ * @overallScore 100
+ */
+export declare function isVideoPageUrl(value: string): boolean;
+/**
+ * Named focal points, as `object-position` percentage pairs.
+ *
+ * A `cover` fit crops, and which part it crops away is the whole editorial decision — the classic
+ * failure is a portrait cropped through the subject's chin. Percentages rather than the equivalent
+ * CSS keywords (`top`, `left top`) because the pair is written into one property from two halves,
+ * and `50% 0%` composes where `center top` would need its own keyword-order rules.
+ */
+declare const FOCAL_POINTS: {
+    readonly center: "50% 50%";
+    readonly top: "50% 0%";
+    readonly bottom: "50% 100%";
+    readonly left: "0% 50%";
+    readonly right: "100% 50%";
+    readonly 'top-left': "0% 0%";
+    readonly 'top-right': "100% 0%";
+    readonly 'bottom-left': "0% 100%";
+    readonly 'bottom-right': "100% 100%";
+};
+export type FocalPoint = keyof typeof FOCAL_POINTS;
+/** The nine named focal points, in the order the parameter schema declares them. */
+export declare const FOCAL_POINT_NAMES: FocalPoint[];
+/**
+ * Resolve a focal point name to an `object-position` value.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function focalPosition(focus: string): string;
+/** How a background clip decides when to run. */
+export type AutoplayMode = 'in-view' | 'always' | 'never';
+export interface BackgroundMediaOptions {
+    /** URL or path to the image or video, already screened by `mediaSource`. */
+    src: string;
+    /** Still shown before a video's first frame; `''` for none. */
+    poster: string;
+    /** `object-fit` for the layer. */
+    fit: 'cover' | 'contain';
+    /** `object-position` for the layer, already resolved from a named focal point. */
+    position: string;
+    /** Scrim colour painted over the media and under the author's children. */
+    overlay: string;
+    /** Scrim opacity, `0`–`1`. */
+    overlayOpacity: number;
+    /** When a clip plays. Ignored for an image. */
+    autoplay: AutoplayMode;
+    /** `playbackRate` for a clip. Ignored for an image. */
+    rate: number;
+    /** Whether a clip restarts when it ends. Ignored for an image. */
+    loop: boolean;
+    /** Suppresses autoplay, leaving the poster frame standing. */
+    reducedMotion: boolean;
+}
+export interface BackgroundLayer {
+    /** Stop observing and delete every node this effect added, leaving the author's own as written. */
+    remove: Cleanup;
+}
+/**
+ * Whether a scrim colour is actually asking for a scrim.
+ *
+ * `transparent` is the default so that the parameter stays a real `type: 'color'` — validated by
+ * the same screen every other colour goes through — rather than an empty string that no colour
+ * grammar accepts. It also happens to be the honest spelling of "no scrim", so an author who
+ * writes it explicitly gets exactly what the default gives them.
+ *
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function paintsOverlay(options: BackgroundMediaOptions): boolean;
+/**
+ * Whether an authored `src` names a video rather than an image.
+ *
+ * @param src - Author-supplied path, already accepted as same-origin.
+ * @returns `true` when the path's final extension is a known video container.
+ * @complexity O(n) time in path length; O(1) space.
+ * @overallScore 100
+ */
+export declare function isVideoSource(src: string): boolean;
+/**
+ * Screen an authored media URL before it can reach `src`/`poster`.
+ *
+ * **Cross-origin URLs are allowed here, unlike `media-scrub`'s frame pattern, and that is a
+ * deliberate divergence rather than an oversight.** `isSameOriginPath` (`core/params.ts`) refuses
+ * every absolute URL on the grounds that `data-kui` is not always written by the site owner — a CMS
+ * field, a comment — so an unconstrained `src` turns the visitor's browser into an
+ * attacker-directed request tool. That reasoning still stands, and it is why the scheme allowlist
+ * above is kept tight.
+ *
+ * It is not the right trade for *this* parameter, though. A background is the one media case where
+ * the file routinely does not live on the page's own origin — an S3 bucket, a CDN, an asset host —
+ * and `media-scrub`'s `src:` is materially more dangerous than this one for a second reason: it is
+ * a `{i}` *template* that fires one request per frame, so a two-hundred-frame sequence is a
+ * two-hundred-request channel where this is a single fixed fetch. A site that does accept untrusted
+ * `data-kui` should set a `Content-Security-Policy` with `img-src`/`media-src`, which is the
+ * control actually designed for this and the one thing a library cannot do on the consumer's
+ * behalf.
+ *
+ * @param authored - Author-supplied value; `''` when none was written.
+ * @param name - Parameter name, for the diagnostic.
+ * @returns The URL, or `''` when it was rejected or absent.
+ * @complexity O(n) time in value length; O(1) space.
+ * @overallScore 100
+ */
+export declare function mediaSource(authored: string, name: string, ctx: PrepareContext): string;
+/**
+ * Apply the authored playback policy to a clip.
+ *
+ * `autoplay:` is the opt-out the three real cases need. `in-view` (default) pairs the clip with the
+ * viewport. `always` is for a short hero clip that must never be caught mid-stall by a visibility
+ * heuristic. `never` installs the clip and leaves it on its poster, which is also what any mode
+ * degrades to under a reduced-motion preference.
+ *
+ * @returns A teardown that stops any observer and leaves the clip paused.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function startPlayback(video: HTMLVideoElement, win: Window, options: BackgroundMediaOptions): Cleanup;
+/**
+ * Play a background clip while any part of it is on screen, and pause it the rest of the time.
+ *
+ * This is the primitive's own observer rather than the animator's `on:enter` gate, because the two
+ * answer different questions: `on:enter` fires once and stays fired, which is right for a reveal
+ * and wrong for a clip that should stop costing decode budget the moment it scrolls away.
+ *
+ * `threshold: 0` — any intersection at all — rather than the `0.25` a card-sized video wants.
+ * `intersectionRatio` is measured against the *target*, and this target is usually a full section:
+ * one taller than four viewports can never reach a ratio of 0.25 no matter where it is scrolled,
+ * so a fractional threshold is a clip that silently never plays.
+ *
+ * @returns A teardown that disconnects the observer and leaves the clip paused.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function autoplayInView(video: HTMLVideoElement, win: Window): Cleanup;
+/**
+ * Create the backdrop layer and hand back the handle that deletes it again.
+ *
+ * @param el - The host element, which keeps every child the author wrote.
+ * @complexity O(1) time and space.
+ * @overallScore 100
+ */
+export declare function installBackgroundMedia(el: Element, ctx: PrepareContext, options: BackgroundMediaOptions): BackgroundLayer;
+export {};

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

@@ -0,0 +1,13 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export declare const DISCRETE_PRIMITIVES: Primitive[];
+export declare const DISCRETE_PRESETS: Preset[];
+/**
+ * Register the `@starting-style` discrete-open catalog (section J).
+ *
+ * @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 registerDiscrete(registry: Registry): Registry;

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

@@ -0,0 +1,24 @@
+import type { Preset, Primitive } from '../../core/types.js';
+import type { Registry } from '../../core/registry.js';
+export declare const PROXIMITY_FIELD_PRIMITIVES: Primitive[];
+export declare const PROXIMITY_FIELD_PRESETS: Preset[];
+export declare const PROXIMITY_GLOW_PRIMITIVES: Primitive[];
+export declare const PROXIMITY_GLOW_PRESETS: Preset[];
+/** Both halves of the family, for `registerInteractionProximity` below. */
+export declare const INTERACTION_PROXIMITY_PRIMITIVES: Primitive[];
+export declare const INTERACTION_PROXIMITY_PRESETS: Preset[];
+/**
+ * Register the cross-element pointer-proximity family.
+ *
+ * A standalone top-level registration called directly from `catalog/index.ts`, the same shape
+ * `registerInteraction`'s own doc comment describes for `registerGestures`/`registerThreeD` —
+ * deliberately not folded into `interaction.ts`'s `INTERACTION_PRIMITIVES`/`_PRESETS`, which sits on
+ * that file's own 400-line lint ceiling and is being edited by another session concurrently with
+ * this one.
+ *
+ * @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 registerInteractionProximity(registry: Registry): Registry;