@abloatai/ablo 0.34.1 → 0.36.0

package/dist/docs/catalog.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The catalog of documentation this package ships.
+ *
+ * One definition of *which docs exist*, read from the files themselves. Every
+ * reader — `ablo docs`, the public `/api/docs/*` routes, the MCP docs tools —
+ * resolves through here rather than keeping its own list, because a
+ * hand-maintained index of a directory is a copy that drifts the moment a page
+ * is added and nothing fails when it does. Before this module the public web
+ * allowlist had fallen 21 pages behind the corpus, including `coordination`.
+ *
+ * Title and description are DERIVED from each file's own convention: an H1,
+ * then a one-paragraph blockquote stating what the page is for. That blockquote
+ * is the description everywhere it is needed — the site frontmatter lifts the
+ * same line — so a page states its own promise exactly once, in the source that
+ * ships in the npm tarball and still reads correctly as plain markdown.
+ *
+ * The published set mirrors the tarball's `files` globs (`docs/*.md`,
+ * `docs/examples/*.md`, plus the three root files). Anything else under `docs/`
+ * — `docs/internal/**` above all — is neither shipped nor catalogued, and that
+ * exclusion is the only thing keeping internal notes off the public routes now
+ * that they read from here.
+ */
+/** Where a page sits in the corpus, and how a reader should group it. */
+export type DocKind = 'guide' | 'example' | 'package';
+/** One documentation page, as shipped. */
+export interface DocEntry {
+    /** Stable reference: `quickstart`, `examples/nextjs`, `agents`. */
+    readonly slug: string;
+    /** Human-readable title — the file's H1, or curated for the root files. */
+    readonly title: string;
+    /** One line stating what the page is for — the file's promise blockquote. */
+    readonly description: string;
+    readonly kind: DocKind;
+    /** Absolute path on disk. */
+    readonly path: string;
+    readonly mime: string;
+}
+/**
+ * Read the catalog from a package root — the directory holding `docs/` and the
+ * three root files.
+ *
+ * The root is a parameter rather than resolved here because each reader knows
+ * it differently and they are genuinely different facts: the CLI resolves it
+ * against its own bundle inside `node_modules`, while the web app resolves it
+ * against the monorepo checkout. Nothing is cached; callers that serve many
+ * requests should memoize the returned array.
+ */
+export declare function readDocsCatalog(packageRoot: string): Promise<DocEntry[]>;
+/**
+ * Pull a page's title and promise line out of its markdown.
+ *
+ * The convention every page follows: an H1, then a blockquote paragraph saying
+ * what the page is for. A page missing either simply reports what it has — the
+ * catalog never invents prose.
+ */
+export declare function parseDocHeader(body: string): {
+    readonly title: string | null;
+    readonly description: string;
+};
+/**
+ * Resolve a reference to a page. Accepts the slug (`coordination`), a curated
+ * alias (`storage`), or a repo-relative path (`docs/coordination.md`,
+ * `AGENTS.md`) — the three forms readers actually arrive with. Returns null
+ * rather than throwing so a caller can render its own not-found.
+ */
+export declare function findDoc(catalog: readonly DocEntry[], reference: string): DocEntry | null;
+/**
+ * Slugs closest to a miss, for a "did you mean" line. Ranks by shared prefix,
+ * then substring containment — enough to catch a typo or a half-remembered
+ * name without pulling in a distance library.
+ */
+export declare function suggestSlugs(catalog: readonly DocEntry[], reference: string, limit?: number): string[];

package/dist/docs/catalog.js

@@ -0,0 +1,230 @@
+/**
+ * The catalog of documentation this package ships.
+ *
+ * One definition of *which docs exist*, read from the files themselves. Every
+ * reader — `ablo docs`, the public `/api/docs/*` routes, the MCP docs tools —
+ * resolves through here rather than keeping its own list, because a
+ * hand-maintained index of a directory is a copy that drifts the moment a page
+ * is added and nothing fails when it does. Before this module the public web
+ * allowlist had fallen 21 pages behind the corpus, including `coordination`.
+ *
+ * Title and description are DERIVED from each file's own convention: an H1,
+ * then a one-paragraph blockquote stating what the page is for. That blockquote
+ * is the description everywhere it is needed — the site frontmatter lifts the
+ * same line — so a page states its own promise exactly once, in the source that
+ * ships in the npm tarball and still reads correctly as plain markdown.
+ *
+ * The published set mirrors the tarball's `files` globs (`docs/*.md`,
+ * `docs/examples/*.md`, plus the three root files). Anything else under `docs/`
+ * — `docs/internal/**` above all — is neither shipped nor catalogued, and that
+ * exclusion is the only thing keeping internal notes off the public routes now
+ * that they read from here.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+const MARKDOWN_MIME = 'text/markdown; charset=utf-8';
+const TEXT_MIME = 'text/plain; charset=utf-8';
+/**
+ * The three files that document the package itself rather than a topic. They
+ * live at the package root, not under `docs/`, and none follows the H1 +
+ * blockquote convention — `llms.txt` opens with a prose paragraph and
+ * `README.md` with a banner — so their titles and descriptions are curated
+ * here, the one place that knows they are a different kind of artifact.
+ *
+ * Their slug is their filename, because the filename IS how these are referred
+ * to everywhere (`AGENTS.md` is an ecosystem convention, not a topic name) and
+ * because a bare word would collide: `docs/agents.md` is a published guide that
+ * the docs index cross-links as `agents`, and whichever of the two won that
+ * name would silently shadow the other. Friendlier spellings are aliases below.
+ */
+const PACKAGE_FILES = [
+    {
+        filename: 'AGENTS.md',
+        title: 'AGENTS.md',
+        description: 'The playbook a coding agent follows to install and drive Ablo without hanging on a prompt.',
+        mime: MARKDOWN_MIME,
+    },
+    {
+        filename: 'README.md',
+        title: 'README',
+        description: 'Package overview — what Ablo is and the shape of the API.',
+        mime: MARKDOWN_MIME,
+    },
+    {
+        filename: 'llms.txt',
+        title: 'llms.txt',
+        description: 'The curated single-file index of the whole API, for machine readers.',
+        mime: TEXT_MIME,
+    },
+];
+/**
+ * Curated redirects for references that are not a slug: the friendly spellings
+ * of the root files, plus the renames the public URLs carried before this
+ * module existed, kept so old links and any agent working from a cached page
+ * still resolve. Identity mappings are NOT listed — a slug resolves to itself
+ * by derivation, and restating the other 30 here would rebuild the
+ * hand-maintained list this module exists to delete.
+ */
+const SLUG_ALIASES = {
+    readme: 'README.md',
+    overview: 'README.md',
+    llms: 'llms.txt',
+    storage: 'data-sources',
+    'docs/storage.md': 'data-sources',
+};
+/**
+ * Read the catalog from a package root — the directory holding `docs/` and the
+ * three root files.
+ *
+ * The root is a parameter rather than resolved here because each reader knows
+ * it differently and they are genuinely different facts: the CLI resolves it
+ * against its own bundle inside `node_modules`, while the web app resolves it
+ * against the monorepo checkout. Nothing is cached; callers that serve many
+ * requests should memoize the returned array.
+ */
+export async function readDocsCatalog(packageRoot) {
+    const docsDir = join(packageRoot, 'docs');
+    const entries = [];
+    entries.push(...(await readDocsDirectory(docsDir, 'guide')));
+    entries.push(...(await readDocsDirectory(join(docsDir, 'examples'), 'example')));
+    for (const file of PACKAGE_FILES) {
+        const path = join(packageRoot, file.filename);
+        const body = await readFileOrNull(path);
+        if (body === null)
+            continue;
+        entries.push({
+            slug: file.filename,
+            title: file.title,
+            description: file.description,
+            kind: 'package',
+            path,
+            mime: file.mime,
+        });
+    }
+    return entries.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+/**
+ * Read one flat directory of markdown. Deliberately non-recursive: the shipped
+ * set is `docs/*.md` plus `docs/examples/*.md`, so descending would catalogue
+ * `docs/internal/**` — notes that are not in the tarball and must not reach a
+ * public route.
+ */
+async function readDocsDirectory(dir, kind) {
+    let names;
+    try {
+        const found = await readdir(dir, { withFileTypes: true });
+        names = found.filter((e) => e.isFile() && e.name.endsWith('.md')).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const name of names) {
+        const path = join(dir, name);
+        const body = await readFileOrNull(path);
+        if (body === null)
+            continue;
+        const stem = basename(name, '.md');
+        const { title, description } = parseDocHeader(body);
+        entries.push({
+            slug: kind === 'example' ? `examples/${stem}` : stem,
+            title: title ?? stem,
+            description,
+            kind,
+            path,
+            mime: MARKDOWN_MIME,
+        });
+    }
+    return entries;
+}
+/** The H1 a page opens with, and the blockquote paragraph that follows it. */
+const H1_LINE = /^#[ \t]+(.+?)[ \t]*$/m;
+const PROMISE_BLOCKQUOTE = /^\s*\n((?:>.*\n)+)/;
+/**
+ * Pull a page's title and promise line out of its markdown.
+ *
+ * The convention every page follows: an H1, then a blockquote paragraph saying
+ * what the page is for. A page missing either simply reports what it has — the
+ * catalog never invents prose.
+ */
+export function parseDocHeader(body) {
+    const heading = H1_LINE.exec(body);
+    const title = heading?.[1] ?? null;
+    const afterHeading = heading === null ? body : body.slice(heading.index + heading[0].length);
+    const promise = PROMISE_BLOCKQUOTE.exec(afterHeading);
+    const description = promise?.[1]
+        ?.split('\n')
+        .filter(Boolean)
+        .map((line) => line.replace(/^>\s?/, ''))
+        .join(' ')
+        .trim() ?? '';
+    return { title, description };
+}
+/**
+ * Resolve a reference to a page. Accepts the slug (`coordination`), a curated
+ * alias (`storage`), or a repo-relative path (`docs/coordination.md`,
+ * `AGENTS.md`) — the three forms readers actually arrive with. Returns null
+ * rather than throwing so a caller can render its own not-found.
+ */
+export function findDoc(catalog, reference) {
+    const trimmed = reference.trim();
+    if (trimmed === '')
+        return null;
+    const direct = matchSlug(catalog, trimmed);
+    if (direct)
+        return direct;
+    const aliased = SLUG_ALIASES[trimmed.toLowerCase()];
+    if (aliased) {
+        const target = matchSlug(catalog, aliased);
+        if (target)
+            return target;
+    }
+    // Path form: `docs/coordination.md`, `docs/examples/nextjs.md`, `llms.txt`.
+    const asSlug = trimmed
+        .replace(/^\.?\//, '')
+        .replace(/^docs\//, '')
+        .replace(/\.(md|txt)$/i, '');
+    return matchSlug(catalog, asSlug);
+}
+function matchSlug(catalog, slug) {
+    const needle = slug.toLowerCase();
+    return catalog.find((entry) => entry.slug.toLowerCase() === needle) ?? null;
+}
+/**
+ * Slugs closest to a miss, for a "did you mean" line. Ranks by shared prefix,
+ * then substring containment — enough to catch a typo or a half-remembered
+ * name without pulling in a distance library.
+ */
+export function suggestSlugs(catalog, reference, limit = 3) {
+    const needle = reference.trim().toLowerCase();
+    if (needle === '')
+        return [];
+    return catalog
+        .map((entry) => {
+        const slug = entry.slug.toLowerCase();
+        let score = 0;
+        if (slug.includes(needle) || needle.includes(slug))
+            score += 10;
+        score += sharedPrefixLength(slug, needle);
+        return { slug: entry.slug, score };
+    })
+        .filter(({ score }) => score > 2)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map(({ slug }) => slug);
+}
+function sharedPrefixLength(a, b) {
+    const max = Math.min(a.length, b.length);
+    let i = 0;
+    while (i < max && a[i] === b[i])
+        i += 1;
+    return i;
+}
+async function readFileOrNull(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/docs/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Programmatic access to the documentation this package ships.
+ *
+ * The docs travel in the npm tarball beside the code they describe, so a reader
+ * that resolves them through here is reading the pages for the version actually
+ * installed — not whatever the website is serving today. That is the whole
+ * point of the subpath: a published version is frozen, its docs are frozen with
+ * it, and `retrieve` never turns back into `get` behind a pinned dependency.
+ */
+export { readDocsCatalog, findDoc, parseDocHeader, suggestSlugs, type DocEntry, type DocKind, } from './catalog.js';

package/dist/docs/index.js

@@ -0,0 +1,10 @@
+/**
+ * Programmatic access to the documentation this package ships.
+ *
+ * The docs travel in the npm tarball beside the code they describe, so a reader
+ * that resolves them through here is reading the pages for the version actually
+ * installed — not whatever the website is serving today. That is the whole
+ * point of the subpath: a published version is frozen, its docs are frozen with
+ * it, and `retrieve` never turns back into `get` behind a pinned dependency.
+ */
+export { readDocsCatalog, findDoc, parseDocHeader, suggestSlugs, } from './catalog.js';

package/dist/environment.d.ts

@@ -1,40 +1 @@
-import { z } from 'zod';
-/**
- * The two environments an Ablo project runs in: `production` for live data and
- * `sandbox` for isolated test data. Every credential and every stored row
- * belongs to exactly one of them.
- */
-export declare const ENVIRONMENTS: readonly ["production", "sandbox"];
-/**
- * How an environment is spelled inside an API-key prefix: a `live` key acts on
- * the production environment and a `test` key acts on the sandbox. Convert
- * between this spelling and {@link Environment} with
- * {@link environmentFromKeyPrefix} and {@link environmentToKeyPrefix}.
- */
-export type KeyPrefixEnvironment = 'live' | 'test';
-/** A Zod schema that validates a value as one of the {@link ENVIRONMENTS}. */
-export declare const environmentSchema: z.ZodEnum<{
-    production: "production";
-    sandbox: "sandbox";
-}>;
-/** One of the {@link ENVIRONMENTS} — either `'production'` or `'sandbox'`. */
-export type Environment = z.infer<typeof environmentSchema>;
-/**
- * Coerces an untrusted value into a valid {@link Environment}, returning
- * `fallback` (which defaults to `'production'`) when the value is not a
- * recognized environment. Use it when reading an environment from configuration
- * or off the wire.
- */
-export declare function normalizeEnvironment(value: unknown, fallback?: Environment): Environment;
-/**
- * Maps an API-key prefix spelling to its {@link Environment}: a `'test'` key
- * operates on the sandbox, and anything else on production.
- */
-export declare function environmentFromKeyPrefix(value: KeyPrefixEnvironment): Environment;
-/**
- * Maps an {@link Environment} to the spelling used in an API-key prefix: the
- * sandbox is `'test'` and production is `'live'`.
- */
-export declare function environmentToKeyPrefix(value: Environment): KeyPrefixEnvironment;
-/** Returns true when the given environment is the sandbox. */
-export declare function isSandboxEnvironment(value: Environment): boolean;
+export * from './transaction/environment.js';

package/dist/environment.js

@@ -1,37 +1,8 @@
-import { z } from 'zod';
-/**
- * The two environments an Ablo project runs in: `production` for live data and
- * `sandbox` for isolated test data. Every credential and every stored row
- * belongs to exactly one of them.
- */
-export const ENVIRONMENTS = ['production', 'sandbox'];
-/** A Zod schema that validates a value as one of the {@link ENVIRONMENTS}. */
-export const environmentSchema = z.enum(ENVIRONMENTS);
-/**
- * Coerces an untrusted value into a valid {@link Environment}, returning
- * `fallback` (which defaults to `'production'`) when the value is not a
- * recognized environment. Use it when reading an environment from configuration
- * or off the wire.
- */
-export function normalizeEnvironment(value, fallback = 'production') {
-    const parsed = environmentSchema.safeParse(value);
-    return parsed.success ? parsed.data : fallback;
-}
-/**
- * Maps an API-key prefix spelling to its {@link Environment}: a `'test'` key
- * operates on the sandbox, and anything else on production.
- */
-export function environmentFromKeyPrefix(value) {
-    return value === 'test' ? 'sandbox' : 'production';
-}
-/**
- * Maps an {@link Environment} to the spelling used in an API-key prefix: the
- * sandbox is `'test'` and production is `'live'`.
- */
-export function environmentToKeyPrefix(value) {
-    return value === 'sandbox' ? 'test' : 'live';
-}
-/** Returns true when the given environment is the sandbox. */
-export function isSandboxEnvironment(value) {
-    return value === 'sandbox';
-}
+// Moved to @ablo/transaction (ADR 0013 — the settlement core extraction).
+// This shim re-exports it at the original path so in-package importers of
+// `../environment.js` keep working; rewire to `@ablo/transaction/environment`
+// and delete this shim once the core package is fully wired.
+//
+// Line comments on purpose: tsc copies a leading JSDoc block into the
+// published `.d.ts`, and this note names a package npm has never heard of.
+export * from './transaction/environment.js';

package/dist/index.d.ts

@@ -26,14 +26,13 @@
  * Related surfaces live on their own import subpaths:
  *   @abloatai/ablo/schema   — defineSchema, model, z (Zod)
  *   @abloatai/ablo/react    — <AbloProvider>, useQuery, useMutate
- *   @abloatai/ablo/testing  — test harnesses and fixtures
  *
  * Reads come in two flavors, distinguished by where the data is fetched from.
  * `ablo.<model>.retrieve({ id })` and `.list({ where })` are asynchronous reads
  * that consult the local cache first and fall back to the network, de-duplicating
  * concurrent requests for the same row. They are the default, and the right
  * choice for stateless callers whose local graph starts empty.
- * `ablo.<model>.get(id)`, `.getAll(...)`, and `.getCount(...)` are synchronous
+ * `ablo.<model>.local.retrieve(id)`, `.local.list(...)`, and `.local.count(...)` are synchronous
  * snapshots of the already-loaded local graph with no network round-trip — use
  * them in reactive React selectors (`useAblo((ablo) => ablo.<model>.get(id))`)
  * once the graph is warm.
@@ -51,56 +50,65 @@
  * If you don't recognize one of these, you don't need it.
  */
 export { Ablo } from './client/Ablo.js';
+export { humans } from './client/humans.js';
+export type { HumansSurface } from './client/humans.js';
+export type { AbloCoreClient } from './client/coreClient.js';
+export type { AbloPlugin, PipelineStage, TransportCapabilities } from './transaction/plugin.js';
 export type { MutationExecutor } from './interfaces/index.js';
-export type { ModelUpdater, ContentionOptions } from './client/functionalUpdate.js';
-export { DEFAULT_CONTENTION_RETRIES } from './client/functionalUpdate.js';
-export type { AbloReads } from './client/Ablo.js';
-export { type AbloHttpClientOptions, type AbloHttpClient, type HttpModelClient, } from './client/httpClient.js';
-export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_URL, normalizeAbloHostedBaseUrl, } from './client/auth.js';
-export type { AbloOptions, LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, } from './client/Ablo.js';
+export type { ModelUpdater, ContentionOptions } from './transaction/resources/functionalUpdate.js';
+export { DEFAULT_CONTENTION_RETRIES } from './transaction/resources/functionalUpdate.js';
+export type { AbloReads } from './client/abloClient.js';
+export { type AbloHttpClientOptions, type AbloHttpClient, type HttpModelClient, } from './transaction/transport/httpClient.js';
+export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_URL, normalizeAbloHostedBaseUrl, } from './transaction/auth/apiKey.js';
+export type { AbloOptions } from './client/Ablo.js';
+export type { LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, } from './client/resourceTypes.js';
 /**
  * @deprecated Use `Ablo.Claim.Held`. This compatibility export remains until
  * the next major release because it was explicitly documented in 0.20.1.
  */
-export type { HeldClaim } from './client/Ablo.js';
+export type { HeldClaim } from './client/resourceTypes.js';
 /** The resolved value of the row-free `ablo.<model>.claim(id)` overload — a
  *  held lease on a key whose row Ablo does not hold (a {@link HeldClaim} with
  *  no `.data`). */
-export type { HeldLease } from './client/Ablo.js';
-export type { AbloPersistence } from './client/persistence.js';
-export { durableWritesConfigSchema, durableWriteStoreSchema, pendingWriteSchema, } from './transactions/durableWriteStore.js';
-export type { DurableWritesConfig, DurableWriteStore, PendingWrite, } from './transactions/durableWriteStore.js';
-export type { CommitOutboxRecord, CommitOutboxStore, } from './transactions/commitOutboxStore.js';
-export { durableCommitEnvelopeSchema, } from './transactions/commitEnvelope.js';
-export type { CommitOutboxScope, DurableCommitEnvelope, } from './transactions/commitEnvelope.js';
-export { durableHttpCommitEnvelopeSchema, } from './transactions/httpCommitEnvelope.js';
-export type { DurableHttpCommitEnvelope, } from './transactions/httpCommitEnvelope.js';
+export type { HeldLease } from './client/resourceTypes.js';
+export type { AbloPersistence } from './transaction/persistence.js';
+export { durableWritesConfigSchema, durableWriteStoreSchema, pendingWriteSchema, } from './transactions/mutations/durableWriteStore.js';
+export type { DurableWritesConfig, DurableWriteStore, PendingWrite, } from './transactions/mutations/durableWriteStore.js';
+export { durableCommitEnvelopeSchema, } from './transaction/transactions/settlement/commitEnvelope.js';
+export type { CommitOutboxScope, DurableCommitEnvelope, } from './transaction/transactions/settlement/commitEnvelope.js';
+export { durableHttpCommitEnvelopeSchema, } from './transaction/transactions/settlement/httpCommitEnvelope.js';
+export type { DurableHttpCommitEnvelope, } from './transaction/transactions/settlement/httpCommitEnvelope.js';
 import { Ablo } from './client/Ablo.js';
 export default Ablo;
 export { dataSource, sourceEventForOperation, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
 export { createSourceConnector, type SourceConnector, type SourceConnectorOptions, type ConnectorStatus, } from './source/connector.js';
 export { defaultPolicy, capabilityPreemptPolicy, interpretConflictAxis } from './policy/index.js';
-export { SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloClaimedError, AbloContentionError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './errors.js';
-export type { RequiredCapability } from './errors.js';
-export type { ErrorCode, WireErrorCode, ErrorCategory, ErrorCodeSpec, RecoveryClass } from './errors.js';
-export { errorEnvelope, statusForType } from './wire/errorEnvelope.js';
-export type { ErrorEnvelope } from './wire/errorEnvelope.js';
-export { WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL } from './auth/credentialSource.js';
-export { ENVIRONMENTS, environmentSchema, normalizeEnvironment, environmentFromKeyPrefix, environmentToKeyPrefix, isSandboxEnvironment, } from './environment.js';
-export type { Environment, KeyPrefixEnvironment } from './environment.js';
-export { writeOptionsSchema, onStaleModeSchema, assertWriteOptions, } from './client/writeOptionsSchema.js';
-export type { WriteOptionsInput } from './client/writeOptionsSchema.js';
+export { AbloSessionError, SyncSessionError, AbloError, AbloAuthenticationError, AbloPermissionError, AbloRateLimitError, AbloIdempotencyError, AbloConnectionError, AbloValidationError, AbloNotFoundError, AbloServerError, AbloStaleContextError, AbloClaimedError, AbloContentionError, CapabilityError, translateHttpError, hasWireCode, errorFromWire, toAbloError, ERROR_CODES, ERROR_CONTRACT_VERSION, errorCodeSpec, isRetryableCode, classifyRecovery, recoveryClassSchema, RECOVERY_CLASSES, } from './transaction/errors.js';
+export type { RequiredCapability } from './transaction/errors.js';
+export type { ErrorCode, WireErrorCode, ErrorCategory, ErrorCodeSpec, RecoveryClass } from './transaction/errors.js';
+export { errorEnvelope, statusForType } from './transaction/wire/errorEnvelope.js';
+export type { ErrorEnvelope } from './transaction/wire/errorEnvelope.js';
+export { WS_BEARER_SUBPROTOCOL_PREFIX, WS_SYNC_SUBPROTOCOL } from './transaction/auth/credentialSource.js';
+export { ENVIRONMENTS, environmentSchema, normalizeEnvironment, environmentFromKeyPrefix, environmentToKeyPrefix, isSandboxEnvironment, } from './transaction/environment.js';
+export type { Environment, KeyPrefixEnvironment } from './transaction/environment.js';
+export { writeOptionsSchema, onStaleModeSchema, assertWriteOptions, } from './transaction/resources/writeOptionsSchema.js';
+export type { WriteOptionsInput } from './transaction/resources/writeOptionsSchema.js';
+export type { OnStaleMode } from './transaction/coordination/schema.js';
 export type { WriteOptions, MutationOptions } from './interfaces/index.js';
-export { staleNotificationSchema, readDependencySchema } from './coordination/schema.js';
-export type { StaleNotification, ReadDependency } from './coordination/schema.js';
-export { ClaimLog, formatClaim, formatConflict } from './coordination/trace.js';
-export type { ClaimLogEntry } from './coordination/trace.js';
+export { staleNotificationSchema, readDependencySchema } from './transaction/coordination/schema.js';
+export { part } from './transaction/coordination/schema.js';
+export type { ClaimPart } from './transaction/coordination/schema.js';
+export type { ClaimField } from './transaction/resources/modelOperations.js';
+export type { StaleNotification, ReadDependency } from './transaction/coordination/schema.js';
+export { ClaimLog, formatClaim, formatConflict } from './coordination/ClaimLog.js';
+export type { ClaimLogEntry } from './coordination/ClaimLog.js';
 export type { ClaimEvent, ConflictEvent, SyncObservabilityProvider, } from './interfaces/index.js';
-export { noopObservability } from './SyncEngineContext.js';
-export { IDBOpenTimeoutError, isStorageOpenTimeout } from './core/openIDBWithTimeout.js';
+export { noopObservability } from './RuntimeContext.js';
+export { IDBOpenTimeoutError, isStorageOpenTimeout } from './stores/openIDBWithTimeout.js';
+export type { CommitLatencySample } from './transactions/mutations/commitLatency.js';
 export { PUBLIC_MODEL_VERBS, PUBLIC_LIST_OPTION_KEYS, PUBLIC_ABLO_OPTION_KEYS, } from './surface.js';
 export type { ModelVerb, ListOptionKey, AbloOptionKey } from './surface.js';
-export type { Register, DefaultSyncShape } from './types/global.js';
+export type { Register, DefaultSyncShape } from './transaction/types/global.js';
 export { defineMutators } from './mutators/defineMutators.js';
 export { createTransaction, type Transaction } from './mutators/Transaction.js';
-export { deepEqual, stableStringify } from './utils/json.js';
+export { deepEqual, stableStringify } from './transaction/utils/json.js';