@rikalabs/akter 0.1.0-alpha.0

package/dist/client/offline/queue.js

@@ -0,0 +1,292 @@
+import { Deferred, Duration, Effect, Match, Option, Schema } from "effect";
+import { ActorError, CommandConflict, CommandExpired, Timeout, Unauthorized, } from "../../errors/actor.js";
+import { retryDeadline } from "../clock.js";
+import { OfflineStoreError } from "./store.js";
+import { reportError } from "../report.js";
+/** How long to wait before asking again after a retryable failure that names no delay. */
+const IDLE_RETRY_MS = 5_000;
+const isFramework = Schema.is(ActorError);
+const isExpired = (failure) => isFramework(failure) && Schema.is(CommandExpired)(failure.reason);
+const isCredentialFailure = (failure) => isFramework(failure) && Schema.is(Unauthorized)(failure.reason) && failure.reason.isCredential;
+const decodeBody = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
+const noop = () => undefined;
+const report = (error) => Effect.sync(() => reportError(error));
+const guard = (operation, work) => Effect.tryPromise({ try: work, catch: (cause) => OfflineStoreError.make({ operation, cause }) });
+const expiredFailure = (commandId) => ActorError.make({ reason: CommandExpired.make({ commandId }) });
+const viewOf = (principal) => ({ command, failure }) => ({
+    commandId: command.commandId,
+    target: command.target,
+    member: command.member,
+    input: command.body === undefined ? undefined : Option.getOrUndefined(decodeBody(command.body)),
+    status: command.status === "queued" && command.principal !== principal ? "held" : command.status,
+    failure,
+});
+/**
+ * The queue behind a client's `offline` option. It keeps each actor's commands
+ * in the order they were called and sends one at a time, so a later command
+ * never overtakes an earlier one that is still waiting for the network;
+ * different actors are delivered independently. A command that expires or is
+ * rejected for good does not hold back those after it.
+ *
+ * Each command is saved under the principal the client ran as, and only
+ * commands of the current principal are sent: another's are `held`, so a
+ * shared store never sends one user's commands with another's credential.
+ *
+ * Ids are minted by the caller and stored with the command, so a replay after
+ * a lost reply, a reload, or a second tab is a retry the receipt answers, never
+ * a second execution. Tabs sharing one store each deliver what they read, and
+ * only the order within a tab is kept.
+ */
+export const openCommandQueue = (options) => {
+    const slots = new Map();
+    const listeners = new Set();
+    const wakers = new Set();
+    const draining = new Set();
+    const parked = new Set();
+    const loading = Deferred.makeUnsafe();
+    let snapshot = [];
+    let principal = undefined;
+    let sequence = 0;
+    let loaded = false;
+    let closed = false;
+    let tail = Deferred.makeUnsafe();
+    Deferred.doneUnsafe(tail, Effect.void);
+    const publish = () => {
+        snapshot = Array.from(slots.values(), viewOf(principal));
+        for (const listener of listeners)
+            try {
+                listener(snapshot);
+            }
+            catch (error) {
+                reportError(error);
+            }
+    };
+    const slotOf = (command) => {
+        const failure = Match.value(command.status).pipe(Match.withReturnType(), Match.when("expired", () => expiredFailure(command.commandId)), Match.when("failed", () => options.failureOf(command)), Match.orElse(() => undefined));
+        return {
+            command,
+            failure,
+            discarded: false,
+            settled: Deferred.makeUnsafe(),
+        };
+    };
+    const awaitWake = Effect.callback((resume) => {
+        const wake = () => resume(Effect.void);
+        wakers.add(wake);
+        return Effect.sync(() => {
+            wakers.delete(wake);
+        });
+    });
+    /** Reads the current principal, and republishes when it changed, since that moves commands in and out of `held`. */
+    const current = Effect.gen(function* () {
+        const next = yield* options.principal;
+        if (next !== principal) {
+            principal = next;
+            publish();
+        }
+        return next;
+    });
+    const sleep = (ms) => Effect.raceFirst(Effect.sleep(Duration.millis(ms)), awaitWake);
+    const stop = (slot, status, failure, answer) => Effect.gen(function* () {
+        slot.command = { ...slot.command, status, answer };
+        slot.failure = failure;
+        yield* Deferred.fail(slot.settled, failure);
+        publish();
+        yield* guard("save", () => options.store.save(slot.command)).pipe(Effect.catch(report));
+        return "settled";
+    });
+    const expire = (slot) => stop(slot, "expired", expiredFailure(slot.command.commandId), undefined);
+    const commit = (slot, value) => Effect.gen(function* () {
+        const { commandId } = slot.command;
+        slots.delete(commandId);
+        yield* Deferred.succeed(slot.settled, value);
+        publish();
+        yield* guard("remove", () => options.store.remove(commandId)).pipe(Effect.catch(report));
+        return "settled";
+    });
+    /**
+     * Attempts one command until the server answers, its id can no longer be
+     * used, or it must wait for the application. A retry never leaves the
+     * command's own id, and a retry that would run past the id's window is not
+     * made: the command expires instead.
+     */
+    const deliver = (slot) => Effect.gen(function* () {
+        const { commandId, target } = slot.command;
+        const attempt = options.begin(slot.command);
+        const deadline = retryDeadline(commandId);
+        while (true) {
+            if (slot.command.principal !== (yield* current))
+                return "held";
+            if (deadline !== undefined && options.now() >= deadline)
+                return yield* expire(slot);
+            const outcome = yield* Effect.match(attempt, {
+                onSuccess: (value) => ({ answered: true, value }),
+                onFailure: (refused) => ({ answered: false, refused }),
+            });
+            if (closed || slot.discarded)
+                return "stopped";
+            if (outcome.answered)
+                return yield* commit(slot, outcome.value);
+            const { failure, retryAfterMs, answer } = outcome.refused;
+            slot.failure = failure;
+            publish();
+            if (Option.isNone(retryAfterMs)) {
+                if (isExpired(failure))
+                    return yield* expire(slot);
+                if (isCredentialFailure(failure)) {
+                    parked.add(target);
+                    return "parked";
+                }
+                if (!(isFramework(failure) && failure.isRetryable))
+                    return yield* stop(slot, "failed", failure, answer);
+            }
+            const delay = Option.getOrElse(retryAfterMs, () => IDLE_RETRY_MS);
+            if (deadline !== undefined && options.now() + delay >= deadline)
+                return yield* expire(slot);
+            yield* sleep(delay);
+            if (closed || slot.discarded)
+                return "stopped";
+        }
+    });
+    const drain = (target) => {
+        if (closed || !loaded || draining.has(target) || parked.has(target))
+            return;
+        draining.add(target);
+        const deliverAll = Effect.gen(function* () {
+            while (true) {
+                const running = yield* current;
+                let head = undefined;
+                for (const slot of slots.values())
+                    if (slot.command.target === target &&
+                        slot.command.status === "queued" &&
+                        slot.command.principal === running) {
+                        head = slot;
+                        break;
+                    }
+                if (head === undefined || (yield* deliver(head)) !== "settled")
+                    return;
+            }
+        });
+        Effect.runFork(deliverAll.pipe(Effect.catchCause((cause) => Effect.sync(() => {
+            reportError(cause);
+            parked.add(target);
+        })), Effect.ensuring(Effect.sync(() => {
+            draining.delete(target);
+        }))));
+    };
+    const drainQueued = () => {
+        for (const slot of slots.values())
+            if (slot.command.status === "queued")
+                drain(slot.command.target);
+    };
+    const load = Effect.gen(function* () {
+        const saved = yield* guard("entries", () => options.store.entries());
+        const prefix = `/actors/${options.actor}`;
+        for (const command of saved) {
+            sequence = Math.max(sequence, command.sequence + 1);
+            if (command.baseUrl === options.baseUrl &&
+                (command.target === prefix || command.target.startsWith(`${prefix}/`)))
+                slots.set(command.commandId, slotOf(command));
+        }
+        loaded = true;
+        principal = Option.getOrUndefined(yield* options.principal.pipe(Effect.asSome, Effect.catchCause(() => Effect.succeedNone)));
+        publish();
+        drainQueued();
+        yield* Effect.forkDetach(options.warm);
+    });
+    Effect.runFork(load.pipe(Deferred.into(loading)));
+    const ready = Effect.runPromise(Deferred.await(loading));
+    ready.catch(noop);
+    const append = (input) => Effect.gen(function* () {
+        const existing = slots.get(input.commandId);
+        if (existing !== undefined) {
+            const { command } = existing;
+            if (command.target !== input.target ||
+                command.member !== input.member ||
+                command.body !== input.body ||
+                command.principal !== (yield* current))
+                return yield* ActorError.make({
+                    reason: CommandConflict.make({ commandId: input.commandId }),
+                });
+            parked.delete(command.target);
+            drain(command.target);
+            return {
+                settled: command.status === "queued"
+                    ? Deferred.await(existing.settled)
+                    : Effect.fail(existing.failure ?? expiredFailure(command.commandId)),
+            };
+        }
+        const command = {
+            ...input,
+            baseUrl: options.baseUrl,
+            principal: yield* current,
+            sequence,
+            status: "queued",
+            answer: undefined,
+        };
+        yield* guard("save", () => options.store.save(command));
+        sequence += 1;
+        const slot = slotOf(command);
+        slots.set(command.commandId, slot);
+        parked.delete(command.target);
+        publish();
+        drain(command.target);
+        return { settled: Deferred.await(slot.settled) };
+    });
+    const submit = (make, signal) => {
+        const previous = tail;
+        const mine = Deferred.makeUnsafe();
+        const aborted = () => signal?.aborted === true;
+        tail = mine;
+        return Effect.runPromise(Deferred.await(previous).pipe(Effect.andThen(Deferred.await(loading)), Effect.andThen(Effect.gen(function* () {
+            if (aborted())
+                return undefined;
+            const command = yield* make;
+            return aborted() ? undefined : yield* append(command);
+        })), Effect.ensuring(Deferred.succeed(mine, undefined))));
+    };
+    const flush = () => {
+        if (closed)
+            return;
+        parked.clear();
+        for (const wake of wakers)
+            wake();
+        drainQueued();
+    };
+    const isOnlineEmitter = "addEventListener" in globalThis;
+    if (isOnlineEmitter)
+        globalThis.addEventListener("online", flush);
+    return {
+        ready,
+        get pending() {
+            return snapshot;
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        flush,
+        discard: (commandId) => Effect.runPromise(Effect.gen(function* () {
+            yield* Deferred.await(loading);
+            const slot = slots.get(commandId);
+            if (slot === undefined)
+                return;
+            slot.discarded = true;
+            slots.delete(commandId);
+            yield* Deferred.fail(slot.settled, ActorError.make({ reason: Timeout.make({ commandId }) }));
+            publish();
+            yield* guard("remove", () => options.store.remove(commandId));
+        })),
+        close: () => {
+            closed = true;
+            for (const wake of wakers)
+                wake();
+            listeners.clear();
+            if (isOnlineEmitter)
+                globalThis.removeEventListener("online", flush);
+        },
+        submit,
+    };
+};

package/dist/client/offline/store.d.ts

@@ -0,0 +1,74 @@
+import { Schema } from "effect";
+/**
+ * A command a client saved before its first attempt. Everything here is plain
+ * data, so an adapter can keep it in any structured store; credentials are
+ * never part of it, since headers are read again for each attempt. It names
+ * the principal it was queued under, so it is never sent as anyone else.
+ */
+export interface QueuedCommand {
+    /** The id minted once for this command; every attempt, in any session, sends it unchanged. */
+    readonly commandId: string;
+    /** Position in the queue; commands of one actor are delivered in this order. */
+    readonly sequence: number;
+    /** The client's `baseUrl`; a client delivers only the commands saved under its own. */
+    readonly baseUrl: string;
+    /**
+     * Who queued the command: the client's `identity`, never a credential. A
+     * client delivers only the commands saved under the principal it runs as.
+     */
+    readonly principal: string;
+    /** The actor's route under `baseUrl`, such as `/actors/Room/r1`. */
+    readonly target: string;
+    /** The member's name. */
+    readonly member: string;
+    /** The JSON text every attempt sends, encoded once when the command was called. */
+    readonly body: string | undefined;
+    /**
+     * `queued` until an answer settles it. `expired` means the id's window
+     * passed before an answer arrived and `failed` that the server answered with
+     * a terminal failure; both stay saved until the application discards them.
+     */
+    readonly status: "queued" | "expired" | "failed";
+    /** The server's terminal answer to a `failed` command, kept so a later session can decode it. */
+    readonly answer: {
+        readonly status: number;
+        readonly text: string;
+    } | undefined;
+}
+/**
+ * Where queued commands survive a reload. `save` resolves only once the
+ * command is durable, because a client sends nothing before then.
+ */
+export interface OfflineStore {
+    /** Every saved command, in the order they were queued. */
+    readonly entries: () => Promise<ReadonlyArray<QueuedCommand>>;
+    /** Saves `command`, replacing the one with the same id. */
+    readonly save: (command: QueuedCommand) => Promise<void>;
+    /** Forgets the command with this id; forgetting an unknown id succeeds. */
+    readonly remove: (commandId: string) => Promise<void>;
+}
+declare const OfflineStoreError_base: Schema.Class<OfflineStoreError, Schema.TaggedStruct<"OfflineStoreError", {
+    readonly operation: Schema.Literals<readonly ["entries", "save", "remove"]>;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An offline store could not read or write a queued command. A command whose
+ * `save` failed was never sent, so nothing about it is unknown.
+ */
+export declare class OfflineStoreError extends OfflineStoreError_base {
+}
+/** Keeps commands in memory, for tests and for pages that need the queue but not a reload. */
+declare const memory: () => OfflineStore;
+/**
+ * Keeps commands in an IndexedDB database named `akter:<name>`, one
+ * record per command. The database opens on first use, so building a client
+ * on a server, where there is none, fails only when a command is queued.
+ * Writes ask for strict durability: a record is on disk when `save` resolves.
+ */
+declare const indexedDb: (name: string) => OfflineStore;
+/** The storage adapters a client's `offline` option accepts. */
+export declare const Offline: {
+    indexedDb: typeof indexedDb;
+    memory: typeof memory;
+};
+export {};

package/dist/client/offline/store.js

@@ -0,0 +1,78 @@
+import { Deferred, Effect, Schema } from "effect";
+/**
+ * An offline store could not read or write a queued command. A command whose
+ * `save` failed was never sent, so nothing about it is unknown.
+ */
+export class OfflineStoreError extends Schema.TaggedError()("OfflineStoreError", { operation: Schema.Literals(["entries", "save", "remove"]), cause: Schema.Defect() }) {
+}
+/** An IndexedDB store could not be opened; `cause` is the browser's error when it gave one. */
+class IndexedDbUnavailable extends Schema.TaggedError()("IndexedDbUnavailable", { reason: Schema.Literals(["absent", "blocked", "failed"]), cause: Schema.Defect() }) {
+}
+const bySequence = (left, right) => left.sequence - right.sequence;
+/** Keeps commands in memory, for tests and for pages that need the queue but not a reload. */
+const memory = () => {
+    const commands = new Map();
+    return {
+        entries: () => Promise.resolve(Array.from(commands.values(), (command) => structuredClone(command)).sort(bySequence)),
+        save: (command) => {
+            commands.set(command.commandId, structuredClone(command));
+            return Promise.resolve();
+        },
+        remove: (commandId) => {
+            commands.delete(commandId);
+            return Promise.resolve();
+        },
+    };
+};
+const COMMANDS = "commands";
+/**
+ * Keeps commands in an IndexedDB database named `akter:<name>`, one
+ * record per command. The database opens on first use, so building a client
+ * on a server, where there is none, fails only when a command is queued.
+ * Writes ask for strict durability: a record is on disk when `save` resolves.
+ */
+const indexedDb = (name) => {
+    let opening;
+    const openDatabase = Effect.callback((resume) => {
+        if (!("indexedDB" in globalThis))
+            return resume(Effect.fail(IndexedDbUnavailable.make({ reason: "absent", cause: undefined })));
+        const request = globalThis.indexedDB.open(`akter:${name}`, 1);
+        request.onupgradeneeded = () => {
+            request.result.createObjectStore(COMMANDS, { keyPath: "commandId" });
+        };
+        request.onsuccess = () => {
+            const opened = request.result;
+            opened.onversionchange = () => {
+                opened.close();
+                opening = undefined;
+            };
+            resume(Effect.succeed(opened));
+        };
+        request.onerror = () => resume(Effect.fail(IndexedDbUnavailable.make({ reason: "failed", cause: request.error })));
+        request.onblocked = () => resume(Effect.fail(IndexedDbUnavailable.make({ reason: "blocked", cause: undefined })));
+    });
+    const database = Effect.suspend(() => {
+        if (opening !== undefined)
+            return Deferred.await(opening);
+        const attempt = Deferred.makeUnsafe();
+        opening = attempt;
+        return openDatabase.pipe(Deferred.into(attempt), Effect.andThen(Deferred.await(attempt)), Effect.tapError(() => Effect.sync(() => {
+            if (opening === attempt)
+                opening = undefined;
+        })));
+    });
+    const transact = (mode, run) => Effect.runPromise(database.pipe(Effect.flatMap((connection) => Effect.callback((resume) => {
+        const transaction = connection.transaction(COMMANDS, mode, { durability: "strict" });
+        const request = run(transaction.objectStore(COMMANDS));
+        transaction.oncomplete = () => resume(Effect.succeed(request.result));
+        transaction.onerror = () => resume(Effect.fail(transaction.error ?? request.error));
+        transaction.onabort = () => resume(Effect.fail(transaction.error ?? request.error));
+    }))));
+    return {
+        entries: () => transact("readonly", (store) => store.getAll()).then((commands) => commands.sort(bySequence)),
+        save: (command) => transact("readwrite", (store) => store.put(command)).then(() => undefined),
+        remove: (commandId) => transact("readwrite", (store) => store.delete(commandId)).then(() => undefined),
+    };
+};
+/** The storage adapters a client's `offline` option accepts. */
+export const Offline = { indexedDb, memory };

package/dist/client/optimistic.d.ts

@@ -0,0 +1,57 @@
+import type { OptimisticReducer, StateValue } from "../actor/served.ts";
+/** A reducer input applied ahead of its receipt. */
+export interface PendingInput {
+    readonly member: string;
+    readonly input: unknown;
+}
+interface Entry extends PendingInput {
+    readonly reducer: OptimisticReducer;
+}
+/**
+ * One actor's state as a client sees it: the committed state it last learned
+ * and the reducer inputs still waiting for receipts, applied in call order.
+ * A listener that throws goes to `reportError`, as a DOM event listener's
+ * would, and the rest still run.
+ */
+export declare class Optimistic {
+    private committed;
+    private entries;
+    private view;
+    private readonly listeners;
+    /** Settles when the last reducer call sent here has; reducer calls send one at a time. */
+    private queue;
+    /** `reducer` is any of the actor's reducers; its state schema copies what goes in and out. */
+    private readonly reducer;
+    constructor(reducer: OptimisticReducer | undefined);
+    /** Committed state with pending inputs applied; undefined until committed state is known. */
+    get state(): StateValue | undefined;
+    /** Copies of the inputs still waiting for receipts, in call order. */
+    get pending(): ReadonlyArray<PendingInput>;
+    /** Nothing pending and nobody listening, so dropping it loses nothing. */
+    get isIdle(): boolean;
+    /** Calls `listener` with the view after each change; returns the unsubscribe. */
+    subscribe(listener: (state: StateValue | undefined) => void): () => void;
+    /** Replaces the committed state and reapplies pending inputs. */
+    reconcile(committed: StateValue): void;
+    /**
+     * Applies `entry` to the view ahead of its receipt and settles it with
+     * `outcome`: a reply confirms it, a failure drops it. The call that decides
+     * `outcome` is the caller's; this only reflects it.
+     */
+    follow(entry: Entry, outcome: Promise<unknown>): void;
+    /**
+     * Sends `entry` once every reducer call sent here before it has settled,
+     * so each reply is the committed state before every later pending input,
+     * and follows it. `send` receives what its first attempt waits for.
+     */
+    sendInOrder<A>(entry: Entry, send: (after: Promise<void>) => Promise<A>): Promise<A>;
+    /**
+     * Its receipt succeeded. A reducer's reply is the committed state; a
+     * commutative reducer replies nothing, so it is applied to committed state here.
+     */
+    private confirm;
+    /** Its call failed, so the input comes out of the view. */
+    private drop;
+    private publish;
+}
+export {};

package/dist/client/optimistic.js

@@ -0,0 +1,136 @@
+import { Data, Effect, Exit, Option, Predicate, Result, Schema } from "effect";
+import { reportError } from "./report.js";
+class Rejected extends Data.TaggedError("Rejected") {
+}
+const copiers = new WeakMap();
+/** Round-trips state through its JSON codec: a private copy, and a check that it fits the schema. */
+const copierOf = (reducer) => {
+    const existing = copiers.get(reducer);
+    if (existing !== undefined)
+        return existing;
+    const json = Schema.toCodecJson(reducer.state);
+    const encode = Schema.encodeEffect(json);
+    const decode = Schema.decodeEffect(json);
+    const copy = (state) => encode(state).pipe(Effect.map((encoded) => structuredClone(encoded)), Effect.flatMap(decode));
+    copiers.set(reducer, copy);
+    return copy;
+};
+/** `entry`'s reducer over a copy of `state`; none when it fails, throws, or returns an invalid state. */
+const apply = (entry, state) => {
+    const copy = copierOf(entry.reducer);
+    const exit = Effect.runSyncExit(Effect.gen(function* () {
+        const given = yield* copy(state);
+        const reduced = yield* Effect.try({
+            try: () => entry.reducer.reduce(given, entry.input),
+            catch: () => new Rejected(),
+        });
+        if (Result.isFailure(reduced))
+            return yield* new Rejected();
+        return yield* copy(reduced.success);
+    }));
+    return Exit.isSuccess(exit) ? Option.some(exit.value) : Option.none();
+};
+const applyOrKeep = (state, entry) => Option.getOrElse(apply(entry, state), () => state);
+/** A private copy of `state`, or `state` itself when it does not fit the schema. */
+const own = (reducer, state) => {
+    if (reducer === undefined)
+        return state;
+    const exit = Effect.runSyncExit(copierOf(reducer)(state));
+    return Exit.isSuccess(exit) ? exit.value : state;
+};
+/**
+ * One actor's state as a client sees it: the committed state it last learned
+ * and the reducer inputs still waiting for receipts, applied in call order.
+ * A listener that throws goes to `reportError`, as a DOM event listener's
+ * would, and the rest still run.
+ */
+export class Optimistic {
+    committed = Option.none();
+    entries = [];
+    view = undefined;
+    listeners = new Set();
+    /** Settles when the last reducer call sent here has; reducer calls send one at a time. */
+    queue = Promise.resolve();
+    /** `reducer` is any of the actor's reducers; its state schema copies what goes in and out. */
+    reducer;
+    constructor(reducer) {
+        this.reducer = reducer;
+    }
+    /** Committed state with pending inputs applied; undefined until committed state is known. */
+    get state() {
+        return this.view;
+    }
+    /** Copies of the inputs still waiting for receipts, in call order. */
+    get pending() {
+        return this.entries.map(({ member, input }) => ({ member, input: structuredClone(input) }));
+    }
+    /** Nothing pending and nobody listening, so dropping it loses nothing. */
+    get isIdle() {
+        return this.entries.length === 0 && this.listeners.size === 0;
+    }
+    /** Calls `listener` with the view after each change; returns the unsubscribe. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /** Replaces the committed state and reapplies pending inputs. */
+    reconcile(committed) {
+        this.committed = Option.some(own(this.reducer, committed));
+        this.publish();
+    }
+    /**
+     * Applies `entry` to the view ahead of its receipt and settles it with
+     * `outcome`: a reply confirms it, a failure drops it. The call that decides
+     * `outcome` is the caller's; this only reflects it.
+     */
+    follow(entry, outcome) {
+        void outcome.then((reply) => {
+            this.confirm(entry, entry.reducer.commutative || !Predicate.isObject(reply) ? undefined : reply);
+        }, () => {
+            this.drop(entry);
+        });
+        this.entries = [...this.entries, entry];
+        this.publish();
+    }
+    /**
+     * Sends `entry` once every reducer call sent here before it has settled,
+     * so each reply is the committed state before every later pending input,
+     * and follows it. `send` receives what its first attempt waits for.
+     */
+    sendInOrder(entry, send) {
+        const previous = this.queue;
+        const settled = send(previous);
+        this.queue = Promise.allSettled([previous, settled]).then(() => undefined);
+        this.follow(entry, settled);
+        return settled;
+    }
+    /**
+     * Its receipt succeeded. A reducer's reply is the committed state; a
+     * commutative reducer replies nothing, so it is applied to committed state here.
+     */
+    confirm(entry, reply) {
+        this.entries = this.entries.filter((pending) => pending !== entry);
+        this.committed =
+            reply !== undefined
+                ? Option.some(own(this.reducer, reply))
+                : Option.map(this.committed, (committed) => applyOrKeep(committed, entry));
+        this.publish();
+    }
+    /** Its call failed, so the input comes out of the view. */
+    drop(entry) {
+        this.entries = this.entries.filter((pending) => pending !== entry);
+        this.publish();
+    }
+    publish() {
+        this.view = Option.getOrUndefined(Option.map(this.committed, (committed) => own(this.reducer, this.entries.reduce(applyOrKeep, committed))));
+        for (const listener of this.listeners)
+            try {
+                listener(this.view);
+            }
+            catch (error) {
+                reportError(error);
+            }
+    }
+}

package/dist/client/report.d.ts

@@ -0,0 +1,2 @@
+/** Reports listener failures without interrupting notification; Node lacks the browser's global reporter. */
+export declare const reportError: typeof globalThis.reportError;

package/dist/client/report.js

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+/** Reports listener failures without interrupting notification; Node lacks the browser's global reporter. */
+export const reportError = (error) => {
+    if (globalThis.reportError !== undefined)
+        globalThis.reportError(error);
+    else
+        Effect.runSync(Effect.logError(error));
+};