@abloatai/ablo 0.27.0 → 0.29.0

package/dist/index.d.ts

@@ -14,9 +14,9 @@
  * type Entry = Ablo.Peer;
  * ```
  *
- * `Ablo({ schema, apiKey })` returns typed model clients. `Ablo({ apiKey })`
- * returns the stateless HTTP model and commit client, which suits agents, MCP
- * route handlers, and custom runtimes.
+ * `Ablo({ schema, apiKey })` returns typed model clients. Server-side agents,
+ * MCP route handlers, and workers select `transport: 'http'`; both transports
+ * keep the same `ablo.<model>` application surface.
  *
  * The whole package reaches you through one name: `Ablo` is at once a factory
  * function, a type, and a namespace. You call model clients with dot access on
@@ -45,7 +45,7 @@
  *
  * A handful of exports are for advanced use and are marked "Advanced" at their
  * declaration below, each with the one situation it is for:
- *   • `dataSource` / `abloSource`  — when your own database stays canonical.
+ *   • `dataSource`                 — when your own database stays canonical.
  *   • `defaultPolicy`              — when you customize conflict resolution.
  *   • `defineMutators` / `createTransaction` — when you write custom mutators.
  * If you don't recognize one of these, you don't need it.
@@ -54,18 +54,30 @@ export { Ablo } from './client/Ablo.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 { HttpClaimApi, InternalAbloOptions } from './client/Ablo.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, ClaimOptions, ClaimParams, ClaimLookupParams, ClaimReorderParams, Claim, ClaimHeartbeat, ClaimHeartbeatOptions, HeldClaim, ModelOperations, } from './client/Ablo.js';
+export type { AbloOptions, LocalCountOptions, LocalReadOptions, ModelListScope, ServerReadOptions, ModelRetrieveParams, ModelCreateParams, ModelUpdateParams, ModelDeleteParams, } from './client/Ablo.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 { 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';
 import { Ablo } from './client/Ablo.js';
 export default Ablo;
-export { dataSource, abloSource, sourceEventForOperation, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
+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 { CommitReceipt, RequiredCapability } 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';

package/dist/index.js

@@ -14,9 +14,9 @@
  * type Entry = Ablo.Peer;
  * ```
  *
- * `Ablo({ schema, apiKey })` returns typed model clients. `Ablo({ apiKey })`
- * returns the stateless HTTP model and commit client, which suits agents, MCP
- * route handlers, and custom runtimes.
+ * `Ablo({ schema, apiKey })` returns typed model clients. Server-side agents,
+ * MCP route handlers, and workers select `transport: 'http'`; both transports
+ * keep the same `ablo.<model>` application surface.
  *
  * The whole package reaches you through one name: `Ablo` is at once a factory
  * function, a type, and a namespace. You call model clients with dot access on
@@ -45,7 +45,7 @@
  *
  * A handful of exports are for advanced use and are marked "Advanced" at their
  * declaration below, each with the one situation it is for:
- *   • `dataSource` / `abloSource`  — when your own database stays canonical.
+ *   • `dataSource`                 — when your own database stays canonical.
  *   • `defaultPolicy`              — when you customize conflict resolution.
  *   • `defineMutators` / `createTransaction` — when you write custom mutators.
  * If you don't recognize one of these, you don't need it.
@@ -63,6 +63,10 @@ export { DEFAULT_CONTENTION_RETRIES } from './client/functionalUpdate.js';
 // `AbloHttpClient` type, which is the return type of that call.
 export {} from './client/httpClient.js';
 export { ABLO_DEFAULT_BASE_URL, ABLO_HOSTED_API_DOMAIN, ABLO_HOSTED_HTTP_BASE_URL, normalizeAbloHostedBaseUrl, } from './client/auth.js';
+export { durableWritesConfigSchema, durableWriteStoreSchema, pendingWriteSchema, } from './transactions/durableWriteStore.js';
+/* eslint-enable @typescript-eslint/no-deprecated */
+export { durableCommitEnvelopeSchema, } from './transactions/commitEnvelope.js';
+export { durableHttpCommitEnvelopeSchema, } from './transactions/httpCommitEnvelope.js';
 // Participant types live under `Ablo.Participant.*` —
 // `Ablo.Participant.Joined`, `Ablo.Participant.Manager`,
 // `Ablo.Participant.JoinOptions`, etc. Same dot-access shape as
@@ -74,7 +78,7 @@ export default Ablo;
 // database. The default is Ablo-managed storage; reach for this only when you
 // have deliberately chosen to keep your database canonical. The matching types
 // live under `Ablo.Source.*` (`Ablo.Source.Operation`, `Ablo.Source.Commit.Params`).
-export { dataSource, abloSource, sourceEventForOperation, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
+export { dataSource, sourceEventForOperation, signAbloSourceRequest, verifyAbloSourceRequest, } from './source/index.js';
 // Serves the Data Source `commit`, `load`, and `list` operations over an
 // outbound WebSocket, so a database with no public inbound URL (running on a
 // developer's machine or inside a locked-down network) can still be reached by

package/dist/interfaces/index.d.ts

@@ -200,8 +200,8 @@ export interface CommitResult {
  * - `idempotencyKey` — when set, the server caches the response for 24 hours and
  *   returns the cached result on any retry using the same key. When omitted, the
  *   SDK generates a fresh UUID per mutation, so every call is retry-safe by
- *   default. Pass `{ idempotencyKey: null }` for the rare case where you want a
- *   write that is not retry-safe.
+ *   default. `null` is retained for source compatibility and is treated like
+ *   omission; write retries never opt out of request identity.
  * - `label` — a human-readable tag recorded with the mutation for debugging, such
  *   as "nightly cleanup" or "user click".
  */
@@ -230,6 +230,9 @@ export interface MutationOptions {
      * checks that none of them moved since their `readAt` and applies the entry's
      * `onStale` behavior to the whole batch. This is distinct from the per-operation
      * `readAt`, which guards only the row being written.
+     *
+     * See `packages/sync-engine/docs/concurrency-convention.md` (§3 the two
+     * footprints, §4 the read-set) for the governing convention.
      */
     reads?: ReadDependency[] | null;
 }

package/dist/mutators/UndoManager.d.ts

@@ -250,6 +250,8 @@ export declare class UndoManager<S extends Schema> {
     private readonly store;
     private readonly organizationId;
     private readonly scopes;
+    /** The options each scope was constructed with, for the mismatch warning below. */
+    private readonly creationOptions;
     constructor(schema: S, store: SyncStoreContract, organizationId: string);
     getScope(name: string, options?: UndoScopeOptions): UndoScope<S>;
     clearAll(): void;

package/dist/mutators/UndoManager.js

@@ -569,6 +569,8 @@ export class UndoManager {
     store;
     organizationId;
     scopes = new Map();
+    /** The options each scope was constructed with, for the mismatch warning below. */
+    creationOptions = new Map();
     constructor(schema, store, organizationId) {
         this.schema = schema;
         this.store = store;
@@ -579,6 +581,36 @@ export class UndoManager {
         if (!scope) {
             scope = new UndoScope(this.schema, this.store, this.organizationId, options);
             this.scopes.set(name, scope);
+            this.creationOptions.set(name, options);
+            return scope;
+        }
+        // A scope keeps the options it was created with; later calls cannot change
+        // them. Requesting the shared scope with no options is the normal pattern
+        // and stays silent — but passing options that conflict with the creation
+        // values means one caller believes it configured a scope that another
+        // caller already configured differently, which is how a surface silently
+        // ends up with, say, no stream recording. Surface that instead of letting
+        // it pass.
+        if (options) {
+            const created = this.creationOptions.get(name);
+            const conflicts = [];
+            if (options.recordFromStream !== undefined &&
+                options.recordFromStream !== (created?.recordFromStream ?? false)) {
+                conflicts.push('recordFromStream');
+            }
+            if (options.maxHistory !== undefined && options.maxHistory !== (created?.maxHistory ?? 100)) {
+                conflicts.push('maxHistory');
+            }
+            if (options.conflictPolicy !== undefined &&
+                options.conflictPolicy !== (created?.conflictPolicy ?? DEFAULT_UNDO_CONFLICT_POLICY)) {
+                conflicts.push('conflictPolicy');
+            }
+            if (conflicts.length > 0) {
+                getContext().logger.warn(`The undo scope "${name}" already exists with different options — ` +
+                    `${conflicts.join(', ')} cannot be changed after creation and the requested ` +
+                    `values are ignored. Create the scope with its full options before any ` +
+                    `caller requests it without them, or use a differently named scope.`);
+            }
         }
         return scope;
     }

package/dist/mutators/defineMutators.d.ts

@@ -13,6 +13,14 @@
  */
 import type { Schema } from '../schema/schema.js';
 import type { Transaction } from './Transaction.js';
+import type { ResolveSchema } from '../types/global.js';
+/**
+ * `ResolveSchema` narrowed to satisfy the `Schema` bound — mirrors
+ * {@link Ablo.RegisteredSchema}. When nothing is registered, `ResolveSchema`
+ * is a loose `{ models }` shape that doesn't extend `Schema`, so we fall back
+ * to `Schema` to keep the mutator tree typed rather than collapsing.
+ */
+type RegisteredSchema = ResolveSchema extends Schema ? ResolveSchema : Schema;
 /**
  * The signature of a single custom mutator. The engine supplies `tx`; you control
  * `args`, in whatever shape you like, and the resolved return value. `TArgs` and
@@ -40,3 +48,13 @@ export type MutatorDefs<S extends Schema> = {
  * work here; the function exists purely as a place for type inference to anchor.
  */
 export declare function defineMutators<S extends Schema, const M extends MutatorDefs<S>>(_schema: S, mutators: M): M;
+/**
+ * Register-anchored overload: omit the schema value and the tree is typed
+ * against `ResolveSchema` (this app's registered schema). Shared product code
+ * used across apps that bind different schemas should use this form — it moves
+ * with each app's `Register` instead of pinning one concrete schema, so the
+ * mutator tree stays assignable at every consumer (which reads the same
+ * `Register`). See docs/plans/per-product-schema-projections.md.
+ */
+export declare function defineMutators<const M extends MutatorDefs<RegisteredSchema>>(mutators: M): M;
+export {};

package/dist/mutators/defineMutators.js

@@ -11,12 +11,8 @@
  * `typeof mutators` carries every mutator's precise `args` and result types
  * through to wherever they are invoked.
  */
-/**
- * Returns the mutators object unchanged while constraining its shape against the
- * schema. The `S` generic pins the model keys, and the `M` generic is inferred as
- * a `const`, so each mutator's literal signature survives. There is no runtime
- * work here; the function exists purely as a place for type inference to anchor.
- */
-export function defineMutators(_schema, mutators) {
-    return mutators;
+export function defineMutators(schemaOrMutators, maybeMutators) {
+    // The schema argument is a type anchor only — never read at runtime. With one
+    // argument the mutator tree is in the first slot; with two it's in the second.
+    return (maybeMutators ?? schemaOrMutators);
 }

package/dist/react/index.d.ts

@@ -43,7 +43,7 @@
  *   useAblo((ablo) => ablo.<model>.claim.state(...))  — reactive coordination reads
  *   useWatch({ scope })                               — join a scope to get its peers and claims
  */
-export type { DefaultSyncShape, ResolveSchema, ResolvePresence, ResolveClaims, ResolveUserMeta, ResolveModelKey, } from '../types/global.js';
+export type { DefaultSyncShape, ResolveSchema, ResolveUserMeta, ResolveModelKey, } from '../types/global.js';
 export { AbloProvider, useWatch, usePeers, useSync, useSyncStore, type AbloProviderProps, type ParticipantScope, type ParticipantStatus, type UseWatchOptions, type UseWatchReturn, type MeshParticipantStatus, } from './AbloProvider.js';
 export { ClientSideSuspense, type ClientSideSuspenseProps, } from './ClientSideSuspense.js';
 export { DefaultFallback } from './DefaultFallback.js';

package/dist/react/useAblo.d.ts

@@ -1,4 +1,4 @@
-import type { Ablo, ModelClaim } from '../client/Ablo.js';
+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';
@@ -11,8 +11,8 @@ import type { ResolveSchema } from '../types/global.js';
 type DefaultModels = ResolveSchema extends {
     models: infer M;
 } ? M extends SchemaRecord ? M : SchemaRecord : SchemaRecord;
-type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: Ablo<R>) => ModelOperations<T, C>;
-type AbloSelector<R extends SchemaRecord, T> = (ablo: Ablo<R>) => T;
+type ModelClientSelector<R extends SchemaRecord, T, C> = (ablo: AbloReads<R>) => ModelOperations<T, C>;
+type AbloSelector<R extends SchemaRecord, T> = (ablo: AbloReads<R>) => T;
 export interface UseAbloModelOptions<T> {
     /**
      * An initial row, usually from a server component or a route loader. The hook
@@ -48,7 +48,9 @@ export type UseAbloHydratedModelResult<T> = Omit<UseAbloModelResult<T>, 'data'>
  * if (!ablo) return <Loading />;
  * const doc = await ablo.documents.retrieve({ id }); // async server read
  *
- * // Reactive selector (a synchronous local snapshot):
+ * // 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 active = useAblo((ablo) => ablo.documents.claim.state({ id }));
  *

package/dist/react/useAblo.js

@@ -5,6 +5,24 @@ import { getModelClientMeta } from '../client/createModelProxy.js';
 import { Model } from '../Model.js';
 import { useReactive } from './useReactive.js';
 const EMPTY_CLAIMS = Object.freeze([]);
+/**
+ * Restore the caller's schema generics on the context-held engine. React
+ * context erases generics (see `AbloInternalContextValue.engine`), so this is
+ * the one deliberate rebind point: the runtime value is the fully typed
+ * client, and `R` is the compile-time view the calling hook declared.
+ */
+function rebindEngine(engine) {
+    return engine;
+}
+/**
+ * The same rebind viewed through the reactive-read surface — the identical
+ * runtime object, with model reads typed as snapshot rows, because everything
+ * a selector returns is converted through `snapshotValue` before the hook
+ * hands it back.
+ */
+function reactiveReads(engine) {
+    return rebindEngine(engine);
+}
 function readModelResult(engine, modelClient, id, initial) {
     if (!modelClient || id === undefined) {
         return { data: initial, claims: EMPTY_CLAIMS, claimed: false };
@@ -43,7 +61,7 @@ export function useAblo(modelOrSelect, id, options) {
     const isSelectorOnly = typeof modelOrSelect === 'function' && id === undefined;
     const modelClient = typeof modelOrSelect === 'function' && id !== undefined
         ? engine
-            ? modelOrSelect(engine)
+            ? modelOrSelect(reactiveReads(engine))
             : undefined
         : typeof modelOrSelect === 'function'
             ? undefined
@@ -66,7 +84,11 @@ export function useAblo(modelOrSelect, id, options) {
         if (!engine || !isSelectorOnly || typeof modelOrSelect !== 'function') {
             return undefined;
         }
-        return snapshotValue(modelOrSelect(engine));
+        // The selector runs against the real engine — reads inside it return the
+        // pool's model instances. `snapshotValue` then converts the RESULT to
+        // plain snapshot rows, which is what the selector's `AbloReads`
+        // parameter type already promised.
+        return snapshotValue(modelOrSelect(reactiveReads(engine)));
     });
     const modelResult = useReactive(() => {
         void claimVersion;
@@ -76,5 +98,5 @@ export function useAblo(modelOrSelect, id, options) {
         return selected;
     if (modelOrSelect)
         return modelResult;
-    return engine;
+    return engine === null ? null : rebindEngine(engine);
 }

package/dist/schema/index.d.ts

@@ -30,9 +30,9 @@ export { syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncD
 export { model, scopeKindOf, type ModelDef, type ModelOptions, type LoadStrategy, type PersistOptions, type RelationRecord, type GrantsRef, type ConflictAxis, } from './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 InferModel, type InferCreate, 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, } from './schema.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, } from './schema.js';
 export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, type SchemaJSON, type ModelJSON, type RelationJSON, } from './serialize.js';
-export { selectModels } from './select.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';

package/dist/schema/index.js

@@ -57,7 +57,7 @@ export { defineSchema, composeIdentitySyncGroups, composeEntitySyncGroups, inter
 // Schema ⇄ JSON — serialize a schema for transport and rebuild it on the far side.
 export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, } from './serialize.js';
 // Schema projection — derive an app's subset from one canonical schema.
-export { selectModels } from './select.js';
+export { selectModels, omitModels } from './select.js';
 // Schema → Postgres DDL — shared by the host implementation and the command-line tools.
 export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSnake, snakeToCamel, q, sqlType, } from './ddl.js';
 // Safe-DDL locking knobs (lock_timeout plus a bounded retry on lock contention),

package/dist/schema/schema.d.ts

@@ -162,8 +162,38 @@ Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields> & BaseModelFields & Bas
  * to `slide.layers` would have no effect at runtime.
  */
 export type InferRelations<S extends Schema, R extends RelationRecord> = string extends keyof R ? unknown : {
-    readonly [K in keyof R]: R[K] extends RelationDef<infer Type, infer Target, infer _F, infer _O> ? Target extends keyof S['models'] ? Type extends 'hasMany' ? InferModel<S, Target>[] : Type extends 'hasOne' | 'belongsTo' ? InferModel<S, Target> | undefined : never : never : never;
+    readonly [K in keyof R]: R[K] extends RelationDef<infer Type, infer Target> ? Target extends keyof S['models'] ? Type extends 'hasMany' ? InferModel<S, Target>[] : Type extends 'hasOne' | 'belongsTo' ? InferModel<S, Target> | undefined : never : never : never;
 };
+/**
+ * The row shape a reactive read returns: the model's data fields, base fields,
+ * and schema computed getters — WITHOUT relation accessors and WITHOUT model
+ * methods. Derived from the model definition, exactly like {@link InferModel},
+ * mirroring what `toReactiveSnapshot()` produces at runtime.
+ *
+ * Relations (`hasMany` / `belongsTo`) are store-backed getters that exist only
+ * on the pool's model instances, so a reactive row honestly omits them —
+ * reading `row.layers` is a compile error instead of a silent `undefined`.
+ * Compose relations through a selector or hook instead.
+ *
+ * The same pairing other data layers converged on: Zero's data-only `Row<...>`
+ * with relations added per-query, Prisma's scalar-only model types with
+ * `GetPayload<{ include }>`, mobx-state-tree's `Instance<T>` / `SnapshotOut<T>`.
+ */
+export type InferRow<S extends Schema, ModelName extends keyof S['models']> = S['models'][ModelName] extends ModelDef<infer Shape, RelationRecord, infer C> ? // Same reserved-field guard as InferModel — see the comment there.
+Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields> & BaseModelFields & InferComputed<C> : never;
+/**
+ * The reactive-row companion to {@link Model}. Once your project's
+ * `ablo/register.ts` registers the schema, a single argument is all it takes:
+ *
+ * ```ts
+ * type SlideRow = Row<'slides'>;    // data fields + computeds, no relations
+ * type Slide    = Model<'slides'>;  // the pool's model instance
+ * ```
+ *
+ * Without that registration, or for a second schema, pass the schema
+ * explicitly: `Row<typeof schema, 'slides'>`.
+ */
+export type Row<A, B = never> = [B] extends [never] ? A extends keyof RegisteredSchema['models'] ? InferRow<RegisteredSchema, A> : never : A extends Schema ? InferRow<A, B extends keyof A['models'] ? B : never> : never;
 /**
  * Infer the return types of computed getters.
  * Maps each computed function's return type into a readonly property.

package/dist/schema/select.d.ts

@@ -23,3 +23,18 @@
  */
 import type { Schema, SchemaRecord } from './schema.js';
 export declare function selectModels<S extends SchemaRecord, K extends keyof S & string>(schema: Schema<S>, keys: readonly K[]): Schema<Pick<S, K>>;
+/**
+ * `omitModels` is `selectModels` from the other side: keep every model EXCEPT
+ * the named ones. Use it when an app is the general case and another product
+ * owns the omitted models — e.g. the product suite shell drops the standalone
+ * Mail store, which `@ablo/mail-schema` selects for the mail app:
+ *
+ * ```ts
+ * export const schema = omitModels(full, ['mailMailboxes', 'mailThreads']);
+ * ```
+ *
+ * Same validation as `selectModels`: relations into the omitted set are
+ * dropped, and a dropped `parent` edge throws — so a model whose scope routes
+ * through an omitted parent cannot be silently kept.
+ */
+export declare function omitModels<S extends SchemaRecord, K extends keyof S & string>(schema: Schema<S>, keys: readonly K[]): Schema<Omit<S, K>>;

package/dist/schema/select.js

@@ -29,7 +29,7 @@ export function selectModels(schema, keys) {
     for (const key of keys) {
         const def = schema.models[key];
         if (!def) {
-            throw new AbloValidationError(`selectModels: "${String(key)}" is not a model in the source schema`, { code: 'invalid_schema', param: String(key) });
+            throw new AbloValidationError(`selectModels: "${key}" is not a model in the source schema`, { code: 'invalid_schema', param: key });
         }
         // Prune relations whose target isn't in the selected set. A pruned
         // `parent` edge is a routing error, not a silent drop.
@@ -40,8 +40,8 @@ export function selectModels(schema, keys) {
                 continue;
             }
             if (rel.options?.parent) {
-                throw new AbloValidationError(`selectModels: model "${String(key)}" has a parent relation "${relName}" → "${rel.target}", ` +
-                    `which is not in the selected set. Include "${rel.target}" so scope inheritance still routes.`, { code: 'invalid_schema', param: `${String(key)}.${relName}` });
+                throw new AbloValidationError(`selectModels: model "${key}" has a parent relation "${relName}" → "${rel.target}", ` +
+                    `which is not in the selected set. Include "${rel.target}" so scope inheritance still routes.`, { code: 'invalid_schema', param: `${key}.${relName}` });
             }
         }
         models[key] = { ...def, relations };
@@ -53,3 +53,27 @@ export function selectModels(schema, keys) {
         identityRoles: schema.identityRoles,
     };
 }
+/**
+ * `omitModels` is `selectModels` from the other side: keep every model EXCEPT
+ * the named ones. Use it when an app is the general case and another product
+ * owns the omitted models — e.g. the product suite shell drops the standalone
+ * Mail store, which `@ablo/mail-schema` selects for the mail app:
+ *
+ * ```ts
+ * export const schema = omitModels(full, ['mailMailboxes', 'mailThreads']);
+ * ```
+ *
+ * Same validation as `selectModels`: relations into the omitted set are
+ * dropped, and a dropped `parent` edge throws — so a model whose scope routes
+ * through an omitted parent cannot be silently kept.
+ */
+export function omitModels(schema, keys) {
+    const drop = new Set(keys);
+    for (const key of keys) {
+        if (!schema.models[key]) {
+            throw new AbloValidationError(`omitModels: "${key}" is not a model in the source schema`, { code: 'invalid_schema', param: key });
+        }
+    }
+    const kept = Object.keys(schema.models).filter((k) => !drop.has(k));
+    return selectModels(schema, kept);
+}

package/dist/source/connector.d.ts

@@ -62,9 +62,9 @@ export interface SourceConnectorOptions {
      */
     readonly apiKey: string;
     /**
-     * The Data Source handler to serve, as returned by `dataSource(options)` or
-     * `abloSource(options)`. The connector feeds it each request and relays the
-     * response back untouched; it never inspects or alters either one.
+     * The Data Source handler to serve, as returned by `dataSource(options)`.
+     * The connector feeds it each request and relays the response back untouched;
+     * it never inspects or alters either one.
      */
     readonly handler: (request: Request) => Promise<Response>;
     /** The Ablo base URL to dial. Defaults to `https://api.abloatai.com`. */

package/dist/source/factory.d.ts

@@ -1,6 +1,6 @@
 /**
- * Builds the Data Source request handler returned by `abloSource()` and its alias
- * `dataSource()`. Given your options — the schema, the API key, and either
+ * Builds the request handler returned by `dataSource()`. Given your options —
+ * the schema, the API key, and either
  * per-model handlers or an ORM adapter — the handler verifies each signed request,
  * enforces the per-key scopes, and routes the four wire operations (`load`,
  * `list`, `commit`, and `events`) to whichever handlers you configured.
@@ -13,7 +13,7 @@ type SourceModels<S extends SchemaRecord, TAuth> = Partial<{
         readonly id: string;
     } & Record<string, unknown>, InferCreate<Schema<S>, K>, TAuth>;
 }>;
-export type AbloSourceOptions<S extends SchemaRecord, TAuth = unknown> = {
+export type DataSourceOptions<S extends SchemaRecord, TAuth = unknown> = {
     readonly schema: Schema<S>;
     /**
      * Your Ablo project credential. Ablo signs each Data Source call with the same
@@ -66,7 +66,7 @@ export type AbloSourceOptions<S extends SchemaRecord, TAuth = unknown> = {
     readonly events?: SourceEventsHandler<TAuth>;
     /**
      * Groups per-model handlers under a `models` key. The spread form below is
-     * usually shorter — `abloSource({ schema, files: { load, list, commit } })` —
+     * usually shorter — `dataSource({ schema, files: { load, list, commit } })` —
      * but this explicit form is available when you prefer it.
      */
     readonly models?: SourceModels<S, TAuth>;
@@ -88,7 +88,5 @@ export type AbloSourceOptions<S extends SchemaRecord, TAuth = unknown> = {
  * canonical rows in your database: Ablo calls a narrow, signed endpoint you
  * control rather than holding your database credentials.
  */
-export declare function abloSource<const S extends SchemaRecord, TAuth = unknown>(options: AbloSourceOptions<S, TAuth>): (request: Request) => Promise<Response>;
-export type DataSourceOptions<S extends SchemaRecord, TAuth = unknown> = AbloSourceOptions<S, TAuth>;
 export declare function dataSource<const S extends SchemaRecord, TAuth = unknown>(options: DataSourceOptions<S, TAuth>): (request: Request) => Promise<Response>;
 export {};

package/dist/source/factory.js

@@ -1,6 +1,6 @@
 /**
- * Builds the Data Source request handler returned by `abloSource()` and its alias
- * `dataSource()`. Given your options — the schema, the API key, and either
+ * Builds the request handler returned by `dataSource()`. Given your options —
+ * the schema, the API key, and either
  * per-model handlers or an ORM adapter — the handler verifies each signed request,
  * enforces the per-key scopes, and routes the four wire operations (`load`,
  * `list`, `commit`, and `events`) to whichever handlers you configured.
@@ -131,8 +131,8 @@ function sameModel(operations) {
  * canonical rows in your database: Ablo calls a narrow, signed endpoint you
  * control rather than holding your database credentials.
  */
-export function abloSource(options) {
-    return async function handleAbloSource(request) {
+export function dataSource(options) {
+    return async function handleDataSource(request) {
         if (request.method !== 'POST') {
             return json({ error: 'method_not_allowed' }, 405);
         }
@@ -263,6 +263,3 @@ export function abloSource(options) {
         return json({ error: 'unknown_source_request' }, 400);
     };
 }
-export function dataSource(options) {
-    return abloSource(options);
-}

package/dist/source/index.d.ts

@@ -4,13 +4,13 @@
  *
  *   - `types.ts`   — the shared wire and handler types, plus `sourceEventForOperation`
  *   - `signing.ts` — request signing and verification
- *   - `factory.ts` — the `abloSource()` / `dataSource()` endpoint factory
+ *   - `factory.ts` — the `dataSource()` endpoint factory
  *
  * Import from here; the sibling modules import one another directly.
  */
-export { sourceEventForOperation, type SourcePrimitive, type SourceWhere, type SourceListQuery, type SourceListPage, type SourceListResult, type SourceRequestContext, type SourceOperation, type SourceDelta, type SourceEvent, type SourceEventForOperationOptions, type SourceCommitResult, type SourceCommitParams, type SourceScope, type SourceEventsResult, type SourceEventsHandler, type SourceAuthorizeContext, type SourceHandlerContext, type SourceModelHandlers, type SourceCommitHandler, type SourceApiKey, type SourceLoadRequest, type SourceListRequest, type SourceCommitRequest, type SourceEventsRequest, type SourceRequest, type SourceResponse, type DataSourcePrimitive, type DataSourceWhere, type DataSourceListQuery, type DataSourceListPage, type DataSourceListResult, type DataSourceRequestContext, type DataSourceOperation, type DataSourceDelta, type DataSourceEvent, type DataSourceEventForOperationOptions, type DataSourceCommitResult, type DataSourceCommitParams, type DataSourceScope, type DataSourceEventsResult, type DataSourceEventsHandler, type DataSourceAuthorizeContext, type DataSourceHandlerContext, type DataSourceModelHandlers, type DataSourceCommitHandler, type DataSourceApiKey, type DataSourceLoadRequest, type DataSourceListRequest, type DataSourceCommitRequest, type DataSourceEventsRequest, type DataSourceRequest, type DataSourceResponse, } from './types.js';
-export { ABLO_SOURCE_HEADERS, SourceSignatureError, signAbloSourceRequest, verifyAbloSourceRequest, type SourceSignatureOptions, type SourceSignatureVerificationOptions, type SourceSignatureVerificationResult, type DataSourceSignatureOptions, type DataSourceSignatureVerificationOptions, type DataSourceSignatureVerificationResult, } from './signing.js';
-export { abloSource, dataSource, type AbloSourceOptions, type DataSourceOptions, } from './factory.js';
+export { sourceEventForOperation, type SourcePrimitive, type SourceWhere, type SourceListQuery, type SourceListPage, type SourceListResult, type SourceRequestContext, type SourceOperation, type SourceDelta, type SourceEvent, type SourceEventForOperationOptions, type SourceCommitResult, type SourceCommitParams, type SourceScope, type SourceEventsResult, type SourceEventsHandler, type SourceAuthorizeContext, type SourceHandlerContext, type SourceModelHandlers, type SourceCommitHandler, type SourceApiKey, type SourceLoadRequest, type SourceListRequest, type SourceCommitRequest, type SourceEventsRequest, type SourceRequest, type SourceResponse, } from './types.js';
+export { ABLO_SOURCE_HEADERS, SourceSignatureError, signAbloSourceRequest, verifyAbloSourceRequest, type SourceSignatureOptions, type SourceSignatureVerificationOptions, type SourceSignatureVerificationResult, } from './signing.js';
+export { dataSource, type DataSourceOptions, } from './factory.js';
 export { createPushQueue, InMemoryPushQueueStorage, STANDARD_WEBHOOKS_RETRY_SCHEDULE, type PushQueue, type PushQueueItem, type PushQueueOptions, type PushQueueStorage, } from './pushQueue.js';
 export { createSourceConnector, DEFAULT_RECONNECT_SCHEDULE, type SourceConnector, type SourceConnectorOptions, type ConnectorWebSocket, type ConnectorWebSocketFactory, type ConnectorStatus, } from './connector.js';
 export { SOURCE_CONNECTOR_PROTOCOL_VERSION, SOURCE_CONNECTOR_WS_PATH, WS_SOURCE_SUBPROTOCOL, sourceConnectorSubprotocols, encodeFrame, decodeFrame, ConnectorProtocolError, connectorFrameSchema, type ConnectorFrame, type RegisterFrame, type ReadyFrame, type RequestFrame, type ResponseFrame, type ErrorFrame, } from './connectorProtocol.js';

package/dist/source/index.js

@@ -4,13 +4,13 @@
  *
  *   - `types.ts`   — the shared wire and handler types, plus `sourceEventForOperation`
  *   - `signing.ts` — request signing and verification
- *   - `factory.ts` — the `abloSource()` / `dataSource()` endpoint factory
+ *   - `factory.ts` — the `dataSource()` endpoint factory
  *
  * Import from here; the sibling modules import one another directly.
  */
 export { sourceEventForOperation, } from './types.js';
 export { ABLO_SOURCE_HEADERS, SourceSignatureError, signAbloSourceRequest, verifyAbloSourceRequest, } from './signing.js';
-export { abloSource, dataSource, } from './factory.js';
+export { dataSource, } from './factory.js';
 export { createPushQueue, InMemoryPushQueueStorage, STANDARD_WEBHOOKS_RETRY_SCHEDULE, } from './pushQueue.js';
 // The reverse-channel connector — an outbound transport for the load, list, and
 // commit leg, and the dial-out counterpart to `createPushQueue`. It lets you serve

package/dist/source/signing.d.ts

@@ -83,6 +83,3 @@ export declare function signAbloSourceRequest(options: SourceSignatureOptions):
  * id and signing time. This is the counterpart to {@link signAbloSourceRequest}.
  */
 export declare function verifyAbloSourceRequest(options: SourceSignatureVerificationOptions): Promise<SourceSignatureVerificationResult>;
-export type DataSourceSignatureOptions = SourceSignatureOptions;
-export type DataSourceSignatureVerificationOptions = SourceSignatureVerificationOptions;
-export type DataSourceSignatureVerificationResult = SourceSignatureVerificationResult;

package/dist/source/types.d.ts

@@ -323,29 +323,3 @@ export type SourceResponse<Row = Record<string, unknown>> = {
     readonly rows?: readonly Row[];
     readonly deltas?: readonly SourceDelta[];
 };
-export type DataSourcePrimitive = SourcePrimitive;
-export type DataSourceWhere = SourceWhere;
-export type DataSourceListQuery = SourceListQuery;
-export type DataSourceListPage<Row> = SourceListPage<Row>;
-export type DataSourceListResult<Row> = SourceListResult<Row>;
-export type DataSourceRequestContext = SourceRequestContext;
-export type DataSourceOperation = SourceOperation;
-export type DataSourceDelta = SourceDelta;
-export type DataSourceEvent = SourceEvent;
-export type DataSourceEventForOperationOptions = SourceEventForOperationOptions;
-export type DataSourceCommitResult<Row = Record<string, unknown>> = SourceCommitResult<Row>;
-export type DataSourceCommitParams<TAuth = unknown> = SourceCommitParams<TAuth>;
-export type DataSourceScope = SourceScope;
-export type DataSourceEventsResult = SourceEventsResult;
-export type DataSourceEventsHandler<TAuth = unknown> = SourceEventsHandler<TAuth>;
-export type DataSourceAuthorizeContext = SourceAuthorizeContext;
-export type DataSourceHandlerContext<TAuth = unknown> = SourceHandlerContext<TAuth>;
-export type DataSourceModelHandlers<Row, CreateInput, TAuth = unknown> = SourceModelHandlers<Row, CreateInput, TAuth>;
-export type DataSourceCommitHandler<TAuth = unknown> = SourceCommitHandler<TAuth>;
-export type DataSourceApiKey = SourceApiKey;
-export type DataSourceLoadRequest = SourceLoadRequest;
-export type DataSourceListRequest = SourceListRequest;
-export type DataSourceCommitRequest = SourceCommitRequest;
-export type DataSourceEventsRequest = SourceEventsRequest;
-export type DataSourceRequest = SourceRequest;
-export type DataSourceResponse<Row = Record<string, unknown>> = SourceResponse<Row>;