coily 0.13.1 → 0.14.0

package/README.md

@@ -2,9 +2,9 @@
 
 Simulate values using spring physics.
 
-Coily animates numbers — and whole numeric shapes — with damped spring motion. Each frame is computed from the closed-form solution of the spring equation — underdamped, critically damped, or overdamped — rather than numerical integration, so motion doesn't accumulate error and springs can be retargeted mid-flight without losing momentum.
+Coily animates numbers and whole numeric shapes with damped spring motion. It computes each frame from the closed-form solution of the spring equation (underdamped, critically damped, or overdamped) rather than numerical integration, so motion doesn't accumulate error and you can retarget a spring mid-flight without losing momentum.
 
-The core has zero dependencies and runs anywhere (it falls back from `requestAnimationFrame` to `setTimeout` outside the browser). Vue and Nuxt integrations ship as separate entry points; `vue` and `@nuxt/kit` are optional peer dependencies.
+The core has zero dependencies and runs anywhere (it falls back from `requestAnimationFrame` to `setTimeout` outside the browser). Vue and Nuxt integrations ship as separate entry points, with `vue` and `@nuxt/kit` as optional peer dependencies.
 
 ## Install
 
@@ -33,7 +33,7 @@ spring.target = 300
 
 ## Configuring springs
 
-`defineSpring` accepts several input shapes; whatever you leave out is derived:
+`defineSpring` accepts several input shapes and derives whatever you leave out:
 
 ```ts
 defineSpring({ tension: 500, damping: 40 }) // direct physical parameters
@@ -43,79 +43,107 @@ defineSpring({ duration: 750, dampingRatio: 1 }) // tuned to settle in ~750ms
 defineSpring({ duration: 750, bounce: 0.5 })
 ```
 
-- **`tension`** — stiffness (> 0)
-- **`damping`** — friction (≥ 0)
-- **`dampingRatio`** — 0 = undamped, < 1 = bouncy, 1 = critically damped, > 1 = overdamped
-- **`bounce`** — friendlier alias for damping ratio: −1 (overdamped) to 1 (max bounce)
-- **`duration`** — target settle time in ms. Assumes an initial displacement of 1; pass `displacement` matching your animation range for accurate timing
-- **`mass`** — defaults to 1
-- **`precision`** — decimal places of the resting threshold (default 2). A spring is _resting_ once its remaining motion cannot reach half a unit in the last place — 0.005 at the default. Values are never rounded; set precision to match your domain's resolution (see [PRECISION.md](https://github.com/tkofh/coily/blob/main/PRECISION.md))
+- **`tension`**: stiffness (> 0)
+- **`damping`**: friction (>= 0)
+- **`dampingRatio`**: 0 = undamped, < 1 = bouncy, 1 = critically damped, > 1 = overdamped
+- **`bounce`**: a friendlier alias for damping ratio, from -1 (overdamped) to 1 (max bounce)
+- **`duration`**: target settle time in ms. Assumes an initial displacement of 1. Pass `displacement` matching your animation range for accurate timing
+- **`mass`**: defaults to 1
+- **`precision`**: decimal places of the resting threshold (default 2). A spring is _resting_ once its remaining motion cannot reach half a unit in the last place (0.005 at the default). Coily never rounds values. Set `precision` to match your domain's resolution (see [PRECISION.md](https://github.com/tkofh/coily/blob/main/PRECISION.md))
 
 Without a config, springs are critically damped with a ~500ms settle time.
 
 ## Spring API
 
-- `spring.target` — set to animate toward a new value
-- `spring.value` — current value; writable to displace the spring
-- `spring.velocity` — current velocity; writable to fling
-- `spring.jumpTo(v)` — snap to a value with no animation
-- `spring.config` — assign a new `SpringConfig`, or `null` to revert to the default (or the leader's, if following)
-- `spring.isResting`, `spring.timeRemaining` — settle state and estimated ms until rest
-- `spring.settled` — a promise that resolves when the spring next comes to rest (immediately if already resting). Retargeting mid-flight extends the wait; disposing resolves it. `await spring.settled` to sequence animations
-- `spring.onUpdate(cb)` / `onStart(cb)` / `onStop(cb)` / `onDispose(cb)` — subscribe; each returns an unsubscribe function. `start` fires when the spring leaves rest, `stop` when it settles — the two always alternate, and retargeting mid-flight fires neither
-- `spring.dispose()` — release the spring (calling it twice is a no-op)
+- `spring.target`: set to animate toward a new value
+- `spring.value`: current value, writable to displace the spring
+- `spring.velocity`: current velocity, writable to fling
+- `spring.jumpTo(v)`: snap to a value with no animation
+- `spring.config`: assign a new `SpringDefinition`, or `null` to revert to the default
+- `spring.isResting`, `spring.timeRemaining`: settle state and estimated ms until rest
+- `spring.settled`: a promise that resolves when the spring next comes to rest (immediately if already resting). Retargeting mid-flight extends the wait; disposing resolves it. `await spring.settled` to sequence animations
+- `spring.onUpdate(cb)` / `onStart(cb)` / `onStop(cb)` / `onDispose(cb)`: subscribe. Each returns an unsubscribe function. `start` fires when the spring leaves rest, `stop` when it settles. The two always alternate, and retargeting mid-flight fires neither
+- `spring.dispose()`: release the spring (calling it twice is a no-op)
 
 ### Chaining
 
-A spring can follow another spring's live value instead of a fixed number:
+A spring can follow another spring's live value instead of a fixed number: assign a spring to `target`, or pass one straight to `createSpring` to follow from birth. `mapSpring` derives new followable values from existing ones (offsets, mirrors, clamps, any pure function of the value):
 
 ```ts
 const leader = system.createSpring(0)
-const follower = system.createSpring({ target: leader })
-const trailing = system.createSpring({ target: { spring: leader, offset: 20 } })
+
+const follower = system.createSpring(leader)
+const trailing = system.createSpring(mapSpring(leader, (v) => v + 20))
+const mirrored = system.createSpring(mapSpring(leader, (v) => -v))
 ```
 
-Followers inherit the leader's config unless given their own. Assigning a number to `target` unfollows.
+A follower's config is its own: following changes what a spring chases, never how it moves. To match a leader's feel, pass its config at creation — `system.createSpring(leader, leader.config)` — or share a `defineSpring` constant. Assigning a number to `target` unfollows.
+
+`mapSpring` also combines several springs: pass a shape (a plain object or array with springs at the leaves, nested arbitrarily) and a function of their values:
+
+```ts
+const x = system.createSpring(0)
+const y = system.createSpring(0)
 
-### Objects
+const distance = system.createSpring(mapSpring({ x, y }, ({ x, y }) => Math.hypot(x, y)))
+```
 
-`system.createSpringObject(value, config?)` springs over any numeric shape — a plain object or array whose leaves are all numbers, nested arbitrarily. Each leaf becomes an independent channel behind one composite API:
+Composite springs (below) are sources of their whole value shape, so one map can derive a scalar from every channel at once:
 
 ```ts
-const spring = system.createSpringObject({ position: { x: 0, y: 0 }, opacity: 1 })
+const point = system.createSpring({ x: 3, y: 4 })
+
+const magnitude = system.createSpring(mapSpring(point, ({ x, y }) => Math.hypot(x, y)))
+```
+
+A mapped value is a `SpringSource`, the contract `target` accepts and every `Spring` implements. A `CompositeSpring` is a source _of its shape_: `mapSpring` reads it, alone or at the leaves of a shape, but only scalar sources can be followed directly.
 
-spring.target = { position: { x: 100 } } // partial — other channels are left alone
+Follow graphs may contain cycles: retargets never re-emit, so nothing loops within a frame. Mutual followers converge to a shared value. A cycle whose maps expand (`(v) => v + 10` in both directions) chases forever and never rests, keeping the system awake until you break the cycle.
+
+### Composites
+
+`createSpring` also takes any numeric shape: a plain object or array whose leaves are all numbers, nested arbitrarily. Each leaf becomes an independent channel behind one composite API, a `CompositeSpring`:
+
+```ts
+const spring = system.createSpring({ position: { x: 0, y: 0 }, opacity: 1 })
+
+spring.target = { position: { x: 100 } } // a partial target leaves other channels alone
 spring.value // { position: { x, y }, opacity } — a stable, read-only mirror
 ```
 
-The shape is fixed at creation, and unknown channels throw with their path (`position.z`). `value`, `velocity`, and `jumpTo` take the same partial shapes. Composite events are coalesced: `update` fires at most once per frame with every channel in its final per-frame state, and `stop` always lands after that frame's final `update`. `settled` and reduced motion compose channel-wise.
+The shape is fixed at creation, and unknown channels throw with their path (`position.z`). `value`, `velocity`, and `jumpTo` take the same partial shapes. Composites coalesce their events: `update` fires at most once per frame with every channel in its final per-frame state, and `stop` always lands after that frame's final `update`. `settled` and reduced motion compose channel-wise.
 
-Shapes are validated at compile time too (the `Shape` type — interfaces like your own `Vector2` work without index signatures): non-numeric, optional, or `undefined`-typed channels are rejected where they're declared.
+The `Shape` type validates shapes at compile time too (interfaces like your own `Vector2` work without index signatures) and rejects non-numeric, optional, or `undefined`-typed channels where they're declared.
 
-Configs apply per channel. Pass a single `SpringConfig` for every channel, or a shape mirroring the value with configs (or `null` to revert) at any level — a config at a subtree covers every channel below it:
+Configs apply per channel. Pass a single `SpringDefinition` for every channel, or a shape mirroring the value with configs (or `null` to revert) at any level. A config at a subtree covers every channel below it:
 
 ```ts
 spring.config = { position: stiff, opacity: defineSpring({ duration: 300, dampingRatio: 1 }) }
 ```
 
-Configs are `SpringConfig` instances — build them with `defineSpring`. Unlike the scalar `useSpring` above, config positions here don't accept bare option objects: a plain object is always a per-channel shape, so any non-config leaf it reaches throws with its path.
+Configs are `SpringDefinition` instances, built with `defineSpring`. Config positions don't accept bare option objects: a plain object is always a per-channel shape, so any non-config leaf it reaches throws with its path.
 
-Spring objects chain channel-wise. Assign another spring object of the exact same shape (optionally with a partial offset shape), and a partial numeric target detaches only the channels it names:
+Composite springs chain channel-wise. Assign another composite spring of the exact same shape to follow it whole, or name channels individually: each channel of a partial target takes a number or a scalar `SpringSource`. While following, a partial target detaches only the channels it names:
 
 ```ts
 follower.target = leader
-trailing.target = { spring: leader, offset: { position: { x: 20 } } }
+
+// or mix numbers and live sources per channel
+follower.target = {
+  opacity: 0.5,
+  position: { x: mapSpring(leader, ({ position }) => -position.x) },
+}
 ```
 
 ## Reduced motion
 
-Coily respects `prefers-reduced-motion` by default. When it's active, springs snap to their targets instead of animating: retargets and value writes apply instantly, velocity impulses are ignored, and springs created displaced start at their target. Events stay coherent — one `update` per change, no `start`/`stop`, and `settled` resolves immediately — so code written against the animated path keeps working.
+Coily respects `prefers-reduced-motion` by default. When it's active, springs snap to their targets instead of animating: retargets and value writes apply instantly, and springs ignore velocity impulses. Events stay coherent (one `update` per change, no `start`/`stop`, and `settled` resolves immediately), so code written against the animated path keeps working.
 
-Control it with the `reducedMotion` system option: `'user'` (default — follow the OS setting, including live changes, which finish in-flight animations instantly), `'always'`, or `'never'`. Read `system.reducedMotion` to gate purely decorative effects (particles, flourishes) in your own code.
+Control it with the `reducedMotion` system option: `'always'`, `'never'`, or the default `'user'`, which follows the OS setting — a live change finishes in-flight animations instantly. Read `system.reducedMotion` to gate decorative effects (particles, flourishes) in your own code.
 
 ## Vue
 
-Call `useSpringSystem()` once near the root of your app. It returns the spring system provided by this component or an ancestor; if none exists, it creates one, provides it to descendants, and starts/stops it with the component lifecycle. It's idempotent, and options apply only when a system is actually created:
+Call `useSpringSystem()` once near the root of your app. It returns the spring system provided by this component or an ancestor. If none exists, it creates one, provides it to descendants, and starts/stops it with the component lifecycle. It's idempotent, and options apply only when a system is created:
 
 ```ts
 import { useSpringSystem } from 'coily/vue'
@@ -140,13 +168,15 @@ const x = useSpring(target, { duration: 500, bounce: 0.3 })
 </template>
 ```
 
-`useSpring` returns a `SpringRef`: a writable ref of the animated value with `velocity`, `isResting`, and `timeRemaining` refs plus `jumpTo()` attached. The target can be a ref, a getter, or another `SpringRef` (which chains the springs). Options are also reactive — swap configs and the spring reconfigures in place.
+`useSpring` returns a `SpringRef`: a writable ref of the animated value with `velocity`, `isResting`, and `timeRemaining` refs plus `jumpTo()` attached. The target can be a ref, a getter, or another `SpringRef` (which chains the springs). Options are also reactive: swap configs and the spring reconfigures in place.
+
+A `SpringRef` is also a `SpringSource`, and `useSpring` follows any source: chain through `mapSpring` (`useSpring(mapSpring({ x, y }, ({ x, y }) => Math.hypot(x, y)))`), or pass a getter of a source to switch leaders reactively (`useSpring(() => (split.value ? left : right))`). Following bypasses Vue reactivity — followers subscribe to the backing spring directly — so an effect or getter never gains a dependency on a leader's animation.
 
-Numeric shapes work the same way: pass a record or array (plain, ref, or getter) and get a `SpringObjectRef`. Reads are the deep-readonly composite value, writes take partial shapes, options accept reactive per-channel config shapes, and passing another `SpringObjectRef` follows it channel-wise. Deeply reactive targets retarget on nested mutation. For several _independent_ scalar springs, map over the targets — composables are loop-safe: `targets.map((t) => useSpring(t))`.
+Numeric shapes work the same way: pass a record or array (plain, ref, or getter) and get a `CompositeSpringRef`. Reads are the deep-readonly composite value, writes take partial shapes, options accept reactive per-channel config shapes, and passing another `CompositeSpringRef` follows it channel-wise. Deeply reactive targets retarget on nested mutation. For several _independent_ scalar springs, map over the targets (composables are loop-safe): `targets.map((t) => useSpring(t))`.
 
 There's also a renderless `<SpringValue :target="n">` component exposing `{ value, velocity, isResting, timeRemaining, jumpTo }` through its default slot.
 
-For imperative work — a dynamic set of springs created and disposed at arbitrary times (particles, per-item effects) — `useSpringPool()` returns `createSpring`/`createSpringObject` bound to the provided system. Every spring created through the pool is disposed automatically when the component's scope is torn down, so leaked motions are structurally impossible; disposing a spring manually before that is fine.
+`useSpringPool()` covers imperative work: a dynamic set of springs created and disposed at arbitrary times (particles, per-item effects). It returns `createSpring` bound to the provided system. The pool disposes every spring created through it when the component's scope is torn down, so leaked motions are structurally impossible. Disposing a spring manually before that is fine.
 
 ## Nuxt
 
@@ -164,7 +194,7 @@ The module provides a spring system for the whole app (started on the client), a
 
 ## Timing
 
-The built-in ticker advances springs once per displayed frame, so motion is as smooth as the screen it runs on — 60Hz, 120Hz, or adaptive sync. The loop sleeps while every spring is at rest (an idle system schedules no frames) and wakes on the next write. Set `fps` (option/property) to cap the rate; caps are paced to whole display frames, and each tick still receives the true elapsed time. Large frame gaps — e.g. returning from a backgrounded tab — are clamped via `lagThreshold` (default 500ms) and `adjustedLag` (default 33ms), so springs don't teleport. For manual stepping, skip `system.start()` and call `system.advance(dtMs)` yourself.
+The built-in ticker advances springs once per displayed frame, so motion is as smooth as the screen it runs on: 60Hz, 120Hz, or adaptive sync. The loop sleeps while every spring is at rest (an idle system schedules no frames) and wakes on the next write. Set `fps` (option/property) to cap the rate: capped ticks land on whole display frames and still receive the true elapsed time. The ticker clamps large frame gaps (e.g. returning from a backgrounded tab) via `lagThreshold` (default 500ms) and `adjustedLag` (default 33ms), so springs don't teleport. For manual stepping, skip `system.start()` and call `system.advance(dtMs)` yourself.
 
 ## License
 

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { _ as SpringOptions, a as ConfigShape, c as Shape, d as SpringObjectWithOffset, f as Spring, g as SpringConfig, h as SpringWithOffset, i as TickerOptions, l as SpringObject, m as SpringTarget, n as SpringSystemOptions, o as PartialShape, p as SpringPosition, r as createSpringSystem, s as ReadonlyShape, t as SpringSystem, u as SpringObjectTarget, v as SpringState, y as defineSpring } from "./system-86fsXJN_.js";
-export { type ConfigShape, type PartialShape, type ReadonlyShape, type Shape, type Spring, type SpringConfig, type SpringObject, type SpringObjectTarget, type SpringObjectWithOffset, type SpringOptions, type SpringPosition, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, type SpringWithOffset, type TickerOptions, createSpringSystem, defineSpring };
+import { C as SpringDefinitionOptions, S as SpringDefinition, T as defineSpring, _ as accelerationOf, a as createSpringSystem, b as SpringSourceSymbol, c as ConfigShape, g as KinematicSource, h as SpringTarget, i as SpringSystemOptions, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, s as CompositeSpringTarget, t as CompositeSpringOptions, u as PurposeShape, v as velocityOf, w as SpringState, x as mapSpring, y as SpringSource } from "./system-Ci-R4RaI.js";
+export { type CompositeSpring, type CompositeSpringOptions, type CompositeSpringTarget, type ConfigShape, type KinematicSource, type Purpose, type PurposeShape, type Spring, type SpringDefinition, type SpringDefinitionOptions, type SpringOptions, type SpringSource, SpringSourceSymbol, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };

package/dist/index.js

@@ -1,2 +1,78 @@
-import { r as defineSpring, t as createSpringSystem } from "./system-Csho09XW.js";
-export { createSpringSystem, defineSpring };
+import { i as mapSpring, n as SpringSourceSymbol, o as defineSpring, r as isSpringSource, s as invariant, t as createSpringSystem } from "./system-BXxAHM2a.js";
+//#region src/kinematic-source.ts
+function isKinematicSource(value) {
+	if (!isSpringSource(value)) return false;
+	const api = value[SpringSourceSymbol];
+	return "velocity" in api && "acceleration" in api;
+}
+const NOT_KINEMATIC = "expected a source in motion (a Spring or CompositeSpring); a value derived with mapSpring has neither velocity nor acceleration";
+/**
+* Derives a source from another's velocity — the rate its value changes,
+* in value units per second. `velocityOf(motion)` is a source that reads
+* `motion`'s current velocity, so speed-driven effects fall out of the
+* same follow and `mapSpring` machinery as everything else: a spring can
+* follow it (`blur.target = velocityOf(motion)`) and a map can shape it
+* (`mapSpring(velocityOf(motion), (v) => 1 + Math.abs(v) * 0.001)` for
+* squash and stretch). A scalar source yields a scalar velocity a spring
+* can follow; a `CompositeSpring` or shape yields a velocity of the same
+* shape, mapped to a scalar the way the composite itself is.
+*
+* The result is a stateless view, not a spring: it holds no
+* subscriptions and needs no disposal, and reads report the source's
+* current velocity on the fly. It updates when the source does and is
+* released with it — followers detach then, keeping their current
+* target, as they would from a disposed spring.
+*
+* Only a source in motion qualifies — a `Spring` or a `CompositeSpring`.
+* A value derived with `mapSpring` has no velocity (its rate of change
+* would need the derivative of the map), so it is rejected at the type
+* level and at runtime; take `velocityOf` of the spring the map reads
+* instead.
+*/
+function velocityOf(source) {
+	invariant(isKinematicSource(source), NOT_KINEMATIC);
+	const api = source[SpringSourceSymbol];
+	return Object.freeze({ [SpringSourceSymbol]: Object.freeze({
+		get value() {
+			return api.velocity;
+		},
+		onUpdate: (callback) => api.onUpdate(callback),
+		onDispose: (callback) => api.onDispose(callback)
+	}) });
+}
+/**
+* Derives a source from another's acceleration — the rate its velocity
+* changes, in value units per second squared. `accelerationOf(motion)`
+* spikes when `motion` is pushed hardest and passes through zero at the
+* peak of a swing, so force-driven effects fall out of the same follow
+* and `mapSpring` machinery: a spring can follow it, and a map can turn
+* it into an impact flash or a jelly wobble
+* (`mapSpring(accelerationOf(motion), (a) => Math.min(1, Math.abs(a) * 1e-4))`).
+* A scalar source yields a scalar acceleration; a `CompositeSpring` or
+* shape yields an acceleration of the same shape, mapped to a scalar the
+* way the composite itself is.
+*
+* The result is a stateless view, not a spring: it holds no
+* subscriptions and needs no disposal, and reads report the source's
+* current acceleration on the fly. It updates when the source does and
+* is released with it, followers detaching then as from a disposed
+* spring.
+*
+* Only a source in motion qualifies — a `Spring` or a `CompositeSpring`.
+* A value derived with `mapSpring` has no acceleration, so it is rejected
+* at the type level and at runtime; take `accelerationOf` of the spring
+* the map reads instead.
+*/
+function accelerationOf(source) {
+	invariant(isKinematicSource(source), NOT_KINEMATIC);
+	const api = source[SpringSourceSymbol];
+	return Object.freeze({ [SpringSourceSymbol]: Object.freeze({
+		get value() {
+			return api.acceleration;
+		},
+		onUpdate: (callback) => api.onUpdate(callback),
+		onDispose: (callback) => api.onDispose(callback)
+	}) });
+}
+//#endregion
+export { SpringSourceSymbol, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };

package/dist/nuxt.d.ts

@@ -1,12 +1,50 @@
 import { NuxtModule } from "@nuxt/schema";
 //#region src/vue/nuxt.d.ts
+/**
+ * Options for the `coily` key in `nuxt.config`, passed to the app-wide
+ * spring system the module creates.
+ */
 interface CoilyModuleOptions {
+  /**
+   * Log active motion counts to the console whenever they change.
+   * @default false
+   */
   debug?: boolean;
+  /**
+   * Frame-rate cap. 0 means uncapped: one tick per displayed frame.
+   * Capped ticks land on whole display frames and receive the true
+   * elapsed time.
+   * @default 0
+   */
   fps?: number;
+  /**
+   * Frame gap in milliseconds above which the gap is treated as lag and
+   * replaced with `adjustedLag`, so springs don't teleport when frames
+   * resume. 0 disables lag clamping.
+   * @default 500
+   */
   lagThreshold?: number;
+  /**
+   * The elapsed milliseconds a lagging frame is replaced with. Clamped
+   * to at most `lagThreshold`.
+   * @default 33
+   */
   adjustedLag?: number;
+  /**
+   * When springs snap to their targets instead of animating: `'user'`
+   * follows the OS prefers-reduced-motion setting, including live
+   * changes; `'always'` and `'never'` force one behavior.
+   * @default 'user'
+   */
   reducedMotion?: 'user' | 'always' | 'never';
 }
+/**
+ * The Nuxt module: creates an app-wide spring system (started on the
+ * client), auto-imports the composables and helpers `useSpring`,
+ * `useSpringSystem`, `useSpringPool`, `defineSpring`, `mapSpring`,
+ * `velocityOf`, and `accelerationOf`, and registers the `SpringValue`
+ * component. Types are left out — they would be noise in most apps.
+ */
 declare const coilyModule: NuxtModule;
 //#endregion
 export { CoilyModuleOptions, coilyModule as default };

package/dist/nuxt.js

@@ -21,6 +21,13 @@ export default defineNuxtPlugin((nuxtApp) => {
   })
 })`;
 }
+/**
+* The Nuxt module: creates an app-wide spring system (started on the
+* client), auto-imports the composables and helpers `useSpring`,
+* `useSpringSystem`, `useSpringPool`, `defineSpring`, `mapSpring`,
+* `velocityOf`, and `accelerationOf`, and registers the `SpringValue`
+* component. Types are left out — they would be noise in most apps.
+*/
 const coilyModule = defineNuxtModule({
 	meta: {
 		name: "coily",
@@ -48,28 +55,20 @@ const coilyModule = defineNuxtModule({
 				name: "useSpringPool"
 			},
 			{
-				from: "coily/vue",
-				name: "SpringRef",
-				type: true
-			},
-			{
-				from: "coily/vue",
-				name: "SpringObjectRef",
-				type: true
+				from: "coily",
+				name: "defineSpring"
 			},
 			{
-				from: "coily/vue",
-				name: "SpringPool",
-				type: true
+				from: "coily",
+				name: "mapSpring"
 			},
 			{
 				from: "coily",
-				name: "defineSpring"
+				name: "velocityOf"
 			},
 			{
 				from: "coily",
-				name: "SpringConfig",
-				type: true
+				name: "accelerationOf"
 			}
 		]);
 		addComponent({