@abloatai/transaction 0.37.0

package/dist/wire/modelShape.js

@@ -0,0 +1,75 @@
+/**
+ * What a model is made of — its fields and its edges.
+ *
+ * These shapes travel twice: they are what `ablo push` serializes into the
+ * schema artifact, and what `GET /api/schema` reports back about the artifact
+ * that is deployed. Two crossings, one definition, and the definition lives
+ * here because `wire/` is the leaf every other layer may depend on.
+ *
+ * They were TypeScript interfaces, so the schema-read route could not send them
+ * without hand-writing a second copy of the record it was refusing to send — the
+ * shadow type wearing the fix's clothes. Declared as Zod and derived back into
+ * TypeScript, there is nowhere for a second copy to live.
+ *
+ * **Vocabulary ownership.** `type` is a CLOSED enum: the engine owns the set of
+ * types it can store and serialize, so a value outside it is a bug, not an
+ * extension. `enumValues` is an OPEN list: the values belong to the application
+ * that declared them, and the protocol never interprets one.
+ */
+import { z } from 'zod';
+/**
+ * The engine's type vocabulary — closed, and owned by the engine.
+ *
+ * Each member maps to storage and serialization behaviour, so this is the whole
+ * set by construction. A schema's own richer types (a `z.email()`, a branded id)
+ * narrow one of these; they do not add a member.
+ */
+export const fieldTypeSchema = z.enum([
+    'string',
+    'number',
+    'boolean',
+    'date',
+    'enum',
+    'json',
+]);
+/** One field of a model, as the schema artifact records it. */
+export const fieldMetaSchema = z.object({
+    /** Sync-engine type tag, which maps to storage and serialization hints. */
+    type: fieldTypeSchema,
+    /** Whether the field was marked optional via `.optional()` or `.nullable()`. */
+    isOptional: z.boolean(),
+    /** Whether the field was marked indexed via `.indexed()`. */
+    isIndexed: z.boolean(),
+    /**
+     * Physical database column name override. When absent, SQL layers derive the
+     * column from the field name using the active casing convention.
+     */
+    column: z.string().optional(),
+    /**
+     * For enums: the allowed values.
+     *
+     * The application's vocabulary, carried verbatim — an open list, because the
+     * protocol has no opinion about what a caller's statuses are called.
+     */
+    enumValues: z.array(z.string()).readonly().optional(),
+});
+/**
+ * How one model points at another. Closed, like {@link fieldTypeSchema}: the
+ * engine resolves exactly these three when it plans a read.
+ */
+export const relationTypeSchema = z.enum(['belongsTo', 'hasMany', 'hasOne']);
+/**
+ * One edge of a model — what a caller may expand, and what it expands into.
+ *
+ * Reported alongside the fields because half the answer is not an answer: an
+ * agent asking what a model looks like wants its shape AND its edges, and
+ * shipping only the scalars invites the second question immediately.
+ */
+export const relationMetaSchema = z.object({
+    type: relationTypeSchema,
+    /** The schema key of the model on the other end. */
+    target: z.string(),
+    /** The field on the owning side that carries the link. */
+    foreignKey: z.string(),
+});
+//# sourceMappingURL=modelShape.js.map

package/dist/wire/modelShape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelShape.js","sourceRoot":"","sources":["../../src/wire/modelShape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC;IACpC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC,CAAC;AAGH,+DAA+D;AAC/D,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,2EAA2E;IAC3E,IAAI,EAAE,eAAe;IACrB,gFAAgF;IAChF,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE;IACvB,6DAA6D;IAC7D,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB;;;OAGG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B;;;;;OAKG;IACH,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACtD,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;AAG7E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,kBAAkB;IACxB,oDAAoD;IACpD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,0DAA0D;IAC1D,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;CACvB,CAAC,CAAC"}

package/dist/wire/protocol.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The timing constants both sides of the protocol must agree on: the ping
+ * cadence and the lease window derived from it. Defining them here once keeps
+ * the client and the server from skewing apart — a change to the ping interval
+ * that did not also move the lease window would make claim expiry and presence
+ * timeouts disagree between the two.
+ *
+ * {@link PING_INTERVAL_MS} is how often the connection pings to prove it is
+ * alive. {@link LEASE_TTL_MS} is how long a claim or presence entry stays valid
+ * without a renewing ping. On the client, these set the heartbeat cadence and
+ * the fallback expiry for a claim taken without an explicit lease. On the
+ * server, they set the keepalive interval, the lease granted per keepalive, and
+ * the presence-entry lifetime, so a silently disconnected client drops off the
+ * roster within one lease window.
+ *
+ * The lease is three ping intervals long and is renewed on every ping, so a
+ * live holder always has at least two intervals of runway and a silent one
+ * lapses about two missed pings after it stops renewing. The window measures
+ * liveness, not how long a task may run: widening the lease without also
+ * widening the ping makes holders flap, and neither value should be redefined
+ * anywhere else.
+ */
+export declare const PING_INTERVAL_MS = 30000;
+export declare const LEASE_TTL_MS: number;
+/**
+ * The WebSocket subprotocols that carry the bearer credential out of the URL.
+ *
+ * A browser cannot set an `Authorization` header on a WebSocket, so the client
+ * offers the token as a `Sec-WebSocket-Protocol` value — `ablo.bearer.<token>` —
+ * alongside the real `ablo.sync.v1` protocol the server selects. This keeps the
+ * credential out of the query string, which access logs, proxies, and browser
+ * history would otherwise capture. The server reads the token from the
+ * subprotocol and echoes back only `ablo.sync.v1`, never the token-bearing
+ * value. Both the client and the server import these constants, so the
+ * handshake format cannot drift.
+ */
+export declare const WS_BEARER_SUBPROTOCOL_PREFIX = "ablo.bearer.";
+export declare const WS_SYNC_SUBPROTOCOL = "ablo.sync.v1";
+//# sourceMappingURL=protocol.d.ts.map

package/dist/wire/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/wire/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gBAAgB,QAAS,CAAC;AACvC,eAAO,MAAM,YAAY,QAAuB,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAC3D,eAAO,MAAM,mBAAmB,iBAAiB,CAAC"}

package/dist/wire/protocol.js

@@ -0,0 +1,39 @@
+/**
+ * The timing constants both sides of the protocol must agree on: the ping
+ * cadence and the lease window derived from it. Defining them here once keeps
+ * the client and the server from skewing apart — a change to the ping interval
+ * that did not also move the lease window would make claim expiry and presence
+ * timeouts disagree between the two.
+ *
+ * {@link PING_INTERVAL_MS} is how often the connection pings to prove it is
+ * alive. {@link LEASE_TTL_MS} is how long a claim or presence entry stays valid
+ * without a renewing ping. On the client, these set the heartbeat cadence and
+ * the fallback expiry for a claim taken without an explicit lease. On the
+ * server, they set the keepalive interval, the lease granted per keepalive, and
+ * the presence-entry lifetime, so a silently disconnected client drops off the
+ * roster within one lease window.
+ *
+ * The lease is three ping intervals long and is renewed on every ping, so a
+ * live holder always has at least two intervals of runway and a silent one
+ * lapses about two missed pings after it stops renewing. The window measures
+ * liveness, not how long a task may run: widening the lease without also
+ * widening the ping makes holders flap, and neither value should be redefined
+ * anywhere else.
+ */
+export const PING_INTERVAL_MS = 30_000;
+export const LEASE_TTL_MS = 3 * PING_INTERVAL_MS;
+/**
+ * The WebSocket subprotocols that carry the bearer credential out of the URL.
+ *
+ * A browser cannot set an `Authorization` header on a WebSocket, so the client
+ * offers the token as a `Sec-WebSocket-Protocol` value — `ablo.bearer.<token>` —
+ * alongside the real `ablo.sync.v1` protocol the server selects. This keeps the
+ * credential out of the query string, which access logs, proxies, and browser
+ * history would otherwise capture. The server reads the token from the
+ * subprotocol and echoes back only `ablo.sync.v1`, never the token-bearing
+ * value. Both the client and the server import these constants, so the
+ * handshake format cannot drift.
+ */
+export const WS_BEARER_SUBPROTOCOL_PREFIX = 'ablo.bearer.';
+export const WS_SYNC_SUBPROTOCOL = 'ablo.sync.v1';
+//# sourceMappingURL=protocol.js.map

package/dist/wire/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/wire/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AACvC,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAG,gBAAgB,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,cAAc,CAAC;AAC3D,MAAM,CAAC,MAAM,mBAAmB,GAAG,cAAc,CAAC"}

package/dist/wire/protocolVersion.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The sync protocol version — a single integer, increasing over time, that
+ * covers everything the client and server must agree on to talk to each other:
+ * the WebSocket frame shapes, the HTTP request and response envelopes, and the
+ * delta encodings a client replays. It is separate from the advisory
+ * app-schema hash, which diagnoses data-model drift; this version selects a
+ * concrete transport codec.
+ *
+ * Deploy ordering: the server is deployed first. It accepts every version in
+ * {@link SUPPORTED_PROTOCOL_VERSIONS}, and a client is never expected to connect
+ * to a server older than itself. If that does happen — for example a partial
+ * server rollback — {@link protocolVersionProblem} reports it as `too_new` so
+ * the mismatch is visible rather than undefined.
+ *
+ * To change the protocol:
+ *   1. Make the change backward-tolerant where you can. The server ignores
+ *      unknown payload keys, so an additive field usually needs no version bump.
+ *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add its codec to
+ *      {@link SUPPORTED_PROTOCOL_VERSIONS}, and add a changelog entry below.
+ *   3. Keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough to cover every
+ *      client still in use; raise it only after a deprecation window.
+ *   4. The protocol contract tests fail on a version without a codec and on any
+ *      unreviewed bump — update them in the same change, deliberately.
+ *
+ * Changelog
+ *   v1 (2026-07-03) — the protocol as of this field's introduction: the
+ *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
+ *      `protocolVersion`), the commit, claim, release, ack, and
+ *      presence-update frames, the bootstrap and delta batches, and the HTTP
+ *      error and list envelopes. A client that predates this field sends no
+ *      `protocolVersion` and is treated as v1, since introducing the field
+ *      changed no behavior.
+ */
+export declare const PROTOCOL_VERSION = 1;
+/**
+ * The oldest client protocol version this build still serves. Raising it cuts
+ * off clients that have not upgraded, so do it only after a deprecation window
+ * and with a changelog entry.
+ */
+export declare const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+/** The version used by clients from before the version field existed. */
+export declare const DEFAULT_PROTOCOL_VERSION = 1;
+/**
+ * Every wire version this build can actually decode. This is intentionally an
+ * explicit manifest rather than a computed numeric range: a version is not
+ * supported merely because its number falls between two constants. Server
+ * codec registries use {@link SupportedProtocolVersion} as their key type, so
+ * adding a version here makes a missing decoder a compile error.
+ */
+export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly [1];
+export type SupportedProtocolVersion = (typeof SUPPORTED_PROTOCOL_VERSIONS)[number];
+export type ProtocolVersionProblem = 'too_old' | 'too_new' | 'codec_missing';
+/**
+ * The WebSocket close code the server sends to reject a protocol-version
+ * mismatch. It sits alongside the other application close codes (4001 for a
+ * credential problem), and its reason string is the
+ * error code `protocol_version_unsupported`. A client should treat this close
+ * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
+ * client or rolling the server forward can.
+ */
+export declare const WS_CLOSE_PROTOCOL_VERSION = 4010;
+/**
+ * Classifies a peer's announced protocol version against what this build
+ * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
+ * compatible. An `undefined` version — a client from before versioning existed
+ * — counts as v1. A non-integer value is treated as `'too_old'` so the check
+ * fails closed and visibly.
+ */
+export declare function protocolVersionProblem(announced: number | undefined): ProtocolVersionProblem | null;
+/** Resolve an announced value to a version that has a concrete codec. */
+export declare function resolveProtocolVersion(announced: number | undefined): SupportedProtocolVersion | null;
+/** The HTTP request header a client uses to announce its protocol version. */
+export declare const PROTOCOL_VERSION_HEADER = "Ablo-Protocol-Version";
+//# sourceMappingURL=protocolVersion.d.ts.map

package/dist/wire/protocolVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolVersion.d.ts","sourceRoot":"","sources":["../../src/wire/protocolVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,cAAe,CAAC;AAExD,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,eAAe,CAAC;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,sBAAsB,GAAG,IAAI,CAO/B;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,wBAAwB,GAAG,IAAI,CAGjC;AAED,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,0BAA0B,CAAC"}

package/dist/wire/protocolVersion.js

@@ -0,0 +1,84 @@
+/**
+ * The sync protocol version — a single integer, increasing over time, that
+ * covers everything the client and server must agree on to talk to each other:
+ * the WebSocket frame shapes, the HTTP request and response envelopes, and the
+ * delta encodings a client replays. It is separate from the advisory
+ * app-schema hash, which diagnoses data-model drift; this version selects a
+ * concrete transport codec.
+ *
+ * Deploy ordering: the server is deployed first. It accepts every version in
+ * {@link SUPPORTED_PROTOCOL_VERSIONS}, and a client is never expected to connect
+ * to a server older than itself. If that does happen — for example a partial
+ * server rollback — {@link protocolVersionProblem} reports it as `too_new` so
+ * the mismatch is visible rather than undefined.
+ *
+ * To change the protocol:
+ *   1. Make the change backward-tolerant where you can. The server ignores
+ *      unknown payload keys, so an additive field usually needs no version bump.
+ *   2. For a breaking change, bump {@link PROTOCOL_VERSION}, add its codec to
+ *      {@link SUPPORTED_PROTOCOL_VERSIONS}, and add a changelog entry below.
+ *   3. Keep {@link MIN_SUPPORTED_PROTOCOL_VERSION} low enough to cover every
+ *      client still in use; raise it only after a deprecation window.
+ *   4. The protocol contract tests fail on a version without a codec and on any
+ *      unreviewed bump — update them in the same change, deliberately.
+ *
+ * Changelog
+ *   v1 (2026-07-03) — the protocol as of this field's introduction: the
+ *      sync-request frame (`cursor`, `lastSyncId`, `capabilities`, optional
+ *      `protocolVersion`), the commit, claim, release, ack, and
+ *      presence-update frames, the bootstrap and delta batches, and the HTTP
+ *      error and list envelopes. A client that predates this field sends no
+ *      `protocolVersion` and is treated as v1, since introducing the field
+ *      changed no behavior.
+ */
+export const PROTOCOL_VERSION = 1;
+/**
+ * The oldest client protocol version this build still serves. Raising it cuts
+ * off clients that have not upgraded, so do it only after a deprecation window
+ * and with a changelog entry.
+ */
+export const MIN_SUPPORTED_PROTOCOL_VERSION = 1;
+/** The version used by clients from before the version field existed. */
+export const DEFAULT_PROTOCOL_VERSION = 1;
+/**
+ * Every wire version this build can actually decode. This is intentionally an
+ * explicit manifest rather than a computed numeric range: a version is not
+ * supported merely because its number falls between two constants. Server
+ * codec registries use {@link SupportedProtocolVersion} as their key type, so
+ * adding a version here makes a missing decoder a compile error.
+ */
+export const SUPPORTED_PROTOCOL_VERSIONS = [1];
+/**
+ * The WebSocket close code the server sends to reject a protocol-version
+ * mismatch. It sits alongside the other application close codes (4001 for a
+ * credential problem), and its reason string is the
+ * error code `protocol_version_unsupported`. A client should treat this close
+ * as terminal: reconnecting cannot heal a version mismatch, but upgrading the
+ * client or rolling the server forward can.
+ */
+export const WS_CLOSE_PROTOCOL_VERSION = 4010;
+/**
+ * Classifies a peer's announced protocol version against what this build
+ * supports, returning `'too_old'`, `'too_new'`, or `null` when the versions are
+ * compatible. An `undefined` version — a client from before versioning existed
+ * — counts as v1. A non-integer value is treated as `'too_old'` so the check
+ * fails closed and visibly.
+ */
+export function protocolVersionProblem(announced) {
+    const v = announced ?? DEFAULT_PROTOCOL_VERSION;
+    if (!Number.isInteger(v) || v < MIN_SUPPORTED_PROTOCOL_VERSION)
+        return 'too_old';
+    if (v > PROTOCOL_VERSION)
+        return 'too_new';
+    return SUPPORTED_PROTOCOL_VERSIONS.some((candidate) => candidate === v)
+        ? null
+        : 'codec_missing';
+}
+/** Resolve an announced value to a version that has a concrete codec. */
+export function resolveProtocolVersion(announced) {
+    const version = announced ?? DEFAULT_PROTOCOL_VERSION;
+    return SUPPORTED_PROTOCOL_VERSIONS.find((candidate) => candidate === version) ?? null;
+}
+/** The HTTP request header a client uses to announce its protocol version. */
+export const PROTOCOL_VERSION_HEADER = 'Ablo-Protocol-Version';
+//# sourceMappingURL=protocolVersion.js.map

package/dist/wire/protocolVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocolVersion.js","sourceRoot":"","sources":["../../src/wire/protocolVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAElC;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC;AAEhD,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,CAAU,CAAC;AAOxD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CACpC,SAA6B;IAE7B,MAAM,CAAC,GAAG,SAAS,IAAI,wBAAwB,CAAC;IAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,8BAA8B;QAAE,OAAO,SAAS,CAAC;IACjF,IAAI,CAAC,GAAG,gBAAgB;QAAE,OAAO,SAAS,CAAC;IAC3C,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,CAAC,CAAC;QACrE,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,eAAe,CAAC;AACtB,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,sBAAsB,CACpC,SAA6B;IAE7B,MAAM,OAAO,GAAG,SAAS,IAAI,wBAAwB,CAAC;IACtD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,OAAO,CAAC,IAAI,IAAI,CAAC;AACxF,CAAC;AAED,8EAA8E;AAC9E,MAAM,CAAC,MAAM,uBAAuB,GAAG,uBAAuB,CAAC"}

package/package.json

@@ -0,0 +1,187 @@
+{
+  "name": "@abloatai/transaction",
+  "version": "0.37.0",
+  "description": "The headless Ablo transaction client and canonical contracts for reads, commits, settlement, claims, and durable observation.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./errorCodes": {
+      "types": "./dist/errorCodes.d.ts",
+      "import": "./dist/errorCodes.js",
+      "default": "./dist/errorCodes.js"
+    },
+    "./environment": {
+      "types": "./dist/environment.d.ts",
+      "import": "./dist/environment.js",
+      "default": "./dist/environment.js"
+    },
+    "./coordination": {
+      "types": "./dist/coordination/index.d.ts",
+      "import": "./dist/coordination/index.js",
+      "default": "./dist/coordination/index.js"
+    },
+    "./wire": {
+      "types": "./dist/wire/index.d.ts",
+      "import": "./dist/wire/index.js",
+      "default": "./dist/wire/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    },
+    "./auth": {
+      "types": "./dist/auth/index.d.ts",
+      "import": "./dist/auth/index.js",
+      "default": "./dist/auth/index.js"
+    },
+    "./keys": {
+      "types": "./dist/keys/index.d.ts",
+      "import": "./dist/keys/index.js",
+      "default": "./dist/keys/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js",
+      "default": "./dist/schema/index.js"
+    },
+    "./schema/*": {
+      "types": "./dist/schema/*.d.ts",
+      "import": "./dist/schema/*.js",
+      "default": "./dist/schema/*.js"
+    },
+    "./source": {
+      "types": "./dist/source/index.d.ts",
+      "import": "./dist/source/index.js",
+      "default": "./dist/source/index.js"
+    },
+    "./source/*": {
+      "types": "./dist/source/*.d.ts",
+      "import": "./dist/source/*.js",
+      "default": "./dist/source/*.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    },
+    "./server/*": {
+      "types": "./dist/server/*.d.ts",
+      "import": "./dist/server/*.js",
+      "default": "./dist/server/*.js"
+    },
+    "./batching": {
+      "types": "./dist/batching/index.d.ts",
+      "import": "./dist/batching/index.js",
+      "default": "./dist/batching/index.js"
+    },
+    "./ai-sdk": {
+      "types": "./dist/ai-sdk/index.d.ts",
+      "import": "./dist/ai-sdk/index.js",
+      "default": "./dist/ai-sdk/index.js"
+    },
+    "./ai-sdk/*": {
+      "types": "./dist/ai-sdk/*.d.ts",
+      "import": "./dist/ai-sdk/*.js",
+      "default": "./dist/ai-sdk/*.js"
+    },
+    "./webhooks": {
+      "types": "./dist/webhooks/index.d.ts",
+      "import": "./dist/webhooks/index.js",
+      "default": "./dist/webhooks/index.js"
+    },
+    "./webhooks/*": {
+      "types": "./dist/webhooks/*.d.ts",
+      "import": "./dist/webhooks/*.js",
+      "default": "./dist/webhooks/*.js"
+    },
+    "./syncLog/*": {
+      "types": "./dist/syncLog/*.d.ts",
+      "import": "./dist/syncLog/*.js",
+      "default": "./dist/syncLog/*.js"
+    },
+    "./syncLog": {
+      "types": "./dist/syncLog/index.d.ts",
+      "import": "./dist/syncLog/index.js",
+      "default": "./dist/syncLog/index.js"
+    },
+    "./docs": {
+      "types": "./dist/docs/index.d.ts",
+      "import": "./dist/docs/index.js",
+      "default": "./dist/docs/index.js"
+    },
+    "./docs/*": {
+      "types": "./dist/docs/*.d.ts",
+      "import": "./dist/docs/*.js",
+      "default": "./dist/docs/*.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/__tests__/**",
+    "!src/**/*.test.ts",
+    "README.md",
+    "CONVENTIONS.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Abloatai/ablo.git",
+    "directory": "packages/transaction"
+  },
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "prepack": "npm run build && node ../ablo/scripts/strip-source-condition.mjs",
+    "postpack": "node ../ablo/scripts/restore-source-condition.mjs",
+    "pack:check": "node ../ablo/scripts/pack-check.mjs",
+    "lint:pkg": "publint",
+    "test": "vitest run src/headlessClient.test.ts && jest",
+    "typecheck": "tsc --noEmit && tsc -p typetests/tsconfig.json"
+  },
+  "dependencies": {
+    "uuid": "^11.1.0",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0",
+    "drizzle-orm": ">=0.44.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ablo/tsconfig": "*",
+    "@jest/globals": "^30.2.0",
+    "@types/jest": "^30.0.0",
+    "ai": "^6.0.0",
+    "jest": "^30.2.0",
+    "jest-environment-node": "^30.2.0",
+    "publint": "^0.3.17",
+    "ts-jest": "^29.4.5",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.4"
+  }
+}

package/src/ablo.ts

@@ -0,0 +1,139 @@
+/**
+ * `Ablo` — the entry point to the coordination layer.
+ *
+ * The factory constructs the stateless client: typed model resources, commits,
+ * claims, and session minting over request/response HTTP. It holds no socket,
+ * no store, and no local copy of anything — the bearer credential is the
+ * identity and the server resolves it on every request. This is the client a
+ * server-side actor installs: an agent, a worker, a cron job, a route handler.
+ *
+ * ```ts
+ * import { Ablo } from '@abloatai/ablo';
+ * import { schema } from './schema';
+ *
+ * const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY, transport: 'http' });
+ * await ablo.tasks.update({ id: taskId, data: { status: 'done' } });
+ * ```
+ *
+ * The reactive materialiser — local store, live queries, presence rendering —
+ * is provided by `@abloatai/humans`, which layers
+ * above this one and shares the same `ablo.<model>` surface (ADR 0016).
+ */
+
+import {
+  createAbloHttpClient,
+  type AbloHttpClient,
+  type AbloHttpClientOptions,
+} from './transport/httpClient.js';
+import type { SchemaRecord } from './schema/schema.js';
+import type * as _Streams from './types/streams.js';
+import type * as _SchemaTypes from './schema/schema.js';
+import type * as _Global from './types/global.js';
+import type * as _Policy from './policy/types.js';
+import type * as _Http from './resources/httpResources.js';
+
+/**
+ * Create a coordination-layer client in one call.
+ *
+ * The core carries one transport today — request/response HTTP — so
+ * `transport: 'http'` is accepted for symmetry with the reactive package's
+ * factory and may be omitted. The duplex transport joins this slot when the
+ * socket carve lands (ADR 0016, follow-up 3a).
+ */
+export function Ablo<const S extends SchemaRecord>(
+  options: AbloHttpClientOptions<S> & { transport?: 'http' },
+): AbloHttpClient<S> {
+  return createAbloHttpClient(options);
+}
+
+// ─────────────────────────────────────────────────────────────────────
+//  Ablo namespace — type access via namespace dots for stateless callers
+// ─────────────────────────────────────────────────────────────────────
+//
+// The stateless subset of the type namespace the reactive package hangs off
+// its own `Ablo` export: every entry a consumer of THIS client would write
+// out (`Ablo.Activity`, `Ablo.Commit.Receipt`, and so on), and nothing that
+// needs a store or a socket behind it. The
+// types live in their canonical homes (`types/streams`, `policy/types`,
+// `resources/httpResources`, `schema/schema`); the namespace is a convenience
+// path, not a second definition.
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace Ablo {
+  // ── Entity pointers (flat — input shapes used everywhere) ─────────
+  export type ClaimTarget = _Streams.ClaimTarget;
+  export type PresenceTarget = _Streams.PresenceTarget;
+  export type Duration = _Streams.Duration;
+
+  // ── Coordination (flat — the surface a contending caller reads) ───
+  export type Peer = _Streams.Peer;
+  export type Activity = _Streams.Activity;
+  export type Claim = _Streams.Claim;
+  export type ClaimHeartbeat = _Streams.ClaimHeartbeat;
+  export type ClaimHeartbeatOptions = _Streams.ClaimHeartbeatOptions;
+
+  // ── Claim (sub-namespace — the durable-lease cohort) ──────────────
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  export namespace Claim {
+    export type Held<
+      T = Record<string, unknown>,
+      M = _Global.ResolveClaimMeta,
+    > = _Streams.HeldClaim<T, M>;
+    export type WaitOptions = _Streams.ClaimWaitOptions;
+    export type LeaseOptions = _Streams.ClaimLeaseOptions;
+  }
+
+  // ── Schema (type + sub-namespace via declaration merge) ───────────
+  export type Schema<S extends _SchemaTypes.SchemaRecord = _SchemaTypes.SchemaRecord> =
+    _SchemaTypes.Schema<S>;
+  /**
+   * The schema this program has registered via `interface Register { Schema }`
+   * (falls back to a loose shape when unregistered). Use it where shared code
+   * needs "this app's schema" without importing a specific one.
+   */
+  export type ResolveSchema = _Global.ResolveSchema;
+  /**
+   * The claim metadata shape this program has registered via
+   * `interface Register { ClaimMeta }` (falls back to a loose record when
+   * unregistered). Every claim surface reads `target.meta` as this.
+   */
+  export type ResolveClaimMeta = _Global.ResolveClaimMeta;
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  export namespace Schema {
+    export type Model<
+      S extends _SchemaTypes.Schema,
+      K extends keyof S['models'],
+    > = _SchemaTypes.Model<S, K>;
+    export type InferCreate<
+      S extends _SchemaTypes.Schema,
+      K extends keyof S['models'],
+    > = _SchemaTypes.InferCreate<S, K>;
+    export type InferRow<
+      S extends _SchemaTypes.Schema,
+      K extends keyof S['models'],
+    > = _SchemaTypes.InferRow<S, K>;
+    export type InferModelNames<S extends _SchemaTypes.Schema> =
+      _SchemaTypes.InferModelNames<S>;
+  }
+
+  // ── Conflict (type + sub-namespace via declaration merge) ─────────
+  export type Conflict = _Policy.Conflict;
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  export namespace Conflict {
+    export type Kind = _Policy.ConflictKind;
+    export type Operation = _Policy.ConflictOperation;
+    export type Decision = _Policy.ConflictDecision;
+    export type Policy = _Policy.ConflictPolicy;
+    export type Axis = _Policy.ConflictAxis;
+  }
+
+  // ── Commit (sub-namespace — write-side cohort) ────────────────────
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  export namespace Commit {
+    export type Wait = _Http.CommitWait;
+    export type OperationAction = _Http.ModelOperationAction;
+    export type OperationInput = _Http.CommitOperationInput;
+    export type CreateOptions = _Http.CommitCreateOptions;
+    export type Receipt = _Http.CommitReceipt;
+    export type Client = _Http.CommitResource;
+  }
+}