ctrl-fx 0.1.0 → 0.1.2

package/dist/effects.d.ts

@@ -1,580 +1,2 @@
-import type { ClipboardError } from './clipboard';
-import type { ScrollElementError } from './scroll';
-import type { DbEffect } from './db/effects';
-import type { DbSetupEffect } from './db/setup';
-import type { DbError } from './db/errors';
-import type { DbName, DbVersion, ObjectStore } from './db/index';
-import { type HttpError, type HttpRequest, type HttpResponse, type RequestError } from './net';
-import { type InternalLocation } from './net/location';
-import { type Lens } from './utils/lens';
-import { type Result } from './utils/result';
-import type { Permission, Uuid } from '.';
-export type { ClipboardError } from './clipboard';
-export type { ScrollElementError } from './scroll';
-export type { DbEffect } from './db/effects';
-export type { DbSetupEffect } from './db/setup';
-export type { DbError, UnexpectedError, NotFoundError, ConstraintError, } from './db/errors';
-export type { DbName, DbVersion, ObjectStore } from './db/index';
-export type { HttpError, HttpRequest, HttpResponse, RequestError, Json, DecodingError, Method, Headers, ResponseBody, } from './net';
-export type { InternalLocation } from './net/location';
-export type { Path } from './net/path';
-export type { QueryParam } from './net/queryparam';
-export type { Fragment } from './net/fragment';
-export type { Lens } from './utils/lens';
-export type { Result } from './utils/result';
-type Alert = {
-    _type: 'Alert';
-    input: any;
-};
-type Async<State, Event> = {
-    _type: 'Async';
-    input: {
-        effect: Effect<State, Event, void>;
-        delayInMillis: number;
-    };
-};
-type CancelTask = {
-    _type: 'CancelTask';
-    input: TaskId;
-};
-type ClearAppBadge = {
-    _type: 'ClearAppBadge';
-    input: void;
-};
-type ReadClipboard = {
-    _type: 'ReadClipboard';
-    input: void;
-};
-type WriteClipboard = {
-    _type: 'WriteClipboard';
-    input: string;
-};
-type SetAppBadge = {
-    _type: 'SetAppBadge';
-    input: number;
-};
-type SetDocumentTitle = {
-    _type: 'SetDocumentTitle';
-    input: string;
-};
-type Confirm = {
-    _type: 'Confirm';
-    input: string;
-};
-type FireEvent<Event> = {
-    _type: 'FireEvent';
-    input: Event;
-};
-type GenerateUuid = {
-    _type: 'GenerateUuid';
-    input: void;
-};
-type GetNotificationPermission = {
-    _type: 'GetNotificationPermission';
-    input: void;
-};
-type RequestNotificationPermission = {
-    _type: 'RequestNotificationPermission';
-    input: void;
-};
-type GetLocation = {
-    _type: 'GetLocation';
-    input: void;
-};
-type GetState = {
-    _type: 'GetState';
-    input: void;
-};
-type GetTime = {
-    _type: 'GetTime';
-    input: void;
-};
-type GetRandom = {
-    _type: 'GetRandom';
-    input: void;
-};
-type Prompt = {
-    _type: 'Prompt';
-    input: {
-        message: string;
-        default: string | undefined;
-    };
-};
-type Log = {
-    _type: 'Log';
-    input: any;
-};
-type MakeHttpRequest = {
-    _type: 'MakeHttpRequest';
-    input: HttpRequest;
-};
-type OpenDatabase = {
-    _type: 'OpenDatabase';
-    input: {
-        db: DbName;
-        version: DbVersion;
-        setup: (oldVersion: DbVersion) => DbSetupEffect<void>;
-    };
-};
-type RunDbTransaction = {
-    _type: 'RunDbTransaction';
-    input: {
-        db: DbName;
-        objectStores: readonly ObjectStore[];
-        mode: 'readonly' | 'readwrite';
-        effect: DbEffect<void>;
-    };
-};
-type Product<State, Event, A, B> = {
-    _type: 'Product';
-    input: [Effect<State, Event, A>, Effect<State, Event, B>];
-};
-/** A branded string that uniquely identifies a scheduled task. */
-export type TaskId = string & {
-    __brand: 'TaskId';
-};
-/** Creates a typed TaskId from a plain string. */
-export declare function taskId(id: string): TaskId;
-type ScheduleTask<State, Event> = {
-    _type: 'ScheduleTask';
-    input: {
-        task: Effect<State, Event, void>;
-        initialDelayInMillis: number;
-        repeatIntervalInMillis: number | undefined;
-        taskId: TaskId | undefined;
-    };
-};
-type SetTimeout = {
-    _type: 'SetTimeout';
-    input: number;
-};
-type UpdateState<State> = {
-    _type: 'UpdateState';
-    input: (state: State) => State;
-};
-export type StorageTarget = 'local' | 'session';
-type GetStorageItem = {
-    _type: 'GetStorageItem';
-    input: {
-        storage: StorageTarget;
-        key: string;
-    };
-};
-type Go = {
-    _type: 'Go';
-    input: number;
-};
-type PushState = {
-    _type: 'PushState';
-    input: InternalLocation;
-};
-type ReplaceState = {
-    _type: 'ReplaceState';
-    input: InternalLocation;
-};
-type SetStorageItem = {
-    _type: 'SetStorageItem';
-    input: {
-        storage: StorageTarget;
-        key: string;
-        value: string;
-    };
-};
-type RemoveStorageItem = {
-    _type: 'RemoveStorageItem';
-    input: {
-        storage: StorageTarget;
-        key: string;
-    };
-};
-type ClearStorage = {
-    _type: 'ClearStorage';
-    input: {
-        storage: StorageTarget;
-    };
-};
-export type ScrollOptions = {
-    top?: number;
-    left?: number;
-    behavior?: 'smooth' | 'instant' | 'auto';
-};
-type ScrollWindow = {
-    _type: 'ScrollWindow';
-    input: ScrollOptions;
-};
-type ScrollElement = {
-    _type: 'ScrollElement';
-    input: {
-        selector: string;
-        options: ScrollOptions;
-    };
-};
-export type DownloadInput = {
-    filename: string;
-    content: string;
-    contentType: string;
-};
-type Download = {
-    _type: 'Download';
-    input: DownloadInput;
-};
-type PostBroadcastMessage = {
-    _type: 'PostBroadcastMessage';
-    input: {
-        channel: string;
-        message: unknown;
-    };
-};
-type SubscribeToBroadcastChannel<State, Event> = {
-    _type: 'SubscribeToBroadcastChannel';
-    input: {
-        channel: string;
-        handler: (message: unknown) => Effect<State, Event, void>;
-        taskId: TaskId | undefined;
-    };
-};
-type CustomEffect<In, Out, Custom> = {
-    _type: 'CustomEffect';
-    input: {
-        args: In;
-        f: (args: In) => Out | Promise<Out>;
-        test: (args: In, data: Custom) => {
-            out: Out;
-            data: Custom;
-        };
-    };
-};
-/**
- * Creates a factory for effects that call an external library function.
- * Use this when you want to call a library whose logic would be too cumbersome
- * to reimplement using built-in effects. In production `f` is called directly.
- * In tests the `test` callback receives the arguments and a queue of scripted
- * return values (`data`), and must return `{ out, data }` where `data` is the
- * remaining queue after consuming one entry.
- *
- * @param f Production implementation. May return a Promise.
- * @param test Test-time implementation. Receives the scripted data queue and
- *   returns `{ out, data }` — `out` is the value to return, `data` is the
- *   remaining queue. Provide scripted values via `newTestData(queue)`.
- */
-export declare function customEffect<State, Event, In, Out, Custom>(f: (args: In) => Out | Promise<Out>, test: (args: In, data: Custom) => {
-    out: Out;
-    data: Custom;
-}): (args: In) => Effect<State, Event, Out>;
-type Operation<State, Event> = Alert | Async<State, Event> | CancelTask | ClearAppBadge | ClearStorage | Confirm | CustomEffect<unknown, unknown, unknown> | Download | FireEvent<Event> | GetLocation | GetNotificationPermission | RequestNotificationPermission | PostBroadcastMessage | ReadClipboard | WriteClipboard | GenerateUuid | GetState | GetStorageItem | GetTime | GetRandom | Log | MakeHttpRequest | Go | OpenDatabase | Product<State, Event, unknown, unknown> | Prompt | PushState | ReplaceState | RemoveStorageItem | RunDbTransaction | ScheduleTask<State, Event> | ScrollElement | ScrollWindow | SetAppBadge | SetDocumentTitle | SetStorageItem | SetTimeout | SubscribeToBroadcastChannel<State, Event> | UpdateState<State>;
-export type Suspend<State, Event, A> = {
-    _type: 'Suspend';
-    operation: Operation<State, Event>;
-    /**
-     * Sequences this effect with another, passing its result to `f` to produce
-     * the next effect. Use this when the second effect depends on the value
-     * produced by the first. For independent sequencing use `and`.
-     */
-    flatMap<B>(f: (a: A) => Effect<State, Event, B>): Effect<State, Event, B>;
-    /**
-     * Sequences this effect and `effect`, discarding this effect's result. Use
-     * this when you want both effects to run but the first result is not needed.
-     * For result-dependent sequencing use `flatMap`.
-     */
-    and<B>(effect: Effect<State, Event, B>): Effect<State, Event, B>;
-    /** Transforms the result of this effect with `f`, without performing any additional effects. */
-    map<B>(f: (a: A) => B): Effect<State, Event, B>;
-    /** Replaces the result of this effect with `b`, discarding the original result. */
-    as<B>(b: B): Effect<State, Event, B>;
-    /** Discards the result, producing `Effect<State, Event, void>`. */
-    void(): Effect<State, Event, void>;
-    /** Passes this effect to `f` and returns the result. Useful for applying a function that takes an effect without breaking a method chain. */
-    apply<B>(f: (effect: Effect<State, Event, A>) => B): B;
-};
-export type Return<State, Event, A> = {
-    _type: 'Return';
-    value: A;
-    /** @inheritDoc Suspend.flatMap */
-    flatMap<B>(f: (a: A) => Effect<State, Event, B>): Effect<State, Event, B>;
-    /** @inheritDoc Suspend.and */
-    and<B>(effect: Effect<State, Event, B>): Effect<State, Event, B>;
-    /** @inheritDoc Suspend.map */
-    map<B>(f: (a: A) => B): Effect<State, Event, B>;
-    /** @inheritDoc Suspend.as */
-    as<B>(b: B): Effect<State, Event, B>;
-    /** @inheritDoc Suspend.void */
-    void(): Effect<State, Event, void>;
-    /** @inheritDoc Suspend.apply */
-    apply<B>(f: (effect: Effect<State, Event, A>) => B): B;
-};
-export type FlatMap<State, Event, A, B> = {
-    _type: 'FlatMap';
-    effect: Effect<State, Event, A>;
-    next: (a: A) => Effect<State, Event, B>;
-    /** @inheritDoc Suspend.flatMap */
-    flatMap<C>(f: (b: B) => Effect<State, Event, C>): Effect<State, Event, C>;
-    /** @inheritDoc Suspend.and */
-    and<C>(effect: Effect<State, Event, C>): Effect<State, Event, C>;
-    /** @inheritDoc Suspend.map */
-    map<C>(f: (b: B) => C): Effect<State, Event, C>;
-    /** @inheritDoc Suspend.as */
-    as<C>(c: C): Effect<State, Event, C>;
-    /** @inheritDoc Suspend.void */
-    void(): Effect<State, Event, void>;
-    /** @inheritDoc Suspend.apply */
-    apply<C>(f: (effect: Effect<State, Event, B>) => C): C;
-};
-/**
- * A lazy, pure description of a side effect to be performed by the framework.
- * An Effect is just a data structure — it does nothing until the framework
- * interprets it. This means effects can be composed, transformed, and tested
- * without executing any real side effects.
- *
- * `State` is the application state type the effect can read and update.
- * `Event` is the component event type the effect can fire.
- * `A` is the value the effect produces when it completes.
- */
-export type Effect<State, Event, A> = Suspend<State, Event, A> | Return<State, Event, A> | FlatMap<State, Event, any, A>;
-/**
- * Wraps a plain value in an Effect that completes immediately without performing any operations.
- * Useful as a base case when building effects conditionally, or to lift a
- * computed value into the Effect chain.
- */
-export declare function pure<State, Event, A>(value: A): Effect<State, Event, A>;
-/** An effect describing a browser alert dialog. */
-export declare function alert<State, Event>(message: any): Effect<State, Event, void>;
-/**
- * An effect describing a browser confirm dialog.
- * @returns true if confirmed
- */
-export declare function confirm<State, Event>(message: string): Effect<State, Event, boolean>;
-/**
- * An effect describing a browser prompt dialog.
- * @returns the entered string, or null if cancelled
- */
-export declare function prompt<State, Event>(message: string, defaultValue?: string): Effect<State, Event, string | null>;
-/** An effect describing a clear of the app badge on the browser/OS icon. */
-export declare function clearAppBadge<State, Event>(): Effect<State, Event, void>;
-/** An effect describing a clipboard text read. */
-export declare function readClipboard<State, Event>(): Effect<State, Event, Result<string, ClipboardError>>;
-/** An effect describing a clipboard write of `text`. */
-export declare function writeClipboard<State, Event>(text: string): Effect<State, Event, Result<void, ClipboardError>>;
-/** An effect describing a `document.title` update. */
-export declare function setDocumentTitle<State, Event>(title: string): Effect<State, Event, void>;
-/** An effect describing an app badge count update on the browser/OS icon. */
-export declare function setAppBadge<State, Event>(count: number): Effect<State, Event, void>;
-/**
- * An effect describing fire-and-forget async dispatch of `effect`.
- * The chain continues without waiting for `effect` to complete.
- * Use `scheduleTask` instead if you need cancellation or debounce/repeat behaviour.
- */
-export declare function async<State, Event>(effect: Effect<State, Event, void>, delayInMillis?: number): Effect<State, Event, void>;
-/** An effect describing the cancellation of a previously scheduled task. */
-export declare function cancelTask<State, Event>(taskId: TaskId): Effect<State, Event, void>;
-/**
- * An effect describing a typed component event to be delivered to any `onEvent` listener
- * registered by the parent that mounted this component. Has no effect when
- * used in a top-level application (which has no parent).
- */
-export declare function fireEvent<State, Event>(event: Event): Effect<State, Event, void>;
-/** An effect describing a UUID v4 generation. */
-export declare function generateUuid<State, Event>(): Effect<State, Event, Uuid>;
-/** An effect describing a read of the current time. */
-export declare function getTime<State, Event>(): Effect<State, Event, Date>;
-/** An effect describing a random number in [0, 1), equivalent to Math.random(). */
-export declare function getRandom<State, Event>(): Effect<State, Event, number>;
-/** An effect describing a console log of `message`. */
-export declare function log<State, Event>(message: any): Effect<State, Event, void>;
-/** An effect describing an HTTP request. */
-export declare function makeHttpRequest<State, Event>(request: HttpRequest): Effect<State, Event, Result<HttpResponse, RequestError | HttpError>>;
-/** An effect describing a read of the current browser location. */
-export declare function getLocation<State, Event>(): Effect<State, Event, InternalLocation>;
-/** An effect describing a read of the current notification permission state. */
-export declare function getNotificationPermission<State, Event>(): Effect<State, Event, Permission>;
-/** An effect describing a notification permission request. */
-export declare function requestNotificationPermission<State, Event>(): Effect<State, Event, Permission>;
-/**
- * An effect describing a read of the current application state. Because state updates are
- * themselves effects sequenced in order, the value produced reflects all
- * `updateState` effects that appear earlier in the same effect chain.
- */
-export declare function getState<State, Event>(): Effect<State, Event, State>;
-/**
- * An effect describing two concurrent sub-effects, returning both results as a tuple `[A, B]`.
- * Both effects share the same initial state snapshot; neither sees state
- * changes made by the other. Use `flatMap` instead when the second effect
- * must observe state updates from the first.
- */
-export declare function product<State, Event, A, B>(effectA: Effect<State, Event, A>, effectB: Effect<State, Event, B>): Effect<State, Event, [A, B]>;
-/**
- * An effect describing the scheduling of `task` to run after `initialDelayInMillis` milliseconds.
- *
- * If `taskId` is provided and a task with that id is already pending, the
- * pending task is cancelled and replaced. This makes `scheduleTask` the
- * idiomatic way to implement debouncing: use the same `taskId` on
- * every keystroke and only the final one will fire.
- *
- * @param repeatIntervalInMillis If provided, the task repeats on this interval
- *   indefinitely after the initial delay. Cancel with `cancelTask`.
- * @param taskId Stable identifier used to cancel-and-reschedule. Create one
- *   with `taskId('name')` and store it as a module-level constant.
- * @returns The TaskId of the newly scheduled task.
- */
-export declare function scheduleTask<State, Event>(task: Effect<State, Event, void>, initialDelayInMillis: number, repeatIntervalInMillis: number | undefined, taskId: TaskId | undefined): Effect<State, Event, TaskId>;
-/** An effect describing a delay of `delayInMilliseconds` ms before continuing the chain. */
-export declare function setTimeout<State, Event>(delayInMilliseconds: number): Effect<State, Event, void>;
-/** An effect describing a state update via `f`. */
-export declare function updateState<State, Event>(f: (state: State) => State): Effect<State, Event, void>;
-/** An effect describing an IndexedDB database open (or create), with `setup` applied for schema migrations. */
-export declare function openDatabase<State, Event>(db: DbName, version: DbVersion, setup: (oldVersion: DbVersion) => DbSetupEffect<void>): Effect<State, Event, Result<void, DbError>>;
-/** An effect describing an IndexedDB transaction containing `effect`. */
-export declare function runDbTransaction<State, Event>(db: DbName, objectStores: readonly ObjectStore[], mode: 'readonly' | 'readwrite', effect: DbEffect<void>): Effect<State, Event, Result<void, DbError>>;
-/** An effect describing a browser history navigation of `delta` steps. */
-export declare function go<State, Event>(delta: number): Effect<State, Event, void>;
-/** An effect describing a `history.pushState` to `location`. */
-export declare function pushState<State, Event>(location: InternalLocation | string): Effect<State, Event, void>;
-/** An effect describing a `history.replaceState` with `location`. */
-export declare function replaceState<State, Event>(location: InternalLocation | string): Effect<State, Event, void>;
-/** An effect describing a localStorage read for `key`. */
-export declare function getLocalStorageItem<State, Event>(key: string): Effect<State, Event, string | null>;
-/** An effect describing a localStorage write of `value` for `key`. */
-export declare function setLocalStorageItem<State, Event>(key: string, value: string): Effect<State, Event, void>;
-/** An effect describing the removal of `key` from localStorage. */
-export declare function removeLocalStorageItem<State, Event>(key: string): Effect<State, Event, void>;
-/** An effect describing a localStorage clear. */
-export declare function clearLocalStorage<State, Event>(): Effect<State, Event, void>;
-/** An effect describing a sessionStorage read for `key`. */
-export declare function getSessionStorageItem<State, Event>(key: string): Effect<State, Event, string | null>;
-/** An effect describing a sessionStorage write of `value` for `key`. */
-export declare function setSessionStorageItem<State, Event>(key: string, value: string): Effect<State, Event, void>;
-/** An effect describing the removal of `key` from sessionStorage. */
-export declare function removeSessionStorageItem<State, Event>(key: string): Effect<State, Event, void>;
-/** An effect describing a sessionStorage clear. */
-export declare function clearSessionStorage<State, Event>(): Effect<State, Event, void>;
-/**
- * Transforms the `Event` type of an effect by mapping each fired event through `f`.
- * Used when composing components: a child component fires `EventA`, and the
- * parent needs to convert those into its own `EventB` before wiring them up.
- * You rarely need to call this directly — `ComponentElement.onEvent` handles it.
- */
-export declare function mapEvent<State, EventA, EventB, R>(effect: Effect<State, EventA, R>, f: (eventA: EventA) => EventB): Effect<State, EventB, R>;
-/**
- * Adapts an effect written against a sub-state `StateA` so it can run in a
- * parent context with state `StateB`. The lens provides the `get`/`set`
- * functions that translate between the two state shapes.
- * Used when composing components whose effects operate on a slice of a larger state.
- */
-export declare function mapState<StateA, StateB, Event, R>(effect: Effect<StateA, Event, R>, lens: Lens<StateB, StateA>): Effect<StateB, Event, R>;
-/** Returns true if `value` is an Effect. */
-export declare function isEffect(value: any): value is Effect<any, any, any>;
-/** An effect describing a window scroll. */
-export declare function scrollWindow<State, Event>(options: ScrollOptions): Effect<State, Event, void>;
-/** An effect describing a scroll of the element matching `selector`. */
-export declare function scrollElement<State, Event>(selector: string, options: ScrollOptions): Effect<State, Event, Result<void, ScrollElementError>>;
-/** An effect describing a file download. */
-export declare function download<State, Event>(filename: string, content: string, contentType?: string): Effect<State, Event, void>;
-/** An effect describing a BroadcastChannel message post. */
-export declare function postBroadcastMessage<State, Event>(channel: string, message: unknown): Effect<State, Event, void>;
-/**
- * An effect describing a BroadcastChannel subscription, with `handler` called for each message received.
- * @returns a TaskId that can be used to cancel the subscription
- */
-export declare function subscribeToBroadcastChannel<State, Event>(channel: string, handler: (message: unknown) => Effect<State, Event, void>, taskId?: TaskId | undefined): Effect<State, Event, TaskId>;
-/** An Effect that does nothing. */
-export declare function noop<State, Event>(): Effect<State, Event, void>;
-/**
- * Returns all built-in effect constructors with `State` and `Event` pre-applied.
- * Call this once per module, passing your application's state and event types,
- * and destructure the effects you need. This removes the need to repeat the
- * type parameters at every call site.
- *
- * ```ts
- * const { updateState, getTime, scheduleTask } = makeEffects<MyState, MyEvent>()
- * ```
- */
-export declare function makeEffects<State, Event>(): {
-    alert: (message: any) => Effect<State, Event, void>;
-    confirm: (message: string) => Effect<State, Event, boolean>;
-    prompt: (message: string, defaultValue?: string) => Effect<State, Event, string | null>;
-    cancelTask: (taskId: TaskId) => Effect<State, Event, void>;
-    getLocation: () => Effect<State, Event, InternalLocation>;
-    getNotificationPermission: () => Effect<State, Event, Permission>;
-    requestNotificationPermission: () => Effect<State, Event, Permission>;
-    clearAppBadge: () => Effect<State, Event, void>;
-    readClipboard: () => Effect<State, Event, Result<string, ClipboardError>>;
-    setAppBadge: (count: number) => Effect<State, Event, void>;
-    setDocumentTitle: (title: string) => Effect<State, Event, void>;
-    writeClipboard: (text: string) => Effect<State, Event, Result<void, ClipboardError>>;
-    fireEvent: (event: Event) => Effect<State, Event, void>;
-    getState: () => Effect<State, Event, State>;
-    getTime: () => Effect<State, Event, Date>;
-    getRandom: () => Effect<State, Event, number>;
-    log: (message: any) => Effect<State, Event, void>;
-    makeHttpRequest: (request: HttpRequest) => Effect<State, Event, Result<HttpResponse, HttpError | RequestError>>;
-    scheduleTask: (task: Effect<State, Event, void>, initialDelayInMillis: number, repeatIntervalInMillis: number | undefined, taskId: TaskId | undefined) => Effect<State, Event, TaskId>;
-    setTimeout: (delayInMilliseconds: number) => Effect<State, Event, void>;
-    updateState: (f: (state: State) => State) => Effect<State, Event, void>;
-    pure<A>(a: A): Effect<State, Event, A>;
-    noop: () => Effect<State, Event, void>;
-    generateUuid: () => Effect<State, Event, Uuid>;
-    getJson: (uri: string) => Effect<State, Event, Result<import("./net").Json, HttpError | RequestError | import("./net").DecodingError>>;
-    go: (delta: number) => Effect<State, Event, void>;
-    scrollWindow: (options: ScrollOptions) => Effect<State, Event, void>;
-    scrollElement: (selector: string, options: ScrollOptions) => Effect<State, Event, Result<void, ScrollElementError>>;
-    download: (filename: string, content: string, contentType?: string) => Effect<State, Event, void>;
-    postBroadcastMessage: (channel: string, message: unknown) => Effect<State, Event, void>;
-    subscribeToBroadcastChannel: (channel: string, handler: (message: unknown) => Effect<State, Event, void>, taskId?: TaskId | undefined) => Effect<State, Event, TaskId>;
-    pushState: (location: InternalLocation | string) => Effect<State, Event, void>;
-    replaceState: (location: InternalLocation | string) => Effect<State, Event, void>;
-    getLocalStorageItem: (key: string) => Effect<State, Event, string | null>;
-    setLocalStorageItem: (key: string, value: string) => Effect<State, Event, void>;
-    removeLocalStorageItem: (key: string) => Effect<State, Event, void>;
-    clearLocalStorage: () => Effect<State, Event, void>;
-    getSessionStorageItem: (key: string) => Effect<State, Event, string | null>;
-    setSessionStorageItem: (key: string, value: string) => Effect<State, Event, void>;
-    removeSessionStorageItem: (key: string) => Effect<State, Event, void>;
-    clearSessionStorage: () => Effect<State, Event, void>;
-    resultT<A, E>(effect: Effect<State, Event, Result<A, E>>): ResultTransformer<State, Event, A, E>;
-};
-/**
- * Maps each element of `as` to an effect and runs them in sequence, collecting
- * all results into an array. Each effect runs after the previous one completes,
- * so state changes from earlier effects are visible to later ones.
- */
-export declare function traverse<State, Event, A, B>(as: readonly A[], f: (a: A) => Effect<State, Event, B>): Effect<State, Event, readonly B[]>;
-/**
- * Wraps an `Effect<State, Event, Result<A, E>>` to allow chaining on the
- * success and error branches without manually unwrapping the `Result` at each
- * step. Methods like `flatMap` and `errorFlatMap` short-circuit on the other
- * branch. Call `.value` to get the underlying effect back.
- */
-export declare class ResultTransformer<State, Event, A, E> {
-    /** The underlying wrapped effect. */
-    readonly value: Effect<State, Event, Result<A, E>>;
-    constructor(value: Effect<State, Event, Result<A, E>>);
-    /** Transforms the success value. */
-    map<B>(f: (a: A) => B): ResultTransformer<State, Event, B, E>;
-    /** Replaces the success value with `b`. */
-    as<B>(b: B): ResultTransformer<State, Event, B, E>;
-    /** Discards the success value. */
-    void(): ResultTransformer<State, Event, void, E>;
-    /** Discards the error value. */
-    errorVoid(): ResultTransformer<State, Event, A, void>;
-    /** Chains on success, short-circuits on failure. */
-    flatMap<B>(f: (a: A) => Effect<State, Event, Result<B, E>>): ResultTransformer<State, Event, B, E>;
-    /** Like `flatMap` but `f` returns an unwrapped Effect rather than an Effect of Result. */
-    semiFlatMap<B>(f: (a: A) => Effect<State, Event, B>): ResultTransformer<State, Event, B, E>;
-    /** Sequences on success, short-circuits on failure. */
-    and<B>(effect: Effect<State, Event, Result<B, E>>): ResultTransformer<State, Event, B, E>;
-    /** Unwraps the Result, returning either the success value or the error. */
-    merge(): Effect<State, Event, A | E>;
-    /** Logs the error to the console without changing the Result. */
-    logError(): ResultTransformer<State, Event, A, E>;
-    /** Logs the error and converts it to void. */
-    logAndDropError(): ResultTransformer<State, Event, A, void>;
-    /** Transforms the error value. */
-    errorMap<EE>(f: (error: E) => EE): ResultTransformer<State, Event, A, EE>;
-    /** Chains on failure, short-circuits on success. */
-    errorFlatMap<EE>(f: (error: E) => Effect<State, Event, EE>): ResultTransformer<State, Event, A, EE>;
-}
-/**
- * Lifts an `Effect<State, Event, Result<A, E>>` into a `ResultTransformer` for
- * chaining. Equivalent to `new ResultTransformer(effect)`.
- */
-export declare function resultT<State, Event, A, E>(effect: Effect<State, Event, Result<A, E>>): ResultTransformer<State, Event, A, E>;
-//# sourceMappingURL=effects.d.ts.map
+export { h as ClipboardError, j as DecodingError, k as DownloadInput, E as Effect, F as FlatMap, l as Fragment, n as Headers, d as HttpError, H as HttpRequest, b as HttpResponse, I as InternalLocation, J as Json, L as Lens, M as Method, o as Path, Q as QueryParam, c as RequestError, f as ResponseBody, R as Result, q as ResultTransformer, r as Return, v as ScrollElementError, S as ScrollOptions, w as StorageTarget, x as Suspend, T as TaskId, y as alert, z as async, B as cancelTask, G as clearAppBadge, K as clearLocalStorage, O as clearSessionStorage, V as confirm, W as customEffect, X as download, Y as fireEvent, Z as generateUuid, _ as getLocalStorageItem, $ as getLocation, a0 as getNotificationPermission, a1 as getRandom, a2 as getSessionStorageItem, a3 as getState, a4 as getTime, a5 as go, a6 as isEffect, a7 as log, a8 as makeEffects, a9 as makeHttpRequest, aa as mapEvent, ab as mapState, ac as noop, ad as openDatabase, ae as postBroadcastMessage, af as product, ag as prompt, ah as pure, ai as pushState, aj as readClipboard, ak as removeLocalStorageItem, al as removeSessionStorageItem, am as replaceState, an as requestNotificationPermission, ao as resultT, ap as runDbTransaction, aq as scheduleTask, ar as scrollElement, as as scrollWindow, at as setAppBadge, au as setDocumentTitle, av as setLocalStorageItem, aw as setSessionStorageItem, ax as setTimeout, ay as subscribeToBroadcastChannel, az as taskId, aA as traverse, aB as updateState, aC as writeClipboard } from './index-DeEjNrg-.js';
+export { ConstraintError, DbEffect, DbError, DbName, DbSetupEffect, DbVersion, NotFoundError, ObjectStore, UnexpectedError } from './db/index.js';