@zvk/game-bridge 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Add the initial headless game bridge, geometry, DOM, React, Phaser, and test utility contracts.

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brandon Schabel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @zvk/game-bridge
+
+`@zvk/game-bridge` is a headless boundary between a browser-game runtime and DOM UI. It owns immutable external-store channels, typed UI intents, exact affine projection, and optional DOM, React, and structurally typed Phaser adapters. Games keep simulation, entity selection, camera policy, rendering, persistence, and action semantics.
+
+```sh
+bun add @zvk/game-bridge
+# Add react and/or phaser only when using those adapter subpaths.
+```
+
+## Two lanes
+
+The lower-frequency `state` lane carries app-defined HUD/menu data. The high-frequency `frame` lane atomically carries one transform and its selected projected anchors. Publishing one lane never notifies subscribers to the other.
+
+```ts
+import { createGameBridge } from "@zvk/game-bridge";
+
+const { bridge, producer } = createGameBridge({
+  initialState: { score: 0 },
+  onIntent: ({ intent }) => runtime.dispatch(intent)
+});
+
+producer.state.publish({ score: 1 });
+const stop = bridge.state.subscribe(() => render(bridge.state.getSnapshot()));
+bridge.intents.dispatch({ type: "menu.close" });
+stop();
+```
+
+React consumers use `@zvk/game-bridge/react`; Phaser connectors use `@zvk/game-bridge/phaser`; pure math lives at `@zvk/game-bridge/geometry`; browser measurement lives at `@zvk/game-bridge/dom`; deterministic fixtures live at `@zvk/game-bridge/test-utils`.
+
+For a world overlay, join a projected anchor ID from `bridge.frame` to semantic state from `bridge.state`, then map `anchor.overlayPoint` into an app component or `@zvk/game-ui/canvas-overlay-layer`. The packages integrate through plain data and do not depend on each other.
+
+The package is SSR/import safe: root and geometry need no optional peers or browser globals; React uses a fixed server snapshot; DOM and Phaser work begins only when their explicit factories are called. Cleanup is idempotent, frame work is latest-value-wins, and runtime failures return discriminated data without implicit logging.
+
+See [package overview](docs/content/index.md), [geometry](docs/content/geometry.md), [Phaser compatibility](docs/content/phaser.md), and [migration](docs/content/migration.md).
+
+## Non-goals
+
+This is not an engine, ECS, simulation store, renderer, UI kit, event bus, entity registry, persistence layer, or networking system. It publishes only app-selected plain-data anchors and intents.

package/dist/core/channel.d.ts

@@ -0,0 +1,67 @@
+export type BridgeListener = () => void;
+export type BridgeUnsubscribe = () => void;
+export type BridgeEquality<T> = (left: T, right: T) => boolean;
+export type BridgeChannelLifecycle = "open" | "closed";
+export interface BridgeChannelStatus {
+    readonly lifecycle: BridgeChannelLifecycle;
+    readonly revision: number;
+    readonly acceptedPublications: number;
+    readonly skippedPublications: number;
+    readonly listenerCount: number;
+    readonly closeReason?: string;
+}
+export type BridgePublishResult = {
+    readonly status: "published";
+    readonly revision: number;
+} | {
+    readonly status: "unchanged";
+    readonly revision: number;
+} | {
+    readonly status: "closed";
+    readonly revision: number;
+    readonly reason?: string;
+} | {
+    readonly status: "queued";
+    readonly revision: number;
+} | {
+    readonly status: "rejected";
+    readonly revision: number;
+    readonly reason: "equality-threw";
+    readonly error: unknown;
+};
+export type BridgeCloseResult = {
+    readonly status: "closed";
+    readonly revision: number;
+} | {
+    readonly status: "already-closed";
+    readonly revision: number;
+};
+export interface BridgeReader<TSnapshot> {
+    readonly getSnapshot: () => TSnapshot;
+    readonly getServerSnapshot: () => TSnapshot;
+    readonly subscribe: (listener: BridgeListener) => BridgeUnsubscribe;
+    readonly getRevision: () => number;
+    readonly getStatus: () => BridgeChannelStatus;
+}
+export interface BridgePublisher<TSnapshot> {
+    readonly publish: (snapshot: TSnapshot) => BridgePublishResult;
+    readonly close: (reason?: string) => BridgeCloseResult;
+}
+export interface BridgeChannel<TSnapshot> {
+    readonly reader: BridgeReader<TSnapshot>;
+    readonly publisher: BridgePublisher<TSnapshot>;
+}
+export interface CreateBridgeChannelOptions<TSnapshot> {
+    readonly initialSnapshot: TSnapshot;
+    readonly serverSnapshot?: TSnapshot;
+    readonly equals?: BridgeEquality<TSnapshot>;
+    readonly onSubscriberError?: (error: unknown, context: {
+        readonly revision: number;
+        readonly listenerIndex: number;
+    }) => void;
+    readonly onPublicationError?: (error: unknown, context: {
+        readonly phase: "equality";
+        readonly revision: number;
+    }) => void;
+}
+export declare function createBridgeChannel<TSnapshot>(options: CreateBridgeChannelOptions<TSnapshot>): BridgeChannel<TSnapshot>;

package/dist/core/channel.js

@@ -0,0 +1,153 @@
+function throwAsynchronously(error) {
+    queueMicrotask(() => {
+        throw error;
+    });
+}
+function assertOptionalFunction(value, name) {
+    if (value !== undefined && typeof value !== "function") {
+        throw new TypeError(`${name} must be a function when provided`);
+    }
+}
+export function createBridgeChannel(options) {
+    if (options === null || typeof options !== "object") {
+        throw new TypeError("createBridgeChannel options must be an object");
+    }
+    assertOptionalFunction(options.equals, "equals");
+    assertOptionalFunction(options.onSubscriberError, "onSubscriberError");
+    assertOptionalFunction(options.onPublicationError, "onPublicationError");
+    const equals = options.equals ?? Object.is;
+    const serverSnapshot = options.serverSnapshot ?? options.initialSnapshot;
+    let snapshot = options.initialSnapshot;
+    let revision = 0;
+    let acceptedPublications = 0;
+    let skippedPublications = 0;
+    let lifecycle = "open";
+    let closeReason;
+    let listeners = [];
+    let notifying = false;
+    const publicationQueue = [];
+    const reportPublicationError = (error) => {
+        if (options.onPublicationError === undefined) {
+            return;
+        }
+        try {
+            options.onPublicationError(error, { phase: "equality", revision });
+        }
+        catch (observerError) {
+            throwAsynchronously(observerError);
+        }
+    };
+    const notify = () => {
+        const stableListeners = listeners.slice();
+        notifying = true;
+        try {
+            for (let index = 0; index < stableListeners.length; index += 1) {
+                const entry = stableListeners[index];
+                if (entry === undefined)
+                    continue;
+                try {
+                    entry.listener();
+                }
+                catch (error) {
+                    if (options.onSubscriberError === undefined) {
+                        throwAsynchronously(error);
+                        continue;
+                    }
+                    try {
+                        options.onSubscriberError(error, { revision, listenerIndex: index });
+                    }
+                    catch (observerError) {
+                        throwAsynchronously(observerError);
+                    }
+                }
+            }
+        }
+        finally {
+            notifying = false;
+        }
+    };
+    const commit = (candidate) => {
+        let unchanged;
+        try {
+            unchanged = equals(snapshot, candidate);
+        }
+        catch (error) {
+            skippedPublications += 1;
+            reportPublicationError(error);
+            return { status: "rejected", revision, reason: "equality-threw", error };
+        }
+        if (unchanged) {
+            skippedPublications += 1;
+            return { status: "unchanged", revision };
+        }
+        snapshot = candidate;
+        revision += 1;
+        acceptedPublications += 1;
+        notify();
+        return { status: "published", revision };
+    };
+    const drain = () => {
+        while (lifecycle === "open" && publicationQueue.length > 0) {
+            const candidate = publicationQueue.shift();
+            commit(candidate);
+        }
+        if (lifecycle === "closed")
+            publicationQueue.length = 0;
+    };
+    const publish = (candidate) => {
+        if (lifecycle === "closed") {
+            return closeReason === undefined
+                ? { status: "closed", revision }
+                : { status: "closed", revision, reason: closeReason };
+        }
+        if (notifying) {
+            publicationQueue.push(candidate);
+            return { status: "queued", revision };
+        }
+        const result = commit(candidate);
+        drain();
+        return result;
+    };
+    const close = (reason) => {
+        if (lifecycle === "closed")
+            return { status: "already-closed", revision };
+        lifecycle = "closed";
+        closeReason = reason;
+        publicationQueue.length = 0;
+        listeners = [];
+        return { status: "closed", revision };
+    };
+    const reader = {
+        getSnapshot: () => snapshot,
+        getServerSnapshot: () => serverSnapshot,
+        subscribe: (listener) => {
+            if (typeof listener !== "function")
+                throw new TypeError("listener must be a function");
+            if (lifecycle === "closed")
+                return () => { };
+            const entry = { listener, active: true };
+            listeners.push(entry);
+            return () => {
+                if (!entry.active)
+                    return;
+                entry.active = false;
+                const index = listeners.indexOf(entry);
+                if (index >= 0)
+                    listeners.splice(index, 1);
+            };
+        },
+        getRevision: () => revision,
+        getStatus: () => {
+            const status = {
+                lifecycle,
+                revision,
+                acceptedPublications,
+                skippedPublications,
+                listenerCount: listeners.length,
+                ...(closeReason === undefined ? {} : { closeReason }),
+            };
+            return status;
+        },
+    };
+    return { reader, publisher: { publish, close } };
+}

package/dist/core/coalesced-publisher.d.ts

@@ -0,0 +1,35 @@
+import type { BridgeCloseResult, BridgePublisher, BridgePublishResult } from "./channel.js";
+export interface BridgeScheduler<THandle = unknown> {
+    readonly request: (flush: () => void) => THandle;
+    readonly cancel: (handle: THandle) => void;
+}
+export type BridgeStageResult = {
+    readonly status: "scheduled";
+} | {
+    readonly status: "replaced-pending";
+} | {
+    readonly status: "scheduler-error";
+    readonly error: unknown;
+} | {
+    readonly status: "closed";
+    readonly reason?: string;
+};
+export type BridgeFlushResult = BridgePublishResult | {
+    readonly status: "empty";
+};
+export type BridgeCancelResult = {
+    readonly status: "cancelled";
+} | {
+    readonly status: "empty";
+} | {
+    readonly status: "closed";
+};
+export interface CoalescedPublisher<TSnapshot> {
+    readonly stage: (snapshot: TSnapshot) => BridgeStageResult;
+    readonly flush: () => BridgeFlushResult;
+    readonly cancel: () => BridgeCancelResult;
+    readonly close: (reason?: string) => BridgeCloseResult;
+}
+export declare function createCoalescedPublisher<TSnapshot, THandle = unknown>(publisher: BridgePublisher<TSnapshot>, scheduler: BridgeScheduler<THandle>, options?: {
+    readonly onSchedulerError?: (error: unknown, phase: "request" | "cancel") => void;
+}): CoalescedPublisher<TSnapshot>;

package/dist/core/coalesced-publisher.js

@@ -0,0 +1,127 @@
+function throwAsynchronously(error) {
+    queueMicrotask(() => {
+        throw error;
+    });
+}
+export function createCoalescedPublisher(publisher, scheduler, options = {}) {
+    if (publisher === null || typeof publisher !== "object" || typeof publisher.publish !== "function" || typeof publisher.close !== "function") {
+        throw new TypeError("publisher must provide publish and close functions");
+    }
+    if (scheduler === null || typeof scheduler !== "object" || typeof scheduler.request !== "function" || typeof scheduler.cancel !== "function") {
+        throw new TypeError("scheduler must provide request and cancel functions");
+    }
+    if (options.onSchedulerError !== undefined && typeof options.onSchedulerError !== "function") {
+        throw new TypeError("onSchedulerError must be a function when provided");
+    }
+    let staged;
+    let hasStaged = false;
+    let handle;
+    let hasHandle = false;
+    let closed = false;
+    let closeReason;
+    let generation = 0;
+    const reportSchedulerError = (error, phase) => {
+        if (options.onSchedulerError === undefined) {
+            throwAsynchronously(error);
+            return;
+        }
+        try {
+            options.onSchedulerError(error, phase);
+        }
+        catch (observerError) {
+            throwAsynchronously(observerError);
+        }
+    };
+    const clearPending = () => {
+        staged = undefined;
+        hasStaged = false;
+        handle = undefined;
+        hasHandle = false;
+    };
+    const cancelHandle = () => {
+        if (!hasHandle)
+            return;
+        const pendingHandle = handle;
+        handle = undefined;
+        hasHandle = false;
+        try {
+            scheduler.cancel(pendingHandle);
+        }
+        catch (error) {
+            reportSchedulerError(error, "cancel");
+        }
+    };
+    const commitStaged = () => {
+        if (!hasStaged)
+            return { status: "empty" };
+        const candidate = staged;
+        staged = undefined;
+        hasStaged = false;
+        return publisher.publish(candidate);
+    };
+    const stage = (snapshot) => {
+        if (closed) {
+            return closeReason === undefined
+                ? { status: "closed" }
+                : { status: "closed", reason: closeReason };
+        }
+        if (hasStaged) {
+            staged = snapshot;
+            return { status: "replaced-pending" };
+        }
+        staged = snapshot;
+        hasStaged = true;
+        const requestedGeneration = generation;
+        let callbackRanSynchronously = false;
+        try {
+            const requestedHandle = scheduler.request(() => {
+                callbackRanSynchronously = true;
+                if (closed || requestedGeneration !== generation)
+                    return;
+                handle = undefined;
+                hasHandle = false;
+                commitStaged();
+            });
+            if (!callbackRanSynchronously) {
+                handle = requestedHandle;
+                hasHandle = true;
+            }
+            return { status: "scheduled" };
+        }
+        catch (error) {
+            clearPending();
+            reportSchedulerError(error, "request");
+            return { status: "scheduler-error", error };
+        }
+    };
+    const flush = () => {
+        if (!hasStaged)
+            return { status: "empty" };
+        generation += 1;
+        cancelHandle();
+        return commitStaged();
+    };
+    const cancel = () => {
+        if (closed)
+            return { status: "closed" };
+        if (!hasStaged && !hasHandle)
+            return { status: "empty" };
+        generation += 1;
+        cancelHandle();
+        staged = undefined;
+        hasStaged = false;
+        return { status: "cancelled" };
+    };
+    const close = (reason) => {
+        if (closed)
+            return publisher.close(reason);
+        closed = true;
+        closeReason = reason;
+        generation += 1;
+        cancelHandle();
+        staged = undefined;
+        hasStaged = false;
+        return publisher.close(reason);
+    };
+    return { stage, flush, cancel, close };
+}

package/dist/core/game-bridge.d.ts

@@ -0,0 +1,60 @@
+import type { GameBridgeTransformSnapshotV1, ProjectedWorldAnchor } from "../geometry/index.js";
+import type { BridgeEquality, BridgePublisher, BridgeReader } from "./channel.js";
+import type { IntentEnvelope, IntentSink } from "./intents.js";
+import type { GameBridgeDiagnostic, JsonValue } from "./types.js";
+export type GameBridgeFrameStatus = "idle" | "not-ready" | "ready" | "disconnected" | "destroyed";
+export interface GameBridgeFrame<TAnchorMetadata extends JsonValue = JsonValue> {
+    readonly protocolVersion: 1;
+    readonly sourceFrameId: number;
+    readonly capturedAtMs: number;
+    readonly clockId: string;
+    readonly status: GameBridgeFrameStatus;
+    readonly transform: GameBridgeTransformSnapshotV1 | null;
+    readonly anchors: readonly ProjectedWorldAnchor<TAnchorMetadata>[];
+    readonly diagnostics: readonly GameBridgeDiagnostic[];
+}
+export declare function createIdleGameBridgeFrame<TAnchorMetadata extends JsonValue = JsonValue>(options?: {
+    readonly sourceFrameId?: number;
+    readonly capturedAtMs?: number;
+    readonly clockId?: string;
+}): GameBridgeFrame<TAnchorMetadata>;
+export interface CreateGameBridgeOptions<TState, TIntent extends JsonValue, TAnchorMetadata extends JsonValue = JsonValue> {
+    readonly initialState: TState;
+    readonly serverState?: TState;
+    readonly stateEquals?: BridgeEquality<TState>;
+    readonly initialFrame?: GameBridgeFrame<TAnchorMetadata>;
+    readonly onIntent?: (envelope: IntentEnvelope<TIntent>) => void;
+    readonly now?: () => number;
+    readonly onSubscriberError?: (error: unknown, context: {
+        readonly lane: "state" | "frame";
+        readonly revision: number;
+        readonly listenerIndex: number;
+    }) => void;
+}
+export interface GameBridgeStatus {
+    readonly lifecycle: "open" | "destroyed";
+    readonly stateRevision: number;
+    readonly frameRevision: number;
+    readonly nextIntentSequence: number;
+}
+export type GameBridgeDestroyResult = {
+    readonly status: "destroyed";
+} | {
+    readonly status: "already-destroyed";
+};
+export interface GameBridge<TState, TIntent extends JsonValue, TAnchorMetadata extends JsonValue = JsonValue> {
+    readonly state: BridgeReader<TState>;
+    readonly frame: BridgeReader<GameBridgeFrame<TAnchorMetadata>>;
+    readonly intents: IntentSink<TIntent>;
+    readonly getStatus: () => GameBridgeStatus;
+    readonly destroy: () => GameBridgeDestroyResult;
+}
+export interface GameBridgeProducer<TState, TAnchorMetadata extends JsonValue = JsonValue> {
+    readonly state: BridgePublisher<TState>;
+    readonly frame: BridgePublisher<GameBridgeFrame<TAnchorMetadata>>;
+}
+export interface CreatedGameBridge<TState, TIntent extends JsonValue, TAnchorMetadata extends JsonValue = JsonValue> {
+    readonly bridge: GameBridge<TState, TIntent, TAnchorMetadata>;
+    readonly producer: GameBridgeProducer<TState, TAnchorMetadata>;
+}
+export declare function createGameBridge<TState, TIntent extends JsonValue, TAnchorMetadata extends JsonValue = JsonValue>(options: CreateGameBridgeOptions<TState, TIntent, TAnchorMetadata>): CreatedGameBridge<TState, TIntent, TAnchorMetadata>;

package/dist/core/game-bridge.js

@@ -0,0 +1,118 @@
+import { createBridgeChannel } from "./channel.js";
+import { createIntentSink } from "./intents.js";
+export function createIdleGameBridgeFrame(options = {}) {
+    const sourceFrameId = options.sourceFrameId ?? 0;
+    const capturedAtMs = options.capturedAtMs ?? 0;
+    const clockId = options.clockId ?? "bridge-idle";
+    if (!Number.isSafeInteger(sourceFrameId) || sourceFrameId < 0) {
+        throw new RangeError("sourceFrameId must be a non-negative safe integer");
+    }
+    if (!Number.isFinite(capturedAtMs))
+        throw new RangeError("capturedAtMs must be finite");
+    if (clockId.length === 0)
+        throw new RangeError("clockId must not be empty");
+    return {
+        protocolVersion: 1,
+        sourceFrameId,
+        capturedAtMs,
+        clockId,
+        status: "idle",
+        transform: null,
+        anchors: [],
+        diagnostics: [],
+    };
+}
+export function createGameBridge(options) {
+    if (options === null || typeof options !== "object") {
+        throw new TypeError("createGameBridge options must be an object");
+    }
+    if (options.onSubscriberError !== undefined && typeof options.onSubscriberError !== "function") {
+        throw new TypeError("onSubscriberError must be a function when provided");
+    }
+    const stateChannel = createBridgeChannel({
+        initialSnapshot: options.initialState,
+        ...(options.serverState === undefined ? {} : { serverSnapshot: options.serverState }),
+        ...(options.stateEquals === undefined ? {} : { equals: options.stateEquals }),
+        ...(options.onSubscriberError === undefined
+            ? {}
+            : {
+                onSubscriberError: (error, context) => options.onSubscriberError?.(error, { lane: "state", ...context }),
+            }),
+    });
+    const initialFrame = options.initialFrame ?? createIdleGameBridgeFrame();
+    const frameChannel = createBridgeChannel({
+        initialSnapshot: initialFrame,
+        ...(options.onSubscriberError === undefined
+            ? {}
+            : {
+                onSubscriberError: (error, context) => options.onSubscriberError?.(error, { lane: "frame", ...context }),
+            }),
+    });
+    const intentPort = createIntentSink({
+        ...(options.onIntent === undefined ? {} : { onIntent: options.onIntent }),
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    let lifecycle = "open";
+    const getStatus = () => ({
+        lifecycle,
+        stateRevision: stateChannel.reader.getRevision(),
+        frameRevision: frameChannel.reader.getRevision(),
+        nextIntentSequence: intentPort.getNextSequence(),
+    });
+    const destroy = () => {
+        if (lifecycle === "destroyed")
+            return { status: "already-destroyed" };
+        lifecycle = "destroyed";
+        intentPort.destroy();
+        const current = frameChannel.reader.getSnapshot();
+        if (current.status !== "destroyed") {
+            frameChannel.publisher.publish({
+                protocolVersion: 1,
+                sourceFrameId: current.sourceFrameId,
+                capturedAtMs: current.capturedAtMs,
+                clockId: current.clockId,
+                status: "destroyed",
+                transform: null,
+                anchors: [],
+                diagnostics: current.diagnostics,
+            });
+        }
+        frameChannel.publisher.close("bridge-destroyed");
+        stateChannel.publisher.close("bridge-destroyed");
+        return { status: "destroyed" };
+    };
+    const destroyedPublication = () => ({
+        status: "closed",
+        revision: stateChannel.reader.getRevision(),
+        reason: "bridge-destroyed",
+    });
+    const statePublisher = {
+        publish: (snapshot) => lifecycle === "destroyed"
+            ? destroyedPublication()
+            : stateChannel.publisher.publish(snapshot),
+        close: (reason) => stateChannel.publisher.close(reason),
+    };
+    const framePublisher = {
+        publish: (frame) => lifecycle === "destroyed"
+            ? {
+                status: "closed",
+                revision: frameChannel.reader.getRevision(),
+                reason: "bridge-destroyed",
+            }
+            : frameChannel.publisher.publish(frame),
+        close: (reason) => frameChannel.publisher.close(reason),
+    };
+    return {
+        bridge: {
+            state: stateChannel.reader,
+            frame: frameChannel.reader,
+            intents: intentPort.sink,
+            getStatus,
+            destroy,
+        },
+        producer: {
+            state: statePublisher,
+            frame: framePublisher,
+        },
+    };
+}

package/dist/core/intents.d.ts

@@ -0,0 +1,33 @@
+import type { JsonValue } from "./types.js";
+export interface IntentEnvelope<TIntent extends JsonValue> {
+    readonly protocolVersion: 1;
+    readonly sequence: number;
+    readonly issuedAtMs: number;
+    readonly source?: string;
+    readonly intent: TIntent;
+}
+export type IntentDispatchResult = {
+    readonly status: "handled";
+    readonly sequence: number;
+} | {
+    readonly status: "unhandled";
+    readonly sequence: number;
+} | {
+    readonly status: "destroyed";
+    readonly sequence: number;
+};
+export interface IntentSink<TIntent extends JsonValue> {
+    readonly dispatch: (intent: TIntent, options?: {
+        readonly source?: string;
+        readonly issuedAtMs?: number;
+    }) => IntentDispatchResult;
+}
+export interface CreatedIntentSink<TIntent extends JsonValue> {
+    readonly sink: IntentSink<TIntent>;
+    readonly getNextSequence: () => number;
+    readonly destroy: () => void;
+}
+export declare function createIntentSink<TIntent extends JsonValue>(options?: {
+    readonly onIntent?: (envelope: IntentEnvelope<TIntent>) => void;
+    readonly now?: () => number;
+}): CreatedIntentSink<TIntent>;