@abloatai/ablo 0.9.1 → 0.9.3

package/dist/source/adapters/kysely.js

@@ -0,0 +1,210 @@
+/**
+ * Kysely Data Source adapter. Same adapter interface + conformance shape as
+ * `prismaDataSource` / `drizzleDataSource`, built against Kysely's REAL
+ * query-builder API:
+ *   - `db.transaction().execute(async (trx) => …)` — interactive transaction.
+ *   - `insertInto/updateTable/deleteFrom/selectFrom` + `returningAll()` —
+ *     the fluent builder; table/column names are plain strings, so no raw
+ *     SQL tag is needed and this module imports NOTHING from `kysely`
+ *     (structural `KyselyLike`, mirroring the Prisma adapter's zero-dep
+ *     `PrismaLike`).
+ *
+ * SCHEMA-DRIVEN COLUMNS. Kysely is SQL-near: it passes the column names you
+ * give it through verbatim (no Prisma-style `@map`). Like the Drizzle
+ * adapter, every table + column name is derived from the SAME rule the
+ * provisioner uses (`generateProvisionPlan`):
+ *   table  = `model.tableName ?? key`
+ *   column = `fieldMeta.column ?? camelToSnake(field)`  (+ the tenancy column)
+ * so `ablo migrate` (which emits `operator_id`) and this adapter COMPOSE.
+ * The adapter is the translation boundary: rows in/out are field-keyed (the
+ * SDK shape); the physical columns it reads/writes are snake_case.
+ *
+ * JSONB note: the outbox `data` / idempotency `response` values are passed
+ * as JSON strings — Postgres infers the parameter type from the target
+ * `jsonb` column, so the coercion is server-side and driver-agnostic (no
+ * `::jsonb` cast available without raw SQL).
+ */
+import { AbloValidationError } from '../../errors.js';
+import { outboxEventSchema } from '../contract.js';
+import { adapterTableMigrations } from '../migrations.js';
+import { toSchemaJSON } from '../../schema/serialize.js';
+import { camelToSnake, snakeToCamel } from '../../schema/ddl.js';
+import { tenancyColumn } from '../../schema/tenancy.js';
+function rowId(op) {
+    const id = op.id ?? op.input?.id;
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new AbloValidationError(`operation on "${op.model}" requires an id`, {
+            code: 'source_operation_id_required',
+        });
+    }
+    return id;
+}
+function buildColumnMaps(schema) {
+    const json = toSchemaJSON(schema);
+    const out = new Map();
+    for (const [key, model] of Object.entries(json.models)) {
+        const fieldToColumn = new Map();
+        const columnToField = new Map();
+        const register = (field, column) => {
+            if (column === camelToSnake(field))
+                return;
+            fieldToColumn.set(field, column);
+            columnToField.set(column, field);
+        };
+        for (const [field, meta] of Object.entries(model.fields)) {
+            if (meta.column)
+                register(field, meta.column);
+        }
+        const orgColumn = tenancyColumn(model.tenancy);
+        if (orgColumn)
+            register('organizationId', orgColumn);
+        out.set(key, { table: model.tableName ?? key, fieldToColumn, columnToField });
+    }
+    return out;
+}
+export function kyselyDataSource(db, schema) {
+    const maps = buildColumnMaps(schema);
+    const modelColumns = (model) => {
+        const mc = maps.get(model);
+        if (!mc) {
+            throw new AbloValidationError(`kyselyDataSource: no model "${model}" in schema`, {
+                code: 'source_adapter_misconfigured',
+            });
+        }
+        return mc;
+    };
+    const columnFor = (mc, field) => mc.fieldToColumn.get(field) ?? camelToSnake(field);
+    const fieldFor = (mc, column) => mc.columnToField.get(column) ?? snakeToCamel(column);
+    /** Field-keyed (SDK shape) → column-keyed (physical), for INSERT/UPDATE. */
+    const toColumns = (mc, row) => {
+        const out = {};
+        for (const k of Object.keys(row))
+            out[columnFor(mc, k)] = row[k];
+        return out;
+    };
+    /** Column-keyed (RETURNING * / SELECT *) → field-keyed (SDK shape). */
+    const toFields = (mc, row) => {
+        const out = {};
+        for (const k of Object.keys(row))
+            out[fieldFor(mc, k)] = row[k];
+        return out;
+    };
+    const applyOperation = async (trx, op) => {
+        const mc = modelColumns(op.model);
+        const id = rowId(op);
+        const input = op.input ?? {};
+        if (op.type === 'DELETE') {
+            const deleted = await trx
+                .deleteFrom(mc.table)
+                .where('id', '=', id)
+                .returningAll()
+                .execute();
+            return deleted[0] ? toFields(mc, deleted[0]) : { id };
+        }
+        if (op.type === 'CREATE') {
+            const inserted = await trx
+                .insertInto(mc.table)
+                .values(toColumns(mc, { id, ...input }))
+                .returningAll()
+                .execute();
+            return inserted[0] ? toFields(mc, inserted[0]) : { id, ...input };
+        }
+        // UPDATE / ARCHIVE / UNARCHIVE — the lifecycle field is `archivedAt`
+        // (camelCase) and goes through `toColumns` like any other, so it lands in
+        // `archived_at` — the same column the provisioner emits.
+        const patch = toColumns(mc, {
+            ...input,
+            ...(op.type === 'ARCHIVE' ? { archivedAt: new Date() } : {}),
+            ...(op.type === 'UNARCHIVE' ? { archivedAt: null } : {}),
+        });
+        const updated = await trx
+            .updateTable(mc.table)
+            .set(patch)
+            .where('id', '=', id)
+            .returningAll()
+            .execute();
+        return updated[0] ? toFields(mc, updated[0]) : { id, ...input };
+    };
+    return {
+        capabilities: { transactions: true, propose: false, schemaIntrospection: true },
+        migrations() {
+            return adapterTableMigrations();
+        },
+        async read(req) {
+            const mc = modelColumns(req.model);
+            if (req.kind === 'load') {
+                const rows = await db
+                    .selectFrom(mc.table)
+                    .selectAll()
+                    .where('id', '=', req.id)
+                    .limit(1)
+                    .execute();
+                return rows.map((r) => toFields(mc, r));
+            }
+            const limit = req.query?.limit ?? 1000;
+            const rows = await db.selectFrom(mc.table).selectAll().limit(limit).execute();
+            return rows.map((r) => toFields(mc, r));
+        },
+        async commit(change) {
+            return db.transaction().execute(async (trx) => {
+                const cached = await trx
+                    .selectFrom('ablo_idempotency')
+                    .selectAll()
+                    .where('client_tx_id', '=', change.clientTxId)
+                    .limit(1)
+                    .execute();
+                if (cached.length > 0) {
+                    const response = cached[0].response;
+                    return {
+                        rows: (typeof response === 'string' ? JSON.parse(response) : response),
+                    };
+                }
+                const rows = [];
+                for (const [index, op] of change.operations.entries()) {
+                    const row = await applyOperation(trx, op);
+                    rows.push(row);
+                    const entityId = String(row.id ?? rowId(op));
+                    await trx
+                        .insertInto('ablo_outbox')
+                        .values({
+                        id: `${change.clientTxId}:${index}`,
+                        model: op.model,
+                        entity_id: entityId,
+                        type: op.type,
+                        data: op.type === 'DELETE' ? null : JSON.stringify(row),
+                        client_tx_id: change.clientTxId,
+                        occurred_at: Date.now(),
+                    })
+                        .execute();
+                }
+                await trx
+                    .insertInto('ablo_idempotency')
+                    .values({ client_tx_id: change.clientTxId, response: JSON.stringify(rows) })
+                    .execute();
+                return { rows };
+            });
+        },
+        async events(cursor, limit) {
+            const after = cursor ?? '0';
+            const rows = await db
+                .selectFrom('ablo_outbox')
+                .selectAll()
+                .where('cursor', '>', after)
+                .orderBy('cursor', 'asc')
+                .limit(limit)
+                .execute();
+            const events = rows.map((r) => outboxEventSchema.parse({
+                id: r.id,
+                model: r.model,
+                entityId: r.entity_id,
+                type: r.type,
+                data: typeof r.data === 'string' ? JSON.parse(r.data) : r.data ?? null,
+                organizationId: r.organization_id ?? null,
+                clientTxId: r.client_tx_id ?? null,
+                occurredAt: r.occurred_at != null ? Number(r.occurred_at) : null,
+                cursor: String(r.cursor),
+            }));
+            return { events, nextCursor: events.length > 0 ? events[events.length - 1].cursor : null };
+        },
+    };
+}

package/dist/source/adapters/memory.js

@@ -8,10 +8,11 @@
  * It models the real semantics minimally but faithfully: one canonical row store
  * per model, an idempotency ledger keyed by `clientTxId`, and a monotonic outbox.
  */
+import { AbloValidationError } from '../../errors.js';
 function rowId(op) {
     const id = op.id ?? op.input?.id;
     if (typeof id !== 'string' || id.length === 0) {
-        throw new Error(`operation on "${op.model}" requires an id`);
+        throw new AbloValidationError(`operation on "${op.model}" requires an id`, { code: 'source_operation_id_required' });
     }
     return id;
 }

package/dist/source/adapters/prisma.js

@@ -12,6 +12,7 @@
  * (`PrismaLike`), so this compiles in the SDK package and is unit-testable with
  * a fake, while a real `PrismaClient` satisfies it at the call site.
  */
+import { AbloValidationError } from '../../errors.js';
 import { outboxEventSchema } from '../contract.js';
 import { adapterTableMigrations } from '../migrations.js';
 const lowerFirst = (s) => (s ? s[0].toLowerCase() + s.slice(1) : s);
@@ -32,7 +33,7 @@ const lowerFirst = (s) => (s ? s[0].toLowerCase() + s.slice(1) : s);
 function delegateFor(client, name) {
     const delegate = client[name];
     if (!delegate || typeof delegate.findMany !== 'function') {
-        throw new Error(`prismaDataSource: no Prisma delegate "${name}" on the client`);
+        throw new AbloValidationError(`prismaDataSource: no Prisma delegate "${name}" on the client`, { code: 'source_adapter_misconfigured' });
     }
     return delegate;
 }
@@ -97,7 +98,7 @@ function findManyArgs(query) {
 function rowId(op) {
     const id = op.id ?? op.input?.id;
     if (typeof id !== 'string' || id.length === 0) {
-        throw new Error(`operation on "${op.model}" requires an id`);
+        throw new AbloValidationError(`operation on "${op.model}" requires an id`, { code: 'source_operation_id_required' });
     }
     return id;
 }

package/dist/source/index.js

@@ -1,3 +1,4 @@
+import { AbloValidationError } from '../errors.js';
 import { changeSetSchema } from './contract.js';
 /**
  * Build the source-event marker customers should write to their outbox table in
@@ -10,7 +11,7 @@ import { changeSetSchema } from './contract.js';
 export function sourceEventForOperation(options) {
     const entityId = options.entityId ?? options.operation.id;
     if (typeof entityId !== 'string' || entityId.length === 0) {
-        throw new Error('sourceEventForOperation requires operation.id or an explicit entityId');
+        throw new AbloValidationError('sourceEventForOperation requires operation.id or an explicit entityId', { code: 'source_event_invalid' });
     }
     const occurredAt = normalizeEventOccurredAt(options.occurredAt);
     return {

package/dist/transactions/TransactionQueue.d.ts

@@ -10,7 +10,7 @@
 import { EventEmitter } from 'events';
 import type { Database } from '../Database.js';
 import { Model } from '../Model.js';
-import type { MutationOptions } from '../interfaces/index.js';
+import type { WriteOptions } from '../interfaces/index.js';
 export interface UserContext {
     userId: string;
     organizationId: string;
@@ -19,7 +19,6 @@ export interface UserContext {
 }
 /** Wire-format mutation payload (post-projection). */
 type MutationInput = Record<string, unknown>;
-type TransactionWriteOptions = Pick<MutationOptions, 'readAt' | 'onStale'>;
 export interface Transaction {
     id: string;
     type: 'create' | 'update' | 'delete' | 'archive' | 'unarchive';
@@ -34,7 +33,7 @@ export interface Transaction {
     attempts: number;
     priority: 'normal' | 'high';
     priorityScore: number;
-    writeOptions?: TransactionWriteOptions;
+    writeOptions?: WriteOptions;
     batchId?: string;
     /** LINEAR PATTERN: syncId threshold - transaction confirms when delta.id >= this value */
     syncIdNeededForCompletion?: number;
@@ -237,16 +236,16 @@ export declare class TransactionQueue extends EventEmitter {
     /**
      * Create operation with optimistic update
      */
-    create(model: Model, context: UserContext, writeOptions?: TransactionWriteOptions): Promise<Transaction>;
+    create(model: Model, context: UserContext, writeOptions?: WriteOptions): Promise<Transaction>;
     /**
      * Update operation with conflict detection
      * @param precomputedChanges - Optional pre-captured changes (avoids re-reading from model)
      */
-    update(model: Model, context: UserContext, precomputedChanges?: Record<string, unknown>, writeOptions?: TransactionWriteOptions): Promise<Transaction>;
+    update(model: Model, context: UserContext, precomputedChanges?: Record<string, unknown>, writeOptions?: WriteOptions): Promise<Transaction>;
     /**
      * Delete operation with cascade handling
      */
-    delete(model: Model, context: UserContext, writeOptions?: TransactionWriteOptions): Promise<Transaction>;
+    delete(model: Model, context: UserContext, writeOptions?: WriteOptions): Promise<Transaction>;
     /**
      * Upload attachment — delegates to attachment-uploader.ts
      */
@@ -269,7 +268,7 @@ export declare class TransactionQueue extends EventEmitter {
     /**
      * Archive operation
      */
-    archive(model: Model, context: UserContext, writeOptions?: TransactionWriteOptions): Promise<Transaction>;
+    archive(model: Model, context: UserContext, writeOptions?: WriteOptions): Promise<Transaction>;
     /**
      * Unarchive operation
      */

package/dist/transactions/TransactionQueue.js

@@ -117,13 +117,31 @@ function hasStaleWriteOptions(options) {
     return (options?.readAt !== undefined ||
         options?.onStale !== undefined);
 }
-function applyStaleWriteOptions(op, transaction) {
+/**
+ * Project a transaction's `writeOptions` onto the wire operation. Stale
+ * guards (`readAt`/`onStale`) ride at the op root; `idempotencyKey`/`label`
+ * ride in the op's `options` slot (`MutationOperation.options` — the
+ * mutation_log cache key + audit tag). This is the single place the
+ * caller-supplied write vocabulary crosses onto the wire.
+ */
+function applyWriteOptions(op, transaction) {
     const operation = op;
-    if (transaction.writeOptions?.readAt !== undefined) {
-        operation.readAt = transaction.writeOptions.readAt;
-    }
-    if (transaction.writeOptions?.onStale !== undefined) {
-        operation.onStale = transaction.writeOptions.onStale;
+    const writeOptions = transaction.writeOptions;
+    if (!writeOptions)
+        return operation;
+    if (writeOptions.readAt !== undefined) {
+        operation.readAt = writeOptions.readAt;
+    }
+    if (writeOptions.onStale !== undefined) {
+        operation.onStale = writeOptions.onStale;
+    }
+    if (writeOptions.idempotencyKey != null || writeOptions.label !== undefined) {
+        operation.options = {
+            ...(writeOptions.idempotencyKey != null
+                ? { idempotencyKey: writeOptions.idempotencyKey }
+                : {}),
+            ...(writeOptions.label !== undefined ? { label: writeOptions.label } : {}),
+        };
     }
     return operation;
 }
@@ -552,7 +570,7 @@ export class TransactionQueue extends EventEmitter {
         // Build operations list
         const operations = pending.map((tx) => {
             this.ensureDerivedFields(tx);
-            return applyStaleWriteOptions({
+            return applyWriteOptions({
                 type: TX_TYPE_TO_MUTATION_OP[tx.type],
                 model: tx.modelKey,
                 id: tx.modelId,
@@ -930,7 +948,7 @@ export class TransactionQueue extends EventEmitter {
                     // matches it via `OptimisticEchoTracker.consumeEcho` to suppress
                     // double-applying optimistic mutations. Distinct from the
                     // batch-level idempotency key in mutation_log.
-                    const op = applyStaleWriteOptions({
+                    const op = applyWriteOptions({
                         type: TX_TYPE_TO_MUTATION_OP[tx.type],
                         model: tx.modelKey,
                         id: tx.modelId,
@@ -1358,6 +1376,12 @@ export class TransactionQueue extends EventEmitter {
         };
         this.commitStore.set(clientTxId, tx);
         this.commitLane.push(tx);
+        // Surface the envelope on its OWN event so the undo stream can record
+        // commit-lane writes too (`SyncClient.onLocalTransaction` enriches each
+        // operation with pool-captured previous state). Deliberately NOT
+        // `transaction:created` — that event also feeds the optimistic-echo
+        // tracker, and commit-lane ops have no optimistic pool apply to echo.
+        this.emit('commit:created', { clientTxId, operations: tx.operations });
         void this.processCommitLane();
     }
     /**
@@ -1674,7 +1698,7 @@ export class TransactionQueue extends EventEmitter {
         const input = (type === 'create' || type === 'update') ? data : undefined;
         try {
             await this.mutationExecutor.commit([
-                applyStaleWriteOptions({ type: mutationType, model, id: modelId, input }, transaction),
+                applyWriteOptions({ type: mutationType, model, id: modelId, input }, transaction),
             ]);
         }
         catch (error) {

package/dist/types/streams.d.ts

@@ -52,7 +52,8 @@ export interface AgentDelta {
     capabilityId?: string | null;
     /** Whether the human explicitly approved the change. */
     confirmationState?: ConfirmationState | null;
-    /** Turn handle that caused this commit. */
+    /** Agent-task id that caused this commit, if any. Dormant on new client
+     *  writes (turns/tasks removed); may hold historical values. */
     causedByTaskId?: string | null;
     createdAt: string;
 }

package/dist/utils/duration.js

@@ -16,6 +16,7 @@
  * without breaking numeric callers — the wrapper below branches on
  * the input type.
  */
+import { AbloValidationError } from '../errors.js';
 const PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h)$/;
 const UNIT_MS = {
     ms: 1,
@@ -34,8 +35,8 @@ export function toMs(input) {
         return input * 1_000;
     const match = PATTERN.exec(input);
     if (!match) {
-        throw new Error(`Invalid duration "${input}" — expected number (seconds) or ` +
-            `a string like "500ms" | "30s" | "3m" | "24h".`);
+        throw new AbloValidationError(`Invalid duration "${input}" — expected number (seconds) or ` +
+            `a string like "500ms" | "30s" | "3m" | "24h".`, { code: 'duration_invalid' });
     }
     const value = Number(match[1]);
     const unit = match[2];

package/dist/wire/frames.d.ts

@@ -76,14 +76,12 @@ export interface CommitMessage {
         operations: CommitOperation[];
         clientTxId: string;
         /**
-         * Optional turn handle. When the SDK opens a turn via
-         * `SyncAgent.beginTurn(...)`, subsequent commits within the handle's
-         * scope auto-attach the `turnId` here. The Hub validates the turn
-         * belongs to the same agent and is open, then threads it onto every
-         * delta's `caused_by_task_id` column. Absent for human-direct commits
-         * and for SDKs that predate the turn protocol — those produce deltas
-         * with `caused_by_task_id = NULL`, which the audit pane treats as "no
-         * prompt-side context recorded."
+         * Dormant agent-task lineage field. The SDK no longer populates it —
+         * turns/tasks were removed and write attribution now rides on the
+         * claim (`intent`) id plus the server-stamped actor/capability. Kept
+         * optional for wire-compat; when present the Hub still validates and
+         * threads it onto `caused_by_task_id`, but client writes leave it
+         * `null` (the audit pane treats null as "no prompt-side context").
          */
         causedByTaskId?: string | null;
     };

package/docs/api.md

@@ -8,7 +8,7 @@ row, you can optionally `claim` it so they serialize instead of clobbering
 each other.
 
 Two things to know before the method list. **Reads come in two flavors:**
-`retrieve(id)` / `list({ where })` are async and hit the server (use them when
+`retrieve({ id })` / `list({ where })` are async and hit the server (use them when
 the row may not be local yet); `get(id)` / `getAll({ where })` / `getCount({ where })`
 are synchronous reads off the local graph (use them in render, after data has
 synced). **Claims don't lock.** If another writer holds the row, `claim` waits

package/docs/cli.md

@@ -57,7 +57,7 @@ either mode) defines the same models test and live see; only the rows differ.
 | `ablo dev`                         | **Hosted** — push the schema to your test sandbox, then watch `ablo/schema.ts` and re-push on save.                                           | `--no-watch`, `--schema <path>`, `--export <name>`, `--url <url>`                                      |
 | `ablo logs`                        | Tail your scope's commit activity (`stripe logs tail`). Follows by default.                                                                   | `-n, --tail <N>`, `--since <dur\|ts>`, `--model`, `--op`, `--json`, `--no-follow`, `--mode test\|live` |
 | `ablo push`                        | **Hosted** — upload the schema to Ablo; the server diffs, migrates, and activates it.                                                         | `--force`, `--rename old:new`, `--backfill model.field=value`, `--schema`, `--export`, `--url`         |
-| `ablo migrate`                     | **Direct Postgres** — apply the schema to your own `DATABASE_URL` (you run the table-creation SQL).                                                          | `--dry-run`, `--output <file>`, `--schema`, `--export`                                                 |
+| `ablo migrate`                     | **Direct Postgres** — provision just the synced models (plus the adapter's `ablo_outbox` / `ablo_idempotency`) in your own `DATABASE_URL`. Leaves your other tables alone.                                                          | `--dry-run`, `--output <file>`, `--schema`, `--export`                                                 |
 | `ablo pull`                        | **Direct Postgres** — generate `defineSchema(...)` from your existing tables (read-only, like `prisma db pull`).                              | `--out <path>`, `--app-schema <name>`, `--import <pkg>`, `--force`                                     |
 | `ablo check`                       | **Direct Postgres** — verify your _existing_ tables fit the schema (read-only, no schema changes).                                                       | `--schema <path>`, `--export <name>`, `--app-schema <name>`                                            |
 | `ablo generate`                    | Emit TypeScript types from the schema.                                                                                                        | `--out <path>`, `--schema`, `--export`                                                                 |
@@ -144,9 +144,9 @@ reshaping it. `ablo check` is read-only; it never proposes a migration.
 ## `migrate` (Direct Postgres) vs `push` (Hosted)
 
 Same engine, two setups. If you use the **Direct Postgres connector**, use
-`ablo migrate` — it applies the schema to your own `DATABASE_URL`, and you run
-the table-creation SQL. If Ablo manages the sandbox/hosted store, use `ablo push` and
-`ablo dev` — the server applies the change and version-gates connecting clients.
+`ablo migrate` — it provisions the synced models in your own `DATABASE_URL`. If
+Ablo manages the sandbox/hosted store, use `ablo push` and `ablo dev` — the
+server applies the change and version-gates connecting clients.
 
 ```bash
 ablo migrate --dry-run            # preview the exact SQL
@@ -154,6 +154,19 @@ ablo migrate                      # apply to DATABASE_URL
 ablo migrate --output schema.sql  # write SQL to a file
 ```
 
+### One database, two schemas
+
+`ablo migrate` does **not** own your whole database. It creates exactly the
+models in your `defineSchema(...)` — the synced, collaborative tables — plus the
+adapter's bookkeeping tables (`ablo_outbox`, `ablo_idempotency`). Nothing else.
+
+Your auth, billing, and any other non-synced tables stay in **your own ORM
+schema** (Drizzle's `schema.ts`, Prisma's `schema.prisma`) and are provisioned by
+**your own migrations** (`drizzle-kit push` / `prisma migrate`). The Ablo schema
+is not a replacement for `schema.prisma`, and `ablo migrate` won't touch, drop,
+or adopt the tables it doesn't manage. One database, two schemas, side by side —
+each owned by its own migration tool.
+
 ## Zod → Postgres type mapping
 
 The one type map, shared by both paths (there is no second mapping):

package/docs/client-behavior.md

@@ -30,7 +30,7 @@ Common options:
 | `schema` | Required for typed model clients. |
 | `apiKey` | Bearer credential for trusted server runtimes. Defaults to `ABLO_API_KEY` when available. |
 | `baseURL` | Override the hosted sync endpoint for staging or private deployments. |
-| `persistence` | `volatile` by default. Use `indexeddb` for a durable browser cache that survives reloads. |
+| `persistence` | `memory` by default. Use `indexeddb` for a durable browser cache that survives reloads. |
 | `fetch` | Custom fetch implementation for tests or non-standard runtimes. |
 | `defaultHeaders` | Extra headers attached to every HTTP request. |
 | `defaultQuery` | Extra query parameters attached to every HTTP request. |