Interface BoundApi<Sh, R>

Bound API: creates pre-bound accessors for a given Store shape + Env.

The runtime implementation lives in internal/runtime/BoundApiRuntime.
The public Bound.ts exports a same-named type alias to keep the public API consistent.

interface BoundApi<Sh extends AnyModuleShape, R = never> {
    actions: Sh["actionMap"];
    dispatch: {
        (action: Type<Sh["actionSchema"]>): Of<Sh, R, void, never>;
        <K extends string | number | symbol>(
            token: Sh["actionMap"][K],
            ...args: ActionArgs<ActionPayload<Sh["actionMap"][K]>>,
        ): Of<Sh, R, void, never>;
        <K extends string | number | symbol>(
            tag: K,
            ...args: ActionArgs<ActionPayload<Sh["actionMap"][K]>>,
        ): Of<Sh, R, void, never>;
    };
    dispatchers: {
        readonly [K in string
        | number
        | symbol]: ActionFn<
            ActionPayload<Sh["actionMap"][K]>,
            Of<Sh, R, void, never>,
        >
    };
    effect: <K extends string | number | symbol>(
        token: Sh["actionMap"][K],
        handler: (
            payload: ActionPayload<Sh["actionMap"][K]>,
        ) => Of<Sh, R, void, any>,
    ) => Of<Sh, R, void, never>;
    flow: Api<Sh, R>;
    lifecycle: {
        onDestroy: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onError: (
            handler: (
                cause: Cause<unknown>,
                context: ErrorContext,
            ) => Effect<void, never, R>,
        ) => Of<Sh, R, void, never>;
        onInit: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onInitRequired: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onReset: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onResume: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onStart: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
        onSuspend: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    };
    match: <V>(value: V) => FluentMatch<V>;
    matchTag: <V extends { _tag: string }>(value: V) => FluentMatchTag<V>;
    on: <V>(source: Stream<V>) => IntentBuilder<V, Sh, R>;
    onAction: {
        <T extends unknown>(
            predicate: (a: Type<Sh["actionSchema"]>) => a is T,
        ): IntentBuilder<T, Sh, R>;
        <K extends string | number | symbol>(
            tag: K,
        ): IntentBuilder<
            Extract<Type<Sh["actionSchema"]>, { _tag: K } | { type: K }>,
            Sh,
            R,
        >;
        <A extends { _tag: string } | { type: string }>(
            value: A,
        ): IntentBuilder<A, Sh, R>;
        <Sc extends unknown>(
            schema: Sc,
        ): IntentBuilder<Extract<Type<Sh["actionSchema"]>, Type<Sc>>, Sh, R>;
        <K extends string | number | symbol>(
            token: Sh["actionMap"][K],
        ): IntentBuilder<ActionPayload<Sh["actionMap"][K]>, Sh, R>;
    } & {
        [K in string
        | number
        | symbol]: IntentBuilder<
            Extract<Type<Sh["actionSchema"]>, { _tag: K } | { type: K }>,
            Sh,
            R,
        >
    };
    onState: <V>(
        selector: (s: Type<Sh["stateSchema"]>) => V,
    ) => IntentBuilder<V, Sh, R>;
    reducer: <
        K extends string
        | number
        | symbol,
        A extends { _tag: K } | { type: K },
    >(
        tag: K,
        reducer: (
            state: Type<Sh["stateSchema"]>,
            action: A,
        ) => Type<Sh["stateSchema"]>,
    ) => Of<Sh, R, void, never>;
    root: {
        resolve: <Svc, Id = unknown>(
            tag: Tag<Id, Svc>,
        ) => Of<Sh, R, Svc, never>;
    };
    state: {
        mutate: (
            f: (draft: Draft<Type<Sh["stateSchema"]>>) => void,
        ) => Of<Sh, R, void, never>;
        read: Of<Sh, R, Type<Sh["stateSchema"]>, never>;
        ref: <V = Type<Sh["stateSchema"]>>(
            selector?: (s: Type<Sh["stateSchema"]>) => V,
        ) => SubscriptionRef<V>;
        update: (
            f: (prev: Type<Sh["stateSchema"]>) => Type<Sh["stateSchema"]>,
        ) => Of<Sh, R, void, never>;
    };
    traits: {
        declare: (traits: object) => void;
        source: {
            refresh: (
                fieldPath: string,
                options?: { force?: boolean },
            ) => Of<Sh, R, void, never>;
        };
    };
    use: {
        <M extends ModuleLike<string, AnyModuleShape, any>>(
            module: M,
        ): Of<Sh, R, ModuleHandle<ModuleShapeOf<M>> & ModuleExtOf<M>, never>;
        <Sh2 extends AnyModuleShape>(
            module: ModuleTagType<string, Sh2>,
        ): Of<Sh, R, ModuleHandle<Sh2>, never>;
        <Svc, Id = unknown>(tag: Tag<Id, Svc>): Of<Sh, R, Svc, never>;
    };
}

Type Parameters

Sh extends AnyModuleShape
R = never

Index

Properties

actions dispatch dispatchers effect flow lifecycle match matchTag on onAction onState reducer root state traits use

Properties

`Readonly`actions

actions: Sh["actionMap"]

`Readonly`dispatch

dispatch: {
    (action: Type<Sh["actionSchema"]>): Of<Sh, R, void, never>;
    <K extends string | number | symbol>(
        token: Sh["actionMap"][K],
        ...args: ActionArgs<ActionPayload<Sh["actionMap"][K]>>,
    ): Of<Sh, R, void, never>;
    <K extends string | number | symbol>(
        tag: K,
        ...args: ActionArgs<ActionPayload<Sh["actionMap"][K]>>,
    ): Of<Sh, R, void, never>;
}

`Readonly`dispatchers

dispatchers: {
    readonly [K in string | number | symbol]: ActionFn<
        ActionPayload<Sh["actionMap"][K]>,
        Of<Sh, R, void, never>,
    >
}

`Readonly`effect

effect: <K extends string | number | symbol>(
    token: Sh["actionMap"][K],
    handler: (
        payload: ActionPayload<Sh["actionMap"][K]>,
    ) => Of<Sh, R, void, any>,
) => Of<Sh, R, void, never>

effect：

Register a side-effect handler for a specific Action token.
Setup registration is the primary path; run-phase dynamic registration is allowed but emits diagnostics and only affects future actions.

Constraints:

Handlers must run outside the transaction window (FR-012); never perform IO inside reducers/transactions.
The runtime de-duplicates by (actionTag, sourceKey) (sourceKey is derived automatically).

`Readonly`flow

flow: Api<Sh, R>

`Readonly`lifecycle

lifecycle: {
    onDestroy: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onError: (
        handler: (
            cause: Cause<unknown>,
            context: ErrorContext,
        ) => Effect<void, never, R>,
    ) => Of<Sh, R, void, never>;
    onInit: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onInitRequired: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onReset: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onResume: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onStart: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
    onSuspend: (eff: Of<Sh, R, void, never>) => Of<Sh, R, void, never>;
}

`Readonly`match

match: <V>(value: V) => FluentMatch<V>

`Readonly`matchTag

matchTag: <V extends { _tag: string }>(value: V) => FluentMatchTag<V>

`Readonly`on

on: <V>(source: Stream<V>) => IntentBuilder<V, Sh, R>

`Readonly`onAction

onAction: {
    <T extends unknown>(
        predicate: (a: Type<Sh["actionSchema"]>) => a is T,
    ): IntentBuilder<T, Sh, R>;
    <K extends string | number | symbol>(
        tag: K,
    ): IntentBuilder<
        Extract<Type<Sh["actionSchema"]>, { _tag: K } | { type: K }>,
        Sh,
        R,
    >;
    <A extends { _tag: string } | { type: string }>(
        value: A,
    ): IntentBuilder<A, Sh, R>;
    <Sc extends unknown>(
        schema: Sc,
    ): IntentBuilder<Extract<Type<Sh["actionSchema"]>, Type<Sc>>, Sh, R>;
    <K extends string | number | symbol>(
        token: Sh["actionMap"][K],
    ): IntentBuilder<ActionPayload<Sh["actionMap"][K]>, Sh, R>;
} & {
    [K in string
    | number
    | symbol]: IntentBuilder<
        Extract<Type<Sh["actionSchema"]>, { _tag: K } | { type: K }>,
        Sh,
        R,
    >
}

`Readonly`onState

onState: <V>(
selector: (s: Type<Sh["stateSchema"]>) => V,
) => IntentBuilder<V, Sh, R>

`Readonly`reducer

reducer: <
    K extends string
    | number
    | symbol,
    A extends { _tag: K } | { type: K },
>(
    tag: K,
    reducer: (
        state: Type<Sh["stateSchema"]>,
        action: A,
    ) => Type<Sh["stateSchema"]>,
) => Of<Sh, R, void, never>

Primary reducer definition entrypoint:

Semantics: register a synchronous, pure state transform reducer for an Action tag.
Implementation: writes directly into the Runtime's _tag -> (state, action) => state map, not watcher / Flow.

Constraints:

At most one primary reducer per Action tag; duplicate registration is an error.
The reducer must be pure: no Env, no Effect.

`Readonly`root

root: {
resolve: <Svc, Id = unknown>(tag: Tag<Id, Svc>) => Of<Sh, R, Svc, never>;
}

`Readonly`state

state: {
    mutate: (
        f: (draft: Draft<Type<Sh["stateSchema"]>>) => void,
    ) => Of<Sh, R, void, never>;
    read: Of<Sh, R, Type<Sh["stateSchema"]>, never>;
    ref: <V = Type<Sh["stateSchema"]>>(
        selector?: (s: Type<Sh["stateSchema"]>) => V,
    ) => SubscriptionRef<V>;
    update: (
        f: (prev: Type<Sh["stateSchema"]>) => Type<Sh["stateSchema"]>,
    ) => Of<Sh, R, void, never>;
}

`Readonly`traits

traits: {
    declare: (traits: object) => void;
    source: {
        refresh: (
            fieldPath: string,
            options?: { force?: boolean },
        ) => Of<Sh, R, void, never>;
    };
}

traits: runtime entrypoints reserved for features like StateTrait.

source.refresh(fieldPath): trigger an explicit refresh of a source field.
Concrete behavior is mounted at runtime by StateTrait.install.

Type Declaration

Readonlydeclare: (traits: object) => void
declare：
- setup-only: contributes trait declarations during the Logic setup phase (pure data/declarative).
- Final merge / conflict detection / freezing is done during Runtime initialization (023).
Readonlysource: {
    refresh: (
        fieldPath: string,
        options?: { force?: boolean },
    ) => Of<Sh, R, void, never>;
}

`Readonly`use

use: {
    <M extends ModuleLike<string, AnyModuleShape, any>>(
        module: M,
    ): Of<Sh, R, ModuleHandle<ModuleShapeOf<M>> & ModuleExtOf<M>, never>;
    <Sh2 extends AnyModuleShape>(
        module: ModuleTagType<string, Sh2>,
    ): Of<Sh, R, ModuleHandle<Sh2>, never>;
    <Svc, Id = unknown>(tag: Tag<Id, Svc>): Of<Sh, R, Svc, never>;
}

Interface BoundApi<Sh, R>

Type Parameters

Index

Properties

Properties

`Readonly`actions

`Readonly`dispatch

`Readonly`dispatchers

`Readonly`effect

`Readonly`flow

`Readonly`lifecycle

`Readonly`match

`Readonly`matchTag

`Readonly`on

`Readonly`onAction

`Readonly`onState

`Readonly`reducer

`Readonly`root

`Readonly`state

`Readonly`traits

Type Declaration

`Readonly`declare: (traits: object) => void

`Readonly`source: {
    refresh: (
        fieldPath: string,
        options?: { force?: boolean },
    ) => Of<Sh, R, void, never>;
}

`Readonly`use

Settings

On This Page

Interface BoundApi<Sh, R>

Type Parameters

Index

Properties

Properties

Readonlyactions

Readonlydispatch

Readonlydispatchers

Readonlyeffect

Readonlyflow

Readonlylifecycle

Readonlymatch

ReadonlymatchTag

Readonlyon

ReadonlyonAction

ReadonlyonState

Readonlyreducer

Readonlyroot

Readonlystate

Readonlytraits

Type Declaration

Readonlydeclare: (traits: object) => void

Readonlysource: { refresh: ( fieldPath: string, options?: { force?: boolean }, ) => Of<Sh, R, void, never>;}

Readonlyuse

Settings

On This Page

`Readonly`actions

`Readonly`dispatch

`Readonly`dispatchers

`Readonly`effect

`Readonly`flow

`Readonly`lifecycle

`Readonly`match

`Readonly`matchTag

`Readonly`on

`Readonly`onAction

`Readonly`onState

`Readonly`reducer

`Readonly`root

`Readonly`state

`Readonly`traits

`Readonly`declare: (traits: object) => void

`Readonly`source: {
refresh: (
fieldPath: string,
options?: { force?: boolean },
) => Of<Sh, R, void, never>;
}

`Readonly`use