@net-mesh/browser 0.37.0

package/dist/store/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The networked game store.
+ *
+ * **The local half:** the type contract, `defineStore`, and the
+ * transport-free {@link StoreCore} that both an authoritative host and
+ * a joined replica are built on — state, subscriptions, status and the
+ * synchronous transaction.
+ *
+ * **The protocol:** the codec and parser ladder (`wire`), chunking and
+ * assembly (`chunker`, `assembly`), the owner's dispatch and the
+ * action ledger (`owner`, `ledger`), and the replica's state machine
+ * (`replica`).
+ *
+ * **The transport halves:** {@link hostStore} and {@link joinStore}.
+ * A frame arrives as a `stream_data` event, the event carries the peer
+ * whose installed session opened the packet, and THAT is the identity
+ * the policy is handed — no store frame has an originator field to
+ * consult (§1.3).
+ *
+ * **What these are not yet evidence for.** §4 gates `joinStore` on
+ * leader-proxy lifecycle: a follower's `ProxyStream` now carries its
+ * peer (6256f970b), which is the precondition, but the store's own use
+ * of a proxied handle on a follower — last-consumer cleanup, the
+ * peer/stream lifecycle across a leader change — is not established.
+ * A host and a joiner in one tab are exercised here; two tabs sharing
+ * a leader are not. See
+ * `docs/internal/plans/BROWSER_GAME_STORE_API_DESIGN.md` §7.
+ */
+export { defineStore } from './definition.js';
+export { hostStore, HOST_SWEEP_MS } from './host.js';
+export { joinStore, ALIVE_INTERVAL_MS, MAX_OUTSTANDING, REQUEST_DEADLINE_MS } from './join.js';
+export { hostPlayer } from './player.js';
+export type { HostPlayerOptions } from './player.js';
+export type { Frame, HostedStoreHandle, HostProjection, HostStoreBaseOptions, HostStoreOptions, StoreTransport, TransportFrame, TransportStream, } from './host.js';
+export type { JoinedStoreHandle, JoinStoreOptions } from './join.js';
+export type { Viewer } from './owner.js';
+export { StoreCore } from './core.js';
+export { StoreError } from './errors.js';
+export { mergeShallow, reconcile } from './state.js';
+export type { StoreErrorCode } from './errors.js';
+export type { AccessRequest, ActionContext, ActionSpec, Cancel, EntityCollection, EntityOf, HostedStore, InputDisposition, InputSpec, JoinedStore, OperationOptions, Parse, ReadonlyState, SelectorOptions, StateUpdate, StoreDefinition, StoreLimits, StorePhase, StoreReader, StoreStatus, } from './types.js';
+export type { LeaveReason, StoreEvent } from './owner.js';
+export { MAX_EVENT_ROUNDS } from './owner.js';
+export { addItems, countItems, emptyInventory, hasItems, InventoryError, inventoryOf, MAX_ITEM_ID_CHARS, onlyOwn, parseInventory, removeItems, } from './inventory.js';
+export type { Inventory, InventoryErrorCode, InventoryRules } from './inventory.js';
+export { assertHidden, HIDDEN, hiddenOr, isHidden, projectVisible, } from './visibility.js';
+export type { Hidden, Visibility, VisibilityPreset, VisibilityRule, VisibilityRules } from './visibility.js';
+export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
+export type { CellOptions } from './interest.js';
+export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';

package/dist/store/index.js

@@ -0,0 +1,40 @@
+/**
+ * The networked game store.
+ *
+ * **The local half:** the type contract, `defineStore`, and the
+ * transport-free {@link StoreCore} that both an authoritative host and
+ * a joined replica are built on — state, subscriptions, status and the
+ * synchronous transaction.
+ *
+ * **The protocol:** the codec and parser ladder (`wire`), chunking and
+ * assembly (`chunker`, `assembly`), the owner's dispatch and the
+ * action ledger (`owner`, `ledger`), and the replica's state machine
+ * (`replica`).
+ *
+ * **The transport halves:** {@link hostStore} and {@link joinStore}.
+ * A frame arrives as a `stream_data` event, the event carries the peer
+ * whose installed session opened the packet, and THAT is the identity
+ * the policy is handed — no store frame has an originator field to
+ * consult (§1.3).
+ *
+ * **What these are not yet evidence for.** §4 gates `joinStore` on
+ * leader-proxy lifecycle: a follower's `ProxyStream` now carries its
+ * peer (6256f970b), which is the precondition, but the store's own use
+ * of a proxied handle on a follower — last-consumer cleanup, the
+ * peer/stream lifecycle across a leader change — is not established.
+ * A host and a joiner in one tab are exercised here; two tabs sharing
+ * a leader are not. See
+ * `docs/internal/plans/BROWSER_GAME_STORE_API_DESIGN.md` §7.
+ */
+export { defineStore } from './definition.js';
+export { hostStore, HOST_SWEEP_MS } from './host.js';
+export { joinStore, ALIVE_INTERVAL_MS, MAX_OUTSTANDING, REQUEST_DEADLINE_MS } from './join.js';
+export { hostPlayer } from './player.js';
+export { StoreCore } from './core.js';
+export { StoreError } from './errors.js';
+export { mergeShallow, reconcile } from './state.js';
+export { MAX_EVENT_ROUNDS } from './owner.js';
+export { addItems, countItems, emptyInventory, hasItems, InventoryError, inventoryOf, MAX_ITEM_ID_CHARS, onlyOwn, parseInventory, removeItems, } from './inventory.js';
+export { assertHidden, HIDDEN, hiddenOr, isHidden, projectVisible, } from './visibility.js';
+export { cellKey, cellsAround, sameCells, stickyCells } from './interest.js';
+export { MAX_INTEREST_KEYS, MAX_INTEREST_KEY_BYTES } from './wire.js';

package/dist/store/interest.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Grid-cell helpers for interest management.
+ *
+ * Interest keys are any strings; a square grid over the ground plane is
+ * the common case, so here it is:
+ *
+ * ```ts
+ * defineStore({ …, interest: { ships: ship => cellKey(ship.x, ship.z, 32) } });
+ *
+ * const replica = joinStore({ …, interest: cellsAround(me.x, me.z, { size: 32 }) });
+ * // each frame, or when the player moves:
+ * const next = stickyCells(current, me.x, me.z, { size: 32 });
+ * if (!sameCells(next, current)) { current = next; void replica.setInterest(next); }
+ * ```
+ *
+ * `stickyCells` keeps a cell you just left until you are `margin` cells
+ * past it, so a player standing on a border does not flip interest on
+ * every step.
+ */
+/** Options for the grid helpers. */
+export interface CellOptions {
+    /** Cell edge length, in world units. */
+    readonly size: number;
+    /** Cells around the centre one to include: 1 → a 3×3 block. Default 1. */
+    readonly radius?: number;
+    /** For `stickyCells`: extra cells a previously held cell may be away before it is dropped. Default 1. */
+    readonly margin?: number;
+}
+/** The cell containing `(x, z)`: `"<column>:<row>"`. */
+export declare function cellKey(x: number, z: number, size: number): string;
+/** The cells within `radius` of the one containing `(x, z)`, centre first. */
+export declare function cellsAround(x: number, z: number, options: CellOptions): string[];
+/**
+ * {@link cellsAround}, plus any cell of `previous` still within
+ * `radius + margin` of the player — the hysteresis that stops a player
+ * on a cell border from churning interest.
+ */
+export declare function stickyCells(previous: readonly string[], x: number, z: number, options: CellOptions): string[];
+/** Whether two interest sets hold the same keys, in any order. */
+export declare function sameCells(a: readonly string[], b: readonly string[]): boolean;

package/dist/store/interest.js

@@ -0,0 +1,77 @@
+/**
+ * Grid-cell helpers for interest management.
+ *
+ * Interest keys are any strings; a square grid over the ground plane is
+ * the common case, so here it is:
+ *
+ * ```ts
+ * defineStore({ …, interest: { ships: ship => cellKey(ship.x, ship.z, 32) } });
+ *
+ * const replica = joinStore({ …, interest: cellsAround(me.x, me.z, { size: 32 }) });
+ * // each frame, or when the player moves:
+ * const next = stickyCells(current, me.x, me.z, { size: 32 });
+ * if (!sameCells(next, current)) { current = next; void replica.setInterest(next); }
+ * ```
+ *
+ * `stickyCells` keeps a cell you just left until you are `margin` cells
+ * past it, so a player standing on a border does not flip interest on
+ * every step.
+ */
+function checkSize(size) {
+    if (!(size > 0) || !Number.isFinite(size))
+        throw new RangeError(`a cell size is a positive number, got ${String(size)}`);
+}
+/** The cell containing `(x, z)`: `"<column>:<row>"`. */
+export function cellKey(x, z, size) {
+    checkSize(size);
+    return `${String(Math.floor(x / size))}:${String(Math.floor(z / size))}`;
+}
+function parseCell(key) {
+    const match = /^(-?\d+):(-?\d+)$/.exec(key);
+    return match === null ? null : [Number(match[1]), Number(match[2])];
+}
+/** The cells within `radius` of the one containing `(x, z)`, centre first. */
+export function cellsAround(x, z, options) {
+    checkSize(options.size);
+    const radius = options.radius ?? 1;
+    const column = Math.floor(x / options.size);
+    const row = Math.floor(z / options.size);
+    const out = [`${String(column)}:${String(row)}`];
+    for (let dc = -radius; dc <= radius; dc += 1) {
+        for (let dr = -radius; dr <= radius; dr += 1) {
+            if (dc !== 0 || dr !== 0)
+                out.push(`${String(column + dc)}:${String(row + dr)}`);
+        }
+    }
+    return out;
+}
+/**
+ * {@link cellsAround}, plus any cell of `previous` still within
+ * `radius + margin` of the player — the hysteresis that stops a player
+ * on a cell border from churning interest.
+ */
+export function stickyCells(previous, x, z, options) {
+    const now = cellsAround(x, z, options);
+    const radius = options.radius ?? 1;
+    const reach = radius + (options.margin ?? 1);
+    const column = Math.floor(x / options.size);
+    const row = Math.floor(z / options.size);
+    const held = new Set(now);
+    for (const key of previous) {
+        if (held.has(key))
+            continue;
+        const cell = parseCell(key);
+        if (cell !== null && Math.abs(cell[0] - column) <= reach && Math.abs(cell[1] - row) <= reach) {
+            now.push(key);
+            held.add(key);
+        }
+    }
+    return now;
+}
+/** Whether two interest sets hold the same keys, in any order. */
+export function sameCells(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const set = new Set(a);
+    return b.every(key => set.has(key));
+}

package/dist/store/inventory.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The bones of a player inventory: stacks of items, kept in the store's
+ * state, changed only by the host.
+ *
+ * An inventory is plain JSON — item id → count — so it rides in any
+ * store document, diffs like the rest of it, and needs no protocol of
+ * its own. These are pure functions: call them inside an action
+ * handler or the `onEvent` hook and `setState` the result. A change
+ * that breaks the rules throws, which inside a handler refuses the
+ * action and discards its writes.
+ *
+ * ```ts
+ * // state: { inventories: Record<peer, Inventory>, … }
+ * onEvent: (event, context) => {
+ *   if (event.type !== 'join') return;
+ *   const inventories = { ...context.getState().inventories };
+ *   inventories[event.peer] ??= addItems(emptyInventory(), 'potion', 3, rules);
+ *   context.setState({ inventories });
+ * },
+ * actions: {
+ *   drink: (_input, context) => {
+ *     const inventories = { ...context.getState().inventories };
+ *     inventories[context.peer] = removeItems(inventoryOf(inventories, context.peer), 'potion', 1);
+ *     context.setState({ inventories });
+ *     return { left: countItems(inventories[context.peer], 'potion') };
+ *   },
+ * },
+ * projectFor: (state, { peer }) => ({ ...state, inventories: onlyOwn(state.inventories, peer) }),
+ * ```
+ *
+ * **Deliberately not here yet:** trading between players (it needs both
+ * sides' consent and one atomic transfer), equipment slots, item
+ * metadata. Item ids are yours; what an item *is* stays game data.
+ */
+/** Item id → how many. Every count is a whole number ≥ 1; absent means none. */
+export type Inventory = Readonly<Record<string, number>>;
+/** Limits an inventory keeps. Every limit is optional. */
+export interface InventoryRules {
+    /** How many different items it may hold at once. */
+    readonly maxKinds?: number;
+    /** The most of one item: one number for all, or per item id (missing ids unlimited). */
+    readonly maxCount?: number | Readonly<Record<string, number>>;
+}
+/** Why an inventory change was refused. */
+export type InventoryErrorCode = 'insufficient' | 'full' | 'invalid';
+export declare class InventoryError extends Error {
+    readonly code: InventoryErrorCode;
+    constructor(code: InventoryErrorCode, message: string);
+}
+/** Longest item id accepted. Ids are keys in a document every player may receive. */
+export declare const MAX_ITEM_ID_CHARS = 64;
+/** An inventory with nothing in it. */
+export declare function emptyInventory(): Inventory;
+/** How many of `item` it holds. */
+export declare function countItems(inventory: Inventory | undefined, item: string): number;
+/** Whether it holds at least `count` of `item`. */
+export declare function hasItems(inventory: Inventory | undefined, item: string, count?: number): boolean;
+/**
+ * Add `count` of `item`. Throws `full` when that would break a rule;
+ * nothing is partly added.
+ */
+export declare function addItems(inventory: Inventory, item: string, count: number, rules?: InventoryRules): Inventory;
+/**
+ * Remove `count` of `item`. Throws `insufficient` when it holds fewer;
+ * nothing is partly removed. An item that reaches zero is gone.
+ */
+export declare function removeItems(inventory: Inventory, item: string, count: number): Inventory;
+/**
+ * A validator for an inventory inside a store definition's `state`:
+ * accepts only whole positive counts under valid item ids, and the
+ * rules if given. Throws otherwise, as a definition validator should.
+ */
+export declare function parseInventory(value: unknown, rules?: InventoryRules): Inventory;
+/** The inventory kept for `peer` in a map of them, or an empty one. */
+export declare function inventoryOf(inventories: Readonly<Record<string, Inventory>>, peer: string): Inventory;
+/**
+ * For `projectFor`: the viewer's own entry of a per-player map, and no
+ * one else's. Hidden entries are absent — not zeroed — so another
+ * player's inventory is never in the frames sent to you.
+ */
+export declare function onlyOwn<T>(byPeer: Readonly<Record<string, T>>, peer: string): Record<string, T>;

package/dist/store/inventory.js

@@ -0,0 +1,140 @@
+/**
+ * The bones of a player inventory: stacks of items, kept in the store's
+ * state, changed only by the host.
+ *
+ * An inventory is plain JSON — item id → count — so it rides in any
+ * store document, diffs like the rest of it, and needs no protocol of
+ * its own. These are pure functions: call them inside an action
+ * handler or the `onEvent` hook and `setState` the result. A change
+ * that breaks the rules throws, which inside a handler refuses the
+ * action and discards its writes.
+ *
+ * ```ts
+ * // state: { inventories: Record<peer, Inventory>, … }
+ * onEvent: (event, context) => {
+ *   if (event.type !== 'join') return;
+ *   const inventories = { ...context.getState().inventories };
+ *   inventories[event.peer] ??= addItems(emptyInventory(), 'potion', 3, rules);
+ *   context.setState({ inventories });
+ * },
+ * actions: {
+ *   drink: (_input, context) => {
+ *     const inventories = { ...context.getState().inventories };
+ *     inventories[context.peer] = removeItems(inventoryOf(inventories, context.peer), 'potion', 1);
+ *     context.setState({ inventories });
+ *     return { left: countItems(inventories[context.peer], 'potion') };
+ *   },
+ * },
+ * projectFor: (state, { peer }) => ({ ...state, inventories: onlyOwn(state.inventories, peer) }),
+ * ```
+ *
+ * **Deliberately not here yet:** trading between players (it needs both
+ * sides' consent and one atomic transfer), equipment slots, item
+ * metadata. Item ids are yours; what an item *is* stays game data.
+ */
+export class InventoryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'InventoryError';
+    }
+}
+/** Longest item id accepted. Ids are keys in a document every player may receive. */
+export const MAX_ITEM_ID_CHARS = 64;
+const EMPTY = Object.freeze({});
+/** An inventory with nothing in it. */
+export function emptyInventory() {
+    return EMPTY;
+}
+function checkItem(item) {
+    if (typeof item !== 'string' || item.length === 0 || item.length > MAX_ITEM_ID_CHARS || item === '__proto__') {
+        throw new InventoryError('invalid', `an item id is 1-${MAX_ITEM_ID_CHARS} characters, got ${JSON.stringify(item)}`);
+    }
+}
+function checkCount(count) {
+    if (!Number.isSafeInteger(count) || count < 1) {
+        throw new InventoryError('invalid', `a count is a whole number of at least 1, got ${String(count)}`);
+    }
+}
+function limitFor(item, rules) {
+    const max = rules?.maxCount;
+    if (max === undefined)
+        return Number.MAX_SAFE_INTEGER;
+    if (typeof max === 'number')
+        return max;
+    return Object.prototype.hasOwnProperty.call(max, item) ? max[item] : Number.MAX_SAFE_INTEGER;
+}
+/** How many of `item` it holds. */
+export function countItems(inventory, item) {
+    if (inventory === undefined || !Object.prototype.hasOwnProperty.call(inventory, item))
+        return 0;
+    return inventory[item] ?? 0;
+}
+/** Whether it holds at least `count` of `item`. */
+export function hasItems(inventory, item, count = 1) {
+    return countItems(inventory, item) >= count;
+}
+/**
+ * Add `count` of `item`. Throws `full` when that would break a rule;
+ * nothing is partly added.
+ */
+export function addItems(inventory, item, count, rules) {
+    checkItem(item);
+    checkCount(count);
+    const had = countItems(inventory, item);
+    const next = had + count;
+    if (!Number.isSafeInteger(next) || next > limitFor(item, rules)) {
+        throw new InventoryError('full', `no room for ${String(count)} more ${item}`);
+    }
+    if (had === 0 && rules?.maxKinds !== undefined && Object.keys(inventory).length >= rules.maxKinds) {
+        throw new InventoryError('full', `no room for another kind of item (${String(rules.maxKinds)} at most)`);
+    }
+    return Object.freeze({ ...inventory, [item]: next });
+}
+/**
+ * Remove `count` of `item`. Throws `insufficient` when it holds fewer;
+ * nothing is partly removed. An item that reaches zero is gone.
+ */
+export function removeItems(inventory, item, count) {
+    checkItem(item);
+    checkCount(count);
+    const had = countItems(inventory, item);
+    if (had < count)
+        throw new InventoryError('insufficient', `has ${String(had)} ${item}, needs ${String(count)}`);
+    const next = { ...inventory };
+    if (had === count)
+        delete next[item];
+    else
+        next[item] = had - count;
+    return Object.freeze(next);
+}
+/**
+ * A validator for an inventory inside a store definition's `state`:
+ * accepts only whole positive counts under valid item ids, and the
+ * rules if given. Throws otherwise, as a definition validator should.
+ */
+export function parseInventory(value, rules) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new InventoryError('invalid', 'an inventory is an object of item id → count');
+    }
+    let out = EMPTY;
+    for (const [item, count] of Object.entries(value)) {
+        if (typeof count !== 'number')
+            throw new InventoryError('invalid', `the count of ${item} is not a number`);
+        out = addItems(out, item, count, rules);
+    }
+    return out;
+}
+/** The inventory kept for `peer` in a map of them, or an empty one. */
+export function inventoryOf(inventories, peer) {
+    return Object.prototype.hasOwnProperty.call(inventories, peer) ? inventories[peer] : EMPTY;
+}
+/**
+ * For `projectFor`: the viewer's own entry of a per-player map, and no
+ * one else's. Hidden entries are absent — not zeroed — so another
+ * player's inventory is never in the frames sent to you.
+ */
+export function onlyOwn(byPeer, peer) {
+    return Object.prototype.hasOwnProperty.call(byPeer, peer) ? { [peer]: byPeer[peer] } : {};
+}

package/dist/store/join.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Slice G, caller half — `joinStore`.
+ *
+ * The replica (slice D/F) decides what may be published; this decides
+ * nothing and carries frames, keeps the lease alive, and turns the
+ * protocol's correlation into the promises a page awaits.
+ *
+ * ## The lease is store machinery, never game code
+ *
+ * `alive` goes out every 20 s while the handle is live, because a page
+ * rendering a spectator view sends nothing and expiring it would be a
+ * defect (§1.6). The honest statement about the pair: a 20 s interval
+ * against a 60 s lease tolerates **one** lost renewal with margin, and
+ * the second is a race — the third renewal lands *at* the boundary
+ * before any scheduling delay is counted.
+ *
+ * ## Correlation, and what a timeout does not mean
+ *
+ * An action that was never submitted is known not to have executed. An
+ * action that was submitted and then timed out is `indeterminate`, and
+ * the store says exactly that rather than retrying: a silent resend is
+ * how one action becomes two.
+ */
+import { type StoreTransport } from './host.js';
+import type { ActionSpec, Cancel, InputDisposition, InputSpec, ReadonlyState, StoreDefinition, StoreStatus } from './types.js';
+import { type Hex } from './wire.js';
+/** How often a live handle renews its lease (§1.6). */
+export declare const ALIVE_INTERVAL_MS = 20000;
+/** How long a request waits before it is a typed timeout (§2). */
+export declare const REQUEST_DEADLINE_MS = 10000;
+/**
+ * How long one TRANSITION call waits for its installation before it
+ * is a typed timeout (§2).
+ *
+ * A transition's answer is its INSTALLATION, never the request
+ * clock's — a snapshot still transferring at 10 s is a success in
+ * progress — but that exemption needs a fence of its own: an owner
+ * that answers every `resync`/`join` with a fresh `man` whose
+ * assembly never completes restarts the 10 s assembly deadline each
+ * time, and the `#abandon → #resync → man` loop would hold the call
+ * (and its `MAX_OUTSTANDING` slot) for ever. So every call carries
+ * this named wall-clock bound from its own start. A timed-out call
+ * removes only that waiter (`cancelWaiter`), and the slot goes with
+ * its last caller.
+ */
+export declare const TRANSITION_DEADLINE_MS = 60000;
+/**
+ * How often the replica's own clock is driven.
+ *
+ * The assembly deadline is 10 s (`assembly.ts`), so a second is fine
+ * resolution and cheap: the tick does nothing at all unless an
+ * assembly is open and overdue.
+ */
+export declare const TICK_INTERVAL_MS = 1000;
+/** Outstanding correlations per caller (§2). */
+export declare const MAX_OUTSTANDING = 64;
+export interface JoinStoreOptions<S extends object, A extends ActionSpec, I extends InputSpec> {
+    readonly definition: StoreDefinition<S, A, I>;
+    readonly transport: StoreTransport;
+    /** The node hosting the store. */
+    readonly host: string;
+    /** The audience this caller wants. */
+    readonly audience: readonly string[];
+    /**
+     * WHICH store of this definition to join, when the host serves
+     * more than one. Defaults to the definition id, which is what a
+     * host serving a single store of it declares.
+     *
+     * Not `key`: that is the caller's opaque policy token, and two
+     * callers of ONE store carry different ones. This is the store's
+     * address, and it is on the wire because every host store on a
+     * node sees every frame and a `join` names no handle — without it
+     * the store that answers is whichever listener ran first.
+     */
+    readonly store?: string;
+    /** The opaque key the host's policy reads. */
+    readonly key: string;
+    /**
+     * The interest set to start with: keys of the definition's `interest`
+     * collections (grid cells, rooms…). Only those entities are delivered.
+     * Omit it to receive every entity.
+     */
+    readonly interest?: readonly string[];
+    readonly maxEventBytes: number;
+    readonly streamId?: string;
+    now?: () => number;
+    newQ?: () => Hex;
+    schedule?: (run: () => void, ms: number) => Cancel;
+}
+/** A joined replica: reads, actions, inputs, audience, teardown. */
+export interface JoinedStoreHandle<S extends object, A extends ActionSpec, I extends InputSpec> {
+    getState(): ReadonlyState<S>;
+    subscribe(listener: (state: ReadonlyState<S>, previous: ReadonlyState<S>) => void): Cancel;
+    getStatus(): StoreStatus;
+    subscribeStatus(listener: (status: StoreStatus, previous: StoreStatus) => void): Cancel;
+    /** Resolves when a consistent view is installed. */
+    ready(): Promise<void>;
+    act<K extends keyof A & string>(name: K, input: A[K]['input']): Promise<A[K]['output']>;
+    input<K extends keyof I & string>(name: K, value: I[K]): InputDisposition;
+    setAudience(names: readonly string[]): Promise<void>;
+    /**
+     * Replace the interest set. Entities entering it arrive and entities
+     * leaving it go in one change — the view never blanks. Resolves once
+     * the host has applied it.
+     */
+    setInterest(keys: readonly string[]): Promise<void>;
+    /** The session was replaced: resume on the new one (§1.6). */
+    reconnect(): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Join a store hosted by `host`.
+ *
+ * Returns as soon as the join is sent; `ready()` is what waits for a
+ * consistent view, because a caller that wants to render a loading
+ * state should not have to await the world first.
+ */
+export declare function joinStore<S extends object, A extends ActionSpec, I extends InputSpec>(options: JoinStoreOptions<S, A, I>): JoinedStoreHandle<S, A, I>;