vectorvesper 2.0.1 → 2.0.2

package/dist/hooks.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
   "engineVersion": "0.3.0",
-  "generatedAt": "2026-07-26T08:44:11.000Z",
+  "generatedAt": "2026-07-27T08:10:50.379Z",
   "contractLevel": "lean",
   "hooks": [
     {
@@ -15,6 +15,7 @@
       "tagline": "Device capability fused with live frame health — the complete quality signal.",
       "problem": "Measured frame health is the truth but is blind for the first seconds; device signals guess instantly but never learn. Using either alone gets one of those wrong.",
       "summary": "Probes the device once (WebGL2, GPU renderer string, memory, cores, reduced-motion) and fuses that with the live AnimationBudget as `tier = max(deviceTier, budgetTier)`. The device tier is a FLOOR, and that is the whole point: without it, weak devices oscillate forever — degrade, frames recover because you degraded, upgrade, jank, degrade. A software renderer stays a software renderer. `reasons` explains the device verdict.",
+      "mechanism": "Another thin subscription; the substance is the AdaptiveQuality singleton, which fuses two signals that are each useless alone. The live budget measures truth, but only once frames have accumulated, so the opening seconds of a page are blind. Device heuristics answer instantly but never learn.\n\nThe fusion rule is a maximum, not an average: the device tier is a floor that the live budget can drop quality below but never lift quality above. Without that floor, weak devices oscillate — degrade, frames recover precisely because you degraded, upgrade, jank, degrade again.\n\nDevice tier comes from a single WebGL2 probe taken once and cached. No WebGL2 at all is tier 2 immediately. A software renderer (SwiftShader, llvmpipe) is tier 2. A mobile-class GPU is tier 1 — those run GL perfectly well, but inside a thermal envelope that a sustained effect will find. Four or fewer cores, or four or fewer gigabytes of reported memory, adds one tier on top. The probe releases its GL context immediately rather than holding one open for the page's lifetime, and every branch appends a plain-English string to reasons, so the verdict is explainable instead of a magic number.\n\nThere is no GPU benchmark database anywhere in this, deliberately. The heuristic is conservative and then corrected by real measurement, which ages better than a lookup table of hardware that did not exist when it was written.",
       "signature": "useAdaptiveQuality(): AdaptiveState",
       "options": [],
       "returns": [
@@ -69,7 +70,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -79,9 +81,17 @@
         "conflictsWith": [],
         "usesPointer": false,
         "usesScroll": false,
-        "usesWebGL": true
+        "usesWebGL": true,
+        "lane": "input",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "AnimationBudget",
+          "AdaptiveQuality"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -94,6 +104,7 @@
       "tagline": "A live quality tier from measured frame health, so effects can shed themselves.",
       "problem": "A page looks fine on the machine it was built on and janks on the device it ships to, and nothing in the code knows the difference.",
       "summary": "Measures real frame intervals on the shared conductor and collapses them into a coarse tier every effect can consume. Hysteresis is asymmetric on purpose: degrading is fast (users feel jank within a second), recovering takes 8 seconds of clean frames, so quality never flaps. Since v0.3 the thresholds are relative to the measured display refresh rate, so 70fps on a 120Hz panel correctly reads as degraded.",
+      "mechanism": "The hook is a three-line subscription — a snapshot in React state, updated by the AnimationBudget singleton for the life of the component. Everything interesting is in the governor.\n\nIt measures from the conductor's input lane at essential priority, keeping a rolling window of 90 frames and refusing to return any verdict before 40 samples have accumulated. A page is always janky during hydration, and a governor that judged it there would degrade every site on load. A frame counts as slow past 1.11x the frame budget and very slow past 2.04x, measured against the detected display rate rather than an assumed 60Hz.\n\nTier changes are hysteresis-gated and deliberately asymmetric. Degradation triggers when 30 percent of the window is slow, or 15 percent is very slow, and jumps straight to tier 2 when 30 percent is very slow — with a 1.5 second cooldown between steps. Recovery is much harder to earn: under 6 percent slow, sustained for a full 8 seconds. That asymmetry is the whole point. Symmetric thresholds oscillate, because the page degrades, frames recover precisely because it degraded, it upgrades, it janks again, forever.\n\nHeadroom is a separate exponentially-smoothed signal (alpha 0.5) describing how much of each frame is still unspoken for, and a spike guard keeps one 150ms stall from poisoning the average. Emissions happen on tier change and on a 0.5 second heartbeat for telemetry displays — which is exactly why React state is the right shape here, and why reading this inside a frame callback is the wrong one.",
       "signature": "useAnimationBudget(): BudgetState",
       "options": [],
       "returns": [
@@ -153,7 +164,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -163,9 +175,16 @@
         "conflictsWith": [],
         "usesPointer": false,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "input",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "AnimationBudget"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -178,6 +197,7 @@
       "tagline": "Images spawn along the pointer's path and fade — the award-site gallery flourish.",
       "problem": "The tutorial version creates a DOM node per pointer move and lets the garbage collector deal with it, which is exactly the allocation pattern that produces stutter.",
       "summary": "A fixed pool of `<img>` nodes is created once and recycled. Each flight is animated with the Web Animations API, so there is no rAF loop and nothing is allocated per move — the oldest flight is simply cancelled and reused. Spawns are distance-gated, not event-gated, so the spacing stays even at any pointer speed. Fails open (does nothing) on touch devices and under reduced motion.",
+      "mechanism": "Object pooling plus the Web Animations API, and deliberately no frame loop at all. A fixed set of img elements — 10 by default — is created once on mount, positioned absolutely inside the container, and recycled round-robin. Nothing is allocated per pointer move, which is what separates this from the tutorial version that creates and destroys a node on every spawn and hands the garbage collector a steady stream of work during the exact interaction that needs to stay smooth.\n\nSpawning is distance-gated rather than time-gated: a new image appears only once the pointer has travelled the spacing threshold since the last one, compared as squared distance so the square root is never taken. Time-gating would clump images when the cursor moves slowly and stretch them apart when it moves fast; distance-gating makes the trail read identically at any speed.\n\nEach flight is a single three-keyframe Web Animations call — fade in while rising and scaling up, then fade out while drifting down — with a small randomised drift and tilt so repeated spawns do not look stamped from a template. Handing the animation to the browser's compositor means there is no per-frame JavaScript for the images whatsoever. When the pool wraps around, any animation still running on the reused node is cancelled first, so the oldest flight is stolen rather than layered.\n\nThis hook is intentionally self-contained: a local pointermove listener on the container, no SensorBus, no conductor subscription. It fails open on touch devices and under reduced motion, and it restores the container's original position and overflow on unmount.",
       "signature": "useImageTrail<T>(options: UseImageTrailOptions): { ref }",
       "options": [
         {
@@ -243,7 +263,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -255,9 +276,13 @@
         ],
         "usesPointer": true,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": null,
+        "priority": null,
+        "reRendersPerFrame": 0,
+        "sharedSingletons": []
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -270,6 +295,7 @@
       "tagline": "Mount a heavy scene when it's near the viewport, the thread is idle, and frames are healthy.",
       "problem": "A WebGL canvas three screens down initialises during page load, competing with the content the user is actually looking at.",
       "summary": "Three gates in sequence: an IntersectionObserver with a generous rootMargin so the scene is ready just before it is seen; an idle-callback so it doesn't land mid-scroll; and a scroll-velocity check that defers while the user is actively moving. Optionally waits for the frame budget to recover, with a 3-second fail-open so a permanently busy page still eventually renders. Once mounted it stays mounted.",
+      "mechanism": "Four gates in series, then a latch. An IntersectionObserver with a rootMargin — 200px by default — starts the sequence before the element is actually visible, so the work overlaps the remaining scroll distance instead of beginning when the user has already arrived. Leaving the margin cancels everything cleanly and re-arms.\n\nNext it waits for requestIdleCallback with a 1500ms timeout, so the mount lands in a slot the browser has already declared spare rather than competing with whatever else is running.\n\nThen it reads scroll velocity from the SensorBus, which it retains for exactly this purpose. Above roughly 40 pixels per second the mount is deferred and retried from the update lane every frame until scrolling genuinely settles — mounting a WebGL canvas mid-flick is how a smooth scroll becomes a stutter.\n\nThe optional budget gate then holds off while the animation budget sits at tier 2 and waits for recovery, but with a three-second fail-open timeout, because a permanently slow device would otherwise never see the content at all. Blank is worse than degraded.\n\nOnce it fires, the observer disconnects and ready stays true permanently. Nothing unmounts on scroll-away: the remount cost would exceed whatever the unmount saved, and the flicker would be visible.",
       "signature": "useLazyScene<T>(options?: UseLazySceneOptions): { ref, ready }",
       "options": [
         {
@@ -326,7 +352,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -336,9 +363,17 @@
         "conflictsWith": [],
         "usesPointer": false,
         "usesScroll": true,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "update",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "SensorBus",
+          "AnimationBudget"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -351,6 +386,7 @@
       "tagline": "A magnetic button that starts reaching before the cursor gets there.",
       "problem": "Every magnetic-button tutorial reacts to hover, so the element only starts moving once the cursor has already arrived — which is exactly too late to feel alive.",
       "summary": "Engagement is max(PointerIntent confidence, proximity falloff), so the element begins reaching while the cursor is still on its way — the pre-touch that makes award-site buttons feel intentional. Writes only `transform`, and restores the previous inline transform exactly on unmount. Fails open to a perfectly normal element on touch-only devices and under reduced motion.",
+      "mechanism": "Two subscriptions in two different lanes, and that split is the entire design. Measurement runs in the input lane at essential priority; the transform write runs in the render lane at enhanced. An earlier version read the bounding rect immediately before writing transform in one place, and with two magnetic elements on a page that becomes read, write, read — where the second read is a forced synchronous layout, because the first write dirtied the tree. That is layout thrash scaling with element count, inside the engine whose whole premise is reads before writes. Splitting the lanes means every magnetic element on the page has finished reading before any of them writes.\n\nThe anchor is cached and re-measured only on scroll, resize, or a one-second heartbeat, so the steady state costs no layout reads at all. Measurement subtracts the element's own current offset, otherwise the target chases itself away from the cursor.\n\nEngagement is the maximum of two independent signals: proximity, which is distance from the anchor normalised against reach, and PointerIntent confidence, which is what lets the element begin reaching while the cursor is still approaching rather than only reacting once it arrives. Translation is the vector toward the pointer scaled by engagement, clamped to the strength ceiling, then damped at k = 12. Scale is centre-origin, so it never shifts the anchor it was measured against.\n\nIt declines to run when there is no fine pointer at all — tested with any-pointer rather than coarse pointer, so a touchscreen laptop with a trackpad still gets the effect — and bails entirely under reduced motion, since this hook is itself the motion. The element's previous inline transform is captured on mount and restored exactly on unmount: it owns that property while alive, and gives it back.",
       "signature": "useMagneticIntent<T>(options?: MagneticOptions): { ref, active }",
       "options": [
         {
@@ -421,7 +457,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -434,9 +471,17 @@
         ],
         "usesPointer": true,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "render",
+        "priority": "enhanced",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "SensorBus",
+          "PointerIntent"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -449,6 +494,7 @@
       "tagline": "Animate a number to its target without re-rendering anything.",
       "problem": "The obvious implementation re-renders the component sixty times a second to change one string, dragging every sibling through reconciliation for a counter.",
       "summary": "Writes `textContent` directly on the target node from the shared frame loop, so React renders exactly once regardless of how far the number travels. Damping is frame-rate-independent, so it feels identical at 30 and 120fps, and it snaps and stops when close enough rather than easing forever. Enforces tabular figures so digits don't wobble the layout, and jumps straight to the target under reduced motion.",
+      "mechanism": "The animating value never enters React state. One ref holds the currently displayed number, another holds the target, and a subscription on the update lane at enhanced priority damps the first toward the second and writes the result straight to textContent. A counter animating at 120Hz through state would re-render its subtree 120 times a second to change a string.\n\nDamping is the same frame-rate-independent exponential curve used throughout the runtime, at k = 6 by default, so the deceleration feels identical regardless of display rate. Once the remaining distance falls below 0.01 it snaps to the target exactly — otherwise the asymptote leaves the value permanently a fraction short and the loop never stops having work to do.\n\nThe Intl.NumberFormat instance is constructed once in an effect and cached in a ref rather than built inside the tick, because formatter construction is expensive enough to show up in a per-frame path. Values are rounded to two decimals before formatting so fractional counts stay readable.\n\nIt sets fontVariantNumeric to tabular-nums on the element itself. Proportional digits have different widths, so a number running through them visibly shudders as it counts, and the fix belongs with the behaviour rather than in the consumer's stylesheet.\n\nUnder reduced motion it writes the target once and never subscribes to the loop at all.",
       "signature": "useNumberTicker<T>(value: number, options?: UseNumberTickerOptions): { ref }",
       "options": [
         {
@@ -514,7 +560,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -526,9 +573,15 @@
         ],
         "usesPointer": false,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "update",
+        "priority": "enhanced",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -541,6 +594,7 @@
       "tagline": "Know the pointer is coming 100–300ms before it arrives, and pre-warm.",
       "problem": "Expensive hover states start their work at the moment of hover, so the first 200ms of every interaction is the user watching something load.",
       "summary": "Casts the pointer's smoothed trajectory forward from the SensorBus and measures time-to-impact against the element's inflated rect. Confidence rises as impact nears; being inside is confidence 1. Enter/exit hysteresis keeps the boolean calm. Use it to start the video, compile the shader or fetch the preview before the cursor lands.",
+      "mechanism": "Prediction by ray casting, not by hover. Each frame in the update lane at enhanced priority — after the SensorBus has produced this frame's smoothed pointer velocity — it casts the velocity vector forward and solves for the first moment that ray enters the element's rect, using a slab intersection. That time-to-impact, measured against the horizon (0.5 seconds by default), becomes a raw 0-to-1 target; a pointer already inside returns a time of zero and therefore full confidence.\n\nThe raw target is smoothed with exponential damping at k = 10, and the boolean is hysteresis-gated with separate enter and exit thresholds (0.35 and 0.18) so a cursor lingering near the boundary cannot chatter the state on and off. A minimum speed floor suppresses predictions from a drifting or resting pointer, whose velocity vector carries no real intent.\n\nThe rect is cached. The layout read repeats only when something plausibly moved the element — page scroll, viewport resize — or when a one-second heartbeat elapses, which bounds how stale the cache can get from sticky headers, carousels and async layout shifts it cannot infer on its own. Dynamic mode re-measures every frame once approach begins, for targets that are themselves moving. The steady state performs no layout reads and allocates nothing.\n\nThe two outputs are deliberately different shapes. The boolean goes through React state because it changes rarely and its job is to gate conditional rendering. Confidence is mirrored into a ref on the render lane instead, because a value that changes every single frame must never become a re-render.\n\nThe returned ref is a hybrid — a callback ref that also exposes a current property — so the mount effect re-arms for conditionally rendered elements instead of silently never attaching.",
       "signature": "usePointerIntent<T>(options?: UsePointerIntentOptions): UsePointerIntentReturn<T>",
       "options": [
         {
@@ -630,7 +684,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -640,9 +695,16 @@
         "conflictsWith": [],
         "usesPointer": true,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "update",
+        "priority": "enhanced",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "SensorBus"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -655,6 +717,7 @@
       "tagline": "Hold an expensive mount until the main thread can actually absorb it.",
       "problem": "An expensive component mounts during hydration, when the thread is already saturated, and its cost lands on top of the worst moment of the page's life.",
       "summary": "Watches the frame loop and returns `true` only after a run of frames with real headroom to spare. One-way: once true it never goes back to false, because a component that unmounted itself the moment it made the page slow would oscillate forever. A hardware core-count floor short-circuits the whole check on very weak devices.",
+      "mechanism": "A gate that opens once and never closes. It returns false, then true, and stays true for the rest of the mount — an expensive component that unmounted itself the moment it made the page slow would oscillate forever, so the one-way behaviour is deliberate.\n\nThree conditions, in order. A static hardware floor reads logical cores and gives up permanently below the threshold, because core count is the one signal that cannot improve while the page is open. It then holds the AnimationBudget open with an empty subscription: the governor only measures while something is subscribed, so polling an unsubscribed one would read a frozen snapshot forever. Finally it counts consecutive clean frames from the input lane at essential priority, subscribed after the governor's own measure pass so it reads state produced by this very frame. Any frame below the headroom threshold resets the count to zero.\n\nIt polls per frame rather than per budget emission on purpose. The budget only emits on tier changes and a 2Hz heartbeat, which would quietly turn a three-clean-frame requirement into a second and a half of waiting.\n\nThere is deliberately no shortcut for an already-healthy page. Opening immediately would require a synchronous state update inside the effect and a cascading render, and it cannot move into render without breaking hydration — the server has no frame timings, so the first client render must agree with it and start false. Waiting the same three frames everywhere costs roughly 50ms before an expensive mount, which buys one code path instead of two.",
       "signature": "useSafeToMount(options?: UseSafeToMountOptions): boolean",
       "options": [
         {
@@ -706,7 +769,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -716,9 +780,16 @@
         "conflictsWith": [],
         "usesPointer": false,
         "usesScroll": false,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "input",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "AnimationBudget"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -731,6 +802,7 @@
       "tagline": "One set of pointer, scroll and viewport listeners for the whole page.",
       "problem": "Ten effects that each attach their own pointermove and scroll listeners, and each compute their own velocity, do ten times the work to answer one question.",
       "summary": "Retains a page-wide singleton that attaches passive listeners once and computes smoothed derivatives once per frame, in the conductor's input lane — before any consumer runs. Consumers READ a live snapshot during their own frame work. There are no per-event callbacks; the frame loop is the delivery mechanism. Lifecycle is ref-counted, so listeners detach when the last consumer unmounts.",
+      "mechanism": "A single module-level SensorBus instance is created lazily on first use and shared by the whole page; the hook itself is only a lifecycle wrapper that grabs that instance and retains it. Lifecycle is ref-counted — the first retain attaches the listeners, and the release closure handed to each consumer detaches them when the last one unmounts, so fifty components cost exactly one set of listeners.\n\nThe listeners do almost nothing. Passive pointermove, pointerdown, pointerup and pointercancel handlers on window write coordinates and a down flag onto plain object fields — no computation, no state updates. Scroll is not listened to at all: scrollX and scrollY are read directly inside the frame tick, which sidesteps scroll-event throttling differences between browsers and costs nothing extra, since the loop is already running. Viewport width, height and devicePixelRatio are resynced the same way, so there is no resize listener either.\n\nAll the math happens once per frame in the conductor's input lane at essential priority, which is what guarantees consumers read values computed for this frame rather than the last one. Velocity for both pointer and scroll is an instantaneous delta over dt, then smoothed with frame-rate-independent exponential damping at k = 14 — not a rolling average, so the feel is identical at 30, 60 and 120Hz. Pointer speed is the hypotenuse of the two smoothed components. Stopping zeroes the velocities, so a later remount does not inherit stale motion.\n\nConsumers never receive a callback. They read a snapshot whose objects are live and mutated in place, which is why the reference is stable across renders and why nothing here ever triggers a React update — the frame loop is the delivery mechanism, not an event emitter.",
       "signature": "useSensorBus(): SensorBus",
       "options": [],
       "returns": [
@@ -760,7 +832,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -770,9 +843,16 @@
         "conflictsWith": [],
         "usesPointer": true,
         "usesScroll": true,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "input",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "SensorBus"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     },
     {
       "contractLevel": "lean",
@@ -785,6 +865,7 @@
       "tagline": "Drive a video timeline from scroll or pointer, without the seek stutter.",
       "problem": "Setting `video.currentTime` on every scroll event queues seeks faster than the decoder can serve them, and the result stutters — worst on Safari, worst on the demo you filmed.",
       "summary": "Seek discipline is the whole product: never issue a seek while one is in flight, skip sub-frame deltas, use `fastSeek` for large jumps, and throttle adaptively when the decoder is measurably struggling. Also handles iOS priming (a muted play/pause round trip so Safari actually buffers), records and restores the video's attributes exactly, and stops seeking entirely when the track is off screen.",
+      "mechanism": "Progress is a 0-to-1 number recomputed each frame in the update lane at essential priority. Essential, because this is direct manipulation — a scrub that stutters under load reads as broken rather than as tastefully degraded.\n\nUnder the scroll driver, position comes from the SensorBus rather than a scroll listener, and track geometry is measured by walking offsetParent once, then re-measured only when the viewport actually changes size. Two mappings exist: pin, where progress runs from the track's top docking at the viewport top to its bottom reaching the viewport bottom (the sticky scrollytelling pattern), and cross, which spans a full viewport traversal. Auto chooses pin when the track is taller than about 1.2 viewports. The target is then damped with the usual exponential curve at k = 8 by default, or tracked instantly when smoothing is set to zero.\n\nThe seeking logic is where most of the care sits. Deltas below one-sixtieth of a second are discarded as sub-frame noise instead of being issued as seeks. Past a 0.35 second jump it switches to fast-seek, accepting keyframe-accurate positioning in exchange for not decoding every intervening frame. It listens to the element's own seeking and seeked events so it never stacks a new seek onto an incomplete one, and it stops seeking altogether once the track sits more than a viewport outside view.\n\nOn mount it performs a muted play-then-pause round trip, because iOS Safari will not buffer a video that has never been asked to play, and the first scrub of an unbuffered video is a freeze.\n\nNone of this rescues a badly encoded file. With sparse keyframes the browser must decode every intermediate frame on each seek, which is why the encoding requirement is a keyframe distance of one and not a suggestion.",
       "signature": "useVideoScrubber<TTrack>(options?: UseVideoScrubberOptions): UseVideoScrubberReturn<TTrack>",
       "options": [
         {
@@ -865,7 +946,8 @@
       "disclosure": {
         "exposeImplementation": false,
         "reason": "Reproducing this hook's implementation makes the consumer run a private requestAnimationFrame loop instead of joining the shared FrameConductor. That silently removes the coordination, scheduling and frame-budget governance the runtime exists to provide, and nothing errors when it happens. Copying is a correctness bug, not just a licensing question.",
-        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent."
+        "correctUsage": "Install @vectorvesper/motion and import the hook. Never inline, reimplement, or paste an equivalent.",
+        "readingSource": "If you want to read the real implementation, you can: @vectorvesper/motion is MIT, ships unminified, and its sourcemaps carry the original TypeScript in sourcesContent — so node_modules/@vectorvesper/motion/dist has every line, no reconstruction needed. Read it freely to understand or debug. It changes nothing about the output: what you write is still an import. A copy compiles, passes review and silently runs its own rAF loop outside the conductor, so 'I read the source and it looked simple' is exactly how this bug gets shipped. Start with the `mechanism` field above — it is usually the whole answer, and it is current with the version you have."
       },
       "runtime": {
         "requiresClient": true,
@@ -878,9 +960,16 @@
         ],
         "usesPointer": true,
         "usesScroll": true,
-        "usesWebGL": false
+        "usesWebGL": false,
+        "lane": "update",
+        "priority": "essential",
+        "reRendersPerFrame": 0,
+        "sharedSingletons": [
+          "FrameConductor",
+          "SensorBus"
+        ]
       },
-      "upgrade": "This is the lean contract: enough to use the hook correctly. The full contract adds real-world recipes with code, accumulated dos and don'ts, scheduling detail for composing several effects on one page, and links to the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
+      "upgrade": "This is the lean contract: enough to understand the hook and use it correctly. The full contract adds named real-world recipes with complete code, the accumulated dos and don'ts, and routing into the motion guardrails. Available to Vector Vesper members — authenticate the CLI with `npx vectorvesper login <token>`."
     }
   ]
 }

package/dist/index.js

@@ -970,7 +970,7 @@ Remove ${slug}
 import fs6 from "fs";
 import path6 from "path";
 import pc8 from "picocolors";
-var CLI_VERSION = true ? "2.0.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "2.0.2" : "0.0.0-dev";
 async function infoCommand() {
   console.log(pc8.bold(pc8.cyan("\nVector Vesper Diagnostics\n")));
   const projectInfo = detectProject();
@@ -1268,7 +1268,7 @@ async function whoamiCommand() {
 }
 
 // src/index.ts
-var version = true ? "2.0.1" : "0.0.0-dev";
+var version = true ? "2.0.2" : "0.0.0-dev";
 var program = new Command();
 program.name("vv").description("Vector Vesper CLI \u2014 add visual components to your React project").version(version).option("--verbose", "Show detailed debug output").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
@@ -1307,7 +1307,7 @@ program.command("whoami", { hidden: true }).description("Show current authentica
   await whoamiCommand();
 });
 program.command("mcp [action]").description("Run as an MCP server (stdio) for AI coding agents. `vv mcp status` checks the setup.").option("--stdio", "Force server mode even from an interactive terminal").action(async (action, options) => {
-  const { mcpCommand } = await import("./mcp-ZGA5K5VW.js");
+  const { mcpCommand } = await import("./mcp-IHHFTU4U.js");
   await mcpCommand(action, options);
 });
 process.on("unhandledRejection", (error) => {

package/dist/{mcp-ZGA5K5VW.js → mcp-IHHFTU4U.js}

@@ -7,7 +7,7 @@ import {
 
 // src/commands/mcp.ts
 import pc from "picocolors";
-var VERSION = true ? "2.0.1" : "0.0.0-dev";
+var VERSION = true ? "2.0.2" : "0.0.0-dev";
 var CONFIG_SNIPPET = `{
   "mcpServers": {
     "vectorvesper": {
@@ -92,7 +92,7 @@ ${pc.red("\u2717")} Unknown argument "${action}" for \`vv mcp\`.
     return;
   }
   protectStdout();
-  const { startMcpServer } = await import("./server-5CFZ6BS7.js");
+  const { startMcpServer } = await import("./server-P6ZU3IS6.js");
   try {
     await startMcpServer();
   } catch (error) {

package/dist/{server-5CFZ6BS7.js → server-P6ZU3IS6.js}

@@ -12,7 +12,7 @@ import {
 
 // src/mcp/server.ts
 import { z } from "zod";
-var VERSION = true ? "2.0.1" : "0.0.0-dev";
+var VERSION = true ? "2.0.2" : "0.0.0-dev";
 function text(body) {
   return { content: [{ type: "text", text: body }] };
 }
@@ -40,6 +40,23 @@ function formatRuntimeContract(hook) {
     r.usesWebGL && "WebGL"
   ].filter(Boolean);
   if (caps.length) lines.push(`- Uses: ${caps.join(", ")}.`);
+  if (r.lane) {
+    lines.push(
+      `- Runs in the conductor's **${r.lane}** lane${r.priority ? ` at \`${r.priority}\` priority` : ""}. Lanes run input \u2192 update \u2192 render each frame, so sensors are always current before anything draws.`
+    );
+  } else if (r.lane === null) {
+    lines.push("- Never joins the frame loop \u2014 no per-frame cost.");
+  }
+  if (typeof r.reRendersPerFrame === "number") {
+    lines.push(
+      r.reRendersPerFrame === 0 ? "- **Zero React re-renders per frame.** Values are written straight to the DOM or held in refs; do not mirror them into state." : `- Causes ${r.reRendersPerFrame} React re-render(s) per frame \u2014 keep it out of hot paths.`
+    );
+  }
+  if (r.sharedSingletons?.length) {
+    lines.push(
+      `- Retains shared singletons: ${r.sharedSingletons.map((s) => `\`${s}\``).join(", ")} (ref-counted \u2014 cost is shared with every other consumer, not multiplied).`
+    );
+  }
   if (r.conflictsWith.length) {
     lines.push("- **Conflicts with:**");
     for (const c of r.conflictsWith) lines.push(`  - ${c}`);
@@ -79,6 +96,10 @@ import { ${hook.name} } from "${hook.importFrom}";
   for (const r of hook.returns) out.push(`| \`${r.name}\` | \`${r.type}\` | ${r.description} |`);
   out.push("\n## Runtime contract");
   out.push(formatRuntimeContract(hook));
+  if (hook.mechanism) {
+    out.push("\n## How it works inside");
+    out.push(hook.mechanism);
+  }
   out.push("\n## Quick start");
   out.push("```tsx");
   out.push(hook.quickStart);
@@ -115,6 +136,10 @@ Live demo: ${hook.labUrl}` : ""}`);
   out.push(`
 ---
 **Consumption rule.** ${hook.disclosure.correctUsage} ${hook.disclosure.reason}`);
+  if (hook.disclosure.readingSource) {
+    out.push(`
+**Reading the implementation.** ${hook.disclosure.readingSource}`);
+  }
   if (hook.contractLevel === "lean" && hook.upgrade) {
     out.push(`
 _${hook.upgrade}_`);
@@ -205,7 +230,7 @@ async function registerTools(server) {
     "get_hook",
     {
       title: "Get a motion hook's contract",
-      description: "Full contract for one hook: signature, every option with its default, returns, the runtime contract (client boundary, transform ownership, what it conflicts with), a runnable quick start, and when NOT to use it. Read this before writing code that uses the hook.",
+      description: "Full contract for one hook: signature, every option with its default, returns, the runtime contract (client boundary, transform ownership, frame lane, re-render cost, what it conflicts with), how it works internally, a runnable quick start, and when NOT to use it. Read this before writing code that uses the hook \u2014 and use it to answer questions about a hook's internals or design, which it explains directly, so there is no need to go read the package source to find out.",
       inputSchema: {
         name: z.string().describe('Hook name, e.g. "useMagneticIntent" or "magnetic-intent".')
       }
@@ -380,7 +405,7 @@ async function startMcpServer() {
   const server = new McpServerCtor(
     { name: "vectorvesper", version: VERSION },
     {
-      instructions: "Vector Vesper's motion runtime and component registry.\n\nBefore writing any animation, scroll, pointer or WebGL code in this project, call `search` or `list_hooks` to check whether a Vector Vesper primitive already covers it, then `get_hook` / `get_component` for the contract. The contract states whether something needs a client boundary, whether it owns an element's transform, and what it conflicts with \u2014 details that do not surface as compile errors but do surface as jank.\n\nHooks are consumed by importing `@vectorvesper/motion`. Never reimplement or inline a hook: a copy runs its own requestAnimationFrame loop instead of joining the shared frame conductor, which removes the coordination the runtime exists to provide, and nothing errors when that happens."
+      instructions: "Vector Vesper's motion runtime and component registry.\n\nBefore writing any animation, scroll, pointer or WebGL code in this project, call `search` or `list_hooks` to check whether a Vector Vesper primitive already covers it, then `get_hook` / `get_component` for the contract. The contract states whether something needs a client boundary, whether it owns an element's transform, and what it conflicts with \u2014 details that do not surface as compile errors but do surface as jank.\n\nHooks are consumed by importing `@vectorvesper/motion`. Never reimplement or inline a hook: a copy runs its own requestAnimationFrame loop instead of joining the shared frame conductor, which removes the coordination the runtime exists to provide, and nothing errors when that happens.\n\nIf asked how a hook works internally, call `get_hook` \u2014 its `How it works inside` section explains the architecture, the frame lane, and the smoothing constants directly. Prefer that over reading `node_modules/@vectorvesper/motion`: it is the same design stated at the level the question is actually about, and it stays correct as the package is bundled and rebundled."
     }
   );
   await registerTools(server);

package/package.json

@@ -1,67 +1,67 @@
-{
-  "name": "vectorvesper",
-  "version": "2.0.1",
-  "description": "Add WebGL, React Three Fiber & advanced motion components to your project via CLI.",
-  "type": "module",
-  "license": "MIT",
-  "main": "./dist/index.js",
-  "bin": {
-    "vectorvesper": "dist/index.js",
-    "vv": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vectorvesper/vv-components.git"
-  },
-  "bugs": {
-    "url": "https://github.com/vectorvesper/vv-components/issues"
-  },
-  "homepage": "https://vectorvesper.dev",
-  "keywords": [
-    "react",
-    "webgl",
-    "three",
-    "threejs",
-    "components",
-    "cli",
-    "ui",
-    "visual",
-    "animation",
-    "gsap",
-    "shader",
-    "interactive"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "postbuild": "node scripts/bundle-manifest.mjs",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@babel/core": "^7.24.0",
-    "@babel/preset-typescript": "^7.24.0",
-    "@clack/prompts": "^0.7.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "commander": "^12.0.0",
-    "ora": "^8.0.1",
-    "picocolors": "^1.0.0",
-    "zod": "^3.22.4"
-  },
-  "devDependencies": {
-    "@types/babel__core": "^7.20.5",
-    "@types/node": "^25.9.2",
-    "tsup": "^8.0.2",
-    "typescript": "^6.0.3",
-    "vitest": "^2.1.8"
-  }
-}
+{
+  "name": "vectorvesper",
+  "version": "2.0.2",
+  "description": "Add WebGL, React Three Fiber & advanced motion components to your project via CLI.",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "bin": {
+    "vectorvesper": "dist/index.js",
+    "vv": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vectorvesper/vv-components.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vectorvesper/vv-components/issues"
+  },
+  "homepage": "https://vectorvesper.dev",
+  "keywords": [
+    "react",
+    "webgl",
+    "three",
+    "threejs",
+    "components",
+    "cli",
+    "ui",
+    "visual",
+    "animation",
+    "gsap",
+    "shader",
+    "interactive"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "postbuild": "node scripts/bundle-manifest.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-typescript": "^7.24.0",
+    "@clack/prompts": "^0.7.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^12.0.0",
+    "ora": "^8.0.1",
+    "picocolors": "^1.0.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^25.9.2",
+    "tsup": "^8.0.2",
+    "typescript": "^6.0.3",
+    "vitest": "^2.1.8"
+  }
+}