@cueframe/kernel 0.1.1 → 0.1.2

package/dist/_members/account-model/testing/conversationStoreContract.d.ts

@@ -1,47 +1,3 @@
-/**
- * THE CONVERSATION STORE CONTRACT — one executable statement, every store.
- *
- * A Director thread is persisted by TWO independent implementations: the
- * desktop's sqlite (`apps/studio/src-tauri/src/database/conversations.rs`) and the
- * org's Convex documents (`the backend conversation store`), reached through
- * an adapter each (`platform/tauri.ts`, `packages/web/adapter.ts`). A third
- * "implementation" exists in the test double the app's own tests run against.
- *
- * THEY AGREED BY REVIEW DISCIPLINE, AND THAT FAILED. Three separate files
- * carried prose saying both stores held the same rules. Two of those rules were
- * true in one store only — the refusal to re-point a thread (Convex threw,
- * sqlite silently accepted) and the immutability of a thread's creation time
- * (Convex's `_creationTime`; sqlite's `INSERT OR REPLACE` rewrote it every
- * turn). A third divergence was the live bug this whole effort started from:
- * sqlite upserted on the app's id while Convex inserted a new document per
- * turn, so one web conversation became N rows. Every one of those was invisible
- * because each store was tested only against itself.
- *
- * This file is the fix: the facts as ASSERTIONS, parameterised over the store.
- * A lane that wants to claim the contract runs it. There is no per-lane copy to
- * drift, and a fact added here fails everywhere it is not yet true.
- *
- * WHY A PARAMETERISED SUITE AND NOT A DATA TABLE like `packages/plane`'s
- * conformance rows: the plane's cases are STATELESS — the fixture travels in
- * the request body, so a row is genuinely lane-agnostic data. Conversation
- * storage is stateful CRUD over four verbs, where a fact reads "save this
- * thrice, then list, then count". Encoding that as data needs an op-script
- * schema plus an interpreter per lane; encoding it as a function needs neither.
- *
- * THESE ARE THE TWO MECHANISMS, and there are only two. `packages/plane/src/
- * conformance.ts` holds stateless OPERATIONS both lanes serve; this shape holds
- * stateful STORES behind one interface. CLAUDE.md carries the decision table —
- * read it before inventing a third.
- *
- * WHY THE RUST LANE IS NOT DRIVEN FROM HERE: it lives behind `cargo test`, and
- * reaching it from TypeScript means either a WebDriver stack (`tauri-driver`
- * does not support macOS, the dev platform) or a codegen bridge — machinery
- * several times the size of the 250 lines it would test. Instead the same facts
- * are written as `#[tokio::test]`s in `database/mod.rs` UNDER THE SAME NAMES.
- * Matching names are the seam: a fact that gains a test on one side and not the
- * other is one grep away.
- */
-/** The project a thread is about, as the store surface spells it. */
 export interface ContractProjectRef {
     id: string;
     home: "local" | "cloud";
@@ -56,17 +12,12 @@ export interface ContractConversationMeta {
 export interface ContractConversation extends ContractConversationMeta {
     messages: string;
 }
-/**
- * The store surface under test — the conversation half of `DatabaseAdapter`.
- * Each lane supplies a thin adapter onto its own implementation.
- */
 export interface ConversationStoreUnderTest {
     list(project: ContractProjectRef | null): Promise<ContractConversationMeta[]>;
     get(id: string, project: ContractProjectRef | null): Promise<ContractConversation | null>;
     save(conversation: ContractConversation): Promise<void>;
     remove(id: string): Promise<void>;
 }
-/** Vitest's primitives, injected so this package needs no test-runner dependency. */
 export interface ContractHarness {
     describe: (name: string, fn: () => void) => void;
     it: ((name: string, fn: () => Promise<void> | void) => void) & {
@@ -81,17 +32,7 @@ export interface ContractHarness {
             toThrow: (matcher?: RegExp) => Promise<void>;
         };
     };
-    /** A fresh, EMPTY store for one fact. */
     makeStore: () => Promise<ConversationStoreUnderTest> | ConversationStoreUnderTest;
-    /**
-     * Facts this lane does not hold yet, by name.
-     *
-     * Borrowed from `packages/plane/src/conformance.ts`: a named row becomes
-     * `it.fails`, which asserts the test does NOT pass — so the day the lane is
-     * fixed, this entry starts failing and whoever fixed it is forced to delete
-     * the marker. A skip would rot silently; this cannot. Use it to record a
-     * divergence, never to excuse one.
-     */
     knownRed?: readonly string[];
 }
 export declare function describeConversationStoreContract(name: string, harness: ContractHarness): void;

package/dist/_members/account-model/testing/index.d.ts

@@ -1,7 +1,2 @@
-/**
- * Test-only exports. Deliberately NOT re-exported from the package root — this
- * subpath injects a test runner's primitives and must never be reachable from
- * production code by importing `@cueframe/account-model`.
- */
 export { describeConversationStoreContract, type ConversationStoreUnderTest, type ContractHarness, type ContractConversation, type ContractConversationMeta, type ContractProjectRef, } from "./conversationStoreContract.js";
 export { describeRestorePointStoreContract, type RestorePointStoreUnderTest, type RestorePointHarness, type ContractRestorePointMeta, } from "./restorePointStoreContract.js";

package/dist/_members/account-model/testing/restorePointStoreContract.d.ts

@@ -1,33 +1,10 @@
-/**
- * THE RESTORE POINT STORE CONTRACT — one executable statement, every lane.
- *
- * Restore points are stored twice: the desktop keeps an index in sqlite with the
- * snapshot in a JSONL beside it, the org's store keeps a pointer at a
- * `compositionVersions` row it already has. Two implementations of one
- * interface, which is the arrangement that produced every bug this codebase
- * spent a day fixing in `conversations`.
- *
- * IT ALREADY WENT WRONG ONCE, EXACTLY AS PREDICTED. Both lanes had a
- * `deleteRestorePointsForConversation`, both were written and tested in
- * isolation, and NEITHER WAS CALLED — so deleting a conversation orphaned its
- * points on disk and, on the cloud, left composition versions pinned where the
- * thinning sweep could never reclaim them. Nothing noticed, because nothing
- * asserted the behaviour across the seam.
- *
- * ONLY THE GENUINELY SHARED FACTS ARE HERE. Recording is desktop-only (the web
- * records inside the server turn), so it is not in this contract — a fact that
- * one lane satisfies by doing nothing is not a shared fact, it is a no-op
- * wearing a method's name.
- */
 export interface ContractRestorePointMeta {
     id: string;
     label: string;
     createdAt: number;
 }
-/** The store surface under test — the shared half of the adapter's verbs. */
 export interface RestorePointStoreUnderTest {
     list(conversationId: string): Promise<ContractRestorePointMeta[]>;
-    /** Put one in place, however this lane does it (test-only seam). */
     seed(conversationId: string, point: {
         id: string;
         label: string;
@@ -46,7 +23,6 @@ export interface RestorePointHarness {
         toHaveLength: (n: number) => void;
     };
     makeStore: () => Promise<RestorePointStoreUnderTest> | RestorePointStoreUnderTest;
-    /** Facts this lane does not hold yet, by name — becomes `it.fails`. */
     knownRed?: readonly string[];
 }
 export declare function describeRestorePointStoreContract(name: string, harness: RestorePointHarness): void;

package/dist/_members/account-model/validators/contextFile.d.ts

@@ -1,10 +1,4 @@
 import { z } from "zod";
-/**
- * A user-curated context document the agent surfaces to the LLM (brand
- * voice notes, audience specs, recurring constraints). `generatedFrom`
- * lists the source IDs (mediaItems, conversations, etc.) that produced
- * the current `content`; bumping `version` indicates a regeneration.
- */
 export declare const ContextFile: z.ZodObject<{
     id: z.ZodBranded<z.ZodString, "Id<contextFiles>">;
     orgId: z.ZodString;

package/dist/_members/account-model/validators/conversation.d.ts

@@ -1,29 +1,4 @@
 import { z } from "zod";
-/**
- * A user's chat thread with the AI surface (Director, clips agent, etc.).
- * `messages` is a JSON-encoded UI message log; the storage column is a
- * single string blob to avoid Convex's per-row JSON shape constraints
- * across long histories.
- *
- * THE `scope` FIELD IS GONE (2026-08-17). It recorded the PAGE the thread was
- * last saved from, and it was a constant: the app writes
- * `resolvePageScope(pathname).location`, and that resolver returns the editor
- * scope on EVERY path — so every row ever written said `"editor"`, including
- * workspace threads, and the enum declared here never contained that value.
- * Nothing read it back (the one scope badge in the UI reads the LIVE
- * `PageScope`, not the stored field). A constant nobody reads is not a column
- * to correct, so it was deleted rather than fixed.
- */
-/**
- * The project a thread is ABOUT, and the home that owns it.
- *
- * `home` is carried rather than inferred: a local project's id is an absolute
- * `.cueframe` path and a cloud project's is an org project id, and reading
- * which from the shape of the string is the sniff the app's residency model
- * exists to delete. Every conversation stored in the org is a cloud project's
- * (or the workspace's), but the reference states that rather than leaving the
- * reader to know it.
- */
 export declare const ConversationProject: z.ZodObject<{
     id: z.ZodString;
     home: z.ZodEnum<["local", "cloud"]>;
@@ -37,37 +12,9 @@ export declare const ConversationProject: z.ZodObject<{
 export type ConversationProject = z.infer<typeof ConversationProject>;
 export declare const Conversation: z.ZodObject<{
     id: z.ZodBranded<z.ZodString, "Id<conversations>">;
-    /**
-     * THE THREAD'S IDENTITY, and the app is the one that mints it.
-     *
-     * A conversation exists in the client before any store has seen it: the
-     * Director opens a chat, the user types, and only when the turn ends does a
-     * row get written. So the id that names a thread has to be one the client
-     * chose (`conv_<nanoid>`), not one a store assigns — otherwise the first
-     * save is an INSERT under a name the client cannot predict, the client keeps
-     * using its own name, and every subsequent save inserts again. That is
-     * exactly what web did until 2026-08-17: an N-turn conversation became N
-     * rows, and Delete silently deleted nothing because the id the user's
-     * sidebar held had never named a document.
-     *
-     * The desktop always had this right — sqlite is an `INSERT OR REPLACE` keyed
-     * on the client id. This field makes the org's store agree, via a unique
-     * lookup on `by_userId_clientId`: writes are an upsert on the id the app
-     * chose, and Convex's `_id` goes back to being an internal detail nobody
-     * outside this table ever sees or stores.
-     */
     clientId: z.ZodString;
     userId: z.ZodString;
     title: z.ZodString;
-    /**
-     * The project whose media, timeline and history this thread's turns are
-     * about. ABSENT is a meaning — a workspace thread, started on a surface with
-     * no project open — not a missing value: such a thread belongs to the user's
-     * workspace and survives every project switch precisely because it names no
-     * project. It is `optional` rather than nullable because rows written before
-     * the field existed have no project recorded, and nothing may invent one for
-     * them.
-     */
     project: z.ZodOptional<z.ZodObject<{
         id: z.ZodString;
         home: z.ZodEnum<["local", "cloud"]>;
@@ -78,34 +25,8 @@ export declare const Conversation: z.ZodObject<{
         id: string;
         home: "local" | "cloud";
     }>>;
-    /**
-     * When the thread was STARTED — supplied by the app, kept by the store.
-     *
-     * Stored rather than read off Convex's `_creationTime`, which is when the
-     * DOCUMENT was inserted and not when the conversation began. Those are the
-     * same moment for a thread born in the cloud and very different for one that
-     * arrives there later: moving a project to the cloud re-homes its threads
-     * (`adoptIntoProject`), and a months-old conversation would have shown up
-     * dated today. The desktop has always stored the app's value; this is the
-     * org's store agreeing, and it is what lets the same thread report the same
-     * age on both sides of a move.
-     *
-     * Immutable after the first write on both stores — a thread's age is a fact
-     * about the thread, not about its most recent turn.
-     */
     createdAt: z.ZodString;
-    /**
-     * When the thread last had a turn — the key the history list sorts on.
-     *
-     * Stored rather than derived because the two things a store can offer for
-     * free are both wrong: Convex's `_creationTime` is when the thread STARTED
-     * (so a months-old thread the user just added a turn to sorts to the bottom,
-     * which is the opposite of what a history list is for), and a patch does not
-     * move it. The desktop has ordered by `updated_at DESC` since migration 015;
-     * this is the org's store agreeing.
-     */
     updatedAt: z.ZodString;
-    /** JSON-encoded array of UI messages (role + content). */
     messages: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     id: string & z.BRAND<"Id<conversations>">;
@@ -133,21 +54,4 @@ export declare const Conversation: z.ZodObject<{
     } | undefined;
 }>;
 export type Conversation = z.infer<typeof Conversation>;
-/**
- * A thread as a history LIST needs it — everything but the turns.
- *
- * The list renders a title and nothing else, so shipping `messages` with it
- * sends the entire chat log of every thread to draw ≤5 lines of text. That was
- * merely wasteful while a thread was one row; it stops being merely wasteful
- * on a store with a per-response size limit, and it is the same read that runs
- * on every project switch.
- *
- * A TYPE, NOT A SCHEMA, and deliberately: `ConversationMeta` would naturally be
- * `Conversation.omit({messages: true})`, but `ZodObject.omit()` is the
- * "instantiation explosion" Zod 3's own v4 notes describe — it re-instantiates
- * deep conditional generics and blew past TypeScript's depth limit (TS2589)
- * where `@cueframe/convex-schemas` used it, silently degrading the derived
- * table types to `{[x: string]: …}`. Nothing parses a meta at a boundary, so
- * the shape is only ever needed as a type.
- */
 export type ConversationMeta = Omit<Conversation, "messages">;

package/dist/_members/account-model/validators/dashboardInsight.d.ts

@@ -1,13 +1,7 @@
 import { z } from "zod";
-/**
- * Cached LLM-generated dashboard summary keyed off a `sourceHash` of the
- * inputs that produced it. Surfaces a one-line hero insight plus a small
- * batch of follow-up content suggestions on the home view.
- */
 export declare const DashboardInsight: z.ZodObject<{
     id: z.ZodBranded<z.ZodString, "Id<dashboardInsights>">;
     orgId: z.ZodString;
-    /** Hash of the input set that produced this snapshot (cache key). */
     sourceHash: z.ZodString;
     heroInsight: z.ZodString;
     contentSuggestions: z.ZodArray<z.ZodString, "many">;

package/dist/_members/account-model/validators/sessionToken.d.ts

@@ -1,10 +1,4 @@
 import { z } from "zod";
-/**
- * Short-lived, session-scoped, read-only bearer token used by a warm render
- * session container (Modal Sandbox) to subscribe to its working composition in Convex
- * without bundling org credentials into the container. Validated as a query
- * argument (the UploadToken precedent), not via Convex-native auth/JWT.
- */
 export declare const SessionTokenScope: z.ZodEnum<["session-read"]>;
 export type SessionTokenScope = z.infer<typeof SessionTokenScope>;
 export declare const SessionToken: z.ZodObject<{
@@ -15,34 +9,11 @@ export declare const SessionToken: z.ZodObject<{
     orgId: z.ZodString;
     scope: z.ZodEnum<["session-read"]>;
     expiresAt: z.ZodString;
-    /** The warm sandbox this session is bound to, set once it's created. The
-     *  session reconnects by this id (provider.get) per render — the platform-native
-     *  persistent-resource pattern. */
     sandboxId: z.ZodOptional<z.ZodString>;
-    /** Epoch-ms when the warm box became ready (stamped alongside `sandboxId`). The
-     *  billable-uptime clock start — `closeSession` bills `compose_session_minutes`
-     *  from here. Absent = the box never booted, so nothing to bill. Stored as a raw
-     *  number (epoch-ms) like `expiresAt`, for cheap arithmetic. */
     readyAt: z.ZodOptional<z.ZodNumber>;
-    /** The `_scheduled_functions` id of the pending durable auto-close
-     *  (`ctx.scheduler.runAfter`). Cancelled + rescheduled on activity (keep-alive),
-     *  fired on idle to reap the sandbox — crash-proof cleanup, not durability. */
     scheduledCloseId: z.ZodOptional<z.ZodString>;
-    /** The session-scoped SCRATCH composition (a derived sibling of the project's
-     *  active composition). Author-ops during the session mutate THIS row, never
-     *  active; `promoteScratch` commits it and `closeSession` discards it. Absent
-     *  until the session derives one (or the project had no active to derive from). */
     scratchCompositionId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id<compositions>">>;
-    /** SERVER-owned evidence box (the sessionless score/preview ops). Managed
-     *  sessions bill per-op only (uptime metering skips them — flat per-op is the
-     *  public contract), run a SHORT idle TTL, never mint a scratch composition,
-     *  and are the only rows the managed resolver may reuse or evict. */
     managed: z.ZodOptional<z.ZodBoolean>;
-    /** Async-evidence lease: the jobId currently staging/judging on this box. A
-     *  second evidence op on the same box while the lease is live gets 409
-     *  box_busy instead of silently bumping the working-composition version out
-     *  from under the in-flight judge. Cleared at the job terminal; expiry is the
-     *  crash backstop. */
     leaseJobId: z.ZodOptional<z.ZodString>;
     leaseExpiresAt: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {

package/dist/_members/account-model/validators/uploadToken.d.ts

@@ -1,8 +1,4 @@
 import { z } from "zod";
-/**
- * Short-lived bearer token used by Tus / Uppy Companion to upload files
- * directly to R2 without bundling org credentials into the browser.
- */
 export declare const UploadTokenScope: z.ZodEnum<["tus", "companion"]>;
 export type UploadTokenScope = z.infer<typeof UploadTokenScope>;
 export declare const UploadToken: z.ZodObject<{

package/dist/_members/account-model/validators/userSettings.d.ts

@@ -1,8 +1,4 @@
 import { z } from "zod";
-/**
- * Per-user preferences. Sparse by design — every field is optional, so
- * downstream readers should use defaults rather than asserting presence.
- */
 export declare const UserSettings: z.ZodObject<{
     id: z.ZodBranded<z.ZodString, "Id<userSettings>">;
     userId: z.ZodString;

package/dist/_members/account-model/validators/workingComposition.d.ts

@@ -1,11 +1,4 @@
 import { z } from "zod";
-/**
- * The single in-progress composition source for a warm render session. Both the
- * Director compose loop (per attempt) and a client debug session write here; the
- * in-container daemon subscribes to it via `getWorkingComposition`. The project
- * `compositions` row and per-candidate `compositionRuns` rows remain the
- * settle-time SSOT + history — this is the live, reactive surface only.
- */
 export declare const WorkingComposition: z.ZodObject<{
     id: z.ZodBranded<z.ZodString, "Id<workingCompositions>">;
     sessionId: z.ZodString;

package/dist/_members/animate/animations/Create.d.ts

@@ -1,36 +1,17 @@
 import React from 'react';
 interface CreateProps {
-    /** SVG path data string to draw */
     path: string;
-    /** Stroke color */
     stroke?: string;
-    /** Stroke width */
     strokeWidth?: number;
-    /** Fill color (revealed after stroke completes if fillAfter is true) */
     fill?: string;
-    /** Delay fill reveal until stroke is nearly complete */
     fillAfter?: boolean;
-    /** SVG width */
     width?: number | string;
-    /** SVG height */
     height?: number | string;
-    /** SVG viewBox */
     viewBox?: string;
-    /** Duration of the stroke drawing animation in frames */
     durationInFrames?: number;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional SVG style */
     style?: React.CSSProperties;
 }
-/**
- * Stroke drawing animation — objects "draw themselves into existence".
- * Wraps evolvePath() from @remotion/paths with Manim-quality easing.
- *
- * Usage:
- *   <Create path="M10,80 Q95,10 180,80" stroke="white" durationInFrames={30} />
- */
 export declare const Create: React.FC<CreateProps>;
 export {};

package/dist/_members/animate/animations/FadeIn.d.ts

@@ -2,35 +2,18 @@ import React from 'react';
 type Direction = 'up' | 'down' | 'left' | 'right' | 'none';
 interface FadeInProps {
     children: React.ReactNode;
-    /** Slide direction (default: 'up') */
     direction?: Direction;
-    /** Slide distance in pixels (default: 30) */
     distance?: number;
-    /** Duration in frames when not using spring (default: 20) */
     durationInFrames?: number;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth). Ignored when useSpring is true. */
     easing?: (t: number) => number;
-    /** Use spring physics instead of easing curve */
     useSpring?: boolean;
-    /** Spring config (used when useSpring is true) */
     springConfig?: {
         damping?: number;
         stiffness?: number;
         mass?: number;
     };
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Directional fade entrance with optional spring physics.
- * Combines opacity fade with a slide from the specified direction.
- *
- * Usage:
- *   <FadeIn direction="up" durationInFrames={20}>
- *     <h1 style={{ color: 'white' }}>Title</h1>
- *   </FadeIn>
- */
 export declare const FadeIn: React.FC<FadeInProps>;
 export {};

package/dist/_members/animate/animations/GrowArrow.d.ts

@@ -1,36 +1,17 @@
 import React from 'react';
 interface GrowArrowProps {
-    /** Start point [x, y] */
     from: [number, number];
-    /** End point [x, y] */
     to: [number, number];
-    /** Stroke color */
     color?: string;
-    /** Stroke width (default: 2) */
     strokeWidth?: number;
-    /** Arrowhead size in pixels (default: 12) */
     tipSize?: number;
-    /** SVG width */
     width?: number | string;
-    /** SVG height */
     height?: number | string;
-    /** SVG viewBox */
     viewBox?: string;
-    /** Duration of the grow animation in frames */
     durationInFrames?: number;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth) */
     easing?: (t: number) => number;
-    /** Additional SVG style */
     style?: React.CSSProperties;
 }
-/**
- * Animated arrow that grows from start to end point with stroke drawing.
- * The arrowhead appears as the line reaches its destination.
- *
- * Usage:
- *   <GrowArrow from={[100, 300]} to={[500, 300]} color="#fff" durationInFrames={30} />
- */
 export declare const GrowArrow: React.FC<GrowArrowProps>;
 export {};

package/dist/_members/animate/animations/GrowFromCenter.d.ts

@@ -1,25 +1,13 @@
 import React from 'react';
 interface GrowFromCenterProps {
     children: React.ReactNode;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Spring physics config */
     springConfig?: {
         damping?: number;
         stiffness?: number;
         mass?: number;
     };
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Scale-from-zero entrance with spring physics.
- * Element grows from its center point with natural overshoot.
- *
- * Usage:
- *   <GrowFromCenter>
- *     <div style={{ background: 'blue', padding: 20 }}>Hello</div>
- *   </GrowFromCenter>
- */
 export declare const GrowFromCenter: React.FC<GrowFromCenterProps>;
 export {};

package/dist/_members/animate/animations/Indicate.d.ts

@@ -1,29 +1,12 @@
 import React from 'react';
 interface IndicateProps {
     children: React.ReactNode;
-    /** Color of the highlight flash (default: '#FBBF24' — amber) */
     color?: string;
-    /** Scale factor at peak of indication (default: 1.15) */
     scaleFactor?: number;
-    /** Duration of the full indicate cycle in frames (default: 30) */
     durationInFrames?: number;
-    /** Delay before indication starts (in frames) */
     delay?: number;
-    /** Number of times to pulse (default: 1) */
     pulses?: number;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Flash/highlight effect to draw attention to an element.
- *
- * Scales up slightly and adds a colored glow, then returns to normal.
- * Like tapping an element to say "look here". Manim's Indicate animation.
- *
- * Usage:
- *   <Indicate color="#D4AF37">
- *     <div style={{ fontSize: 48, color: '#fff' }}>Important!</div>
- *   </Indicate>
- */
 export declare const Indicate: React.FC<IndicateProps>;
 export {};

package/dist/_members/animate/animations/MoveAlongPath.d.ts

@@ -1,30 +1,12 @@
 import React from 'react';
 interface MoveAlongPathProps {
     children: React.ReactNode;
-    /** SVG path data string to follow */
     path: string;
-    /** Duration of the movement in frames */
     durationInFrames?: number;
-    /** Delay before movement starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth) */
     easing?: (t: number) => number;
-    /** Rotate element to align with path tangent (default: false) */
     rotate?: boolean;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Move a child element along an SVG path over time.
- * Wraps getPointAtLength() and getTangentAtLength() from @remotion/paths.
- *
- * The child is positioned absolutely at the current point on the path,
- * optionally rotated to align with the path direction.
- *
- * Usage:
- *   <MoveAlongPath path="M 100,400 C 200,100 400,100 500,400" durationInFrames={60} rotate>
- *     <div style={{ width: 20, height: 20, borderRadius: '50%', background: '#fff' }} />
- *   </MoveAlongPath>
- */
 export declare const MoveAlongPath: React.FC<MoveAlongPathProps>;
 export {};

package/dist/_members/animate/animations/Transform.d.ts

@@ -1,46 +1,18 @@
 import React from 'react';
 interface TransformProps {
-    /** Starting SVG path data */
     fromPath: string;
-    /** Ending SVG path data */
     toPath: string;
-    /** Stroke color */
     stroke?: string;
-    /** Stroke width */
     strokeWidth?: number;
-    /** Fill color */
     fill?: string;
-    /** SVG width */
     width?: number | string;
-    /** SVG height */
     height?: number | string;
-    /** SVG viewBox */
     viewBox?: string;
-    /** Duration of the morph animation in frames */
     durationInFrames?: number;
-    /** Delay before animation starts (in frames) */
     delay?: number;
-    /** Easing function (default: smooth) */
     easing?: (t: number) => number;
-    /** Fade in at the start and fade out at the end */
     fadeEdges?: boolean;
-    /** Additional SVG style */
     style?: React.CSSProperties;
 }
-/**
- * SVG path morphing — shape A smoothly transforms into shape B.
- * Wraps interpolatePath() from @remotion/paths with Manim-quality easing.
- *
- * Both paths should have the same number of points for best results.
- * Remotion's interpolatePath handles automatic point alignment.
- *
- * Usage:
- *   <Transform
- *     fromPath="M 50,250 C 150,50 350,50 450,250"
- *     toPath="M 50,250 L 250,50 L 450,250"
- *     stroke="#fff" strokeWidth={3} durationInFrames={45}
- *     viewBox="0 0 500 300"
- *   />
- */
 export declare const Transform: React.FC<TransformProps>;
 export {};

package/dist/_members/animate/animations/Wiggle.d.ts

@@ -1,31 +1,13 @@
 import React from 'react';
 interface WiggleProps {
     children: React.ReactNode;
-    /** Maximum rotation angle in degrees (default: 8) */
     angle?: number;
-    /** Maximum X displacement in pixels (default: 4) */
     xAmplitude?: number;
-    /** Maximum Y displacement in pixels (default: 2) */
     yAmplitude?: number;
-    /** Duration of the wiggle in frames (default: 30) */
     durationInFrames?: number;
-    /** Delay before wiggle starts (in frames) */
     delay?: number;
-    /** Number of oscillation cycles (default: 3) */
     cycles?: number;
-    /** Additional wrapper style */
     style?: React.CSSProperties;
 }
-/**
- * Shake/wobble animation — element oscillates with decaying amplitude.
- *
- * Creates a natural-feeling shake that decays over time, like a spring
- * settling. Good for drawing attention, error states, or playful emphasis.
- *
- * Usage:
- *   <Wiggle angle={10} cycles={4}>
- *     <div style={{ fontSize: 24, color: '#fff' }}>Shake me!</div>
- *   </Wiggle>
- */
 export declare const Wiggle: React.FC<WiggleProps>;
 export {};