@abloatai/ablo 0.34.1 → 0.35.0

package/dist/react/AbloProvider.js

@@ -5,7 +5,7 @@ import { Ablo } from '../client/Ablo.js';
 import { createParticipantClaimId, parseParticipantTtlSeconds, resolveParticipantSyncGroups, } from '../sync/participants.js';
 import { SyncContext } from './context.js';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 import { useSyncStatus } from './useSyncStatus.js';
 import { DefaultFallback } from './DefaultFallback.js';
 // ── Implementation ───────────────────────────────────────────────────
@@ -224,8 +224,8 @@ export function useJoin(opts) {
     const ctx = useContext(AbloInternalContext);
     const engine = ctx?.engine ?? null;
     const { paused = false } = opts;
-    // Resolve the model-form scope ({ decks: id } / refs) THROUGH the schema, so a
-    // model's declared `scope` kind is honored (typename `SlideDeck` → `deck:<id>`,
+    // Resolve the model-form scope ({ reports: id } / refs) THROUGH the schema, so a
+    // model's declared `scope` kind is honored (typename `Report` → `report:<id>`,
     // not the `type:id` string fallback). Schema appears once the engine is ready;
     // until then refs resolve by convention, then re-resolve when it arrives.
     const scopeKey = JSON.stringify(resolveParticipantSyncGroups(opts.scope, engine?.schema).sort());
@@ -298,8 +298,6 @@ export function useJoin(opts) {
         if (syncStatus.name !== 'connected')
             return;
         const ws = engine._ws;
-        if (!ws)
-            return;
         const store = engine._store;
         let cancelled = false;
         const claimId = createParticipantClaimId();
@@ -370,7 +368,7 @@ export function useJoin(opts) {
  * subscription on unmount).
  *
  * ```ts
- * const peers = usePeers({ slideDecks: deckId });
+ * const peers = usePeers({ reports: reportId });
  * const alone = !peers.some((p) => p.participantKind === 'user');
  * ```
  */
@@ -408,7 +406,7 @@ export function usePeers(scope) {
  *
  * The generic parameter narrows the return type to your schema's
  * model record so call sites get typed `sync.tasks.findMany()` /
- * `sync.slides.create(...)` without a cast at the call site:
+ * `sync.sections.create(...)` without a cast at the call site:
  *
  * ```ts
  * const sync = useSync<(typeof schema)['models']>();

package/dist/react/context.d.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from 'react';
-import type { Schema } from '../schema/schema.js';
+import type { Schema } from '../transaction/schema/schema.js';
 import type { SyncStoreContract } from '../core/storeContract.js';
 export type { SyncStoreContract, LocalMutation } from '../core/storeContract.js';
 export interface SyncReactContext {

package/dist/react/context.js

@@ -1,6 +1,6 @@
 'use client';
 import { createContext, createElement, useContext } from 'react';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 export const SyncContext = createContext(null);
 /**
  * Reads the sync store context from inside a provider subtree, throwing a clear

package/dist/react/index.d.ts

@@ -21,9 +21,9 @@
  *
  * # Data hooks
  *
- *   useAblo((ablo) => ablo.tasks.get(id))  — subscribe to a local snapshot (the main read API)
+ *   useAblo((ablo) => ablo.tasks.local.retrieve(id))  — subscribe to a local snapshot (the main read API)
  *   useAblo()                              — the typed client, for callbacks and effects:
- *                                            synchronous local reads (`ablo.<model>.get`/`getAll`),
+ *                                            synchronous local reads (`ablo.<model>.local.retrieve`/`local.list`),
  *                                            async server reads (`retrieve`/`list`),
  *                                            and writes (`create`/`update`/`delete`)
  *   useMutators(defs, opts?)               — define custom mutators
@@ -43,8 +43,8 @@
  *   useAblo((ablo) => ablo.<model>.claim.state(...))  — reactive coordination reads
  *   useJoin({ scope })                                — join a scope to get its peers and claims
  */
-export type { DefaultSyncShape, ResolveSchema, ResolveUserMeta, ResolveModelKey, } from '../types/global.js';
-export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseJoinOptions, type UseJoinReturn, type MeshParticipantStatus, } from './AbloProvider.js';
+export type { DefaultSyncShape, ResolveSchema, ResolveUserMeta, ResolveClaimMeta, ResolveModelKey, } from '../transaction/types/global.js';
+export { AbloProvider, useJoin, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseJoinOptions, type UseJoinReturn, } from './AbloProvider.js';
 export { ClientSideSuspense, type ClientSideSuspenseProps, } from './ClientSideSuspense.js';
 export { DefaultFallback } from './DefaultFallback.js';
 export type { SyncStoreContract } from './context.js';
@@ -58,4 +58,4 @@ export type { ReaderActions, ReaderFindOptions } from '../mutators/readerActions
 export { useMutators, type MutatorInvokers, type InvokerFor, type UseMutatorsOptions, } from './useMutators.js';
 export { useUndoScope, type UseUndoScopeResult } from './useUndoScope.js';
 export { useAblo, type UseAbloHydratedModelResult, type UseAbloModelOptions, type UseAbloModelResult, } from './useAblo.js';
-export { ModelScope } from '../types/index.js';
+export { ModelScope } from '../transaction/types/index.js';

package/dist/react/index.js

@@ -21,9 +21,9 @@
  *
  * # Data hooks
  *
- *   useAblo((ablo) => ablo.tasks.get(id))  — subscribe to a local snapshot (the main read API)
+ *   useAblo((ablo) => ablo.tasks.local.retrieve(id))  — subscribe to a local snapshot (the main read API)
  *   useAblo()                              — the typed client, for callbacks and effects:
- *                                            synchronous local reads (`ablo.<model>.get`/`getAll`),
+ *                                            synchronous local reads (`ablo.<model>.local.retrieve`/`local.list`),
  *                                            async server reads (`retrieve`/`list`),
  *                                            and writes (`create`/`update`/`delete`)
  *   useMutators(defs, opts?)               — define custom mutators
@@ -63,4 +63,4 @@ export { useMutators, } from './useMutators.js';
 export { useUndoScope } from './useUndoScope.js';
 export { useAblo, } from './useAblo.js';
 // ── ModelScope re-export ───────────────────────────────────────────
-export { ModelScope } from '../types/index.js';
+export { ModelScope } from '../transaction/types/index.js';

package/dist/react/internalContext.d.ts

@@ -1,5 +1,5 @@
 import type { Ablo } from '../client/Ablo.js';
-import type { SchemaRecord } from '../schema/schema.js';
+import type { SchemaRecord } from '../transaction/schema/schema.js';
 /**
  * The context that `<AbloProvider>` populates for its own hooks. It is kept
  * separate from the data-hook context, which carries the store and schema,

package/dist/react/useAblo.d.ts

@@ -1,7 +1,7 @@
 import type { Ablo, AbloReads, ModelClaim } from '../client/Ablo.js';
 import type { ModelOperations } from '../client/createModelProxy.js';
-import type { SchemaRecord } from '../schema/schema.js';
-import type { ResolveSchema } from '../types/global.js';
+import type { SchemaRecord } from '../transaction/schema/schema.js';
+import type { ResolveSchema } from '../transaction/types/global.js';
 /**
  * The app's resolved schema-record type. It reads your `Register` module
  * augmentation when you declare one and falls back to the loose
@@ -51,7 +51,7 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * // Reactive selector (a synchronous local snapshot). The selector's reads
  * // are typed as snapshot rows — data fields + computeds, no relation
  * // accessors — matching what the hook actually returns:
- * const doc = useAblo((ablo) => ablo.documents.get(id)) ?? serverDoc;
+ * const doc = useAblo((ablo) => ablo.documents.local.retrieve(id)) ?? serverDoc;
  * const active = useAblo((ablo) => ablo.documents.claim.state({ id }));
  *
  * // Without the augmentation, pass the schema as a type argument:

package/dist/react/useAblo.js

@@ -27,7 +27,7 @@ function readModelResult(engine, modelClient, id, initial) {
     if (!modelClient || id === undefined) {
         return { data: initial, claims: EMPTY_CLAIMS, claimed: false };
     }
-    const data = snapshotValue(modelClient.get(id) ?? initial);
+    const data = snapshotValue(modelClient.local.retrieve(id) ?? initial);
     const meta = getModelClientMeta(modelClient);
     const claims = meta && engine
         ? engine.claims.list({ model: meta.key, id })

package/dist/react/useCurrentUserId.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * Returns the application user id passed to the nearest `<AbloProvider>`, or
  * `null` when your app did not provide one.

package/dist/react/useErrorListener.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * Registers a callback that runs whenever the provider surfaces an error. This
  * covers engine errors such as bootstrap failures and mutation rejections,

package/dist/react/useMutationFailureListener.d.ts

@@ -1,6 +1,6 @@
-import type { Transaction } from '../transactions/TransactionQueue.js';
+import type { QueuedMutation } from '../transactions/mutations/MutationQueue.js';
 export interface MutationFailurePayload {
-    transaction: Transaction;
+    transaction: QueuedMutation;
     error: Error;
     permanent?: boolean;
 }

package/dist/react/useMutationFailureListener.js

@@ -1,7 +1,7 @@
 'use client';
 import { useContext, useEffect, useRef } from 'react';
 import { AbloInternalContext } from './internalContext.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 /**
  * Subscribes a listener to mutation failures. The callback fires whenever the
  * transaction queue rolls back an optimistic write — both permanent rejections

package/dist/react/useMutators.d.ts

@@ -1,7 +1,7 @@
-import type { Schema } from '../schema/schema.js';
+import type { Schema } from '../transaction/schema/schema.js';
 import type { MutatorDefs } from '../mutators/defineMutators.js';
 import type { UndoScope } from '../mutators/UndoManager.js';
-import type { ResolveSchema } from '../types/global.js';
+import type { ResolveSchema } from '../transaction/types/global.js';
 /**
  * Turns a mutator tree built with `defineMutators` into callable invokers. The
  * returned object mirrors that tree one-to-one, but each leaf becomes an
@@ -41,7 +41,7 @@ export type MutatorInvokers<M> = {
 };
 /**
  * Options passed to `useMutators`. When `undoScope` is set, every mutator
- * invocation is wrapped in a `RecordingTransaction` and its inverses are
+ * invocation is wrapped in a `RecordingMutation` and its inverses are
  * pushed to the scope as one undo entry.
  */
 export interface UseMutatorsOptions<S extends Schema> {

package/dist/react/useMutators.js

@@ -1,9 +1,9 @@
 'use client';
 import { useMemo } from 'react';
 import { createTransaction } from '../mutators/Transaction.js';
-import { createRecordingTransaction } from '../mutators/RecordingTransaction.js';
+import { createRecordingMutation } from '../mutators/RecordingMutation.js';
 import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 import { getContext } from '../context.js';
 export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
     const { store, organizationId, schema: ctxSchema } = useSyncContext();
@@ -48,7 +48,7 @@ export function useMutators(schemaOrMutators, mutatorsOrOptions, maybeOptions) {
                     // interleave their shared-model snapshots. See UndoScope.runRecorded.
                     if (undoScope) {
                         return undoScope.runRecorded(async () => {
-                            const recording = createRecordingTransaction(schema, store, organizationId);
+                            const recording = createRecordingMutation(schema, store, organizationId);
                             try {
                                 const result = await fn({ tx: recording.tx, args });
                                 const entry = recording.getEntry(label);

package/dist/react/useUndoScope.d.ts

@@ -1,9 +1,9 @@
-import type { Schema } from '../schema/schema.js';
+import type { Schema } from '../transaction/schema/schema.js';
 import type { UndoScope, UndoScopeOptions } from '../mutators/UndoManager.js';
-import type { ResolveSchema } from '../types/global.js';
+import type { ResolveSchema } from '../transaction/types/global.js';
 /**
  * Provides per-surface undo and redo for mutator invocations. Each named scope
- * owns an independent undo/redo stack, so different parts of your app — a deck
+ * owns an independent undo/redo stack, so different parts of your app — a main
  * editor, a sidebar form — can undo separately without stepping on each other.
  *
  * Wire the returned `scope` into `useMutators(schema, mutators, { undoScope:
@@ -12,8 +12,8 @@ import type { ResolveSchema } from '../types/global.js';
  * themselves; the manager moves the entry between the two stacks explicitly.
  *
  * @example
- * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('deck-editor');
- * const mutate = useMutators(schema, deckMutators, { undoScope: scope });
+ * const { undo, redo, canUndo, canRedo, scope } = useUndoScope('report-editor');
+ * const mutate = useMutators(schema, reportMutators, { undoScope: scope });
  *
  * // Cmd+Z handler
  * useHotkey('mod+z', () => { if (canUndo) void undo(); });

package/dist/react/useUndoScope.js

@@ -2,7 +2,7 @@
 import { useEffect, useMemo, useState } from 'react';
 import { UndoManager } from '../mutators/UndoManager.js';
 import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 // Module-level weak registry: `SyncStoreContract` → `UndoManager`.
 // A single app wiring through one SyncProvider shares one manager across
 // every useUndoScope call, so scopes with the same name are identity-equal.

package/dist/schema/coordination.d.ts

@@ -1,23 +1,33 @@
 /**
  * Authoring helpers for a model's `conflict` axis — the setting that decides
  * what happens when two writers touch the same row. Instead of writing a raw
- * disposition map, you compose small, named functions the way the rest of the
- * schema DSL reads (`relation.belongsTo()`, `field.string()`):
+ * disposition map, you name the rules the way the rest of the schema DSL reads
+ * (`relation.belongsTo()`, `field.string()`), and chain them the way a field
+ * chains its own modifiers:
  *
  * ```ts
- * import { coordination, humansOverwrite, agentsReject } from '@abloatai/ablo/schema';
+ * import { coordination } from '@abloatai/ablo/schema';
  *
- * conflict: coordination(humansOverwrite(), agentsReject())
+ * conflict: coordination.humansOverwrite().agentsReject()
  * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
  * ```
  *
- * Each helper is named for the disposition it applies — drawn from the same
+ * Each rule is named for the disposition it applies — drawn from the same
  * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
- * and returns a partial {@link ConflictAxis}. {@link coordination} merges the
- * pieces, with later rules winning on key collisions. The result is plain,
- * serializable data that the engine reads at commit time.
+ * and every one of them is also available as a standalone function, which
+ * {@link coordination} merges when the rules are assembled dynamically rather
+ * than written out:
+ *
+ * ```ts
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ *
+ * Either way the result is plain, serializable data that the engine reads at
+ * commit time. The `humans`/`agents` wording belongs to the author; the `user`/
+ * `agent`/`system` keys belong to the wire, and this module is the one place
+ * the two are mapped to each other.
  */
-import type { ConflictAxis } from '../policy/types.js';
+import type { ConflictAxis } from '../transaction/policy/types.js';
 /**
  * One coordination rule: a partial {@link ConflictAxis} produced by a
  * disposition helper below. Compose with {@link coordination}.
@@ -41,6 +51,34 @@ export declare const systemOverwrite: () => ConflictRule;
 export declare const systemReject: () => ConflictRule;
 /** A system or automation stale write triggers a notification: it re-reads and re-applies. */
 export declare const systemNotify: () => ConflictRule;
+/**
+ * A conflict axis that is still open to more rules. Every method applies one
+ * disposition and hands back a new axis, so a model's whole stance reads as a
+ * single sentence and the reader never has to hold a merge in their head.
+ *
+ * Each method delegates to the standalone rule of the same name, so a
+ * disposition map like `{ user: 'overwrite' }` is written in exactly one place
+ * no matter which authoring style a schema uses. Dispositions are own
+ * enumerable properties and the methods live on the prototype, so an axis
+ * serializes to the same plain object the server has always received.
+ */
+declare class CoordinationAxis implements ConflictAxis {
+    readonly user?: ConflictAxis['user'];
+    readonly agent?: ConflictAxis['agent'];
+    readonly system?: ConflictAxis['system'];
+    constructor(axis: ConflictAxis);
+    /** Apply one more rule, later winning on a repeated kind. */
+    private and;
+    humansOverwrite(): CoordinationAxis;
+    humansReject(): CoordinationAxis;
+    humansNotify(): CoordinationAxis;
+    agentsOverwrite(): CoordinationAxis;
+    agentsReject(): CoordinationAxis;
+    agentsNotify(): CoordinationAxis;
+    systemOverwrite(): CoordinationAxis;
+    systemReject(): CoordinationAxis;
+    systemNotify(): CoordinationAxis;
+}
 /**
  * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
  * on key collisions, and a committer kind you leave out falls through to the
@@ -50,4 +88,25 @@ export declare const systemNotify: () => ConflictRule;
  * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }
  * ```
  */
-export declare function coordination(...rules: readonly ConflictRule[]): ConflictAxis;
+declare function mergeRules(...rules: readonly ConflictRule[]): ConflictAxis;
+/**
+ * The coordination vocabulary, reachable through one name. Call it to merge
+ * rules you have assembled; reach through it to start a chain.
+ *
+ * ```ts
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ */
+export declare const coordination: typeof mergeRules & {
+    humansOverwrite: () => CoordinationAxis;
+    humansReject: () => CoordinationAxis;
+    humansNotify: () => CoordinationAxis;
+    agentsOverwrite: () => CoordinationAxis;
+    agentsReject: () => CoordinationAxis;
+    agentsNotify: () => CoordinationAxis;
+    systemOverwrite: () => CoordinationAxis;
+    systemReject: () => CoordinationAxis;
+    systemNotify: () => CoordinationAxis;
+};
+export {};

package/dist/schema/coordination.js

@@ -1,21 +1,31 @@
 /**
  * Authoring helpers for a model's `conflict` axis — the setting that decides
  * what happens when two writers touch the same row. Instead of writing a raw
- * disposition map, you compose small, named functions the way the rest of the
- * schema DSL reads (`relation.belongsTo()`, `field.string()`):
+ * disposition map, you name the rules the way the rest of the schema DSL reads
+ * (`relation.belongsTo()`, `field.string()`), and chain them the way a field
+ * chains its own modifiers:
  *
  * ```ts
- * import { coordination, humansOverwrite, agentsReject } from '@abloatai/ablo/schema';
+ * import { coordination } from '@abloatai/ablo/schema';
  *
- * conflict: coordination(humansOverwrite(), agentsReject())
+ * conflict: coordination.humansOverwrite().agentsReject()
  * // → { user: 'overwrite', agent: 'reject' }  (a human's write wins, an agent's yields)
  * ```
  *
- * Each helper is named for the disposition it applies — drawn from the same
+ * Each rule is named for the disposition it applies — drawn from the same
  * `overwrite | reject | notify` vocabulary the write guards use (`onStale`) —
- * and returns a partial {@link ConflictAxis}. {@link coordination} merges the
- * pieces, with later rules winning on key collisions. The result is plain,
- * serializable data that the engine reads at commit time.
+ * and every one of them is also available as a standalone function, which
+ * {@link coordination} merges when the rules are assembled dynamically rather
+ * than written out:
+ *
+ * ```ts
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ *
+ * Either way the result is plain, serializable data that the engine reads at
+ * commit time. The `humans`/`agents` wording belongs to the author; the `user`/
+ * `agent`/`system` keys belong to the wire, and this module is the one place
+ * the two are mapped to each other.
  */
 // ── Humans (user sessions) ──────────────────────────────────────────────
 /** A human's conflicting write wins and overwrites the other; it is never blocked. Among humans this gives last-write-wins. */
@@ -38,6 +48,53 @@ export const systemOverwrite = () => ({ system: 'overwrite' });
 export const systemReject = () => ({ system: 'reject' });
 /** A system or automation stale write triggers a notification: it re-reads and re-applies. */
 export const systemNotify = () => ({ system: 'notify' });
+/**
+ * A conflict axis that is still open to more rules. Every method applies one
+ * disposition and hands back a new axis, so a model's whole stance reads as a
+ * single sentence and the reader never has to hold a merge in their head.
+ *
+ * Each method delegates to the standalone rule of the same name, so a
+ * disposition map like `{ user: 'overwrite' }` is written in exactly one place
+ * no matter which authoring style a schema uses. Dispositions are own
+ * enumerable properties and the methods live on the prototype, so an axis
+ * serializes to the same plain object the server has always received.
+ */
+class CoordinationAxis {
+    constructor(axis) {
+        Object.assign(this, Object.fromEntries(Object.entries(axis).filter(([, mode]) => mode !== undefined)));
+    }
+    /** Apply one more rule, later winning on a repeated kind. */
+    and(rule) {
+        return new CoordinationAxis({ ...this, ...rule });
+    }
+    humansOverwrite() {
+        return this.and(humansOverwrite());
+    }
+    humansReject() {
+        return this.and(humansReject());
+    }
+    humansNotify() {
+        return this.and(humansNotify());
+    }
+    agentsOverwrite() {
+        return this.and(agentsOverwrite());
+    }
+    agentsReject() {
+        return this.and(agentsReject());
+    }
+    agentsNotify() {
+        return this.and(agentsNotify());
+    }
+    systemOverwrite() {
+        return this.and(systemOverwrite());
+    }
+    systemReject() {
+        return this.and(systemReject());
+    }
+    systemNotify() {
+        return this.and(systemNotify());
+    }
+}
 /**
  * Merges coordination rules into a single {@link ConflictAxis}. Later rules win
  * on key collisions, and a committer kind you leave out falls through to the
@@ -47,6 +104,26 @@ export const systemNotify = () => ({ system: 'notify' });
  * coordination(humansOverwrite(), agentsReject())  // → { user: 'overwrite', agent: 'reject' }
  * ```
  */
-export function coordination(...rules) {
+function mergeRules(...rules) {
     return Object.assign({}, ...rules);
 }
+/**
+ * The coordination vocabulary, reachable through one name. Call it to merge
+ * rules you have assembled; reach through it to start a chain.
+ *
+ * ```ts
+ * conflict: coordination.humansOverwrite().agentsReject()
+ * conflict: coordination(humansOverwrite(), agentsReject())
+ * ```
+ */
+export const coordination = Object.assign(mergeRules, {
+    humansOverwrite: () => new CoordinationAxis(humansOverwrite()),
+    humansReject: () => new CoordinationAxis(humansReject()),
+    humansNotify: () => new CoordinationAxis(humansNotify()),
+    agentsOverwrite: () => new CoordinationAxis(agentsOverwrite()),
+    agentsReject: () => new CoordinationAxis(agentsReject()),
+    agentsNotify: () => new CoordinationAxis(agentsNotify()),
+    systemOverwrite: () => new CoordinationAxis(systemOverwrite()),
+    systemReject: () => new CoordinationAxis(systemReject()),
+    systemNotify: () => new CoordinationAxis(systemNotify()),
+});

package/dist/schema/ddl.js

@@ -21,8 +21,8 @@
  *    by a {@link diffSchema} step list: drops, renames, type casts, and
  *    backfills.
  */
-import { AbloValidationError } from '../errors.js';
-import { resolveTenancy, tenancyColumn } from './tenancy.js';
+import { AbloValidationError } from '../transaction/errors.js';
+import { resolveTenancy, tenancyColumn } from '../transaction/schema/tenancy.js';
 // ── Identifier safety ────────────────────────────────────────────────────────
 /** Postgres unquoted-identifier-safe slug: lowercase `[a-z0-9_]`, ≤50 chars. */
 function slug(raw) {

package/dist/schema/diff.d.ts

@@ -28,7 +28,7 @@
  * drop models. A newly added column is never created `NOT NULL`; making a column
  * required is a separate nullability change that a backfill must run before.
  */
-import type { FieldMeta } from './field.js';
+import type { FieldMeta } from '../transaction/schema/field.js';
 import type { SchemaJSON } from './serialize.js';
 export type FieldType = FieldMeta['type'];
 /** Whether a Postgres `ALTER COLUMN … TYPE` can preserve the existing data. */

package/dist/schema/generate.js

@@ -14,7 +14,7 @@
  * enums emitted as string-literal unions. Relations are not expanded here — the
  * runtime SDK resolves those through its typed accessors.
  */
-import { BASE_FIELDS } from './schema.js';
+import { BASE_FIELDS } from '../transaction/schema/schema.js';
 function tsType(meta) {
     switch (meta.type) {
         case 'string':

package/dist/schema/index.d.ts

@@ -21,21 +21,21 @@
  * ```
  */
 export { z } from 'zod';
-export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from './field.js';
-export { relation, type RelationDef, type RelationType } from './relation.js';
-export { tenancySchema, scopedViaRefSchema, policyInputSchema, resolvePolicy, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, type Tenancy, type ScopedViaRef, type PolicyInput, } from './tenancy.js';
-export { residencySchema, DEFAULT_RESIDENCY, type ModelResidency, planeSchema, DEFAULT_PLANE, type SchemaPlane, } from './residency.js';
-export { syncDeltaCoreSchema, deltaAttributionSchema, deltaProvenanceSchema, syncDeltaRowSchema, participantKindSchema, confirmationStateSchema, backfillProvenanceSchema, DELTA_DATA_CLASSIFICATION, DELTA_PHYSICAL_STORAGE, DELTA_RESIDENCY, type SyncDeltaCore, type DeltaAttribution, type DeltaProvenance, type SyncDeltaRow, type ParticipantKind, type ConfirmationState, type BackfillProvenance, } from './syncDeltaRow.js';
-export { syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, type SyncDeltaAction, type WireDeltaData, type ParticipantRef, type SyncDeltaWireCore, type ClientSyncDelta, type ServerSyncDelta, } from '../wire/delta.js';
-export { model, scopeKindOf, type ModelDef, type ModelOptions, type LoadStrategy, type PersistOptions, type RelationRecord, type GrantsRef, type ConflictAxis, } from './model.js';
+export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from '../transaction/schema/field.js';
+export { relation, type RelationDef, type RelationType } from '../transaction/schema/relation.js';
+export { tenancySchema, scopedViaRefSchema, policyInputSchema, resolvePolicy, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, type Tenancy, type ScopedViaRef, type PolicyInput, } from '../transaction/schema/tenancy.js';
+export { residencySchema, DEFAULT_RESIDENCY, type ModelResidency, } from '../transaction/schema/residency.js';
+export { syncDeltaCoreSchema, deltaAttributionSchema, syncDeltaRowSchema, participantKindSchema, confirmationStateSchema, backfillProvenanceSchema, DELTA_DATA_CLASSIFICATION, DELTA_PHYSICAL_STORAGE, type SyncDeltaCore, type DeltaAttribution, type SyncDeltaRow, type ParticipantKind, type ConfirmationState, type BackfillProvenance, } from './syncDeltaRow.js';
+export { syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, type SyncDeltaAction, type WireDeltaData, type ParticipantRef, type SyncDeltaWireCore, type ClientSyncDelta, type ServerSyncDelta, } from '../transaction/wire/delta.js';
+export { model, scopeKindOf, LoadStrategy, DEFAULT_LOAD_STRATEGY, loadsAtBootstrap, type ModelDef, type ModelOptions, type PersistOptions, type RelationRecord, type GrantsRef, type ConflictAxis, } from '../transaction/schema/model.js';
 export { coordination, humansOverwrite, humansReject, humansNotify, agentsOverwrite, agentsReject, agentsNotify, systemOverwrite, systemReject, systemNotify, type ConflictRule, } from './coordination.js';
 export { mutable, readOnly, type SugarOptions } from './sugar.js';
-export { defineSchema, composeIdentitySyncGroups, type Schema, type SchemaRecord, type Model, type Row, type InferModel, type InferCreate, type InferRow, type InferModelNames, type BaseModelFields, type InsertValue, type UpsertValue, type UpdateValue, type DeleteId, type DefineSchemaOptions, type Casing, type CasingConvention, type CasingFn, composeEntitySyncGroups, intersectRequestedWithAllowed, type IdentityRole, type IdentityContext, type IdentityRoleSource, type EntityRole, type EntityContext, type EntityRoleSource, type RoleSource, type RoleContext, type SyncGroup, type SyncGroupInput, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, type GroupsInput, type SessionSettings, type SessionSettingSource, RESERVED_SESSION_SETTINGS, } from './schema.js';
-export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, type SchemaJSON, type ModelJSON, type RelationJSON, } from './serialize.js';
+export { defineSchema, composeIdentitySyncGroups, type Schema, type SchemaRecord, type Model, type Row, type InferCreate, type InferRow, type InferModelNames, type BaseModelFields, type InsertValue, type UpsertValue, type UpdateValue, type DeleteId, type DefineSchemaOptions, type Casing, type CasingConvention, type CasingFn, composeEntitySyncGroups, intersectRequestedWithAllowed, type IdentityRole, type IdentityContext, type IdentityRoleSource, type EntityRole, type EntityContext, type EntityRoleSource, type RoleSource, type RoleContext, type SyncGroup, type SyncGroupInput, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, type GroupsInput, type SessionSettings, type SessionSettingSource, RESERVED_SESSION_SETTINGS, } from '../transaction/schema/schema.js';
+export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, modelHash, type SchemaJSON, type ModelJSON, type RelationJSON, } from './serialize.js';
 export { selectModels, omitModels } from './select.js';
 export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSnake, snakeToCamel, q, sqlType, type ProvisionPlan, type MigrationPlan, } from './ddl.js';
 export { PG_LOCK_NOT_AVAILABLE, resolveDdlLockTimeout, resolveDdlMaxLockAttempts, ddlLockRetryBackoffMs, type DdlLockEnv, } from './ddlLock.js';
 export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlockerResolved, unresolvedBlockers, type BackfillValue, type MigrationStep, type FieldChanges, type FieldColumnChange, type FieldTypeChange, type NullabilityChange, type EnumValuesChange, type IndexChange, type CastSafety, type FieldType, type RenameHints, type MigrationSignal, type MigrationClassification, type WarningCode, type BlockerCode, } from './diff.js';
 export { generateTypes } from './generate.js';
 export { query, defineQueries, type QueryDef, type QueryRecord, type Queries, type InferQueryInput, type InferQueryResult, } from './queries.js';
-export { schemaToOpenApi, type SchemaToOpenApiOptions } from './openapi.js';
+export { abloOpenApi, schemaToOpenApi, type SchemaToOpenApiOptions } from '../transaction/schema/openapi.js';