@abloatai/ablo 0.3.0

package/dist/sync/createIntentStream.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Transport-driven IntentStream factory.
+ *
+ * Mirrors `createPresenceStream` — built directly on `SyncWebSocket`,
+ * no SyncAgent wrapper. Intents derive their `others` view from the
+ * same `presence_update` frames the presence stream consumes (the
+ * Hub piggybacks `activeIntents` on every presence frame). Outbound
+ * announce/revoke ride the same socket via `intent_begin` /
+ * `intent_abandon` frames.
+ *
+ * Wire contract (apps/sync-server/src/hub/types.ts):
+ *   • Outbound: `{ type: 'intent_begin', payload: { intentId,
+ *       entityType, entityId, action, field?, estimatedMs? } }`
+ *   • Outbound: `{ type: 'intent_abandon', payload: { intentId } }`
+ *   • Inbound (via presence): `event.activeIntents: IntentClaim[]`
+ *     stamped with `declaredAt`, `expiresAt`.
+ *   • Inbound: `intent_rejected` event with conflict metadata.
+ *
+ * After the dual-engine collapse (step #36), this is the only
+ * IntentStream factory in the SDK; the older compatibility path
+ * deletes.
+ */
+import type { SyncWebSocket } from './SyncWebSocket.js';
+import type { IntentStream } from '../types/streams.js';
+export interface IntentStreamConfig {
+    /** Identity used to filter our own active intents out of `others`. */
+    participantId: string;
+}
+export interface AttachableIntentStream extends IntentStream {
+    attach(transport: SyncWebSocket): void;
+    dispose(): void;
+}
+export declare function createIntentStream(config: IntentStreamConfig, transport?: SyncWebSocket | null): AttachableIntentStream;

package/dist/sync/createIntentStream.js

@@ -0,0 +1,243 @@
+/**
+ * Transport-driven IntentStream factory.
+ *
+ * Mirrors `createPresenceStream` — built directly on `SyncWebSocket`,
+ * no SyncAgent wrapper. Intents derive their `others` view from the
+ * same `presence_update` frames the presence stream consumes (the
+ * Hub piggybacks `activeIntents` on every presence frame). Outbound
+ * announce/revoke ride the same socket via `intent_begin` /
+ * `intent_abandon` frames.
+ *
+ * Wire contract (apps/sync-server/src/hub/types.ts):
+ *   • Outbound: `{ type: 'intent_begin', payload: { intentId,
+ *       entityType, entityId, action, field?, estimatedMs? } }`
+ *   • Outbound: `{ type: 'intent_abandon', payload: { intentId } }`
+ *   • Inbound (via presence): `event.activeIntents: IntentClaim[]`
+ *     stamped with `declaredAt`, `expiresAt`.
+ *   • Inbound: `intent_rejected` event with conflict metadata.
+ *
+ * After the dual-engine collapse (step #36), this is the only
+ * IntentStream factory in the SDK; the older compatibility path
+ * deletes.
+ */
+import { asyncIteratorFrom } from '../utils/asyncIterator.js';
+import { toMs } from '../utils/duration.js';
+export function createIntentStream(config, transport = null) {
+    const { participantId } = config;
+    // ── State: others' open intents, keyed by intentId ───────────────
+    const activeByIntentId = new Map();
+    let intentsSnapshot = Object.freeze([]);
+    // ── State: our own open intents (for re-announce on reconnect) ───
+    const ownIntents = new Map();
+    // ── Subscribers ──────────────────────────────────────────────────
+    const listeners = new Set();
+    const rejectionListeners = new Set();
+    const notifyListeners = () => {
+        intentsSnapshot = Object.freeze(Array.from(activeByIntentId.values()));
+        for (const l of listeners) {
+            try {
+                l();
+            }
+            catch {
+                /* listener errors don't break siblings */
+            }
+        }
+    };
+    // ── Wire wiring ──────────────────────────────────────────────────
+    let attached = null;
+    const unsubs = [];
+    function attach(t) {
+        if (attached)
+            return;
+        attached = t;
+        // (1) Inbound presence frames carry every participant's full
+        //     active-intent set. Prune previous claims by holder, then
+        //     re-add from the frame — the frame is authoritative for that
+        //     participant's open intents at that moment.
+        unsubs.push(t.subscribe('presence_update', (event) => {
+            if (!event.userId)
+                return;
+            if (event.userId === participantId)
+                return;
+            let mutated = false;
+            if (event.kind === 'leave') {
+                for (const [id, intent] of activeByIntentId) {
+                    if (intent.heldBy === event.userId) {
+                        activeByIntentId.delete(id);
+                        mutated = true;
+                    }
+                }
+                if (mutated)
+                    notifyListeners();
+                return;
+            }
+            for (const [id, intent] of activeByIntentId) {
+                if (intent.heldBy === event.userId) {
+                    activeByIntentId.delete(id);
+                    mutated = true;
+                }
+            }
+            for (const claim of event.activeIntents ?? []) {
+                activeByIntentId.set(claim.intentId, {
+                    id: claim.intentId,
+                    heldBy: event.userId,
+                    participantKind: event.isAgent ? 'agent' : 'human',
+                    target: {
+                        type: claim.entityType,
+                        id: claim.entityId,
+                        path: claim.path,
+                        range: claim.range,
+                        field: claim.field,
+                        meta: claim.meta,
+                    },
+                    reason: claim.action,
+                    ttlSeconds: Math.max(0, Math.floor((claim.expiresAt - Date.now()) / 1000)),
+                    announcedAt: new Date(claim.declaredAt).toISOString(),
+                    expiresAt: new Date(claim.expiresAt).toISOString(),
+                });
+                mutated = true;
+            }
+            if (mutated)
+                notifyListeners();
+        }));
+        // (2) Server-side rejection frames.
+        unsubs.push(t.subscribe('intent_rejected', (payload) => {
+            const rejection = payload;
+            if (!rejection.intentId)
+                return;
+            // Drop the rejected own-claim so reconnect doesn't re-announce
+            // a claim the server already rejected (would just spam both
+            // sides with conflicts).
+            ownIntents.delete(rejection.intentId);
+            for (const l of rejectionListeners) {
+                try {
+                    l(rejection);
+                }
+                catch {
+                    /* isolate */
+                }
+            }
+        }));
+        // (3) On reconnect, re-announce every open self-claim — the
+        //     server's intent state is in-memory and is lost across
+        //     restarts. Without this, peers would see our claims vanish
+        //     whenever the connection blipped.
+        unsubs.push(t.subscribe('connected', () => {
+            for (const [intentId, intent] of ownIntents) {
+                sendBegin(intentId, intent);
+            }
+        }));
+    }
+    if (transport)
+        attach(transport);
+    // ── Outbound ────────────────────────────────────────────────────
+    function sendBegin(intentId, intent) {
+        if (!attached?.isConnected())
+            return;
+        attached.send({
+            type: 'intent_begin',
+            payload: {
+                intentId,
+                entityType: intent.entityType,
+                entityId: intent.entityId,
+                path: intent.path,
+                range: intent.range,
+                action: intent.action,
+                field: intent.field,
+                meta: intent.meta,
+                estimatedMs: intent.estimatedMs,
+            },
+        });
+    }
+    function sendAbandon(intentId) {
+        if (!attached?.isConnected())
+            return;
+        attached.send({ type: 'intent_abandon', payload: { intentId } });
+    }
+    function mintHandle(args) {
+        const intentId = crypto.randomUUID();
+        const estimatedMs = args.ttl !== undefined ? toMs(args.ttl) : undefined;
+        const intent = {
+            entityType: args.entityType,
+            entityId: args.entityId,
+            path: args.path,
+            range: args.range,
+            field: args.field,
+            meta: args.meta,
+            action: args.action,
+            estimatedMs,
+        };
+        ownIntents.set(intentId, intent);
+        sendBegin(intentId, intent);
+        let revoked = false;
+        const revoke = () => {
+            if (revoked)
+                return;
+            revoked = true;
+            ownIntents.delete(intentId);
+            sendAbandon(intentId);
+        };
+        return {
+            id: intentId,
+            revoke,
+            [Symbol.asyncDispose]: async () => {
+                revoke();
+            },
+        };
+    }
+    function resolveTarget(target) {
+        if (Array.isArray(target))
+            return { type: target[0], id: target[1] };
+        return target;
+    }
+    return {
+        claim(target, opts) {
+            const resolved = resolveTarget(target);
+            return mintHandle({
+                entityType: resolved.type,
+                entityId: resolved.id,
+                path: resolved.path,
+                range: resolved.range,
+                field: resolved.field,
+                meta: resolved.meta,
+                action: opts?.reason ?? 'editing',
+                ttl: opts?.ttl,
+            });
+        },
+        get others() {
+            return intentsSnapshot;
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        onRejected: (listener) => {
+            rejectionListeners.add(listener);
+            return () => {
+                rejectionListeners.delete(listener);
+            };
+        },
+        [Symbol.asyncIterator]() {
+            return asyncIteratorFrom((onChange) => {
+                listeners.add(onChange);
+                return () => {
+                    listeners.delete(onChange);
+                };
+            }, () => intentsSnapshot);
+        },
+        attach,
+        dispose() {
+            for (const off of unsubs)
+                off();
+            unsubs.length = 0;
+            listeners.clear();
+            rejectionListeners.clear();
+            activeByIntentId.clear();
+            ownIntents.clear();
+            intentsSnapshot = Object.freeze([]);
+            attached = null;
+        },
+    };
+}

package/dist/sync/createPresenceStream.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Transport-driven PresenceStream factory.
+ *
+ * This is the engine's home for presence — built directly on
+ * `SyncWebSocket`, no SyncAgent wrapper, no second connection. The
+ * older compatibility path predates this and will be deleted when
+ * the dual-engine collapse completes.
+ *
+ * Two construction modes:
+ *
+ *   1. Direct — pass `transport: SyncWebSocket` when it's already
+ *      open (agent worker, tests).
+ *   2. Deferred — pass `attachLater: true` and call `.attach(transport)`
+ *      once the engine's WS lifecycle has produced one. The returned
+ *      stream object is stable from construction; attachment can
+ *      happen later without callers having to re-grab the reference.
+ *
+ * Wire contract (apps/sync-server/src/hub/types.ts):
+ *   • Outbound: `{ type: 'presence_update', payload: { status, activity? } }`
+ *     — server stamps `userId`, `kind`, `timestamp`, `isAgent` and
+ *       broadcasts to other clients on the same sync groups.
+ *   • Inbound:  same frame, with `kind: 'enter' | 'update' | 'leave'`.
+ */
+import type { SyncWebSocket } from './SyncWebSocket.js';
+import type { PresenceStream } from '../types/streams.js';
+export interface PresenceStreamConfig {
+    /** Identity used to filter our own echoed frames out of `others`. */
+    participantId: string;
+    /** Optional human label for the self entry. */
+    label?: string;
+    /** Sync groups the participant is broadcasting on. Used for the
+     *  initial `self` entry and for `othersIn(...)` filtering. */
+    syncGroups: readonly string[];
+    /** Marks `self` as an agent. Server is the source of truth for
+     *  peers' `isAgent`, but `self` is local — caller decides. */
+    isAgent?: boolean;
+}
+/** PresenceStream extended with engine-lifecycle hooks. */
+export interface AttachablePresenceStream extends PresenceStream {
+    /** Wire the stream to a now-ready transport. Calls before this are
+     *  buffered (self mutations only — no wire send). Idempotent. */
+    attach(transport: SyncWebSocket): void;
+    /** Tear down listeners. Stream object stays usable as a no-op. */
+    dispose(): void;
+}
+export declare function createPresenceStream(config: PresenceStreamConfig, transport?: SyncWebSocket | null): AttachablePresenceStream;

package/dist/sync/createPresenceStream.js

@@ -0,0 +1,192 @@
+/**
+ * Transport-driven PresenceStream factory.
+ *
+ * This is the engine's home for presence — built directly on
+ * `SyncWebSocket`, no SyncAgent wrapper, no second connection. The
+ * older compatibility path predates this and will be deleted when
+ * the dual-engine collapse completes.
+ *
+ * Two construction modes:
+ *
+ *   1. Direct — pass `transport: SyncWebSocket` when it's already
+ *      open (agent worker, tests).
+ *   2. Deferred — pass `attachLater: true` and call `.attach(transport)`
+ *      once the engine's WS lifecycle has produced one. The returned
+ *      stream object is stable from construction; attachment can
+ *      happen later without callers having to re-grab the reference.
+ *
+ * Wire contract (apps/sync-server/src/hub/types.ts):
+ *   • Outbound: `{ type: 'presence_update', payload: { status, activity? } }`
+ *     — server stamps `userId`, `kind`, `timestamp`, `isAgent` and
+ *       broadcasts to other clients on the same sync groups.
+ *   • Inbound:  same frame, with `kind: 'enter' | 'update' | 'leave'`.
+ */
+import { asyncIteratorFrom } from '../utils/asyncIterator.js';
+export function createPresenceStream(config, transport = null) {
+    const { participantId, label, syncGroups, isAgent = false } = config;
+    // ── Self ─────────────────────────────────────────────────────────
+    const self = {
+        participantKind: isAgent ? 'agent' : 'human',
+        participantId,
+        label,
+        syncGroups: [...syncGroups],
+        activity: { entityType: 'Unknown', entityId: '', action: 'idle' },
+        lastActive: new Date().toISOString(),
+    };
+    // ── Others ───────────────────────────────────────────────────────
+    const othersById = new Map();
+    let othersSnapshot = Object.freeze([]);
+    const listeners = new Set();
+    const notifyListeners = () => {
+        othersSnapshot = Object.freeze(Array.from(othersById.values()));
+        for (const l of listeners) {
+            try {
+                l();
+            }
+            catch {
+                /* one bad listener doesn't break the others */
+            }
+        }
+    };
+    // ── Wire wiring ──────────────────────────────────────────────────
+    let attached = null;
+    const unsubs = [];
+    function attach(t) {
+        if (attached)
+            return; // idempotent
+        attached = t;
+        // Reconnect: clear roster (Hub sends fresh snapshot), re-announce
+        // own activity (peers don't auto-learn about us across reconnects).
+        unsubs.push(t.subscribe('connected', () => {
+            if (othersById.size > 0) {
+                othersById.clear();
+                othersSnapshot = Object.freeze([]);
+                notifyListeners();
+            }
+            if (self.activity.entityId)
+                sendUpdate(self.activity);
+        }));
+        // Inbound presence frames — translate the legacy wire vocabulary
+        // (userId / isAgent / timestamp) into the engine shape
+        // (participantId / participantKind / lastActive). When the server
+        // adopts the engine names this block collapses to a pass-through.
+        unsubs.push(t.subscribe('presence_update', (event) => {
+            if (event.userId === participantId)
+                return; // own echo
+            if (!event.userId)
+                return;
+            switch (event.kind) {
+                case 'leave':
+                    if (othersById.delete(event.userId))
+                        notifyListeners();
+                    return;
+                case 'enter':
+                case 'update':
+                case undefined: {
+                    const entry = {
+                        participantKind: event.isAgent ? 'agent' : 'human',
+                        participantId: event.userId,
+                        syncGroups: event.syncGroups ?? [],
+                        activity: event.activity
+                            ? {
+                                entityType: event.activity.entityType,
+                                entityId: event.activity.entityId,
+                                path: event.activity.path,
+                                range: event.activity.range,
+                                field: event.activity.field,
+                                meta: event.activity.meta,
+                                action: event.activity.action,
+                                detail: event.activity.detail,
+                            }
+                            : { entityType: 'Unknown', entityId: '', action: event.status },
+                        lastActive: event.timestamp
+                            ? new Date(event.timestamp).toISOString()
+                            : new Date().toISOString(),
+                    };
+                    othersById.set(event.userId, entry);
+                    notifyListeners();
+                    return;
+                }
+            }
+        }));
+        // If self was already mutated before attach, broadcast it now.
+        if (self.activity.entityId)
+            sendUpdate(self.activity);
+    }
+    if (transport)
+        attach(transport);
+    // ── Outbound ────────────────────────────────────────────────────
+    // Note: do NOT include `isAgent` in the payload. Server derives it
+    // authoritatively from the connection's identity prefix; clients
+    // self-declaring `isAgent` caused human sessions to broadcast as
+    // agents to peers (real bug we caught earlier).
+    function sendUpdate(activity) {
+        if (!attached?.isConnected())
+            return; // no-op until connected
+        attached.send({
+            type: 'presence_update',
+            payload: { status: 'online', activity },
+        });
+    }
+    function doUpdate(activity) {
+        self.activity = activity;
+        self.lastActive = new Date().toISOString();
+        sendUpdate(activity);
+    }
+    function resolveTarget(target) {
+        if (Array.isArray(target)) {
+            return { entityType: target[0], entityId: target[1], action: 'unknown' };
+        }
+        const obj = target;
+        return {
+            entityType: obj.type,
+            entityId: obj.id,
+            path: obj.path,
+            range: obj.range,
+            field: obj.field,
+            meta: obj.meta,
+            action: 'unknown',
+        };
+    }
+    const withVerb = (action) => (target, detail) => {
+        doUpdate({ ...resolveTarget(target), action, detail });
+    };
+    return {
+        self,
+        update: doUpdate,
+        editing: withVerb('editing'),
+        reading: withVerb('reading'),
+        viewing: withVerb('viewing'),
+        idle: () => {
+            doUpdate({ entityType: 'Unknown', entityId: '', action: 'idle' });
+        },
+        get others() {
+            return othersSnapshot;
+        },
+        othersIn: (syncGroup) => othersSnapshot.filter((e) => e.syncGroups.includes(syncGroup)),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        [Symbol.asyncIterator]() {
+            return asyncIteratorFrom((onChange) => {
+                listeners.add(onChange);
+                return () => {
+                    listeners.delete(onChange);
+                };
+            }, () => othersSnapshot);
+        },
+        attach,
+        dispose() {
+            for (const off of unsubs)
+                off();
+            unsubs.length = 0;
+            listeners.clear();
+            othersById.clear();
+            othersSnapshot = Object.freeze([]);
+            attached = null;
+        },
+    };
+}

package/dist/sync/createSnapshot.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Engine-attached snapshot factory.
+ *
+ * Captures the engine's current entity state + watermark for context-
+ * staleness detection. The returned Snapshot is what an LLM caller
+ * threads into a prompt: `stamp` flows into writes as `readAt` so the
+ * server rejects mutations against now-stale data; `signal` fires on
+ * any captured-entity delta so mid-generation invalidations abort
+ * the token stream rather than producing output against dead context.
+ *
+ * Reads from the engine's MobX-reactive ObjectPool, picks up the
+ * engine's `lastSyncId`, and subscribes to delta frames on the
+ * engine's transport. Same socket as entity sync — no second
+ * connection.
+ */
+import type { ObjectPool } from '../ObjectPool.js';
+import type { Schema } from '../schema/schema.js';
+import type { SyncWebSocket } from './SyncWebSocket.js';
+import type { Snapshot } from '../types/streams.js';
+export interface CreateSnapshotArgs<TSchema extends Schema = Schema, K extends keyof TSchema['models'] & string = keyof TSchema['models'] & string> {
+    pool: ObjectPool;
+    /** Live transport for delta subscriptions. May be null if the engine
+     *  hasn't connected yet — the snapshot still resolves with current
+     *  pool state, but `signal` won't fire until reconnect. */
+    transport: SyncWebSocket | null;
+    /** Returns the engine's current `lastSyncId`. Read at snapshot time
+     *  to stamp the watermark; not re-read after. */
+    getLastSyncId: () => number;
+    entities: {
+        readonly [M in K]: string | readonly string[];
+    };
+}
+export declare function createSnapshot<TSchema extends Schema, K extends keyof TSchema['models'] & string>(args: CreateSnapshotArgs<TSchema, K>): Snapshot<TSchema, K>;

package/dist/sync/createSnapshot.js

@@ -0,0 +1,124 @@
+/**
+ * Engine-attached snapshot factory.
+ *
+ * Captures the engine's current entity state + watermark for context-
+ * staleness detection. The returned Snapshot is what an LLM caller
+ * threads into a prompt: `stamp` flows into writes as `readAt` so the
+ * server rejects mutations against now-stale data; `signal` fires on
+ * any captured-entity delta so mid-generation invalidations abort
+ * the token stream rather than producing output against dead context.
+ *
+ * Reads from the engine's MobX-reactive ObjectPool, picks up the
+ * engine's `lastSyncId`, and subscribes to delta frames on the
+ * engine's transport. Same socket as entity sync — no second
+ * connection.
+ */
+import { AbloValidationError } from '../errors.js';
+import { Model, modelAsRow } from '../Model.js';
+/**
+ * Three top-level keys that conflict with the per-model buckets if a
+ * customer's schema declares a model named `stamp` / `signal` /
+ * `onChange`. Throw at snapshot time so the collision is loud.
+ */
+const RESERVED_SNAPSHOT_KEYS = new Set([
+    'stamp',
+    'signal',
+    'onChange',
+]);
+export function createSnapshot(args) {
+    const { pool, transport, getLastSyncId, entities } = args;
+    // ── Validate keys ────────────────────────────────────────────────
+    for (const key of Object.keys(entities)) {
+        if (RESERVED_SNAPSHOT_KEYS.has(key)) {
+            throw new AbloValidationError(`engine.snapshot: model key "${key}" collides with a reserved ` +
+                `snapshot field (stamp / signal / onChange). Rename the model ` +
+                'in your schema.', { code: 'snapshot_reserved_key' });
+        }
+    }
+    // ── Watermark ────────────────────────────────────────────────────
+    const stamp = getLastSyncId();
+    // ── Capture data + watched set ───────────────────────────────────
+    const watched = new Set(); // `${type}:${id}`
+    const data = {};
+    for (const [type, idOrIds] of Object.entries(entities)) {
+        const ids = Array.isArray(idOrIds)
+            ? idOrIds
+            : [idOrIds];
+        const bucket = {};
+        for (const id of ids) {
+            const m = pool.get(id);
+            // Only include if the model actually has the requested type —
+            // pool keys models globally by id, so `pool.get(id)` could
+            // return a different model that happens to share the id (rare,
+            // but type guards keep the surface honest).
+            if (m && m instanceof Model && m.getModelName() === type) {
+                bucket[id] = modelAsRow(m);
+            }
+            watched.add(`${type}:${id}`);
+        }
+        data[type] = bucket;
+    }
+    // ── Invalidation wiring ──────────────────────────────────────────
+    const listeners = new Set();
+    const controller = new AbortController();
+    const fireChange = (change) => {
+        if (!controller.signal.aborted) {
+            controller.abort(new Error('snapshot invalidated — underlying entity received a delta'));
+        }
+        for (const l of listeners) {
+            try {
+                l(change);
+            }
+            catch {
+                /* listener errors don't break siblings */
+            }
+        }
+    };
+    let unsubDelta = null;
+    if (transport) {
+        unsubDelta = transport.subscribe('delta', (delta) => {
+            const key = `${delta.modelName}:${delta.modelId}`;
+            if (!watched.has(key))
+                return;
+            // The snapshot API treats every delta as 'semantic' severity.
+            // Future: distinguish metadata-only deltas (e.g., updatedAt
+            // bumps) from content changes — that's a separate scope.
+            fireChange({
+                model: delta.modelName,
+                id: delta.modelId,
+                severity: 'semantic',
+            });
+        });
+    }
+    // ── Build the flat result ────────────────────────────────────────
+    const result = {
+        stamp,
+        signal: controller.signal,
+        onChange: (listener) => {
+            listeners.add(listener);
+            // Caller is responsible for unsubscribing when they're done.
+            // The delta subscription itself stays for the snapshot's life;
+            // there's no public dispose because snapshots are short-lived
+            // (one LLM call's worth) and the transport-level subscription
+            // is cheap. If a long-lived consumer needs explicit teardown,
+            // we can add `.dispose()` in a follow-up.
+            return () => {
+                listeners.delete(listener);
+                // If the last listener AND the abort fired, drop the delta
+                // subscription too — no one's listening anymore.
+                if (listeners.size === 0 && controller.signal.aborted && unsubDelta) {
+                    unsubDelta();
+                    unsubDelta = null;
+                }
+            };
+        },
+    };
+    for (const [modelName, bucket] of Object.entries(data)) {
+        result[modelName] = bucket;
+    }
+    // Dynamic-shape boundary — `result` is built at runtime by iterating
+    // schema-derived buckets, so it structurally satisfies
+    // `Snapshot<TSchema, K>`. TS can't prove the static cast, but the
+    // runtime invariant holds.
+    return result;
+}