@cynodia/axiom-server 0.6.0-alpha.1

package/dist/server.js

@@ -0,0 +1,419 @@
+import { DEFAULT_THEME, PRINCIPAL, SERVER_IR_CONTRACT, optionalType, entityType, validateValueAgainstType, } from '@cynodia/axiom-core';
+import { MemoryElement, createAxiomRuntime, createMemoryHost } from '@cynodia/axiom-runtime';
+import { createMemoryPersistence } from './persistence.js';
+import { createServerHost } from './host.js';
+import { PROTOCOL_VERSION } from './protocol.js';
+/**
+ * Diagnostic codes the authority adds to the runtime vocabulary. They describe failures of
+ * the boundary, not of an application rule.
+ */
+export const SERVER_DIAGNOSTIC_CODES = {
+    /** The request named an action this authority does not execute. */
+    UNKNOWN_SERVER_ACTION: 'UNKNOWN_SERVER_ACTION',
+    /** An argument did not conform to its declared parameter type. */
+    ARGUMENT_TYPE_MISMATCH: 'ARGUMENT_TYPE_MISMATCH',
+    /** The caller may not invoke this action. */
+    AUTHORIZATION_DENIED: 'AUTHORIZATION_DENIED',
+    /** Another transaction committed the same state first; nothing was applied. */
+    CONCURRENCY_CONFLICT: 'CONCURRENCY_CONFLICT',
+    /** The request itself was malformed, or spoke an unknown protocol. */
+    MALFORMED_REQUEST: 'MALFORMED_REQUEST',
+    /** The authority could not be reached, or did not answer. */
+    AUTHORITY_UNREACHABLE: 'AUTHORITY_UNREACHABLE',
+};
+const IDEMPOTENCY_WINDOW = 256;
+function diagnostic(code, message, details) {
+    // Server codes join the same structured vocabulary, so a client matches on `code` exactly
+    // as it does for a local failure.
+    return {
+        code: code,
+        message,
+        severity: 'error',
+        ...(details ? { details } : {}),
+    };
+}
+/**
+ * The authoritative runtime.
+ *
+ * It executes the **same semantic engine** the client runs, given an IR that contains no UI
+ * and no routes. That is deliberate rather than convenient: transaction boundaries,
+ * provisional writes, `for-each` ordering, constraint and transition evaluation, rollback
+ * and the mutation log are not reimplemented here, so a graph cannot behave differently
+ * merely because execution moved to the authority.
+ *
+ * Requests are serialized. One action runs at a time, and its persistence commit completes
+ * before the next begins, so two callers cannot both commit from the same snapshot.
+ */
+export function createAxiomServer(options) {
+    if (options.ir.contract !== SERVER_IR_CONTRACT) {
+        throw new Error(`Unsupported Server IR contract "${String(options.ir.contract)}"; this runtime executes ${SERVER_IR_CONTRACT}`);
+    }
+    const ir = options.ir;
+    const persistence = options.persistence ?? createMemoryPersistence();
+    const host = options.host ?? createServerHost();
+    const window = options.idempotencyWindow ?? IDEMPOTENCY_WINDOW;
+    const entities = new Map(ir.entities.map((entity) => [entity.id, entity]));
+    const statesById = new Map(ir.states.map((state) => [state.id, state]));
+    /** Persistable state: derived values are recomputed, never stored. */
+    const durableStateIds = ir.states.filter((state) => !state.derivation).map((state) => state.id);
+    const runtime = buildRuntime(ir, host);
+    let storeRevision = 0;
+    const revisions = new Map();
+    const replies = new Map();
+    let queue = Promise.resolve();
+    let started = false;
+    /** Runs `body` after every earlier request has finished, and before any later one. */
+    function serialize(body) {
+        const next = queue.then(body, body);
+        queue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    function report(event) {
+        host.report?.(event);
+    }
+    /** The caller's identity field only. A whole principal record is never reported. */
+    function principalIdentity(principal) {
+        if (!principal || !ir.principalEntityId) {
+            return undefined;
+        }
+        const identity = entities.get(ir.principalEntityId)?.identityFieldId;
+        return identity ? principal[identity] : undefined;
+    }
+    async function resolvePrincipal(request) {
+        if (!host.authenticate) {
+            return null;
+        }
+        return (await host.authenticate(request.credential ?? null)) ?? null;
+    }
+    /** Untrusted input, checked against the declared parameter types. */
+    function checkArguments(action, args) {
+        const problems = [];
+        const declared = new Map((action.parameters ?? []).map((parameter) => [String(parameter.id), parameter]));
+        for (const key of Object.keys(args)) {
+            if (!declared.has(key)) {
+                problems.push(diagnostic(SERVER_DIAGNOSTIC_CODES.ARGUMENT_TYPE_MISMATCH, `${action.name ?? action.id} has no parameter ${key}`, { parameterId: key, expected: [...declared.keys()] }));
+            }
+        }
+        for (const parameter of action.parameters ?? []) {
+            const present = Object.prototype.hasOwnProperty.call(args, String(parameter.id));
+            const value = args[String(parameter.id)];
+            if (!present || value === undefined || value === null) {
+                if (parameter.required) {
+                    problems.push(diagnostic(SERVER_DIAGNOSTIC_CODES.ARGUMENT_TYPE_MISMATCH, `${action.name ?? action.id} requires ${parameter.name ?? parameter.id}`, { parameterId: parameter.id }));
+                }
+                continue;
+            }
+            if (!parameter.valueType) {
+                continue;
+            }
+            // The same walk that checks seed data checks hostile input; there is no second
+            // validation system to drift from the type model.
+            const issues = validateValueAgainstType(value, parameter.valueType, {
+                path: String(parameter.id),
+                getEntity: (id) => entities.get(id),
+            });
+            for (const problem of issues) {
+                problems.push(diagnostic(SERVER_DIAGNOSTIC_CODES.ARGUMENT_TYPE_MISMATCH, problem.message, {
+                    parameterId: parameter.id,
+                    ...problem.details,
+                }));
+            }
+        }
+        return problems;
+    }
+    /** Authorization, evaluated here and nowhere else. */
+    function authorize(action, context) {
+        if (!action.authorization) {
+            return null;
+        }
+        runtime.hydrateState(PRINCIPAL, context.principal);
+        const outcome = runtime.evaluate(action.authorization);
+        if (!outcome.ok) {
+            // A rule that cannot be evaluated denies, exactly as an unevaluable constraint is
+            // counted as violated.
+            return diagnostic(SERVER_DIAGNOSTIC_CODES.AUTHORIZATION_DENIED, `Authorization for ${action.name ?? action.id} could not be evaluated`, { actionId: action.id, cause: outcome.diagnostic.code });
+        }
+        const permitted = Array.isArray(outcome.value) ? outcome.value.length > 0 : Boolean(outcome.value);
+        return permitted
+            ? null
+            : diagnostic(SERVER_DIAGNOSTIC_CODES.AUTHORIZATION_DENIED, `The caller may not invoke ${action.name ?? action.id}`, { actionId: action.id, principal: principalIdentity(context.principal) });
+    }
+    function snapshotOf() {
+        const states = {};
+        for (const stateId of ir.observableStateIds) {
+            states[stateId] = runtime.getState(stateId);
+        }
+        return { revision: storeRevision, states };
+    }
+    function remember(requestId, response) {
+        replies.set(requestId, response);
+        if (replies.size > window) {
+            const oldest = replies.keys().next().value;
+            if (oldest !== undefined) {
+                replies.delete(oldest);
+            }
+        }
+    }
+    async function invoke(request) {
+        const startedAt = Date.now();
+        if (request.requestId) {
+            const previous = replies.get(request.requestId);
+            if (previous) {
+                // A retry after a lost response must not execute the action a second time.
+                report({ kind: 'replay', actionId: request.actionId, requestId: request.requestId });
+                return { ...previous, replayed: true };
+            }
+        }
+        // Resolved from this authority's own IR. A client's idea of what an action does is
+        // never consulted.
+        const action = ir.actions[request.actionId];
+        if (!action) {
+            const diagnostics = [
+                diagnostic(SERVER_DIAGNOSTIC_CODES.UNKNOWN_SERVER_ACTION, `This authority does not execute ${String(request.actionId)}`, { actionId: request.actionId }),
+            ];
+            report({ kind: 'reject', actionId: request.actionId, ok: false, diagnostics });
+            return refusal(diagnostics, request.requestId);
+        }
+        const context = {
+            principal: await resolvePrincipal(request),
+            ...(request.credential !== undefined ? { credential: request.credential } : {}),
+            ...(request.requestId ? { requestId: request.requestId } : {}),
+        };
+        const argumentProblems = checkArguments(action, request.arguments ?? {});
+        if (argumentProblems.length > 0) {
+            report({ kind: 'reject', actionId: action.id, ok: false, diagnostics: argumentProblems });
+            return refusal(argumentProblems, request.requestId);
+        }
+        const denial = authorize(action, context);
+        if (denial) {
+            report({
+                kind: 'reject',
+                actionId: action.id,
+                ok: false,
+                principal: principalIdentity(context.principal),
+                diagnostics: [denial],
+            });
+            return refusal([denial], request.requestId);
+        }
+        // Everything the transaction might touch, as it stands now, so a refused commit can be
+        // undone exactly.
+        const before = new Map();
+        for (const stateId of durableStateIds) {
+            before.set(stateId, runtime.getState(stateId));
+        }
+        const mark = runtime.getMutationLog().length;
+        runtime.clearDiagnostics();
+        const result = runtime.invokeAction(action.id, request.arguments ?? {});
+        const written = new Set();
+        for (const entry of runtime.getMutationLog().slice(mark)) {
+            if (entry.outcome === 'committed') {
+                written.add(entry.path.rootStateId);
+            }
+        }
+        const writes = [...written].filter((stateId) => durableStateIds.includes(stateId));
+        if (!result.ok || writes.length === 0) {
+            const response = respond(result.ok, result.diagnostics, {}, request.requestId);
+            report({
+                kind: 'invoke',
+                actionId: action.id,
+                ok: result.ok,
+                principal: principalIdentity(context.principal),
+                requestId: request.requestId,
+                durationMs: Date.now() - startedAt,
+                revision: storeRevision,
+                diagnostics: result.diagnostics,
+                committed: [],
+            });
+            if (request.requestId) {
+                remember(request.requestId, response);
+            }
+            return response;
+        }
+        const expected = {};
+        for (const stateId of writes) {
+            expected[stateId] = revisions.get(stateId) ?? 0;
+        }
+        const outcome = await persistence.commit({
+            writes: writes.map((stateId) => ({ stateId, value: runtime.getState(stateId) })),
+            expected,
+        });
+        if (!outcome.committed) {
+            // Nothing durable was written, so nothing in memory may survive either.
+            for (const stateId of writes) {
+                runtime.hydrateState(stateId, before.get(stateId));
+            }
+            const diagnostics = [
+                diagnostic(SERVER_DIAGNOSTIC_CODES.CONCURRENCY_CONFLICT, `${action.name ?? action.id} was not committed: ${outcome.conflicts.join(', ')} changed while it ran`, { actionId: action.id, conflicts: outcome.conflicts }),
+            ];
+            report({ kind: 'conflict', actionId: action.id, ok: false, diagnostics, revision: outcome.revision });
+            const response = refusal(diagnostics, request.requestId);
+            if (request.requestId) {
+                remember(request.requestId, response);
+            }
+            return response;
+        }
+        storeRevision = outcome.revision;
+        for (const stateId of writes) {
+            revisions.set(stateId, outcome.revision);
+        }
+        const changes = {};
+        for (const stateId of ir.observableStateIds) {
+            if (written.has(stateId) || ir.states.find((state) => state.id === stateId)?.derivation) {
+                changes[stateId] = runtime.getState(stateId);
+            }
+        }
+        const response = respond(true, result.diagnostics, changes, request.requestId);
+        report({
+            kind: 'invoke',
+            actionId: action.id,
+            ok: true,
+            principal: principalIdentity(context.principal),
+            requestId: request.requestId,
+            durationMs: Date.now() - startedAt,
+            revision: storeRevision,
+            committed: writes,
+        });
+        if (request.requestId) {
+            remember(request.requestId, response);
+        }
+        return response;
+    }
+    function respond(ok, diagnostics, changes, requestId) {
+        return {
+            kind: 'result',
+            protocol: PROTOCOL_VERSION,
+            ok,
+            diagnostics,
+            changes,
+            revision: storeRevision,
+            ...(requestId ? { requestId } : {}),
+        };
+    }
+    function refusal(diagnostics, requestId) {
+        return respond(false, diagnostics, {}, requestId);
+    }
+    return {
+        async start() {
+            if (started) {
+                return;
+            }
+            started = true;
+            // Committed state is restored administratively: it is already authoritative, so it
+            // is not re-validated as though it were being proposed.
+            for (const entry of await persistence.load()) {
+                if (statesById.has(entry.stateId)) {
+                    runtime.hydrateState(entry.stateId, entry.value);
+                    revisions.set(entry.stateId, entry.revision);
+                }
+            }
+            storeRevision = await persistence.revision();
+        },
+        handle(request) {
+            return serialize(async () => {
+                if (request?.protocol !== PROTOCOL_VERSION) {
+                    return {
+                        kind: 'error',
+                        protocol: PROTOCOL_VERSION,
+                        diagnostics: [
+                            diagnostic(SERVER_DIAGNOSTIC_CODES.MALFORMED_REQUEST, `Unsupported protocol ${String(request?.protocol)}`),
+                        ],
+                    };
+                }
+                if (request.kind === 'snapshot') {
+                    report({ kind: 'snapshot', revision: storeRevision });
+                    const response = {
+                        kind: 'snapshot',
+                        protocol: PROTOCOL_VERSION,
+                        snapshot: snapshotOf(),
+                    };
+                    return response;
+                }
+                if (request.kind === 'invoke') {
+                    return invoke(request);
+                }
+                return {
+                    kind: 'error',
+                    protocol: PROTOCOL_VERSION,
+                    diagnostics: [
+                        diagnostic(SERVER_DIAGNOSTIC_CODES.MALFORMED_REQUEST, `Unknown request kind ${String(request.kind)}`),
+                    ],
+                };
+            });
+        },
+        snapshot: snapshotOf,
+        getState: (id) => runtime.getState(id),
+        revision: () => storeRevision,
+        mutationLog: () => runtime.getMutationLog(),
+        async stop() {
+            await queue.catch(() => undefined);
+            await persistence.close?.();
+        },
+    };
+}
+/**
+ * Wraps the Server IR as an `ApplicationIR` with no UI, no routes and no presentation, and
+ * runs the ordinary semantic engine over it. Nothing about transactions, constraints or
+ * iteration is reimplemented, which is the only way to guarantee the semantics match.
+ */
+function buildRuntime(ir, host) {
+    const nodes = {};
+    for (const entity of ir.entities) {
+        nodes[entity.id] = entity;
+    }
+    for (const state of ir.states) {
+        nodes[state.id] = state;
+    }
+    for (const action of Object.values(ir.actions)) {
+        nodes[action.id] = action;
+    }
+    for (const constraint of ir.constraints) {
+        nodes[constraint.id] = constraint;
+    }
+    for (const constraint of ir.transitionConstraints) {
+        nodes[constraint.id] = constraint;
+    }
+    const states = [...ir.states];
+    if (ir.principalEntityId) {
+        // The caller is bound through an ordinary state so that `ref(PRINCIPAL)` resolves with
+        // the existing scope rules. It is never persisted and never observable.
+        const principalState = {
+            id: PRINCIPAL,
+            kind: 'state',
+            name: 'principal',
+            valueType: optionalType(entityType(ir.principalEntityId)),
+            ephemeral: true,
+            initialValue: null,
+        };
+        states.push(principalState);
+        nodes[PRINCIPAL] = principalState;
+    }
+    const applicationIR = {
+        id: ir.id,
+        name: ir.name,
+        version: ir.version,
+        nodes,
+        fields: ir.fields,
+        entities: ir.entities,
+        states,
+        actions: ir.actions,
+        uiNodes: {},
+        constraints: ir.constraints,
+        transitionConstraints: ir.transitionConstraints,
+        routes: [],
+        edges: [],
+        locationTypes: {},
+        locationRoots: {},
+        locationRequired: {},
+        repeatIdentityFields: {},
+        authority: {},
+        remoteActionIds: [],
+        theme: DEFAULT_THEME,
+        presentation: {},
+    };
+    const dom = createMemoryHost();
+    return createAxiomRuntime({
+        ir: applicationIR,
+        rootElement: new MemoryElement('div'),
+        host: { ...dom, now: () => host.now(), uuid: () => host.uuid() },
+    });
+}

package/dist/sqlite-persistence.d.ts

@@ -0,0 +1,21 @@
+import type { PersistenceAdapter } from './persistence.js';
+/**
+ * Durable persistence on SQLite, through Node's built-in `node:sqlite`.
+ *
+ * State is stored in document form — one row per state, holding its serialized semantic
+ * value and its revision. That is deliberate: 0.6 is about persistence *semantics*, and a
+ * relational projection of the semantic model is separate design work. What matters here is
+ * durability, atomicity, identity preservation and transaction correctness.
+ *
+ * The whole semantic transaction is written inside one SQL transaction, so a crash cannot
+ * leave half of an action committed.
+ */
+export interface SqlitePersistenceOptions {
+    /** A file path, or `':memory:'`. */
+    location: string;
+    table?: string;
+}
+/** Whether this Node build offers `node:sqlite` at all. */
+export declare function isSqliteAvailable(): Promise<boolean>;
+export declare function createSqlitePersistence(options: SqlitePersistenceOptions): Promise<PersistenceAdapter>;
+//# sourceMappingURL=sqlite-persistence.d.ts.map

package/dist/sqlite-persistence.js

@@ -0,0 +1,73 @@
+/** Whether this Node build offers `node:sqlite` at all. */
+export async function isSqliteAvailable() {
+    try {
+        const module = (await import('node:sqlite'));
+        return typeof module.DatabaseSync === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+export async function createSqlitePersistence(options) {
+    const module = (await import('node:sqlite'));
+    const table = options.table ?? 'axiom_state';
+    const database = new module.DatabaseSync(options.location);
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS ${table} (
+      state_id TEXT PRIMARY KEY,
+      revision INTEGER NOT NULL,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS ${table}_meta (
+      key TEXT PRIMARY KEY,
+      value INTEGER NOT NULL
+    );
+  `);
+    const readAll = database.prepare(`SELECT state_id, revision, value FROM ${table}`);
+    const readRevision = database.prepare(`SELECT value FROM ${table}_meta WHERE key = 'revision'`);
+    const readOne = database.prepare(`SELECT revision FROM ${table} WHERE state_id = ?`);
+    const upsert = database.prepare(`INSERT INTO ${table} (state_id, revision, value) VALUES (?, ?, ?)
+     ON CONFLICT(state_id) DO UPDATE SET revision = excluded.revision, value = excluded.value`);
+    const setRevision = database.prepare(`INSERT INTO ${table}_meta (key, value) VALUES ('revision', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`);
+    const currentRevision = () => Number(readRevision.get()?.value ?? 0);
+    return {
+        async load() {
+            return readAll.all().map((row) => ({
+                stateId: String(row.state_id),
+                revision: Number(row.revision),
+                value: JSON.parse(String(row.value)),
+            }));
+        },
+        async commit(commit) {
+            const conflicts = commit.writes
+                .map((write) => write.stateId)
+                .filter((stateId) => Number(readOne.get(stateId)?.revision ?? 0) !== (commit.expected[stateId] ?? 0));
+            if (conflicts.length > 0) {
+                return { committed: false, revision: currentRevision(), conflicts };
+            }
+            const revision = currentRevision() + 1;
+            // One SQL transaction for one semantic transaction. A failure part-way leaves the
+            // store exactly as it was.
+            database.exec('BEGIN IMMEDIATE');
+            try {
+                for (const write of commit.writes) {
+                    upsert.run(write.stateId, revision, JSON.stringify(write.value ?? null));
+                }
+                setRevision.run(revision);
+                database.exec('COMMIT');
+            }
+            catch (error) {
+                database.exec('ROLLBACK');
+                throw error;
+            }
+            return { committed: true, revision, conflicts: [] };
+        },
+        async revision() {
+            return currentRevision();
+        },
+        async close() {
+            database.close();
+        },
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,38 @@
+import type { ServerResponse, TransportAdapter } from './protocol.js';
+import type { AxiomServer } from './server.js';
+import type { RemoteGateway } from '@cynodia/axiom-runtime';
+/**
+ * In-process transport: the client runtime talks to an authority in the same process,
+ * without opening a port.
+ *
+ * This is what makes an end-to-end semantic test deterministic — the whole client/server
+ * round trip, with the real authority, and nothing asynchronous but the call itself.
+ */
+export interface DirectTransportOptions {
+    /** Read per request, so a client is configured the same way on every transport. */
+    credential?: () => string | null;
+}
+export declare function createDirectTransport(server: AxiomServer, options?: DirectTransportOptions): TransportAdapter;
+export interface HttpTransportOptions {
+    url: string;
+    /** Supplied per request, so a host can refresh a credential without rebuilding the client. */
+    credential?: () => string | null;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}
+/**
+ * The reference network transport.
+ *
+ * HTTP is an implementation detail of this adapter: one endpoint carrying semantic
+ * requests, never a route per entity. No ApplicationGraph mentions a URL or a verb, and
+ * replacing this with a WebSocket or a worker channel changes nothing in a graph.
+ */
+export declare function createHttpTransport(options: HttpTransportOptions): TransportAdapter;
+/**
+ * Adapts a transport into the gateway a client runtime expects, so a client is configured
+ * with one object and knows nothing about how the authority is reached.
+ */
+export declare function createRemoteGateway(transport: TransportAdapter): RemoteGateway;
+/** Reads and dispatches one semantic request. Shared by every server-side transport. */
+export declare function dispatch(server: AxiomServer, body: unknown): Promise<ServerResponse>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.js

@@ -0,0 +1,106 @@
+import { PROTOCOL_VERSION, isServerRequest } from './protocol.js';
+import { SERVER_DIAGNOSTIC_CODES } from './server.js';
+function boundaryFailure(code, message) {
+    return {
+        kind: 'error',
+        protocol: PROTOCOL_VERSION,
+        diagnostics: [
+            {
+                code: code,
+                message,
+                severity: 'error',
+            },
+        ],
+    };
+}
+export function createDirectTransport(server, options = {}) {
+    return {
+        async send(request) {
+            const credential = options.credential?.() ?? request.credential ?? null;
+            // The request crosses a real boundary even here: it is serialized, so a test cannot
+            // accidentally hand the authority a live object reference.
+            const copy = JSON.parse(JSON.stringify({ ...request, credential }));
+            return server.handle(copy);
+        },
+    };
+}
+/**
+ * The reference network transport.
+ *
+ * HTTP is an implementation detail of this adapter: one endpoint carrying semantic
+ * requests, never a route per entity. No ApplicationGraph mentions a URL or a verb, and
+ * replacing this with a WebSocket or a worker channel changes nothing in a graph.
+ */
+export function createHttpTransport(options) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    return {
+        async send(request) {
+            if (!fetchImpl) {
+                return boundaryFailure(SERVER_DIAGNOSTIC_CODES.AUTHORITY_UNREACHABLE, 'No fetch implementation is available');
+            }
+            const credential = options.credential?.() ?? null;
+            const controller = options.timeoutMs ? new AbortController() : undefined;
+            const timer = controller
+                ? setTimeout(() => controller.abort(), options.timeoutMs)
+                : undefined;
+            try {
+                const response = await fetchImpl(options.url, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ ...request, credential }),
+                    ...(controller ? { signal: controller.signal } : {}),
+                });
+                if (!response.ok) {
+                    return boundaryFailure(SERVER_DIAGNOSTIC_CODES.AUTHORITY_UNREACHABLE, `The authority answered ${response.status}`);
+                }
+                return (await response.json());
+            }
+            catch (error) {
+                // A network failure becomes a structured diagnostic, not an exception escaping into
+                // application code.
+                return boundaryFailure(SERVER_DIAGNOSTIC_CODES.AUTHORITY_UNREACHABLE, error instanceof Error ? error.message : String(error));
+            }
+            finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            }
+        },
+    };
+}
+/**
+ * Adapts a transport into the gateway a client runtime expects, so a client is configured
+ * with one object and knows nothing about how the authority is reached.
+ */
+export function createRemoteGateway(transport) {
+    return {
+        async invoke(request) {
+            const answer = await transport.send({
+                kind: 'invoke',
+                protocol: PROTOCOL_VERSION,
+                actionId: request.actionId,
+                arguments: request.arguments,
+                requestId: request.requestId,
+            });
+            if (answer.kind === 'result') {
+                return { ok: answer.ok, diagnostics: answer.diagnostics, changes: answer.changes };
+            }
+            return {
+                ok: false,
+                diagnostics: answer.kind === 'error' ? answer.diagnostics : [],
+                changes: {},
+            };
+        },
+        async snapshot() {
+            const answer = await transport.send({ kind: 'snapshot', protocol: PROTOCOL_VERSION });
+            return { states: answer.kind === 'snapshot' ? answer.snapshot.states : {} };
+        },
+    };
+}
+/** Reads and dispatches one semantic request. Shared by every server-side transport. */
+export async function dispatch(server, body) {
+    if (!isServerRequest(body)) {
+        return boundaryFailure(SERVER_DIAGNOSTIC_CODES.MALFORMED_REQUEST, 'The request is not an Axiom semantic request');
+    }
+    return server.handle(body);
+}