@akashjs/runtime 0.2.0 → 0.2.1

package/dist/machine.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunk5EFX654I_cjs=require('./chunk-5EFX654I.cjs');require('./chunk-V7VG23IO.cjs');Object.defineProperty(exports,"createMachine",{enumerable:true,get:function(){return chunk5EFX654I_cjs.a}});//# sourceMappingURL=machine.cjs.map
+'use strict';var chunkNVZLEJXB_cjs=require('./chunk-NVZLEJXB.cjs');require('./chunk-3AL2DVPZ.cjs');Object.defineProperty(exports,"createMachine",{enumerable:true,get:function(){return chunkNVZLEJXB_cjs.a}});//# sourceMappingURL=machine.cjs.map
 //# sourceMappingURL=machine.cjs.map

package/dist/machine.d.cts

@@ -0,0 +1,87 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.cjs';
+
+/**
+ * State machines for complex UI flows.
+ *
+ * Finite state machines with typed states, events, guards,
+ * actions, and reactive current state signal.
+ *
+ * ```ts
+ * const checkout = createMachine({
+ *   initial: 'cart',
+ *   states: {
+ *     cart: { on: { CHECKOUT: 'shipping' } },
+ *     shipping: { on: { NEXT: 'payment', BACK: 'cart' } },
+ *     payment: { on: { PAY: 'processing', BACK: 'shipping' } },
+ *     processing: { on: { SUCCESS: 'complete', FAIL: 'payment' } },
+ *     complete: { type: 'final' },
+ *   },
+ * });
+ *
+ * checkout.state();  // 'cart'
+ * checkout.send('CHECKOUT');
+ * checkout.state();  // 'shipping'
+ * checkout.matches('shipping'); // true
+ * ```
+ */
+
+interface MachineConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Initial state */
+    initial: TState;
+    /** Initial context data */
+    context?: TContext;
+    /** State definitions */
+    states: Record<TState, StateConfig<TState, TEvent, TContext>>;
+}
+interface StateConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Transitions: event → target state */
+    on?: Partial<Record<TEvent, TState | TransitionConfig<TState, TEvent, TContext>>>;
+    /** Entry action — runs when entering this state */
+    entry?: (ctx: MachineContext<TContext>) => void;
+    /** Exit action — runs when leaving this state */
+    exit?: (ctx: MachineContext<TContext>) => void;
+    /** Final state — machine stops accepting events */
+    type?: 'final';
+}
+interface TransitionConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Target state */
+    target: TState;
+    /** Guard — transition only if this returns true */
+    guard?: (ctx: MachineContext<TContext>) => boolean;
+    /** Action — runs during the transition */
+    action?: (ctx: MachineContext<TContext>) => void;
+}
+interface MachineContext<TContext> {
+    /** The context data (mutable) */
+    data: TContext;
+    /** The current event that triggered the transition */
+    event: string;
+    /** Optional payload passed with the event via send(event, payload) */
+    payload?: unknown;
+}
+interface Machine<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Current state (reactive signal) */
+    state: ReadonlySignal<TState>;
+    /** Context data (reactive signal) */
+    context: ReadonlySignal<TContext>;
+    /** Send an event to the machine */
+    send(event: TEvent, payload?: Record<string, unknown>): void;
+    /** Check if currently in a specific state */
+    matches(state: TState): boolean;
+    /** Whether the machine is in a final state */
+    done: ReadonlySignal<boolean>;
+    /** Reset to initial state */
+    reset(): void;
+    /** State history */
+    history: ReadonlySignal<TState[]>;
+    /** Can a specific event be sent in the current state? */
+    can(event: TEvent): boolean;
+    /** Get all possible events from current state */
+    nextEvents: ReadonlySignal<TEvent[]>;
+}
+/**
+ * Create a finite state machine.
+ */
+declare function createMachine<TState extends string, TEvent extends string, TContext = unknown>(config: MachineConfig<TState, TEvent, TContext>): Machine<TState, TEvent, TContext>;
+
+export { type Machine, type MachineConfig, type MachineContext, type StateConfig, type TransitionConfig, createMachine };

package/dist/machine.d.ts

@@ -0,0 +1,87 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.js';
+
+/**
+ * State machines for complex UI flows.
+ *
+ * Finite state machines with typed states, events, guards,
+ * actions, and reactive current state signal.
+ *
+ * ```ts
+ * const checkout = createMachine({
+ *   initial: 'cart',
+ *   states: {
+ *     cart: { on: { CHECKOUT: 'shipping' } },
+ *     shipping: { on: { NEXT: 'payment', BACK: 'cart' } },
+ *     payment: { on: { PAY: 'processing', BACK: 'shipping' } },
+ *     processing: { on: { SUCCESS: 'complete', FAIL: 'payment' } },
+ *     complete: { type: 'final' },
+ *   },
+ * });
+ *
+ * checkout.state();  // 'cart'
+ * checkout.send('CHECKOUT');
+ * checkout.state();  // 'shipping'
+ * checkout.matches('shipping'); // true
+ * ```
+ */
+
+interface MachineConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Initial state */
+    initial: TState;
+    /** Initial context data */
+    context?: TContext;
+    /** State definitions */
+    states: Record<TState, StateConfig<TState, TEvent, TContext>>;
+}
+interface StateConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Transitions: event → target state */
+    on?: Partial<Record<TEvent, TState | TransitionConfig<TState, TEvent, TContext>>>;
+    /** Entry action — runs when entering this state */
+    entry?: (ctx: MachineContext<TContext>) => void;
+    /** Exit action — runs when leaving this state */
+    exit?: (ctx: MachineContext<TContext>) => void;
+    /** Final state — machine stops accepting events */
+    type?: 'final';
+}
+interface TransitionConfig<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Target state */
+    target: TState;
+    /** Guard — transition only if this returns true */
+    guard?: (ctx: MachineContext<TContext>) => boolean;
+    /** Action — runs during the transition */
+    action?: (ctx: MachineContext<TContext>) => void;
+}
+interface MachineContext<TContext> {
+    /** The context data (mutable) */
+    data: TContext;
+    /** The current event that triggered the transition */
+    event: string;
+    /** Optional payload passed with the event via send(event, payload) */
+    payload?: unknown;
+}
+interface Machine<TState extends string, TEvent extends string, TContext = unknown> {
+    /** Current state (reactive signal) */
+    state: ReadonlySignal<TState>;
+    /** Context data (reactive signal) */
+    context: ReadonlySignal<TContext>;
+    /** Send an event to the machine */
+    send(event: TEvent, payload?: Record<string, unknown>): void;
+    /** Check if currently in a specific state */
+    matches(state: TState): boolean;
+    /** Whether the machine is in a final state */
+    done: ReadonlySignal<boolean>;
+    /** Reset to initial state */
+    reset(): void;
+    /** State history */
+    history: ReadonlySignal<TState[]>;
+    /** Can a specific event be sent in the current state? */
+    can(event: TEvent): boolean;
+    /** Get all possible events from current state */
+    nextEvents: ReadonlySignal<TEvent[]>;
+}
+/**
+ * Create a finite state machine.
+ */
+declare function createMachine<TState extends string, TEvent extends string, TContext = unknown>(config: MachineConfig<TState, TEvent, TContext>): Machine<TState, TEvent, TContext>;
+
+export { type Machine, type MachineConfig, type MachineContext, type StateConfig, type TransitionConfig, createMachine };

package/dist/machine.js

@@ -1,2 +1,2 @@
-export{a as createMachine}from'./chunk-SRPWGLOQ.js';import'./chunk-EUKRTV4W.js';//# sourceMappingURL=machine.js.map
+export{a as createMachine}from'./chunk-Z5LQV5ND.js';import'./chunk-POLTPHUA.js';//# sourceMappingURL=machine.js.map
 //# sourceMappingURL=machine.js.map

package/dist/offline.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunkR3W5W647_cjs=require('./chunk-R3W5W647.cjs');require('./chunk-V7VG23IO.cjs');Object.defineProperty(exports,"createOfflineStore",{enumerable:true,get:function(){return chunkR3W5W647_cjs.a}});//# sourceMappingURL=offline.cjs.map
+'use strict';var chunkH4SAK7A5_cjs=require('./chunk-H4SAK7A5.cjs');require('./chunk-3AL2DVPZ.cjs');Object.defineProperty(exports,"createOfflineStore",{enumerable:true,get:function(){return chunkH4SAK7A5_cjs.a}});//# sourceMappingURL=offline.cjs.map
 //# sourceMappingURL=offline.cjs.map

package/dist/offline.d.cts

@@ -0,0 +1,73 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.cjs';
+
+/**
+ * Offline-first store with IndexedDB persistence and background sync.
+ *
+ * Data persists across page reloads. Changes made offline queue up
+ * and sync automatically when connection returns. Conflict resolution
+ * via configurable strategies (last-write-wins, merge, custom).
+ *
+ * ```ts
+ * const todos = createOfflineStore('todos', {
+ *   sync: { url: '/api/todos', strategy: 'last-write-wins' },
+ * });
+ *
+ * todos.add({ id: '1', text: 'Buy milk', done: false });
+ * todos.items();    // reactive list
+ * todos.syncing();  // boolean
+ * todos.pending();  // number of unsynced changes
+ * ```
+ */
+
+type ConflictStrategy = 'last-write-wins' | 'client-wins' | 'server-wins' | 'manual';
+interface OfflineStoreOptions<T> {
+    /** Sync configuration */
+    sync?: {
+        /** Server URL for sync */
+        url: string;
+        /** Conflict resolution strategy (default: 'last-write-wins') */
+        strategy?: ConflictStrategy;
+        /** Sync interval in ms (default: 30000) */
+        interval?: number;
+        /** Custom fetch */
+        fetch?: typeof globalThis.fetch;
+        /** Auth headers */
+        headers?: Record<string, string>;
+    };
+    /** Key field for items (default: 'id') */
+    keyField?: string;
+    /** Version for schema migrations */
+    version?: number;
+}
+interface OfflineStore<T extends Record<string, unknown>> {
+    /** All items (reactive) */
+    items: ReadonlySignal<T[]>;
+    /** Get a single item by key */
+    get(key: string): T | undefined;
+    /** Add or update an item */
+    put(item: T): void;
+    /** Add a new item */
+    add(item: T): void;
+    /** Update an existing item */
+    update(key: string, partial: Partial<T>): void;
+    /** Remove an item by key */
+    remove(key: string): void;
+    /** Clear all items */
+    clear(): void;
+    /** Number of unsynced changes */
+    pending: ReadonlySignal<number>;
+    /** Whether sync is in progress */
+    syncing: ReadonlySignal<boolean>;
+    /** Whether online */
+    online: ReadonlySignal<boolean>;
+    /** Force a sync now */
+    sync(): Promise<void>;
+    /** Dispose the store (stop sync, close DB) */
+    dispose(): void;
+}
+/**
+ * Create an offline-first store backed by IndexedDB.
+ */
+declare function createOfflineStore<T extends Record<string, unknown>>(name: string, options?: OfflineStoreOptions<T>): OfflineStore<T>;
+
+export { type ConflictStrategy, type OfflineStore, type OfflineStoreOptions, createOfflineStore };

package/dist/offline.d.ts

@@ -0,0 +1,73 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.js';
+
+/**
+ * Offline-first store with IndexedDB persistence and background sync.
+ *
+ * Data persists across page reloads. Changes made offline queue up
+ * and sync automatically when connection returns. Conflict resolution
+ * via configurable strategies (last-write-wins, merge, custom).
+ *
+ * ```ts
+ * const todos = createOfflineStore('todos', {
+ *   sync: { url: '/api/todos', strategy: 'last-write-wins' },
+ * });
+ *
+ * todos.add({ id: '1', text: 'Buy milk', done: false });
+ * todos.items();    // reactive list
+ * todos.syncing();  // boolean
+ * todos.pending();  // number of unsynced changes
+ * ```
+ */
+
+type ConflictStrategy = 'last-write-wins' | 'client-wins' | 'server-wins' | 'manual';
+interface OfflineStoreOptions<T> {
+    /** Sync configuration */
+    sync?: {
+        /** Server URL for sync */
+        url: string;
+        /** Conflict resolution strategy (default: 'last-write-wins') */
+        strategy?: ConflictStrategy;
+        /** Sync interval in ms (default: 30000) */
+        interval?: number;
+        /** Custom fetch */
+        fetch?: typeof globalThis.fetch;
+        /** Auth headers */
+        headers?: Record<string, string>;
+    };
+    /** Key field for items (default: 'id') */
+    keyField?: string;
+    /** Version for schema migrations */
+    version?: number;
+}
+interface OfflineStore<T extends Record<string, unknown>> {
+    /** All items (reactive) */
+    items: ReadonlySignal<T[]>;
+    /** Get a single item by key */
+    get(key: string): T | undefined;
+    /** Add or update an item */
+    put(item: T): void;
+    /** Add a new item */
+    add(item: T): void;
+    /** Update an existing item */
+    update(key: string, partial: Partial<T>): void;
+    /** Remove an item by key */
+    remove(key: string): void;
+    /** Clear all items */
+    clear(): void;
+    /** Number of unsynced changes */
+    pending: ReadonlySignal<number>;
+    /** Whether sync is in progress */
+    syncing: ReadonlySignal<boolean>;
+    /** Whether online */
+    online: ReadonlySignal<boolean>;
+    /** Force a sync now */
+    sync(): Promise<void>;
+    /** Dispose the store (stop sync, close DB) */
+    dispose(): void;
+}
+/**
+ * Create an offline-first store backed by IndexedDB.
+ */
+declare function createOfflineStore<T extends Record<string, unknown>>(name: string, options?: OfflineStoreOptions<T>): OfflineStore<T>;
+
+export { type ConflictStrategy, type OfflineStore, type OfflineStoreOptions, createOfflineStore };

package/dist/offline.js

@@ -1,2 +1,2 @@
-export{a as createOfflineStore}from'./chunk-CGKMCVEZ.js';import'./chunk-EUKRTV4W.js';//# sourceMappingURL=offline.js.map
+export{a as createOfflineStore}from'./chunk-D6QQYZIC.js';import'./chunk-POLTPHUA.js';//# sourceMappingURL=offline.js.map
 //# sourceMappingURL=offline.js.map

package/dist/pwa.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunkCHF5LH56_cjs=require('./chunk-CHF5LH56.cjs');require('./chunk-V7VG23IO.cjs');Object.defineProperty(exports,"generateSWScript",{enumerable:true,get:function(){return chunkCHF5LH56_cjs.b}});Object.defineProperty(exports,"registerServiceWorker",{enumerable:true,get:function(){return chunkCHF5LH56_cjs.a}});Object.defineProperty(exports,"subscribePush",{enumerable:true,get:function(){return chunkCHF5LH56_cjs.c}});//# sourceMappingURL=pwa.cjs.map
+'use strict';var chunk6NX6JRSV_cjs=require('./chunk-6NX6JRSV.cjs');require('./chunk-3AL2DVPZ.cjs');Object.defineProperty(exports,"generateSWScript",{enumerable:true,get:function(){return chunk6NX6JRSV_cjs.b}});Object.defineProperty(exports,"registerServiceWorker",{enumerable:true,get:function(){return chunk6NX6JRSV_cjs.a}});Object.defineProperty(exports,"subscribePush",{enumerable:true,get:function(){return chunk6NX6JRSV_cjs.c}});//# sourceMappingURL=pwa.cjs.map
 //# sourceMappingURL=pwa.cjs.map

package/dist/pwa.d.cts

@@ -0,0 +1,80 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.cjs';
+
+/**
+ * PWA / Service Worker support.
+ *
+ * Register service workers, configure caching strategies,
+ * handle updates, and manage push notifications.
+ *
+ * ```ts
+ * const sw = registerServiceWorker('/sw.js', {
+ *   onUpdate: () => toast.info('New version available!'),
+ * });
+ * sw.ready;        // Promise<ServiceWorkerRegistration>
+ * sw.update();     // check for updates
+ * ```
+ */
+
+interface SWOptions {
+    /** Callback when a new version is available */
+    onUpdate?: (registration: ServiceWorkerRegistration) => void;
+    /** Callback when the SW is ready */
+    onReady?: (registration: ServiceWorkerRegistration) => void;
+    /** Callback on registration error */
+    onError?: (error: Error) => void;
+    /** Auto-reload on update (default: false) */
+    autoReload?: boolean;
+    /** Scope of the service worker */
+    scope?: string;
+}
+interface SWRegistration {
+    /** Whether the SW is registered */
+    registered: ReadonlySignal<boolean>;
+    /** Whether an update is available */
+    updateAvailable: ReadonlySignal<boolean>;
+    /** Whether the app is running offline */
+    offline: ReadonlySignal<boolean>;
+    /** The raw SW registration (available after ready) */
+    ready: Promise<ServiceWorkerRegistration>;
+    /** Check for updates */
+    update(): Promise<void>;
+    /** Skip waiting and activate new SW */
+    skipWaiting(): void;
+    /** Unregister the service worker */
+    unregister(): Promise<boolean>;
+}
+/**
+ * Register a service worker with update detection.
+ */
+declare function registerServiceWorker(swUrl: string, options?: SWOptions): SWRegistration;
+type CacheStrategy = 'cache-first' | 'network-first' | 'stale-while-revalidate' | 'network-only' | 'cache-only';
+interface CacheRoute {
+    /** URL pattern to match (string or regex) */
+    match: string | RegExp;
+    /** Caching strategy */
+    strategy: CacheStrategy;
+    /** Cache name */
+    cacheName?: string;
+    /** Max entries in cache */
+    maxEntries?: number;
+    /** Max age in seconds */
+    maxAgeSeconds?: number;
+}
+/**
+ * Generate a service worker script from cache route configs.
+ *
+ * ```ts
+ * const swScript = generateSWScript([
+ *   { match: /\.(?:js|css)$/, strategy: 'cache-first', cacheName: 'assets' },
+ *   { match: '/api/', strategy: 'network-first', maxAgeSeconds: 300 },
+ *   { match: /\.(?:png|jpg|svg)$/, strategy: 'cache-first', cacheName: 'images' },
+ * ]);
+ * ```
+ */
+declare function generateSWScript(routes: CacheRoute[]): string;
+/**
+ * Request push notification permission and subscribe.
+ */
+declare function subscribePush(registration: ServiceWorkerRegistration, vapidPublicKey: string): Promise<PushSubscription | null>;
+
+export { type CacheRoute, type CacheStrategy, type SWOptions, type SWRegistration, generateSWScript, registerServiceWorker, subscribePush };

package/dist/pwa.d.ts

@@ -0,0 +1,80 @@
+import { R as ReadonlySignal } from './signals-C7XfOHHR.js';
+
+/**
+ * PWA / Service Worker support.
+ *
+ * Register service workers, configure caching strategies,
+ * handle updates, and manage push notifications.
+ *
+ * ```ts
+ * const sw = registerServiceWorker('/sw.js', {
+ *   onUpdate: () => toast.info('New version available!'),
+ * });
+ * sw.ready;        // Promise<ServiceWorkerRegistration>
+ * sw.update();     // check for updates
+ * ```
+ */
+
+interface SWOptions {
+    /** Callback when a new version is available */
+    onUpdate?: (registration: ServiceWorkerRegistration) => void;
+    /** Callback when the SW is ready */
+    onReady?: (registration: ServiceWorkerRegistration) => void;
+    /** Callback on registration error */
+    onError?: (error: Error) => void;
+    /** Auto-reload on update (default: false) */
+    autoReload?: boolean;
+    /** Scope of the service worker */
+    scope?: string;
+}
+interface SWRegistration {
+    /** Whether the SW is registered */
+    registered: ReadonlySignal<boolean>;
+    /** Whether an update is available */
+    updateAvailable: ReadonlySignal<boolean>;
+    /** Whether the app is running offline */
+    offline: ReadonlySignal<boolean>;
+    /** The raw SW registration (available after ready) */
+    ready: Promise<ServiceWorkerRegistration>;
+    /** Check for updates */
+    update(): Promise<void>;
+    /** Skip waiting and activate new SW */
+    skipWaiting(): void;
+    /** Unregister the service worker */
+    unregister(): Promise<boolean>;
+}
+/**
+ * Register a service worker with update detection.
+ */
+declare function registerServiceWorker(swUrl: string, options?: SWOptions): SWRegistration;
+type CacheStrategy = 'cache-first' | 'network-first' | 'stale-while-revalidate' | 'network-only' | 'cache-only';
+interface CacheRoute {
+    /** URL pattern to match (string or regex) */
+    match: string | RegExp;
+    /** Caching strategy */
+    strategy: CacheStrategy;
+    /** Cache name */
+    cacheName?: string;
+    /** Max entries in cache */
+    maxEntries?: number;
+    /** Max age in seconds */
+    maxAgeSeconds?: number;
+}
+/**
+ * Generate a service worker script from cache route configs.
+ *
+ * ```ts
+ * const swScript = generateSWScript([
+ *   { match: /\.(?:js|css)$/, strategy: 'cache-first', cacheName: 'assets' },
+ *   { match: '/api/', strategy: 'network-first', maxAgeSeconds: 300 },
+ *   { match: /\.(?:png|jpg|svg)$/, strategy: 'cache-first', cacheName: 'images' },
+ * ]);
+ * ```
+ */
+declare function generateSWScript(routes: CacheRoute[]): string;
+/**
+ * Request push notification permission and subscribe.
+ */
+declare function subscribePush(registration: ServiceWorkerRegistration, vapidPublicKey: string): Promise<PushSubscription | null>;
+
+export { type CacheRoute, type CacheStrategy, type SWOptions, type SWRegistration, generateSWScript, registerServiceWorker, subscribePush };

package/dist/pwa.js

@@ -1,2 +1,2 @@
-export{b as generateSWScript,a as registerServiceWorker,c as subscribePush}from'./chunk-VFOAULHK.js';import'./chunk-EUKRTV4W.js';//# sourceMappingURL=pwa.js.map
+export{b as generateSWScript,a as registerServiceWorker,c as subscribePush}from'./chunk-IM2VW4TK.js';import'./chunk-POLTPHUA.js';//# sourceMappingURL=pwa.js.map
 //# sourceMappingURL=pwa.js.map

package/dist/signals-C7XfOHHR.d.cts

@@ -0,0 +1,55 @@
+/**
+ * Fine-grained reactivity system.
+ *
+ * Inspired by SolidJS/Preact Signals. Provides signal(), computed(),
+ * effect(), and untrack() primitives with automatic dependency tracking
+ * and glitch-free diamond dependency resolution.
+ */
+interface Signal<T> {
+    /** Read the current value (tracks dependency if inside a reactive scope) */
+    (): T;
+    /** Set a new value */
+    set(value: T): void;
+    /** Update the value using the previous value */
+    update(fn: (prev: T) => T): void;
+    /** Read without tracking (no dependency registered) */
+    peek(): T;
+}
+type ReadonlySignal<T> = () => T;
+declare function signal<T>(initialValue: T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): Signal<T>;
+declare function computed<T>(fn: () => T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): ReadonlySignal<T>;
+declare function effect(fn: () => void | (() => void), options?: {
+    render?: boolean;
+}): () => void;
+/** Execute a function without tracking any signal reads */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Create an effect callback that only tracks specific signals.
+ * All other signal reads inside the callback are untracked.
+ *
+ * ```ts
+ * effect(on(url, (currentUrl, prevUrl) => {
+ *   fetch(currentUrl, options()); // options() not tracked
+ * }));
+ *
+ * effect(on([url, page], ([u, p], prev) => {
+ *   fetch(`${u}?page=${p}`);
+ * }));
+ * ```
+ */
+declare function on<T>(dep: () => T, fn: (value: T, prev: T | undefined) => void | (() => void), options?: {
+    defer?: boolean;
+}): () => void | (() => void);
+declare function on<T extends readonly (() => unknown)[]>(deps: [...T], fn: (values: {
+    [K in keyof T]: ReturnType<T[K]>;
+}, prev: {
+    [K in keyof T]: ReturnType<T[K]>;
+} | undefined) => void | (() => void), options?: {
+    defer?: boolean;
+}): () => void | (() => void);
+
+export { type ReadonlySignal as R, type Signal as S, computed as c, effect as e, on as o, signal as s, untrack as u };

package/dist/signals-C7XfOHHR.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Fine-grained reactivity system.
+ *
+ * Inspired by SolidJS/Preact Signals. Provides signal(), computed(),
+ * effect(), and untrack() primitives with automatic dependency tracking
+ * and glitch-free diamond dependency resolution.
+ */
+interface Signal<T> {
+    /** Read the current value (tracks dependency if inside a reactive scope) */
+    (): T;
+    /** Set a new value */
+    set(value: T): void;
+    /** Update the value using the previous value */
+    update(fn: (prev: T) => T): void;
+    /** Read without tracking (no dependency registered) */
+    peek(): T;
+}
+type ReadonlySignal<T> = () => T;
+declare function signal<T>(initialValue: T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): Signal<T>;
+declare function computed<T>(fn: () => T, options?: {
+    equals?: (a: T, b: T) => boolean;
+}): ReadonlySignal<T>;
+declare function effect(fn: () => void | (() => void), options?: {
+    render?: boolean;
+}): () => void;
+/** Execute a function without tracking any signal reads */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Create an effect callback that only tracks specific signals.
+ * All other signal reads inside the callback are untracked.
+ *
+ * ```ts
+ * effect(on(url, (currentUrl, prevUrl) => {
+ *   fetch(currentUrl, options()); // options() not tracked
+ * }));
+ *
+ * effect(on([url, page], ([u, p], prev) => {
+ *   fetch(`${u}?page=${p}`);
+ * }));
+ * ```
+ */
+declare function on<T>(dep: () => T, fn: (value: T, prev: T | undefined) => void | (() => void), options?: {
+    defer?: boolean;
+}): () => void | (() => void);
+declare function on<T extends readonly (() => unknown)[]>(deps: [...T], fn: (values: {
+    [K in keyof T]: ReturnType<T[K]>;
+}, prev: {
+    [K in keyof T]: ReturnType<T[K]>;
+} | undefined) => void | (() => void), options?: {
+    defer?: boolean;
+}): () => void | (() => void);
+
+export { type ReadonlySignal as R, type Signal as S, computed as c, effect as e, on as o, signal as s, untrack as u };

package/dist/ssr.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunkUOD4PYAN_cjs=require('./chunk-UOD4PYAN.cjs');require('./chunk-V7VG23IO.cjs');Object.defineProperty(exports,"escapeHtml",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.a}});Object.defineProperty(exports,"isServerRendering",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.b}});Object.defineProperty(exports,"nodeToHtml",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.i}});Object.defineProperty(exports,"renderNodes",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.j}});Object.defineProperty(exports,"renderToStream",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.e}});Object.defineProperty(exports,"renderToString",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.c}});Object.defineProperty(exports,"renderToStringSync",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.d}});Object.defineProperty(exports,"ssrElement",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.f}});Object.defineProperty(exports,"ssrRaw",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.h}});Object.defineProperty(exports,"ssrText",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.g}});//# sourceMappingURL=ssr.cjs.map
+'use strict';var chunkUOD4PYAN_cjs=require('./chunk-UOD4PYAN.cjs');require('./chunk-3AL2DVPZ.cjs');Object.defineProperty(exports,"escapeHtml",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.a}});Object.defineProperty(exports,"isServerRendering",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.b}});Object.defineProperty(exports,"nodeToHtml",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.i}});Object.defineProperty(exports,"renderNodes",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.j}});Object.defineProperty(exports,"renderToStream",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.e}});Object.defineProperty(exports,"renderToString",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.c}});Object.defineProperty(exports,"renderToStringSync",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.d}});Object.defineProperty(exports,"ssrElement",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.f}});Object.defineProperty(exports,"ssrRaw",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.h}});Object.defineProperty(exports,"ssrText",{enumerable:true,get:function(){return chunkUOD4PYAN_cjs.g}});//# sourceMappingURL=ssr.cjs.map
 //# sourceMappingURL=ssr.cjs.map