@abloatai/transaction 0.37.0

package/dist/transport/heartbeat.js

@@ -0,0 +1,94 @@
+/**
+ * Application-level heartbeat for the sync WebSocket.
+ *
+ * The browser WebSocket API hides RFC 6455 protocol-level ping and pong frames
+ * from JavaScript, so the server's keepalive cannot be observed by client
+ * code. That leaves the client unable to tell a healthy idle connection apart
+ * from a "zombie" socket whose underlying TCP connection has silently broken
+ * (laptop sleep, NAT timeout, mobile handoff). To close the gap, the client
+ * sends an application-level `{ type: 'ping' }` every 30 seconds and
+ * force-closes the socket if no inbound traffic arrives within 10 seconds. Any
+ * inbound message counts as proof the connection is alive; the explicit `pong`
+ * merely guarantees that something arrives even on an otherwise idle stream.
+ */
+import { PING_INTERVAL_MS } from '../wire/protocol.js';
+import { noopSocketObservability, } from '../observability.js';
+/**
+ * The interval between application-level pings, shared with both sides of the
+ * connection: the client pings at the same {@link PING_INTERVAL_MS} the server
+ * uses for its own keepalive, and the claim lease window is derived from the
+ * same constant.
+ */
+export const HEARTBEAT_INTERVAL_MS = PING_INTERVAL_MS;
+export const HEARTBEAT_TIMEOUT_MS = 10_000;
+/**
+ * Runs the application-level heartbeat for one socket. While the socket is
+ * open, it sends a `{ type: 'ping' }` frame every {@link HEARTBEAT_INTERVAL_MS}
+ * and arms a {@link HEARTBEAT_TIMEOUT_MS} watchdog. Any inbound frame clears
+ * the watchdog — the owner calls {@link HeartbeatController.clearHeartbeatTimeout}
+ * from its message handler. If the watchdog fires first, the connection is
+ * treated as a zombie and force-closed, which lets the owner's reconnect path
+ * run.
+ *
+ * The heartbeat exists because the client cannot see the protocol-level
+ * keepalive: browsers answer the server's pings automatically but never expose
+ * those frames to JavaScript. On a half-open connection (laptop wake, NAT
+ * timeout, mobile handoff) the socket can report itself open for minutes
+ * before the operating system surfaces the break, so observable application
+ * traffic is the only reliable signal.
+ */
+export class HeartbeatController {
+    transport;
+    observability;
+    heartbeatTimer = null;
+    heartbeatTimeoutTimer = null;
+    constructor(transport, observability = noopSocketObservability) {
+        this.transport = transport;
+        this.observability = observability;
+    }
+    start() {
+        this.stop();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.transport.isSocketOpen())
+                return;
+            // Send the ping. If it throws, the socket is already dead, so
+            // force-close it to let the close event drive the reconnect cycle.
+            try {
+                this.transport.sendPing();
+            }
+            catch (err) {
+                this.observability.captureWebSocketError({
+                    context: 'heartbeat-send-failed',
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                this.transport.forceClose('heartbeat-send-failed');
+                return;
+            }
+            // Arm the timeout. Any inbound message clears it; an explicit `pong` is
+            // not required, since a delta or any other frame is equally good proof
+            // that the connection is alive.
+            if (this.heartbeatTimeoutTimer)
+                clearTimeout(this.heartbeatTimeoutTimer);
+            this.heartbeatTimeoutTimer = setTimeout(() => {
+                this.observability.captureWebSocketError({
+                    context: 'heartbeat-timeout',
+                });
+                this.transport.forceClose('heartbeat-timeout');
+            }, HEARTBEAT_TIMEOUT_MS);
+        }, HEARTBEAT_INTERVAL_MS);
+    }
+    stop() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        this.clearHeartbeatTimeout();
+    }
+    clearHeartbeatTimeout() {
+        if (this.heartbeatTimeoutTimer) {
+            clearTimeout(this.heartbeatTimeoutTimer);
+            this.heartbeatTimeoutTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/transport/heartbeat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeat.js","sourceRoot":"","sources":["../../src/transport/heartbeat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EACL,uBAAuB,GAExB,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,gBAAgB,CAAC;AACtD,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAoB3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,mBAAmB;IAKX;IACA;IALX,cAAc,GAA0C,IAAI,CAAC;IAC7D,qBAAqB,GAAyC,IAAI,CAAC;IAE3E,YACmB,SAA6B,EAC7B,gBAAwC,uBAAuB;QAD/D,cAAS,GAAT,SAAS,CAAoB;QAC7B,kBAAa,GAAb,aAAa,CAAkD;IAC/E,CAAC;IAEJ,KAAK;QACH,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE;gBAAE,OAAO;YAE3C,8DAA8D;YAC9D,mEAAmE;YACnE,IAAI,CAAC;gBACH,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;YAC5B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC;oBACvC,OAAO,EAAE,uBAAuB;oBAChC,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;iBACxD,CAAC,CAAC;gBACH,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;gBACnD,OAAO;YACT,CAAC;YAED,wEAAwE;YACxE,uEAAuE;YACvE,gCAAgC;YAChC,IAAI,IAAI,CAAC,qBAAqB;gBAAE,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACzE,IAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC3C,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC;oBACvC,OAAO,EAAE,mBAAmB;iBAC7B,CAAC,CAAC;gBACH,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;YACjD,CAAC,EAAE,oBAAoB,CAAC,CAAC;QAC3B,CAAC,EAAE,qBAAqB,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI;QACF,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACnC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAED,qBAAqB;QACnB,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACzC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QACpC,CAAC;IACH,CAAC;CACF"}

package/dist/transport/httpClient.d.ts

@@ -0,0 +1,143 @@
+import type { HttpClientConfig } from './httpOptions.js';
+import type { CommitResource, HttpClaimApi, HttpClaimsResource, HttpLogsResource, ModelReadOptions, SessionResource } from '../resources/httpResources.js';
+import type { ModelCreateParams, ModelDeleteParams, ServerReadOptions, ModelRetrieveParams, ModelTrackParams, ModelTrackResult, ModelUpdateParams } from '../resources/modelOperations.js';
+import type { Schema, SchemaRecord, InferModel, InferCreate } from '../schema/schema.js';
+import type { ModelUpdater, ContentionOptions } from '../resources/functionalUpdate.js';
+export interface AbloHttpClientOptions<S extends SchemaRecord> extends HttpClientConfig<S> {
+    /**
+     * Per-request deadline. A black-holed HTTP request otherwise has no platform
+     * timeout and can stall a headless worker forever. Pass `0` to disable it.
+     * @default 30_000
+     */
+    readonly timeoutMs?: number;
+}
+/**
+ * The per-model surface of the stateless HTTP client — everything reachable over
+ * request/response: reads (`get` and `list`), writes (`create`, `update`,
+ * and `delete`), the durable-lease {@link HttpClaimApi | claim} plane for
+ * coordinated writes, and `track`, which registers a durable premise on a row.
+ * It deliberately omits the stateful client's local-only
+ * reads (the `local` namespace) and live subscriptions (`onChange`), which need
+ * a resident graph and a persistent socket; those are absent from the type, so
+ * reaching for one is a compile error rather than a runtime gap.
+ *
+ * This is also the base the reactive per-model surface is composed from, rather
+ * than a parallel list it happens to agree with — a verb added here arrives
+ * there without a second edit.
+ *
+ * The typed model contract is transport-independent: `get` returns one row,
+ * `list` returns rows, `create`/`update` return the resulting row, and `delete`
+ * returns nothing. The low-level protocol client keeps its read watermark and
+ * commit receipt envelopes internally; callers should not have to change data
+ * access syntax when they switch transport.
+ */
+export interface HttpModelClient<T, C = T> {
+    /**
+     * Reads one row by id. Resolves to `undefined` when no such row exists — a
+     * miss is data-absence, not an error.
+     *
+     * This is the default "get me this row", and the one a stateless client
+     * wants, since it holds nothing locally. A client with a resident graph
+     * answers from it first and falls back to the network, which is why the
+     * synchronous `local.get` exists alongside this: same read, restricted
+     * to what is already here.
+     */
+    /** Canonical authoritative point lookup. A miss resolves to `undefined`. */
+    get(params: ModelRetrieveParams & ModelReadOptions): Promise<T | undefined>;
+    /** @deprecated Use `get({ id })` for an authoritative point lookup. */
+    retrieve(params: ModelRetrieveParams & ModelReadOptions): Promise<T | undefined>;
+    /**
+     * Reads the rows matching a filter. Same resolution as `get`, in bulk,
+     * and deduplicated so concurrent identical calls share one request.
+     */
+    list(options?: ServerReadOptions<T>): Promise<T[]>;
+    /**
+     * Creates a row and returns it, including any framework-applied defaults.
+     * Passing an id that already exists is idempotent: the existing row is
+     * returned unchanged.
+     *
+     * When the client keeps a local graph the write is optimistic — it resolves
+     * once the mutation is queued locally, and a server rejection rolls it back
+     * (watch `sync.syncStatus`). A stateless client has no local graph to roll
+     * back, so it resolves on the server's confirmation instead. The same is true
+     * of `update` and `delete`.
+     */
+    create(params: ModelCreateParams<T, C>): Promise<T>;
+    update(params: ModelUpdateParams<T, C>): Promise<T>;
+    /**
+     * Updates a row with a function of its latest value — `update(id, current =>
+     * next)`, the data-layer equivalent of a `setState(prev => next)` reducer. The
+     * client reads the freshest row, runs your updater, and writes the result as a
+     * compare-and-swap against the row's watermark; if another write landed first it
+     * re-reads and re-runs. No claim or conflict handling is needed: the write either
+     * lands or throws `AbloContentionError` once its retry budget is spent. Return
+     * `null` or `undefined` from the updater to skip the write.
+     */
+    update(id: string, updater: ModelUpdater<T>, options?: ContentionOptions): Promise<T | undefined>;
+    delete(params: ModelDeleteParams<T, C>): Promise<void>;
+    claim: HttpClaimApi<T, C>;
+    /**
+     * Registers a durable premise on a row — "keep telling me about this one".
+     * Any change that lands on the tracked row rides back on the `notifications`
+     * of this client's next commit, so a long-running agent learns its context
+     * went stale without re-reading. A track it already holds is refreshed, not
+     * duplicated.
+     *
+     * ```ts
+     * await ablo.tasks.track({ id: 'task_42' });
+     * // …minutes of other work later, on the next write…
+     * const res = await ablo.commits.create({ operations: [ … ] });
+     * res.notifications; // populated if task_42 moved in the meantime
+     * ```
+     *
+     * The returned `notifications` are only the tracks that had ALREADY fired at
+     * registration time; the ongoing signal arrives on later receipts.
+     */
+    track(params: ModelTrackParams): Promise<ModelTrackResult>;
+}
+/**
+ * The type of the stateless HTTP client: a typed {@link HttpModelClient} per
+ * schema model, plus `commits`, `dispose`, and the session-mint surface. It
+ * exposes only what request/response transport can do, so reaching for a
+ * stateful-only capability — the `local` reads, `onChange`, or the synchronous
+ * `claim.state`/`queue`/`reorder` reads — is a compile error rather than a value
+ * that is `undefined` at runtime.
+ */
+export type AbloHttpClient<S extends SchemaRecord> = {
+    readonly [K in keyof S & string]: HttpModelClient<InferModel<Schema<S>, K>, InferCreate<Schema<S>, K>>;
+} & {
+    /** Runs one-time setup (durable-outbox scope resolution and replay) before the client is used. It also runs lazily ahead of the first request, so calling it yourself is optional. */
+    ready(): Promise<void>;
+    /** Replays every pending durable HTTP write in seal order and waits for settlement. */
+    waitForFlush(): Promise<void>;
+    readonly commits: CommitResource;
+    /**
+     * Claim-ticket operations keyed by `claimId`: `retrieve` polls a queued
+     * ticket to its grant, `heartbeat` keeps one lease (held or queued) alive,
+     * `heartbeatAll` beats every lease this identity holds in one round trip.
+     * The id comes from `AbloClaimedError('claim_queued')`, which carries it on
+     * `error.claims`.
+     */
+    readonly claims: HttpClaimsResource;
+    /** Durable, credential-scoped authoritative event pages. */
+    readonly logs: HttpLogsResource;
+    dispose(): Promise<void>;
+    /** Resolves the bearer credential this client authenticates with, or `null` if none is set. */
+    getAuthToken(): Promise<string | null>;
+    /**
+     * Mints a short-lived, scoped session token. Minting is itself a stateless
+     * request, so it is available here even though the local-cache reads are not.
+     * Pass `{ user }` to mint an end-user key (`ek_`) or `{ agent, can }` to mint a
+     * scoped agent key (`rk_`). See {@link CreateSessionParams}.
+    */
+    readonly sessions: SessionResource<S>;
+};
+/**
+ * Builds the stateless, typed HTTP client. Each `client.<model>` resolves to the
+ * protocol client's model accessor, while `commits`, `dispose`, and the other
+ * protocol members pass through unchanged. No socket is ever opened; the bearer
+ * credential is the identity.
+ */
+/** @internal Constructed only through the public `Ablo({ transport: 'http' })` factory. */
+export declare function createAbloHttpClient<S extends SchemaRecord>(options: AbloHttpClientOptions<S>): AbloHttpClient<S>;
+//# sourceMappingURL=httpClient.d.ts.map

package/dist/transport/httpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.d.ts","sourceRoot":"","sources":["../../src/transport/httpClient.ts"],"names":[],"mappings":"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"}

package/dist/transport/httpClient.js

@@ -0,0 +1,150 @@
+/**
+ * Creates a stateless, typed HTTP client for server-side actors — agents,
+ * workers, and serverless handlers. It talks to Ablo over plain request/response
+ * HTTP, uses the bearer credential as its identity, and holds no WebSocket and no
+ * connection state.
+ *
+ * This is the counterpart to the stateful {@link Ablo} client. The stateful
+ * client is for interactive participants: it opens a WebSocket, learns its
+ * identity (user id and organization id) during the connect-and-bootstrap step,
+ * and routes writes through a queue that waits for that identity. A server-side
+ * actor has no socket, so instead of reusing that machinery it uses this client,
+ * where the credential itself carries identity and the server resolves it on
+ * every request.
+ *
+ * Under the hood this wraps one schema-agnostic protocol client in a typed
+ * proxy. That protocol layer keeps transport envelopes and string-keyed model
+ * routing private; application code gets the same `client.<model>` surface the
+ * stateful client offers.
+ */
+import { createHttpTransport, } from './httpTransport.js';
+import { modelWireNames } from '../auth/capability.js';
+import { AbloConnectionError, AbloValidationError } from '../errors.js';
+/**
+ * Private transport members that pass straight through the facade. Everything
+ * else must be a declared schema model; there is no dynamic fallback namespace.
+ */
+const PROTOCOL_MEMBERS = new Set([
+    'ready',
+    'waitForFlush',
+    'dispose',
+    'commits',
+    'claims',
+    'logs',
+    'getAuthToken',
+    'sessions',
+]);
+/** Narrows a bare property name to a transport key so the facade can index it typed. */
+function isProtocolMember(prop) {
+    return PROTOCOL_MEMBERS.has(prop);
+}
+/**
+ * Adapts one low-level protocol model to the public typed model contract. The
+ * protocol deliberately retains `{ data, stamp, claims }` reads and commit
+ * receipts because functional updates need them. This is the single boundary
+ * that unwraps those transport details for application code.
+ */
+function createHttpModelClient(protocol) {
+    async function readRow(id) {
+        const read = await protocol.get({ id });
+        return read.data;
+    }
+    async function requireUpdatedRow(id) {
+        const row = await readRow(id);
+        if (row === undefined) {
+            throw new AbloConnectionError(`update settled but ${id} could not be read back from the server.`, { code: 'commit_no_result' });
+        }
+        return row;
+    }
+    // The protocol resource is schema-agnostic and types claim handles as records.
+    // The typed facade carries the same handle with its row type attached; runtime
+    // mutation code only reads the handle identity. Normalize that one generic
+    // boundary here instead of leaking casts into every model method.
+    function mutationOptions(params) {
+        const { claim, ...rest } = params;
+        return {
+            ...rest,
+            ...(claim !== undefined ? { claim } : {}),
+        };
+    }
+    async function update(arg, updater, options) {
+        if (typeof arg === 'string') {
+            if (!updater) {
+                throw new AbloValidationError('Functional update requires an updater function.', { code: 'write_options_invalid' });
+            }
+            const receipt = await protocol.update(arg, updater, options);
+            return receipt === undefined ? undefined : requireUpdatedRow(arg);
+        }
+        await protocol.update({
+            ...mutationOptions(arg),
+            data: arg.data,
+        });
+        return requireUpdatedRow(arg.id);
+    }
+    const get = async (params) => {
+        const read = await protocol.get(params);
+        return read.data;
+    };
+    return {
+        get,
+        retrieve: get,
+        list: (options) => protocol.list(options),
+        async create(params) {
+            const row = await protocol.create({
+                ...mutationOptions(params),
+                data: params.data,
+            });
+            return row;
+        },
+        update,
+        async delete(params) {
+            await protocol.delete(mutationOptions(params));
+        },
+        claim: protocol.claim,
+        track: (params) => protocol.track(params),
+    };
+}
+/**
+ * Builds the stateless, typed HTTP client. Each `client.<model>` resolves to the
+ * protocol client's model accessor, while `commits`, `dispose`, and the other
+ * protocol members pass through unchanged. No socket is ever opened; the bearer
+ * credential is the identity.
+ */
+/** @internal Constructed only through the public `Ablo({ transport: 'http' })` factory. */
+export function createAbloHttpClient(options) {
+    const { schema, ...rest } = options;
+    const transport = createHttpTransport({
+        ...rest,
+        // Derived from the schema this client is bound to, never assembled by hand
+        // — see `auth/capability.ts`.
+        modelTypenames: modelWireNames(schema.models),
+    });
+    const schemaModels = new Set(Object.keys(schema.models));
+    const models = new Map();
+    const model = (name) => {
+        const cached = models.get(name);
+        if (cached)
+            return cached;
+        const created = createHttpModelClient(transport.model(name));
+        models.set(name, created);
+        return created;
+    };
+    const facade = new Proxy({}, {
+        get(_target, prop) {
+            if (typeof prop !== 'string')
+                return undefined;
+            // Real protocol members pass through unchanged.
+            if (isProtocolMember(prop)) {
+                return transport[prop];
+            }
+            // Only schema models become model accessors. A typo or retired top-level
+            // member resolves to undefined instead of manufacturing a plausible client.
+            return schemaModels.has(prop) ? model(prop) : undefined;
+        },
+    });
+    // A single boundary cast. `AbloHttpClient<S>` declares only what the model
+    // accessor and the passed-through protocol members actually implement, so no
+    // method on this type is missing at runtime.
+    return facade;
+}
+//# sourceMappingURL=httpClient.js.map

package/dist/transport/httpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.js","sourceRoot":"","sources":["../../src/transport/httpClient.ts"],"names":[],"mappings":"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"}

package/dist/transport/httpFeed.d.ts

@@ -0,0 +1,4 @@
+import type { HttpLogsResource } from '../resources/httpResources.js';
+import type { ObserveOptions, ObservedDelta } from '../transactionLayer.js';
+export declare function createHttpFeed(logs: HttpLogsResource): (input?: ObserveOptions | string | readonly string[]) => AsyncIterable<ObservedDelta>;
+//# sourceMappingURL=httpFeed.d.ts.map

package/dist/transport/httpFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpFeed.d.ts","sourceRoot":"","sources":["../../src/transport/httpFeed.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACd,MAAM,wBAAwB,CAAC;AAuChC,wBAAgB,cAAc,CAC5B,IAAI,EAAE,gBAAgB,GACrB,CACD,KAAK,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,KAChD,aAAa,CAAC,aAAa,CAAC,CA8DhC"}

package/dist/transport/httpFeed.js

@@ -0,0 +1,94 @@
+import { formatFeedCursor, parseFeedCursor } from '../wire/feedCursor.js';
+const DEFAULT_PAGE_SIZE = 100;
+const DEFAULT_POLL_INTERVAL_MS = 500;
+const DEDUPE_WINDOW_SIZE = 400;
+function normalizeOptions(input) {
+    if (typeof input === 'string')
+        return { models: input };
+    if (Array.isArray(input))
+        return { models: input };
+    return input ?? {};
+}
+function cancelled(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error('Observation was cancelled.');
+}
+async function pause(ms, signal) {
+    if (signal?.aborted)
+        throw cancelled(signal);
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(finish, ms);
+        function finish() {
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        }
+        function abort() {
+            clearTimeout(timer);
+            reject(cancelled(signal));
+        }
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+export function createHttpFeed(logs) {
+    return async function* observe(input) {
+        const options = normalizeOptions(input);
+        const cursorKey = options.cursorKey ?? 'default';
+        const storedCursor = options.cursorStore
+            ? await options.cursorStore.load(cursorKey)
+            : null;
+        let after = options.after ?? storedCursor ?? undefined;
+        const models = typeof options.models === 'string'
+            ? [options.models]
+            : options.models ?? [];
+        const requestedModels = new Set(models.map((model) => model.toLowerCase()));
+        const delivered = new Set();
+        while (true) {
+            if (options.signal?.aborted)
+                throw cancelled(options.signal);
+            const page = await logs.list({
+                ...(after !== undefined ? { after } : {}),
+                limit: DEFAULT_PAGE_SIZE,
+                ...(requestedModels.size === 1
+                    ? { model: requestedModels.values().next().value }
+                    : {}),
+                ...(options.signal ? { signal: options.signal } : {}),
+            });
+            const nextCursor = page.next_cursor ?? after;
+            const parsedCursor = nextCursor ? parseFeedCursor(nextCursor) : null;
+            for (const event of page.data) {
+                if (event.object !== 'log_event' || event.delta === undefined)
+                    continue;
+                if (requestedModels.size > 0
+                    && !requestedModels.has(event.model.toLowerCase())) {
+                    continue;
+                }
+                const deliveryKey = `log:${event.id}`;
+                if (delivered.has(deliveryKey))
+                    continue;
+                delivered.add(deliveryKey);
+                if (delivered.size > DEDUPE_WINDOW_SIZE) {
+                    const oldest = delivered.values().next().value;
+                    if (oldest !== undefined)
+                        delivered.delete(oldest);
+                }
+                const cursor = formatFeedCursor({
+                    log: event.id,
+                    claims: parsedCursor?.claims ?? 0,
+                });
+                yield {
+                    ...event.delta,
+                    cursor,
+                    checkpoint: () => options.cursorStore?.save(cursorKey, cursor)
+                        ?? Promise.resolve(),
+                };
+            }
+            if (nextCursor !== undefined)
+                after = nextCursor;
+            if (page.has_more)
+                continue;
+            await pause(Math.max(0, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS), options.signal);
+        }
+    };
+}
+//# sourceMappingURL=httpFeed.js.map

package/dist/transport/httpFeed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpFeed.js","sourceRoot":"","sources":["../../src/transport/httpFeed.ts"],"names":[],"mappings":"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"}

package/dist/transport/httpOptions.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The slice of client configuration the HTTP transport reads.
+ *
+ * The composed `Ablo({ ... })` bag is assembled by the consumer and carries far
+ * more than this — persistence, offline, reactivity. The transport needs only
+ * the fields below, so the core declares them and stays out of the composition
+ * surface (ADR 0016).
+ *
+ * TypeScript is structural, so a consumer's full options object satisfies this
+ * without declaring `extends`; the composition root keeps owning its own type.
+ */
+import type { Schema, SchemaRecord } from '../schema/schema.js';
+import type { AuthClientOptions } from '../auth/apiKey.js';
+import type { CoordinationObservability } from '../observability.js';
+import type { CommitOutboxScope } from '../transactions/settlement/commitEnvelope.js';
+import type { DurableWriteStore, DurableWritesConfig } from '../durableWrites.js';
+export interface HttpClientConfig<S extends SchemaRecord = SchemaRecord> extends AuthClientOptions {
+    schema: Schema<S>;
+    /** Overrides where credential exchange and bootstrap are reached. */
+    bootstrapBaseUrl?: string;
+    fetch?: typeof fetch | undefined;
+    defaultHeaders?: Record<string, string | null | undefined> | undefined;
+    defaultQuery?: Record<string, string | undefined> | undefined;
+    observability?: CoordinationObservability;
+    /** Crash-durable writes: the outbox is sealed before a request is dispatched. */
+    durableWrites?: DurableWritesConfig;
+    /** Compatibility input for pre-`durableWrites` clients. */
+    commitOutbox?: DurableWriteStore;
+    /** Compatibility input and internal child-client identity seam. */
+    commitOutboxScope?: CommitOutboxScope;
+    /** Which transport carries this client's traffic. */
+    transport?: 'websocket' | 'http' | undefined;
+}
+//# sourceMappingURL=httpOptions.d.ts.map

package/dist/transport/httpOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpOptions.d.ts","sourceRoot":"","sources":["../../src/transport/httpOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,CAGrE,SAAQ,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,KAAK,GAAG,SAAS,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IAC9D,aAAa,CAAC,EAAE,yBAAyB,CAAC;IAC1C,iFAAiF;IACjF,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,2DAA2D;IAC3D,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,qDAAqD;IACrD,SAAS,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;CAC9C"}

package/dist/transport/httpOptions.js

@@ -0,0 +1,13 @@
+/**
+ * The slice of client configuration the HTTP transport reads.
+ *
+ * The composed `Ablo({ ... })` bag is assembled by the consumer and carries far
+ * more than this — persistence, offline, reactivity. The transport needs only
+ * the fields below, so the core declares them and stays out of the composition
+ * surface (ADR 0016).
+ *
+ * TypeScript is structural, so a consumer's full options object satisfies this
+ * without declaring `extends`; the composition root keeps owning its own type.
+ */
+export {};
+//# sourceMappingURL=httpOptions.js.map

package/dist/transport/httpOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpOptions.js","sourceRoot":"","sources":["../../src/transport/httpOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/transport/httpTransport.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Private HTTP protocol client behind `Ablo({ schema, transport: 'http' })`.
+ * It carries no object pool, local database, or WebSocket and maps Model,
+ * Claim, and Commit protocol shapes directly to server routes. The typed
+ * facade in `httpClient.ts` is the application boundary; this module owns
+ * transport envelopes, watermarks, replay, and route details.
+ */
+import type { HttpClientConfig } from './httpOptions.js';
+import type { CommitResource, HttpClaimsResource, HttpTransportModel, HttpLogsResource, SessionResource } from '../resources/httpResources.js';
+import type { SchemaRecord } from '../schema/schema.js';
+import type { CoordinationObservability } from '../observability.js';
+/** @internal Private options for the schema-agnostic HTTP protocol transport. */
+export type HttpTransportOptions = Omit<HttpClientConfig, 'schema'> & {
+    readonly bootstrapBaseUrl?: string | undefined;
+    /** Schema-key to wire-typename mapping used only when minting agent sessions. */
+    readonly modelTypenames?: Readonly<Record<string, string>> | undefined;
+    /**
+     * The observability provider forwarded from `Ablo({ observability })`. The HTTP
+     * transport emits the same claim and conflict events as the WebSocket transport,
+     * so a `ClaimLog` works identically for headless server-agent evaluations.
+     */
+    readonly observability?: CoordinationObservability;
+    /**
+     * Per-request deadline in milliseconds for the stateless HTTP transport.
+     * Every request this client issues is aborted after this long and surfaces
+     * as a retryable connection error — without it a black-holed server hangs
+     * a headless agent forever (browsers never time fetch out on their own).
+     * Pass `0` to disable the deadline.
+     *
+     * @default 30_000
+     */
+    readonly timeoutMs?: number;
+};
+/** @internal Default per-request deadline for the private HTTP transport. */
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+/** @internal Private protocol surface wrapped by `AbloHttpClient`. */
+export interface HttpTransport {
+    ready(): Promise<void>;
+    waitForFlush(): Promise<void>;
+    dispose(): Promise<void>;
+    purge(): Promise<void>;
+    readonly commits: CommitResource;
+    /**
+     * Claim-ticket operations keyed by `claimId` — the id a queued acquire
+     * hands back on `AbloClaimedError('claim_queued')`. See
+     * {@link HttpClaimsResource}.
+     */
+    readonly claims: HttpClaimsResource;
+    readonly logs: HttpLogsResource;
+    model<T = Record<string, unknown>, Fields = T>(name: string): HttpTransportModel<T, Fields>;
+    /**
+     * Resolve the active bearer credential this client authenticates with — the
+     * same token its own requests carry in `Authorization`. Returns `null` when
+     * no credential is configured. Async because the API key may be supplied as
+     * an async setter. Use it to authenticate a side-band request to the same
+     * server with the credential this client already holds — no re-mint.
+     */
+    getAuthToken(): Promise<string | null>;
+    /**
+     * Mint a short-lived scoped session. Minting is a control-plane HTTP call (no
+     * socket), so it lives on this stateless client too, not only the realtime one.
+     * `{ user }` mints an `ek_`; `{ agent, can }` mints an `rk_`.
+     */
+    readonly sessions: SessionResource<SchemaRecord>;
+}
+/** @internal Constructed only by the typed HTTP facade. */
+export declare function createHttpTransport(options: HttpTransportOptions): HttpTransport;
+//# sourceMappingURL=httpTransport.d.ts.map