@pixerate/flair 0.0.0-stage → 0.1.1

package/dist/renderer-Oyynz-fs.d.ts

@@ -0,0 +1,293 @@
+import { T as TextureSettings, a as ControlDef, C as ControlValue } from './controls-DdXMbovi.js';
+
+/** Why an image control's URL could not be shown. */
+declare class ImageLoadError extends Error {
+    readonly url: string;
+    constructor(url: string, cause?: unknown);
+}
+/**
+ * The long edge, in pixels, SVG images are rasterised at. WebGL2 guarantees
+ * textures this large on every device.
+ */
+declare const SVG_EDGE = 2048;
+/** Whether `url` is an SVG: a `data:image/svg+xml` URL, or a path ending in `.svg`. */
+declare function isSvgUrl(url: string): boolean;
+/**
+ * An SVG's markup with `width` and `height` set so its long edge is `edge`
+ * pixels, keeping its aspect ratio. An image decodes an SVG at its own size
+ * (often icon-sized, or 300 × 150 when it has none), so it would make a
+ * small, blurry texture; at this size it is rasterised crisply. A `viewBox`
+ * is added where missing, so the drawing scales with the new size rather
+ * than staying in the corner. Throws for markup that is not an SVG.
+ */
+declare function sizeSvg(markup: string, edge: number): string;
+/**
+ * Loads and decodes an image for WebGL. Images from other origins are
+ * requested with CORS (`crossOrigin = "anonymous"`): WebGL refuses pixels a
+ * page is not allowed to read. SVGs (see {@link isSvgUrl}) are fetched, also
+ * with CORS, and sized to {@link SVG_EDGE} pixels on their long edge before
+ * they are decoded, so they stay sharp however small they were drawn.
+ */
+declare function loadImage(url: string): Promise<HTMLImageElement>;
+/**
+ * Loads and decodes images ahead of time, for every WebGL context on the
+ * page: a texture cache that meets one of them afterwards (in a
+ * `ShaderRenderer`, `ShaderFrames` or thumbnail) uploads it at once, so even
+ * its first frame shows the image. Otherwise an image arrives a moment after
+ * the first frame, which is black where it goes. Use it before drawing frames
+ * that cannot wait, such as a video player asking a new `ShaderFrames` for
+ * frame _n_.
+ *
+ * Each URL loads once, however often it is preloaded. Rejects with the first
+ * {@link ImageLoadError}; the other images still load. Preloaded images stay
+ * in memory until {@link releaseImages}.
+ */
+declare function preloadImages(urls: Iterable<string>): Promise<void>;
+/** Forgets preloaded images (all of them without `urls`). Textures already made from them stay. */
+declare function releaseImages(urls?: Iterable<string>): void;
+/** Something that hands `drawFrame` a texture for an image URL. */
+interface TextureSource {
+    /** The texture for `url`: the image once loaded, a 1 × 1 opaque black placeholder until then. */
+    texture(url: string): WebGLTexture | null;
+}
+/**
+ * The textures of one WebGL context, by image URL. A URL starts loading the
+ * first time it is asked for; until it arrives the placeholder is drawn, and
+ * `onLoad` hears when it does (or fails) so the owner can redraw. An image
+ * already decoded by {@link preloadImages} is uploaded at once instead. Images are
+ * uploaded upright (`fragCoord / iResolution` samples them the right way up)
+ * with mipmaps.
+ */
+declare class TextureCache implements TextureSource {
+    private readonly gl;
+    private readonly entries;
+    private readonly onLoad;
+    private readonly load;
+    private placeholder;
+    private disposed;
+    constructor(gl: WebGL2RenderingContext, onLoad?: (url: string, error: ImageLoadError | null) => void, load?: (url: string) => Promise<TexImageSource>);
+    texture(url: string): WebGLTexture | null;
+    /** Starts loading `url` if it is new. */
+    request(url: string): void;
+    private entry;
+    /** The error for `url`, if it failed to load. */
+    error(url: string): ImageLoadError | null;
+    /**
+     * Settles once every one of `urls` has loaded or failed (starting any that
+     * are new). Rejects with the first {@link ImageLoadError}.
+     */
+    ready(urls: Iterable<string>): Promise<void>;
+    /** Deletes the textures of every URL not in `urls`; a later request loads them again. */
+    retain(urls: Iterable<string>): void;
+    /** Deletes every texture; loads still in flight are dropped. */
+    dispose(): void;
+    private blank;
+    private upload;
+}
+/** Sets the bound `TEXTURE_2D`'s filter and wrap. */
+declare function applyTextureSettings(gl: WebGL2RenderingContext, settings: TextureSettings): void;
+
+/**
+ * Shaders are written Shadertoy-style: the source defines
+ * `void mainImage(out vec4 fragColor, in vec2 fragCoord)` and may use the
+ * built-in uniforms below. It is compiled as GLSL ES 3.00 (WebGL2) inside a
+ * small wrapper; `#line 1` keeps compiler line numbers matching the source.
+ */
+declare const BUILTIN_UNIFORMS: readonly [{
+    readonly name: "iResolution";
+    readonly type: "vec3";
+    readonly doc: "viewport size in pixels (z = 1)";
+}, {
+    readonly name: "iTime";
+    readonly type: "float";
+    readonly doc: "seconds since the shader started";
+}, {
+    readonly name: "iTimeDelta";
+    readonly type: "float";
+    readonly doc: "seconds since the previous frame";
+}, {
+    readonly name: "iFrame";
+    readonly type: "int";
+    readonly doc: "frame number";
+}, {
+    readonly name: "iMouse";
+    readonly type: "vec4";
+    readonly doc: "xy = pointer while pressed (pixels), zw = press position (negative once released)";
+}];
+/** A full-screen triangle from `gl_VertexID` alone: no buffers or attributes. */
+declare const VERTEX_SOURCE = "#version 300 es\nvoid main() {\n  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n}\n";
+/** One compiler message, mapped back to the user's source. */
+interface CompileError {
+    /** 1-based line in the user's source (0 when the driver gave none, or it is outside the source). */
+    line: number;
+    message: string;
+}
+/** A linked program and the uniform locations `drawFrame` sets. */
+interface CompiledShader {
+    program: WebGLProgram;
+    builtins: Record<string, WebGLUniformLocation | null>;
+    uniforms: Map<string, WebGLUniformLocation | null>;
+}
+type CompileResult = {
+    ok: true;
+    shader: CompiledShader;
+} | {
+    ok: false;
+    errors: CompileError[];
+};
+/** Thrown by the APIs that cannot carry on without a program (`ShaderFrames`, `recordGif`). */
+declare class ShaderCompileError extends Error {
+    readonly errors: CompileError[];
+    constructor(errors: CompileError[]);
+}
+/** "The shader does not compile (line 3): 'x' : undeclared identifier", from the first error. */
+declare function formatCompileError(errors: CompileError[]): string;
+/** The complete GLSL ES 3.00 fragment shader for a `mainImage` source. */
+declare function wrapSource(source: string): string;
+/** Turns a driver log ("ERROR: 0:12: 'foo' : undeclared identifier") into line-numbered errors. */
+declare function parseCompileLog(log: string, lineCount: number): CompileError[];
+/** Forgets cached GL objects. Call it after a context loss, before compiling on the restored context. */
+declare function resetGlCaches(): void;
+/**
+ * Compiles and links a `mainImage` source. Errors come back with lines in
+ * the user's source, never thrown. `controls` (from `parseControls`) says
+ * which uniform locations to look up.
+ */
+declare function compileShader(gl: WebGL2RenderingContext, source: string, controls: ControlDef[]): CompileResult;
+/** What one frame shows: its size in pixels, its time and the pointer. */
+interface FrameState {
+    width: number;
+    height: number;
+    /** `iTime`, in seconds. */
+    time: number;
+    /** `iTimeDelta`, in seconds. */
+    delta: number;
+    /** `iFrame`. */
+    frame: number;
+    /** `iMouse`, Shadertoy semantics. */
+    mouse: [number, number, number, number];
+}
+/**
+ * Draws one frame of a compiled shader into the bound framebuffer, from (0, 0).
+ * Image controls are bound to texture units 0, 1, … in source order, with
+ * textures from `textures` (a {@link TextureCache} for the same context);
+ * without it they sample nothing.
+ */
+declare function drawFrame(gl: WebGL2RenderingContext, shader: CompiledShader, controls: ControlDef[], values: Record<string, ControlValue> | undefined, state: FrameState, textures?: TextureSource): void;
+/**
+ * A WebGL2 context set up for full-screen fragment shaders: opaque, no depth,
+ * stencil or antialiasing. `preserveDrawingBuffer` keeps the last frame
+ * readable after the task that drew it (for captures). Null without WebGL2.
+ */
+declare function createContext(canvas: HTMLCanvasElement | OffscreenCanvas, preserveDrawingBuffer?: boolean): WebGL2RenderingContext | null;
+
+/** Whether the latest source compiled, and if not, why. */
+interface CompileStatus {
+    ok: boolean;
+    errors: CompileError[];
+}
+/** What `onStats` reports: on play, pause, seek and restart, and twice a second while running. */
+interface RendererStats {
+    /** `iTime`, in seconds. */
+    time: number;
+    /** Frames drawn per second over the last half second (0 while paused). */
+    fps: number;
+    playing: boolean;
+    /** The drawing buffer's size in device pixels. */
+    width: number;
+    height: number;
+}
+/**
+ * Runs one shader on a canvas: the editor's live preview. A source that does
+ * not compile leaves the last working program on screen, so a typo never
+ * blanks the preview; the errors are reported instead.
+ *
+ * The renderer owns its canvas (added to `host`, removed on dispose): a
+ * canvas keeps its WebGL context for life, so reusing one after disposing
+ * (a remount, hot reload) would get the released, lost context back.
+ */
+declare class ShaderRenderer {
+    readonly canvas: HTMLCanvasElement;
+    private gl;
+    private shader;
+    private textures;
+    private controls;
+    private values;
+    private source;
+    private raf;
+    private lastNow;
+    private frame;
+    private fpsFrames;
+    private fpsSince;
+    private resizeObserver;
+    private mouse;
+    private disposed;
+    /** The latest source's status. */
+    status: CompileStatus;
+    /** `iTime`, in seconds. Use `seek` to change it. */
+    time: number;
+    /** Playback speed: 1 is real time. */
+    speed: number;
+    /** Device pixels per CSS pixel; lower renders faster. Use `setPixelRatio` to change it. */
+    pixelRatio: number;
+    playing: boolean;
+    fps: number;
+    onStats?: (stats: RendererStats) => void;
+    /** Called with `true` when the GL context is lost and `false` once it is restored and recompiled. */
+    onContextLost?: (lost: boolean) => void;
+    /** Called when an image control's URL cannot be loaded; the control shows black. */
+    onImageError?: (error: ImageLoadError) => void;
+    /** Creates a canvas in `host` (with `className`) and starts the animation loop. Size the canvas with CSS. */
+    constructor(host: HTMLElement, className?: string);
+    /** False when the browser has no WebGL2. */
+    get supported(): boolean;
+    /** Compiles a new source; returns its status. Keeps the previous program when it fails. */
+    setSource(source: string): CompileStatus;
+    /**
+     * Sets control values (see `controlValue`); a paused preview redraws.
+     * Images load in the background and show once they arrive: await
+     * `ready()` before a `capture` that needs them.
+     */
+    setValues(values: Record<string, ControlValue> | undefined): void;
+    /**
+     * Settles once the images the current controls show have loaded. Rejects
+     * with an {@link ImageLoadError} when one cannot be (it shows black).
+     */
+    ready(): Promise<void>;
+    play(): void;
+    pause(): void;
+    /** Back to `iTime` 0 and frame 0. */
+    restart(): void;
+    /** Jumps to `time` seconds (not below 0) and draws it. */
+    seek(time: number): void;
+    setPixelRatio(ratio: number): void;
+    /**
+     * Captures the current frame (optionally at another time) as a data URL
+     * (JPEG unless `type` says PNG), at most `maxEdge` pixels on the long side
+     * (default 1024). Playback time is left as it was. Null when nothing has
+     * compiled yet.
+     */
+    capture(options?: {
+        time?: number;
+        maxEdge?: number;
+        type?: "image/jpeg" | "image/png";
+    }): string | null;
+    /** Stops the loop, releases the context and removes the canvas. The renderer cannot be used again. */
+    dispose(): void;
+    private resize;
+    private render;
+    private textureCache;
+    /** Starts loading the images now shown, and frees the ones no longer shown. */
+    private syncTextures;
+    private tick;
+    private emit;
+    /** Pointer position in shader pixels (origin bottom-left, like gl_FragCoord). */
+    private toPixels;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onLost;
+    private onRestored;
+}
+
+export { BUILTIN_UNIFORMS as B, type CompileError as C, type FrameState as F, ImageLoadError as I, type RendererStats as R, SVG_EDGE as S, TextureCache as T, VERTEX_SOURCE as V, type CompileStatus as a, type CompileResult as b, type CompiledShader as c, ShaderCompileError as d, ShaderRenderer as e, type TextureSource as f, applyTextureSettings as g, compileShader as h, createContext as i, drawFrame as j, formatCompileError as k, isSvgUrl as l, loadImage as m, preloadImages as n, resetGlCaches as o, parseCompileLog as p, releaseImages as r, sizeSvg as s, wrapSource as w };

package/dist/types-CkKkavvB.d.ts

@@ -0,0 +1,71 @@
+import { C as ControlValue, a as ControlDef } from './controls-DdXMbovi.js';
+import { S as SvgMotion } from './motion-D0TVv2CF.js';
+
+/** What an effect is for, used to group the catalog. */
+type EffectCategory = "gradient" | "organic" | "pattern" | "light" | "space" | "retro" | "image" | "transition" | "loader" | "data" | "icon";
+/** Every category, in the order the catalog lists them. */
+declare const EFFECT_CATEGORIES: readonly EffectCategory[];
+/** Named control values: a look an effect can be switched to. */
+interface EffectPreset {
+    name: string;
+    values: Record<string, ControlValue>;
+}
+interface EffectBase {
+    /** Stable id, kebab-case: `aurora`, `image-glitch`. */
+    id: string;
+    name: string;
+    /** One sentence: what it looks like. */
+    description: string;
+    category: EffectCategory;
+    tags: readonly string[];
+    presets?: readonly EffectPreset[];
+}
+/**
+ * A WebGL2 fragment shader (Shadertoy-style `mainImage`). Its controls are the
+ * `// @control` uniforms in `source`; run it with `ShaderRenderer`,
+ * `ShaderFrames`, `ThumbnailPool`, `recordGif` or `standaloneHtml`.
+ */
+interface ShaderEffect extends EffectBase {
+    kind: "shader";
+    source: string;
+    /** Seconds after which it repeats exactly, when it loops seamlessly. */
+    loop?: number;
+}
+/**
+ * A control of a vector effect. The same shape as a shader's controls (see
+ * `ControlDef`) less what only sources have; `vec3` colours are written into
+ * the picture as `#rrggbb`.
+ */
+type VectorControl = Pick<ControlDef, "name" | "type" | "default"> & Partial<Pick<ControlDef, "label" | "color" | "min" | "max" | "step">>;
+/**
+ * An animated SVG picture (see `SvgMotion`). `{{name}}` in the motion is
+ * replaced by the control's value (see {@link renderVectorEffect}); run the
+ * result with `SvgPlayer`.
+ */
+interface VectorEffect extends EffectBase {
+    kind: "vector";
+    motion: SvgMotion;
+    controls: readonly VectorControl[];
+    /**
+     * More placeholders worked out from the control values (a bar's height
+     * from its value, say), filled in after the controls.
+     */
+    derived?: (values: Record<string, ControlValue>) => Record<string, string | number>;
+    /** Ms to rest on the last frame before it loops (default 600). */
+    hold?: number;
+}
+type EffectDefinition = ShaderEffect | VectorEffect;
+/** A vector control as a full `ControlDef`, so editors treat both kinds of effect alike. */
+declare function vectorControlDef(control: VectorControl, line?: number): ControlDef;
+/**
+ * A vector effect's motion with its controls filled in: `"{{name}}"` (a
+ * whole JSON string) becomes the value itself, so numbers stay numbers, and
+ * `{{name}}` inside a string becomes its text. Missing values use defaults.
+ */
+declare function renderVectorEffect(effect: Pick<VectorEffect, "motion" | "controls" | "derived">, values?: Record<string, ControlValue>): SvgMotion;
+/** A colour control for vector effects. */
+declare function colorControl(name: string, hex: string, label?: string): VectorControl;
+/** A number control for vector effects. */
+declare function numberControl(name: string, value: number, min: number, max: number, label?: string, step?: number): VectorControl;
+
+export { type EffectDefinition as E, type ShaderEffect as S, type VectorControl as V, type EffectCategory as a, EFFECT_CATEGORIES as b, type EffectPreset as c, type VectorEffect as d, colorControl as e, numberControl as n, renderVectorEffect as r, vectorControlDef as v };

package/dist/vector/index.d.ts

@@ -0,0 +1,83 @@
+import { S as SvgMotion } from '../motion-D0TVv2CF.js';
+export { D as DataKey, E as EASES, a as EaseName, b as STEP_MS, c as SVG_PICTURE, d as SvgAnimation, e as SvgBox, f as SvgElementFrame, g as defaultDataKey, l as lerpAttr, h as lerpData, s as stepData, i as stepProgress, j as stepStart, k as svgFrame, m as svgMotionIssues, n as svgOpeningTag } from '../motion-D0TVv2CF.js';
+import { C as Clock } from '../clock-BhdXWH-n.js';
+
+/**
+ * Drawing animated SVG pictures (see `SvgMotion`) in the DOM: a sanitising
+ * parser, a view that applies frames, and a player that runs on a `Clock`.
+ */
+
+/**
+ * The `<svg>` in `markup`, parsed and made safe to show: no scripts, event
+ * handlers, `<foreignObject>` or links outside itself. Undefined when it is
+ * not an SVG.
+ */
+declare function parseSvg(markup: string): SVGSVGElement | undefined;
+interface SvgViewOptions {
+    /** Called with the id of the innermost element with an id that is clicked. */
+    onPick?: (id: string) => void;
+}
+/** An {@link SvgMotion} drawn into an element; call `draw` with a time to show it then. */
+interface SvgView {
+    /** A `div` filled by the picture; put it anywhere. */
+    readonly element: HTMLDivElement;
+    /** Shows the picture at `timeMs`, with steps starting at `steps` (ms). */
+    draw(timeMs: number, steps?: readonly number[]): void;
+    /** An image of the picture as drawn now. */
+    capture(pixels: {
+        width: number;
+        height: number;
+    }): Promise<HTMLCanvasElement | undefined>;
+}
+/** Shows an {@link SvgMotion} as a live view; with `onPick`, clicks report the id of the element clicked. */
+declare function svgView(motion: SvgMotion, options?: SvgViewOptions): SvgView;
+/** How long an {@link SvgMotion} runs: its last change's end, in ms (at least 1). */
+declare function svgDuration(motion: SvgMotion, steps?: readonly number[]): number;
+interface SvgPlayerOptions extends SvgViewOptions {
+    /** Time source (default: animation frames). Pass a `ManualClock` to step frames yourself. */
+    clock?: Clock;
+    /** Start playing at once (default `true`). */
+    autoplay?: boolean;
+    /** Start again at the end (default `true`). */
+    loop?: boolean;
+    /** Loop length in ms (default: the picture's own, see {@link svgDuration}, plus `hold`). */
+    duration?: number;
+    /** Ms to rest on the last frame before looping (default 600). */
+    hold?: number;
+    /** Playback speed (default 1). */
+    speed?: number;
+    /** Step start times in ms, for pictures that change on steps (default none). */
+    steps?: readonly number[];
+}
+/**
+ * Plays an {@link SvgMotion} inside `container`: loops by default, and can be
+ * paused, sought and sped up. Dispose it to stop and remove the picture.
+ */
+declare class SvgPlayer {
+    private readonly container;
+    readonly view: SvgView;
+    private readonly clock;
+    private readonly steps;
+    private readonly loop;
+    private readonly length;
+    private speed;
+    private time;
+    private last;
+    private playing;
+    private disposed;
+    constructor(container: HTMLElement, motion: SvgMotion, options?: SvgPlayerOptions);
+    /** The loop length in ms. */
+    get duration(): number;
+    /** The time shown, in ms. */
+    get currentTime(): number;
+    get isPlaying(): boolean;
+    play(): void;
+    pause(): void;
+    /** Shows the picture at `ms` (wrapped into the loop when looping). */
+    seek(ms: number): void;
+    setSpeed(speed: number): void;
+    dispose(): void;
+    private run;
+}
+
+export { SvgMotion, SvgPlayer, type SvgPlayerOptions, type SvgView, type SvgViewOptions, parseSvg, svgDuration, svgView };

package/dist/vector/index.js

@@ -0,0 +1,39 @@
+import "../chunk-CFCLT2XL.js";
+import {
+  EASES,
+  STEP_MS,
+  SVG_PICTURE,
+  SvgPlayer,
+  defaultDataKey,
+  lerpAttr,
+  lerpData,
+  parseSvg,
+  stepData,
+  stepProgress,
+  stepStart,
+  svgDuration,
+  svgFrame,
+  svgMotionIssues,
+  svgOpeningTag,
+  svgView
+} from "../chunk-G5FNZDTA.js";
+import "../chunk-WMZQCUFJ.js";
+export {
+  EASES,
+  STEP_MS,
+  SVG_PICTURE,
+  SvgPlayer,
+  defaultDataKey,
+  lerpAttr,
+  lerpData,
+  parseSvg,
+  stepData,
+  stepProgress,
+  stepStart,
+  svgDuration,
+  svgFrame,
+  svgMotionIssues,
+  svgOpeningTag,
+  svgView
+};
+//# sourceMappingURL=index.js.map

package/dist/vector/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,96 @@
 {
   "name": "@pixerate/flair",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Web visual effects and motion graphics: WebGL2 shader effects, animated vector effects, a catalog of ready-made effects, and a UI-agnostic, agent-ready effect editor.",
+  "author": "Pixerate",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pixerate/flair.git"
+  },
+  "homepage": "https://pixerate.github.io/flair/",
+  "bugs": "https://github.com/Pixerate/flair/issues",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./catalog": {
+      "types": "./dist/catalog/index.d.ts",
+      "import": "./dist/catalog/index.js"
+    },
+    "./editor": {
+      "types": "./dist/editor/index.d.ts",
+      "import": "./dist/editor/index.js"
+    },
+    "./vector": {
+      "types": "./dist/vector/index.d.ts",
+      "import": "./dist/vector/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "flair": "dist/cli.js"
+  },
+  "keywords": [
+    "webgl2",
+    "shaders",
+    "shadertoy",
+    "motion-graphics",
+    "animation",
+    "svg",
+    "effects",
+    "generative",
+    "editor",
+    "ai-agents"
+  ],
+  "dependencies": {
+    "commander": "^12.0.0",
+    "gifenc": "^1.0.3"
+  },
+  "peerDependencies": {
+    "@pixerate/editor": ">=0.27.0 <1"
+  },
+  "peerDependenciesMeta": {
+    "@pixerate/editor": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.12",
+    "@pixerate/editor": "^0.27.0",
+    "@types/node": "^24.19.2",
+    "jsdom": "^30.1.3",
+    "tsup": "^8.5",
+    "typescript": "^5.9",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "pnpm --filter demo dev",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit && pnpm --filter demo typecheck",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "changeset publish"
+  }
 }