@abloatai/ablo 0.57.0 → 0.59.0

package/examples/stale-context-agent-turn.ts

@@ -0,0 +1,106 @@
+/**
+ * Canonical stale-context turn: abort early, retain the authoritative write
+ * guard, rebuild context on a bounded retry, and never blindly replay an
+ * irreversible tool side effect.
+ *
+ * The application-owned model and notification functions below are small,
+ * deterministic stand-ins. Keep their cancellation/idempotency contracts when
+ * replacing them with real providers.
+ *
+ * Run: ABLO_API_KEY=sk_... RECORD_ID=record_... npx tsx examples/stale-context-agent-turn.ts
+ */
+import { Ablo, AbloStaleContextError } from '@abloatai/ablo';
+import { context } from '@abloatai/ablo/context';
+import { defineSchema, model, z } from '@abloatai/ablo/schema';
+
+const schema = defineSchema({
+  records: model({
+    title: z.string(),
+    status: z.enum(['pending', 'done']),
+    result: z.string().optional(),
+  }),
+});
+
+const delivered = new Set<string>();
+
+async function callModel(title: string, signal: AbortSignal): Promise<string> {
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(resolve, 25);
+    signal.addEventListener('abort', () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+  return `Completed: ${title}`;
+}
+
+async function sendResult(operationKey: string, signal: AbortSignal): Promise<void> {
+  signal.throwIfAborted();
+  // Replace with a provider call that accepts operationKey as its idempotency key.
+  delivered.add(operationKey);
+}
+
+async function wasResultSent(operationKey: string): Promise<boolean> {
+  // Replace with the provider's outcome lookup using the same key.
+  return delivered.has(operationKey);
+}
+
+const recordId = process.env.RECORD_ID;
+if (!recordId) throw new Error('RECORD_ID is required');
+
+const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
+
+async function completeRecord(id: string): Promise<void> {
+  const operationKey = `complete-record:${id}`;
+  const maxAttempts = 3;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const ctx = await context({
+      ablo,
+      data: { record: ablo.records.read({ id }) },
+    });
+    if (!ctx.data.record) throw new Error(`Record ${id} was not found`);
+
+    const controller = new AbortController();
+    const stop = ctx.onChange((error) => controller.abort(error));
+    let resultMayHaveBeenSent = false;
+
+    try {
+      const result = await callModel(ctx.data.record.title, controller.signal);
+      resultMayHaveBeenSent = true;
+      await sendResult(operationKey, controller.signal);
+
+      await ablo.records.update({
+        id: ctx.data.record.id,
+        data: { status: 'done', result },
+        reads: ctx.reads,
+        idempotencyKey: operationKey,
+      });
+      console.log({ attempt, operationKey, status: 'done' });
+      return;
+    } catch (error) {
+      const stale = error instanceof AbloStaleContextError ||
+        controller.signal.reason instanceof AbloStaleContextError;
+      if (!stale) throw error;
+
+      if (resultMayHaveBeenSent) {
+        const sent = await wasResultSent(operationKey);
+        throw new Error(
+          `Context changed after the external action (sent=${sent}). ` +
+          `Reconcile operation ${operationKey}; do not replay it automatically.`,
+        );
+      }
+      if (attempt === maxAttempts) throw error;
+      // The next iteration assembles new data and new read evidence.
+    } finally {
+      stop();
+    }
+  }
+}
+
+try {
+  await ablo.ready();
+  await completeRecord(recordId);
+} finally {
+  await ablo.dispose();
+}

package/llms.txt

@@ -1,6 +1,6 @@
 # Ablo
 
-Ablo is collaboration infrastructure for AI agents: one API for agents, apps, and services to claim, change, and confirm the same rows.
+Ablo is coordination infrastructure for agents, applications, services, and people working on shared state.
 
 Here is the problem it solves. Two agents reach for `report_stockholm` at once. One claims the row, does slow work (an LLM call, a fetch, a chain of tools), and commits. The second is neither rejected nor allowed to clobber: it waits in line, is handed the row as it now stands, and proceeds. Claims don't lock. If another writer holds the row, `claim` waits for them, re-reads the fresh row, then hands it to you — so writers serialize instead of colliding. A person editing that row is simply another holder; the agent waits behind them the same way. And a claim is as narrow as its target: name a `path`, a `range`, or a `field` and two claims on non-overlapping parts of the same row are both granted — region locking within one row, with no queueing between regions.
 
@@ -27,7 +27,7 @@ These are the jobs it is WRONG for, and saying so saves you a wasted integration
 - **Vector search, embeddings, or retrieval.** Different problem. Ablo coordinates the rows; your vector store indexes them.
 - **A file, blob, or artifact store.** Coordinate the ROW that points at the object; put the bytes in object storage.
 
-How to call it, shortest path first: install `@abloatai/ablo`, run `npx ablo init --yes --framework <nextjs|vite|remix|vanilla>`, and construct `Ablo({ schema, apiKey: process.env.ABLO_API_KEY })`. Read with `ablo.<model>.get({ id })` / `.list({ where })`, write with `ablo.<model>.update({ id, data, readAt })`, and wrap anything slow in `await using claim = await ablo.<model>.claim({ id })`. The sections below cover the rest; "Start here" is the first thing to run.
+How to call it, shortest path first: install `@abloatai/ablo`, run `npx ablo init --yes --framework <nextjs|vite|remix|vanilla>`, and construct `Ablo({ schema, apiKey: process.env.ABLO_API_KEY })`. Use `ablo.<model>.get({ id })` to observe a row. Use `const input = await ablo.<model>.read({ id })`, then pass `reads: [input]` to the create/update/delete whose decision used it; if the row moved, that mutation does not land. `list({ where })` is observational. Wrap anything slow and exclusive in `await using claim = await ablo.<model>.claim({ id })`. The sections below cover the rest; "Start here" is the first thing to run.
 
 ## Machine-readable surfaces
 
@@ -38,10 +38,15 @@ Everything below is public, needs no credential, and is served from `https://www
 - `/developers` — every developer surface named on one page: the SDK, the API reference, the OpenAPI document, the MCP server, the CLI.
 - `/openapi.json` — the REST contract as OpenAPI 3.1: every route, a stable `operationId` and description on each, typed responses, and the `ErrorEnvelope` every 4xx and 5xx decodes through. Generate a client from it when no SDK exists for your runtime.
 - `/mcp` — the integration-helper MCP server over Streamable HTTP. POST your JSON-RPC here; a GET returns a descriptor rather than the protocol.
+- `/.well-known/mcp` — the same Streamable HTTP server at its direct discovery endpoint, with no page/transport negotiation.
 - `/.well-known/mcp.json` — that server's manifest, in the MCP registry's `server.json` format.
 - `/api/docs/<page>` — any documentation page as plain Markdown, for a client that fetches URLs rather than speaking MCP.
 - `/sitemap.xml` — every indexable page on the domain.
 
+Pricing and plan limits are public at [Ablo pricing](https://docs.abloatai.com/pricing). Do not
+infer prices or follow a dashboard billing link: the documentation page is the canonical rate
+card and needs no sign-in.
+
 Every page on that host serves a Markdown representation from its own URL: send
 `Accept: text/markdown` (q-values are honoured), or append `.md` to the path if
 your client cannot set the header. Responses carry `Vary: Accept`, a client that
@@ -65,6 +70,7 @@ Every surface reaches the same coordinated state. They are not interchangeable.
 - Coordination MCP, `@abloatai/mcp` — an agent living inside an MCP host (Claude, Cursor). Two jobs: MANAGING your Ablo the way the CLI does (`get_schema`, `list_projects`, `create_project`, `tail_logs`, `get_usage`), and claim/commit as tools over your rows. Call `get_schema` first — it is the only way to learn the model names every data tool needs. `init`, `push`, `pull`, `generate` have no tools (they touch your repo); run those in a shell.
 - `humans()` with `@abloatai/humans/react` — the interfaces a person watches agent work arrive in. The bare client is the coordination layer (commit, read, observe, claim); `humans()` is the plugin that adds the local watchable copy, live queries, and presence. It `requires: { duplex: true }`, so a `transport: 'http'` agent is rejected at construction rather than left holding a subscription that never delivers. It remains the compatibility default for omitted `plugins`; new code should install it explicitly from `@abloatai/humans`. There is no `agents()` plugin — agents are the default caller, not a special one. A browser NEVER receives the secret key; mint a session token.
 - CLI, `ablo` — scaffolding, schema push, connecting a database. Terminals and CI. Agents must run it non-interactively (see the CLI section below).
+- CLI package, [`@abloatai/cli`](https://www.npmjs.com/package/@abloatai/cli) — the official npm package that installs the `ablo` binary.
 - REST, `/api/v1` — runtimes with no SDK.
 - Integration-helper MCP, hosted `/api/mcp` — teaching a coding assistant the SDK WHILE BUILDING an integration. Docs, schema lint, and scaffolds only; it has NO per-model data tools and cannot touch application rows.
 
@@ -103,7 +109,7 @@ const schema = defineSchema({
 
 const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
 
-const report = await ablo.weatherReports.get({ id: 'report_stockholm' });
+const report = await ablo.weatherReports.read({ id: 'report_stockholm' });
 if (!report) throw new Error('Row not found');
 
 // Claim the row (waits if someone else holds it), read the fresh copy off
@@ -115,7 +121,7 @@ const updated = await ablo.weatherReports.update({
 });
 ```
 
-That is the normal app path: declare models in a schema, then use `ablo.<model>.get({ id })`, `ablo.<model>.create(...)`, `ablo.<model>.update(...)`, and `ablo.<model>.delete(...)`. Every verb takes a single options object.
+That is the normal app path: declare models in a schema, then use `ablo.<model>.read({ id })`, `ablo.<model>.create(...)`, `ablo.<model>.update(...)`, and `ablo.<model>.delete(...)`. Every verb takes a single options object.
 
 Treat the schema as the integration contract. It drives typed model clients,
 React selectors, server and agent writes, Data Source request/response shape,
@@ -126,12 +132,12 @@ For full integrations, use `integration-guide` as the canonical doc. It covers
 the same model API across your own Data Source-backed app databases,
 React selectors, multiplayer, and future agent workers.
 
-Reads come in two flavors, and you pick by whether you can wait. `get({ id })`
-(one row) and `list({ where })` (many) are async — they answer from the local
-graph and fall back to the server, so await them. `local.get(id)`,
+Server reads separate observation from decision input. `get({ id })` and
+`list({ where })` return current data without creating stale evidence.
+`read({ id })` returns the same row with private `{ model, id, readAt }` evidence
+for a specific mutation's `reads` array. `local.get(id)`,
 `local.list({ where })`, and `local.count({ where })` are the same reads narrowed
-to what has already synced: nothing to await, reactive in render. There is no
-second verb to learn — `local.` is the only difference. The query reads accept
+to what has already synced: nothing to await, reactive in render. The collection queries accept
 `where`, `filter`, `orderBy`, `limit`, `offset`,
 and `state`; state defaults to `'live'`, with `'archived'` and `'all'` to include
 retired rows.
@@ -168,7 +174,7 @@ coordination until the app reports it through Data Source events.
 
 ## Change propagation
 
-A change to one row reaches other rows three ways. ROUTING: a write fans out to every sync group the row belongs to, INCLUDING its ancestors' groups (editing a block routes to `block:` + `document:` + `workspace:`), so everyone watching the workspace sees it — delivery, not recomputation. DELETE CASCADE: deleting a parent emits explicit tombstone deltas for its descendants, so open clients never silently hold rows that are gone. VALUE: derived values are NOT recomputed server-side — Ablo surfaces that the source moved and the actor decides. To keep dependent work fresh, declare what you read as a batch premise: `reads: [{ group: 'workspace:abc', readAt: N, onStale: 'notify' }]`. At commit the server checks whether anything in that group moved past `readAt`; `notify` holds the write and returns a `StaleNotification` (re-read the group and regenerate), `reject` aborts. To chain A→B→C, put A+B in one group and B+C in another: A's change reaches B, and C hears it only once B ITSELF writes — the engine wires the edges and signals each hop, the actor walks them. No transitive auto-recompute, no convergence guarantee for cycles. `reads` guards ONE commit; for a long-running actor that reads now and writes much later, register a DURABLE premise with `track`: `ablo.<model>.track({ id })` for a row, or the `track:` write option (`track: [{ group: 'workspace:abc' }]`) alongside a write. A track persists server-side; the next time you commit anything, a change that landed on the tracked target rides back on your receipt's `notifications` (same `StaleNotification` shape as `onStale: 'notify'`). It is an idempotent registration, re-baselines so a change fires once, and never notifies you of your own writes. Delivery is on your next commit — a track does not yet push out of band between commits.
+A change to one row reaches other rows three ways. ROUTING: a write fans out to every sync group the row belongs to, INCLUDING its ancestors' groups (editing a block routes to `block:` + `document:` + `workspace:`), so everyone watching the workspace sees it — delivery, not recomputation. DELETE CASCADE: deleting a parent emits explicit tombstone deltas for its descendants, so open clients never silently hold rows that are gone. VALUE: derived values are NOT recomputed server-side — Ablo surfaces that the source moved and the actor decides. To keep dependent work fresh, pass rows returned by `ablo.<model>.read({ id })` in the mutation's `reads` array. Ablo records compact model/id/readAt evidence, not row contents. At commit the server checks whether anything moved past the read watermark; if so, the mutation does not land. Use `get` when no such relationship exists. To chain A→B→C, put A+B in one group and B+C in another: A's change reaches B, and C hears it only once B ITSELF writes. No transitive auto-recompute, no convergence guarantee for cycles.
 
 ## Nouns
 
@@ -180,7 +186,7 @@ A change to one row reaches other rows three ways. ROUTING: a write fans out to
 ## Claimed Behavior
 
 Reads never silently block. Schema reads stay open while a row is claimed.
-Typed reads through `ablo.<model>.get({ id })` return the row by default,
+Typed reads through `ablo.<model>.read({ id })` return the row by default,
 even while it is claimed. Pass `ifClaimed: 'fail'` to throw
 `AbloClaimedError`, and inspect active coordination separately through
 `ablo.<model>.claim.state({ id })`.
@@ -198,7 +204,7 @@ frees. Use `ifClaimed: 'fail'` when you'd rather refuse to read a claimed row.
 
 ## Guarantees
 
-Schema model writes update local state optimistically, while their returned promise always waits for authoritative confirmation. Server rejection rolls back local state. To prevent lost updates, read with `snapshot(...)` to capture a `readAt`, then write with `onStale: 'reject'` — the server rejects your update if someone else changed the row after that `readAt`.
+Schema model writes update local state optimistically, while their returned promise always waits for authoritative confirmation. Server rejection rolls back local state. To prevent lost updates, fetch the decision input with `read({ id })` and pass that exact row in the mutation's `reads` array. If it changed, the mutation does not land.
 
 Claims coordinate writers; they do not block readers. Most users should stay on
 schema-backed reads/writes and `claim(...)`; manual protocol bookkeeping is not
@@ -282,6 +288,11 @@ Import from these public paths only:
 
 Do not teach `/api`, `/agent`, `/core`, `/realtime`, or internal subpaths. (`/source` and `/ai-sdk` are public.)
 
+`onChange` is WebSocket-only. It exists on the reactive client because that
+client holds an open socket and a local graph. The stateless HTTP client does
+not expose it at the type or runtime level; HTTP agents re-read or inspect
+durable logs instead.
+
 ## CLI: agents run it NON-INTERACTIVELY
 
 `ablo init` and other prompts need a TTY; an agent/CI run has none and will HANG. Always:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abloatai/ablo",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "The public Ablo SDK for coordinated reads, commits, claims, observation, and reactive applications.",
   "license": "Apache-2.0",
   "type": "module",
@@ -81,9 +81,9 @@
       "default": "./dist/ai-sdk.js"
     },
     "./context": {
-      "types": "./dist/context.d.ts",
-      "import": "./dist/context.js",
-      "default": "./dist/context.js"
+      "types": "./dist/context/index.d.ts",
+      "import": "./dist/context/index.js",
+      "default": "./dist/context/index.js"
     },
     "./wire": {
       "types": "./dist/wire.d.ts",
@@ -112,6 +112,7 @@
     "prepack": "npm run build && node scripts/strip-source-condition.mjs",
     "postpack": "node scripts/restore-source-condition.mjs",
     "pack:check": "node scripts/pack-check.mjs",
+    "verify:context-package": "node scripts/verify-context-package.mjs",
     "typecheck": "tsc --noEmit && tsc -p typetests/tsconfig.json && tsc -p examples/tsconfig.json",
     "test": "vitest run",
     "generate:errors": "tsx scripts/generate-error-docs.mts",
@@ -139,8 +140,8 @@
     "directory": "packages/ablo"
   },
   "dependencies": {
-    "@abloatai/humans": "^0.57.0",
-    "@abloatai/transaction": "^0.57.0",
+    "@abloatai/humans": "^0.59.0",
+    "@abloatai/transaction": "^0.59.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {

package/dist/context/sources.d.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import type { ContextEvidenceSlice } from './evidence.js';
-export declare const contextSourceSchema: z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodObject<{
-    key: z.ZodString;
-    kind: z.ZodLiteral<"ablo">;
-    guarantee: z.ZodLiteral<"guardable">;
-    cursor: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    key: z.ZodString;
-    kind: z.ZodLiteral<"value">;
-    guarantee: z.ZodLiteral<"informational">;
-    cursor: z.ZodNull;
-}, z.core.$strip>, z.ZodObject<{
-    key: z.ZodString;
-    kind: z.ZodLiteral<"mixed">;
-    guarantee: z.ZodLiteral<"partial">;
-    cursor: z.ZodNumber;
-}, z.core.$strip>], "kind">>;
-export type ContextSource = z.infer<typeof contextSourceSchema>;
-export declare function sourceFor(key: string, evidence: ContextEvidenceSlice): ContextSource;
-//# sourceMappingURL=sources.d.ts.map

package/dist/context/sources.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../src/context/sources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;4BAmBnB,CAAC;AAEd,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,oBAAoB,GAC7B,aAAa,CAaf"}

package/dist/context/sources.js

@@ -1,36 +0,0 @@
-import { z } from 'zod';
-export const contextSourceSchema = z.discriminatedUnion('kind', [
-    z.object({
-        key: z.string(),
-        kind: z.literal('ablo'),
-        guarantee: z.literal('guardable'),
-        cursor: z.number().int().nonnegative(),
-    }),
-    z.object({
-        key: z.string(),
-        kind: z.literal('value'),
-        guarantee: z.literal('informational'),
-        cursor: z.null(),
-    }),
-    z.object({
-        key: z.string(),
-        kind: z.literal('mixed'),
-        guarantee: z.literal('partial'),
-        cursor: z.number().int().nonnegative(),
-    }),
-]).readonly();
-export function sourceFor(key, evidence) {
-    if (evidence.reads.length === 0) {
-        return contextSourceSchema.parse({
-            key,
-            kind: 'value',
-            guarantee: 'informational',
-            cursor: null,
-        });
-    }
-    const cursor = Math.max(...evidence.reads.map((item) => item.entry.watermark));
-    return evidence.includesInformational
-        ? contextSourceSchema.parse({ key, kind: 'mixed', guarantee: 'partial', cursor })
-        : contextSourceSchema.parse({ key, kind: 'ablo', guarantee: 'guardable', cursor });
-}
-//# sourceMappingURL=sources.js.map

package/dist/context/sources.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sources.js","sourceRoot":"","sources":["../../src/context/sources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC9D,CAAC,CAAC,MAAM,CAAC;QACP,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;QACf,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;QACjC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;KACvC,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;QACf,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QACxB,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;QACrC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE;KACjB,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;QACf,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QACxB,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAC/B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;KACvC,CAAC;CACH,CAAC,CAAC,QAAQ,EAAE,CAAC;AAId,MAAM,UAAU,SAAS,CACvB,GAAW,EACX,QAA8B;IAE9B,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,mBAAmB,CAAC,KAAK,CAAC;YAC/B,GAAG;YACH,IAAI,EAAE,OAAO;YACb,SAAS,EAAE,eAAe;YAC1B,MAAM,EAAE,IAAI;SACb,CAAC,CAAC;IACL,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/E,OAAO,QAAQ,CAAC,qBAAqB;QACnC,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;QACjF,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;AACvF,CAAC"}

package/dist/context.d.ts

@@ -1,22 +0,0 @@
-import type { CapturedRow } from '@abloatai/transaction';
-import { type AwaitedDeep } from './context/await.js';
-import { type ContextSource } from './context/sources.js';
-export { contextSourceSchema, type ContextSource } from './context/sources.js';
-export type { AwaitedDeep } from './context/await.js';
-export interface ContextOptions<TData extends Readonly<Record<string, unknown>>> {
-    /** The client whose read evidence may guard a later write. */
-    readonly ablo: object;
-    /** Values selected by the application. Nested promises are accepted. */
-    readonly data: TData;
-}
-export interface ContextResult<TData extends Readonly<Record<string, unknown>>> {
-    readonly data: AwaitedDeep<TData>;
-    /** Exact returned Ablo rows, ready to pass to a write's `reads` option. */
-    readonly reads: readonly CapturedRow[];
-    /** The greatest watermark among included authoritative reads. */
-    readonly cursor: number | null;
-    readonly sources: readonly ContextSource[];
-}
-/** Assemble selected application values and the Ablo evidence they retain. */
-export declare function context<const TData extends Readonly<Record<string, unknown>>>(options: ContextOptions<TData>): Promise<ContextResult<TData>>;
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EAAa,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC/E,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7E,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACtB;AAED,MAAM,WAAW,aAAa,CAAC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5E,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IACvC,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAED,8EAA8E;AAC9E,wBAAsB,OAAO,CAAC,KAAK,CAAC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACjF,OAAO,EAAE,cAAc,CAAC,KAAK,CAAC,GAC7B,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAsB/B"}

package/dist/context.js

@@ -1,33 +0,0 @@
-/**
- * Additive context assembly for one Ablo client.
- *
- * The caller chooses the data. This module awaits it, reports the exact Ablo
- * rows it contains, and leaves model execution and external retrieval alone.
- */
-import { z } from 'zod';
-import { awaitDeep } from './context/await.js';
-import { bindContextEvidence } from './context/evidence.js';
-import { sourceFor } from './context/sources.js';
-export { contextSourceSchema } from './context/sources.js';
-const contextDataSchema = z.record(z.string(), z.unknown());
-/** Assemble selected application values and the Ablo evidence they retain. */
-export async function context(options) {
-    const collectEvidence = bindContextEvidence(options.ablo);
-    const data = await awaitDeep(options.data);
-    const parsed = contextDataSchema.safeParse(data);
-    if (!parsed.success) {
-        throw new TypeError('context() requires `data` to be an object.', { cause: parsed.error });
-    }
-    const evidence = collectEvidence(data);
-    const sources = Object.entries(data).map(([key, value]) => sourceFor(key, evidence.inspect(value)));
-    const cursor = evidence.all.length === 0
-        ? null
-        : Math.max(...evidence.all.map((item) => item.entry.watermark));
-    return {
-        data: data,
-        reads: evidence.all.map((item) => item.row),
-        cursor,
-        sources,
-    };
-}
-//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,SAAS,EAAoB,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAsB,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAE,mBAAmB,EAAsB,MAAM,sBAAsB,CAAC;AAG/E,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;AAkB5D,8EAA8E;AAC9E,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,OAA8B;IAE9B,MAAM,eAAe,GAAG,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACjD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,SAAS,CAAC,4CAA4C,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CACxD,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CACxC,CAAC;IACF,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC;QACtC,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IAElE,OAAO;QACL,IAAI,EAAE,IAA0B;QAChC,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAkB,CAAC;QAC1D,MAAM;QACN,OAAO;KACR,CAAC;AACJ,CAAC"}