@abloatai/transaction 0.37.0

package/dist/schema/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @abloatai/transaction/schema — Schema Definition DSL
+ *
+ * Define your data models with Zod. Types are inferred automatically.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { defineSchema, model, relation } from '@abloatai/transaction/schema';
+ *
+ * export const schema = defineSchema({
+ *   tasks: model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   }),
+ * });
+ *
+ * type Task = Model<typeof schema, 'tasks'>;
+ * ```
+ */
+export { z } from 'zod';
+export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from './field.js';
+export { fieldSelection, isFieldRef, type FieldRef, type FieldSelection, type FieldSelector, } from './fieldRef.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, } from './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 '../log/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, LoadStrategy, DEFAULT_LOAD_STRATEGY, loadsAtBootstrap, type ModelDef, type ModelOptions, 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 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 './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 { abloOpenApi, schemaToOpenApi, type SchemaToOpenApiOptions } from './openapi.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/schema/index.js

@@ -0,0 +1,81 @@
+/**
+ * @abloatai/transaction/schema — Schema Definition DSL
+ *
+ * Define your data models with Zod. Types are inferred automatically.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { defineSchema, model, relation } from '@abloatai/transaction/schema';
+ *
+ * export const schema = defineSchema({
+ *   tasks: model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   }),
+ * });
+ *
+ * type Task = Model<typeof schema, 'tasks'>;
+ * ```
+ */
+// Re-export Zod for convenience (consumers can also import directly)
+export { z } from 'zod';
+// Field helpers (optional convenience wrappers around Zod)
+export { field, indexed, getFieldMeta } from './field.js';
+// A field as a value rather than a quoted name — `schema.fields.tasks.status`.
+// Surfaces that name a field (claims today) take one of these so a name that
+// does not exist stops compiling.
+export { fieldSelection, isFieldRef, } from './fieldRef.js';
+// Relation builders
+export { relation } from './relation.js';
+// Tenancy — the single source of truth for how a model's rows are tenant-scoped.
+export { tenancySchema, scopedViaRefSchema, policyInputSchema, resolvePolicy, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, } from './tenancy.js';
+// Model residency — which database a model's rows live in (`tenant` can be a
+// customer's own database, `control` is Ablo's). A sibling axis to `tenancy`.
+export { residencySchema, DEFAULT_RESIDENCY, } from './residency.js';
+// The stored `sync_deltas` row, described as Zod schemas grouped by subsystem and by
+// which database the columns live in.
+export { syncDeltaCoreSchema, deltaAttributionSchema, syncDeltaRowSchema, participantKindSchema, confirmationStateSchema, backfillProvenanceSchema, DELTA_DATA_CLASSIFICATION, DELTA_PHYSICAL_STORAGE, } from '../log/syncDeltaRow.js';
+// The wire delta contract — the server-to-client projection of the stored row.
+// Both the client SDK and the server derive their `SyncDelta` type from these with
+// `z.infer`, so the two ends cannot drift apart.
+export { syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, } from '../wire/delta.js';
+// Model builder
+export { model, scopeKindOf, 
+// Both meanings: the value a tool enumerates to learn the strategies, and the
+// type a `load` option is checked against. `loadsAtBootstrap` is the one
+// predicate both the client subscription and the server payload ask.
+LoadStrategy, DEFAULT_LOAD_STRATEGY, loadsAtBootstrap, } from './model.js';
+// Coordination authoring helpers for the `conflict` axis — composable disposition
+// functions plus a combinator that merges them.
+export { coordination, humansOverwrite, humansReject, humansNotify, agentsOverwrite, agentsReject, agentsNotify, systemOverwrite, systemReject, systemNotify, } from './coordination.js';
+// Claim-first shorthand for common model options: `mutable.lazy({...})` and friends
+// encode a model's write-safety and load strategy in the verb, and fall back to
+// sensible defaults for everything else.
+export { mutable, readOnly } from './sugar.js';
+// Schema definition + type inference
+export { defineSchema, composeIdentitySyncGroups, composeEntitySyncGroups, intersectRequestedWithAllowed, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, RESERVED_SESSION_SETTINGS, } from './schema.js';
+// Schema ⇄ JSON — serialize a schema for transport and rebuild it on the far side.
+export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, modelHash, } from './serialize.js';
+// Schema projection — derive an app's subset from one canonical schema.
+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),
+// shared by `ablo migrate` and the host that applies a schema push, so tuning the
+// ABLO_SCHEMA_LOCK_* variables changes both paths the same way.
+export { PG_LOCK_NOT_AVAILABLE, resolveDdlLockTimeout, resolveDdlMaxLockAttempts, ddlLockRetryBackoffMs, } from './ddlLock.js';
+// Schema diff + migration planning — produces the plan the DDL layer turns into SQL.
+export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlockerResolved, unresolvedBlockers, } from './diff.js';
+// Schema → TypeScript type emission.
+export { generateTypes } from './generate.js';
+// Query definition DSL + type inference
+export { query, defineQueries, } from './queries.js';
+// The OpenAPI generator describes the language-agnostic `/v1` surface — the
+// primitive itself, which a Python or Go caller consumes with no TypeScript
+// anywhere — so it lives in the settlement core (ADR 0016). Re-exported here so
+// the `@abloatai/ablo/schema` import path keeps resolving.
+export { abloOpenApi, schemaToOpenApi } from './openapi.js';
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"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"}

package/dist/schema/loadStrategy.d.ts

@@ -0,0 +1,46 @@
+/**
+ * When a model's rows are loaded from the server.
+ *
+ *   - `instant` — loaded during bootstrap, before the model is first used.
+ *   - `lazy`    — loaded all at once on first access.
+ *
+ * One declaration serves both sides of the seam. `LoadStrategy.instant` is the
+ * value the engine branches on once a model is registered; `'instant'` is the
+ * word an author writes in `model(…, { load })`. They are the same name because
+ * they are the same axis — a const object merged with the type of its own
+ * values, rather than an enum, because a string enum is nominal and would
+ * refuse the plain `'instant'` an author actually types.
+ *
+ * The set is deliberately this small. It previously named `partial`,
+ * `explicitlyRequested`, and `local` on the runtime side and `manual` on the
+ * authoring side, and not one of those was reachable end to end: `manual` had
+ * no implementation and resolved to `lazy`, while the other three had no way to
+ * be declared. A member no schema can produce, or no branch can observe, is a
+ * promise the engine has no way to keep.
+ */
+export declare const LoadStrategy: {
+    /** Loaded during startup, before it is first used — for models needed right away. */
+    readonly instant: "instant";
+    /** Loaded all at once the first time it is needed — for secondary models. */
+    readonly lazy: "lazy";
+};
+export type LoadStrategy = (typeof LoadStrategy)[keyof typeof LoadStrategy];
+/** The strategy a model gets when it declares none. */
+export declare const DEFAULT_LOAD_STRATEGY: LoadStrategy;
+/**
+ * Whether a model's rows arrive in the bootstrap payload rather than on first
+ * access. This is the question the client asks when it builds the bootstrap
+ * subscription and the question the server asks when it assembles the payload,
+ * and the two must answer it identically or a model is requested by one side
+ * and withheld by the other.
+ *
+ * It is a function rather than a comparison spelled at each site because the
+ * sites disagreed about how to spell it: one asked `load !== 'lazy'`, another
+ * `load === 'instant'`, a third `load === 'lazy' ? … : …`. Against a two-member
+ * set those are the same predicate, so nothing failed. Against a third member
+ * they are three different predicates, and the first would have enrolled it in
+ * bootstrap while the second withheld it — the kind of split that surfaces as
+ * rows that never arrive, far from the line that caused it.
+ */
+export declare function loadsAtBootstrap(load: LoadStrategy | undefined): boolean;
+//# sourceMappingURL=loadStrategy.d.ts.map

package/dist/schema/loadStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadStrategy.d.ts","sourceRoot":"","sources":["../../src/schema/loadStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,YAAY;IACvB,qFAAqF;;IAGrF,6EAA6E;;CAErE,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE5E,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,EAAE,YAAmC,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,CAExE"}

package/dist/schema/loadStrategy.js

@@ -0,0 +1,47 @@
+/**
+ * When a model's rows are loaded from the server.
+ *
+ *   - `instant` — loaded during bootstrap, before the model is first used.
+ *   - `lazy`    — loaded all at once on first access.
+ *
+ * One declaration serves both sides of the seam. `LoadStrategy.instant` is the
+ * value the engine branches on once a model is registered; `'instant'` is the
+ * word an author writes in `model(…, { load })`. They are the same name because
+ * they are the same axis — a const object merged with the type of its own
+ * values, rather than an enum, because a string enum is nominal and would
+ * refuse the plain `'instant'` an author actually types.
+ *
+ * The set is deliberately this small. It previously named `partial`,
+ * `explicitlyRequested`, and `local` on the runtime side and `manual` on the
+ * authoring side, and not one of those was reachable end to end: `manual` had
+ * no implementation and resolved to `lazy`, while the other three had no way to
+ * be declared. A member no schema can produce, or no branch can observe, is a
+ * promise the engine has no way to keep.
+ */
+export const LoadStrategy = {
+    /** Loaded during startup, before it is first used — for models needed right away. */
+    instant: 'instant',
+    /** Loaded all at once the first time it is needed — for secondary models. */
+    lazy: 'lazy',
+};
+/** The strategy a model gets when it declares none. */
+export const DEFAULT_LOAD_STRATEGY = LoadStrategy.instant;
+/**
+ * Whether a model's rows arrive in the bootstrap payload rather than on first
+ * access. This is the question the client asks when it builds the bootstrap
+ * subscription and the question the server asks when it assembles the payload,
+ * and the two must answer it identically or a model is requested by one side
+ * and withheld by the other.
+ *
+ * It is a function rather than a comparison spelled at each site because the
+ * sites disagreed about how to spell it: one asked `load !== 'lazy'`, another
+ * `load === 'instant'`, a third `load === 'lazy' ? … : …`. Against a two-member
+ * set those are the same predicate, so nothing failed. Against a third member
+ * they are three different predicates, and the first would have enrolled it in
+ * bootstrap while the second withheld it — the kind of split that surfaces as
+ * rows that never arrive, far from the line that caused it.
+ */
+export function loadsAtBootstrap(load) {
+    return (load ?? DEFAULT_LOAD_STRATEGY) === LoadStrategy.instant;
+}
+//# sourceMappingURL=loadStrategy.js.map

package/dist/schema/loadStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadStrategy.js","sourceRoot":"","sources":["../../src/schema/loadStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,qFAAqF;IACrF,OAAO,EAAE,SAAS;IAElB,6EAA6E;IAC7E,IAAI,EAAE,MAAM;CACJ,CAAC;AAIX,uDAAuD;AACvD,MAAM,CAAC,MAAM,qBAAqB,GAAiB,YAAY,CAAC,OAAO,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAA8B;IAC7D,OAAO,CAAC,IAAI,IAAI,qBAAqB,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC;AAClE,CAAC"}

package/dist/schema/model.d.ts

@@ -0,0 +1,380 @@
+/**
+ * Defines a model — one table's worth of fields, and one options object holding
+ * everything else the engine needs to know about it. A model is a Zod object schema
+ * paired with those options; the row type is inferred directly from Zod, with no
+ * separate type system to keep in sync.
+ *
+ * Usage:
+ *   import { z } from 'zod';
+ *   import { model, relation } from '@abloatai/transaction/schema';
+ *
+ *   const tasks = model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     relations: { project: relation.belongsTo('projects', 'projectId') },
+ *     load: 'lazy',
+ *   });
+ */
+import { z } from 'zod';
+import type { RelationDef } from './relation.js';
+import type { EntityRole, GroupsInput } from './roles.js';
+import { type FieldMeta } from './field.js';
+import { type Tenancy, type PolicyInput } from './tenancy.js';
+export type { ScopedViaRef, Tenancy, PolicyInput } from './tenancy.js';
+import { type ModelResidency } from './residency.js';
+import type { ConflictAxis } from '../policy/types.js';
+export type { ConflictAxis } from '../policy/types.js';
+import { LoadStrategy } from './loadStrategy.js';
+export { LoadStrategy, DEFAULT_LOAD_STRATEGY, loadsAtBootstrap } from './loadStrategy.js';
+/** A record of relation definitions */
+export type RelationRecord = Record<string, RelationDef>;
+/**
+ * Persistence hints for IndexedDB write-through and hydration.
+ *
+ * The sync engine's generic loader uses these to route incoming rows to
+ * the right client-side store without the consumer wiring each model by
+ * hand. `store` defaults to the model's {@link ModelDef.typename} (which
+ * itself defaults to the schema key), so consumers only set this when
+ * the IDB store name diverges from the typename.
+ */
+export interface PersistOptions {
+    /**
+     * Name of the IndexedDB object store that backs this model.
+     * Defaults to the model's {@link ModelDef.typename}.
+     */
+    store?: string;
+}
+/**
+ * Declares a membership edge on a join model. See {@link ModelOptions.grants}
+ * for semantics and how the server membership resolver reads it. Both fields
+ * name `belongsTo` relations declared on the same model.
+ */
+export interface GrantsRef {
+    /** Relation name pointing at the identity that gains access (e.g. `'user'`). */
+    subject: string;
+    /** Relation name pointing at the scope-root entity (e.g. `'workspace'`). */
+    scope: string;
+}
+/** Options for model() */
+export interface ModelOptions {
+    /**
+     * Edges from this model to others, keyed by the accessor name they create. The
+     * engine reads them to index foreign keys, to order inserts so a parent row lands
+     * before the rows referencing it, and to generate the accessors that let you read
+     * `task.project` or `project.tasks` directly. Built with the {@link relation}
+     * factories.
+     *
+     * ```ts
+     * relations: {
+     *   project: relation.belongsTo('projects', 'projectId'),
+     *   comments: relation.hasMany('comments', 'taskId'),
+     * }
+     * ```
+     */
+    relations?: RelationRecord;
+    /** When to load this model's data. Default: 'instant' */
+    load?: LoadStrategy;
+    /** Max records to bootstrap. Default: unlimited. Only applies to 'instant' strategy. */
+    bootstrapLimit?: number;
+    /** Order to sort by during bootstrap (e.g., 'created_at DESC'). */
+    bootstrapOrderBy?: string;
+    /**
+     * The wire type name for this model — the value that identifies its rows on the
+     * wire (the `__typename`). The loader stamps it onto incoming rows and uses it to
+     * find the matching model class. It defaults to the schema key (`tasks` →
+     * `'tasks'`); set it explicitly when the wire shape uses different casing, such as
+     * schema key `block` mapping to typename `'Block'`.
+     *
+     * This is the one value that identifies the model on the wire; the client-side
+     * store name, query result references, and delta routing all resolve through it.
+     */
+    typename?: string;
+    /**
+     * IndexedDB persistence hints. See {@link PersistOptions}.
+     */
+    persist?: PersistOptions;
+    /**
+     * The database table this model maps to. Defaults to the snake_case form of the
+     * model name. Set it when the real table name does not follow that convention, so
+     * queries read from the right table instead of a guessed name.
+     */
+    tableName?: string;
+    /**
+     * Row-access policy — decides which rows a tenant may read at all. A discriminated
+     * union on `by`:
+     *
+     * - `{ by: 'column' }` — the row carries its own tenancy column (the default when
+     *   omitted). `column` overrides the column name, which defaults to
+     *   `organization_id`.
+     * - `{ by: 'parent', fk, parent }` — inherit tenancy through a foreign key when the
+     *   table has no tenancy column of its own (for example `blocks` → section →
+     *   report → organization). In place of `organization_id = $1` the read emits
+     *   `WHERE <table>.<fk> IN (SELECT <parentKey> FROM <parent> WHERE
+     *   <parentTenantColumn> = $1)`. Use it for any `load: 'instant'` child table that
+     *   would otherwise expose other tenants' rows at bootstrap.
+     * - `{ by: 'none' }` — genuinely global or reference data, such as a lookup table.
+     *   This makes the whole table readable across tenants, so it is only correct for
+     *   tables that have no tenant at all. It is a named branch rather than a falsy
+     *   flag, so it cannot be selected by accident.
+     *
+     * {@link resolvePolicy} normalizes this into the canonical {@link Tenancy} when the
+     * model is built.
+     */
+    policy?: PolicyInput;
+    /**
+     * Which database a model's rows live in. `tenant` (the default) is tenant data
+     * that provisioning places in the customer's own database; `control` is Ablo's own
+     * data — the sync log, attribution, and audit records — which never leaves Ablo's
+     * database. See {@link ModelResidency}.
+     */
+    plane?: ModelResidency;
+    /**
+     * Sync-group routing — decides which delta channels a row fans out to. This is
+     * independent of {@link policy}, which governs read access. One object with three
+     * optional parts:
+     *
+     * - `root` — marks this model a scope root, so each of its records forms the group
+     *   `<kind>:<id>`. The kind defaults to the lowercased typename (`Report` →
+     *   `report:<id>`); pass a string to override it (`root: 'matter'`). Child models
+     *   inherit a root's group through their `belongsTo` relations.
+     * - `grants` — a membership edge that grants an identity access to a scope root.
+     *   Both values name `belongsTo` relations on this model (`subject` names the
+     *   identity, `scope` names the scope root). Use it only for sharing within an
+     *   organization.
+     * - `roles` — explicit record-to-group roles keyed on a plain field, for routing
+     *   that does not follow a relation, such as fanning a message into a recipient's
+     *   inbox. Accepts one role or many.
+     *
+     * ```ts
+     * // dataroomMember: { userId, dataroomId }
+     * groups: { grants: { subject: 'user', scope: 'workspace' } }
+     * // a message → its addressee's inbox, keyed on `toId`
+     * groups: { roles: [entityRole({ kind: 'inbox', source: 'toId' })] }
+     * ```
+     */
+    groups?: GroupsInput;
+    /**
+     * Write-conflict disposition, set per committer kind — decides what happens when a
+     * commit collides with another participant's claim or with a stale snapshot of this
+     * model. This is independent of {@link policy} (read access) and {@link groups}
+     * (delta routing). It is a map keyed by the committer's kind (`user`, `agent`, or
+     * `system`), with these outcomes as values:
+     *
+     * - `'overwrite'` — the write wins; that committer is never blocked.
+     * - `'reject'`    — the write is refused; that committer yields.
+     * - `'notify'`    — hold the write and hand the current value back so the committer
+     *                   re-reads and re-applies (for stale writes only).
+     *
+     * A kind you omit falls back to the engine default: reject, while honoring
+     * `onStale: 'notify'`. The value is plain data that travels with the schema to the
+     * server, where the engine interprets it. For example:
+     *
+     * ```ts
+     * // "a human's edit always wins (never blocked); an agent yields"
+     * conflict: { user: 'overwrite', agent: 'reject' }
+     * ```
+     */
+    conflict?: ConflictAxis;
+    /**
+     * Whether clients may create, update, and delete this model's rows through the
+     * commit protocol. Defaults to true: declaring a model in your schema is the
+     * opt-in, since a synced entity is almost always one you want to write. A model
+     * left out of the mutation allowlist rejects writes with
+     * `server_execute_unknown_model`.
+     *
+     * Set `mutable: false` (or use the `readOnly.*` shorthand, which sets it for you)
+     * for server-managed projections such as stats, digests, or audit views, so those
+     * cannot be written from a client. The server derives its mutation allowlist from
+     * this flag; there is no separate hardcoded list to keep in step.
+     */
+    mutable?: boolean;
+    /**
+     * Defer setting up MobX observability until the model is first accessed by an
+     * observing component. Defaults to false, which observes immediately.
+     *
+     * Use it for models created in bulk — during an import or a batch bootstrap —
+     * where most instances are never rendered. The constructor skips the observability
+     * setup, and calling `model.makeObservable()` performs it later when the model
+     * enters the render tree. This avoids roughly 10ms of setup per instance when
+     * creating hundreds of models that are never observed.
+     */
+    lazyObservable?: boolean;
+    /**
+     * Computed getters to install on the model instance. Each key becomes a getter;
+     * its function receives the model instance as `self` and returns the computed
+     * value.
+     *
+     * @example
+     * model({ title: z.string(), metadata: z.string() }, {
+     *   computed: {
+     *     displayTitle: (self) => self.title || `Untitled`,
+     *     metadataObject: (self) => {
+     *       try { return JSON.parse(self.metadata || '{}'); }
+     *       catch { return {}; }
+     *     },
+     *   },
+     * })
+     */
+    computed?: ComputedRecord;
+    /**
+     * Fields to back-fill from the connected sync identity when a stored row is missing
+     * them, during self-healing of the local store.
+     *
+     * Healing runs on every row loaded from the local store at hydration and on every
+     * delta merge. When a row is missing one of these fields, the engine writes the
+     * matching identity value (the `organizationId` or `userId` passed to the sync
+     * client) into the row before it is loaded. Without this, rows written by an older
+     * version that did not set the field would read as `undefined` and break code that
+     * assumes it is present.
+     *
+     * @example
+     * autoFill: [
+     *   { field: 'organizationId', from: 'organizationId' },
+     *   { field: 'createdBy', from: 'userId' },
+     * ]
+     */
+    autoFill?: readonly AutoFillRule[];
+    /**
+     * Fields whose absence marks a stored row as orphaned — corrupt enough that the
+     * engine drops it instead of loading it.
+     *
+     * During self-healing, a row missing any listed field is discarded rather than
+     * loaded. Use it for foreign keys whose absence would crash code that depends on
+     * them — for example a child row that cannot be placed without its parent's id.
+     *
+     * @example requiredFields: ['sectionId']
+     */
+    requiredFields?: readonly string[];
+}
+/** Base type for computed getter records. Preserves return types via inference. */
+export type ComputedRecord = Record<string, (self: any) => any>;
+/**
+ * Identity sources the sync engine can pull from when auto-filling a
+ * record's missing field during IndexedDB self-healing.
+ *
+ * - `'organizationId'` — the org id passed to `SyncClient.initialize`
+ * - `'userId'` — the user id passed to `SyncClient.initialize`
+ */
+export type AutoFillSource = 'organizationId' | 'userId';
+/**
+ * Declares one field to back-fill from the connected sync identity when it is
+ * missing from a stored row. The engine repairs rows during self-healing — for
+ * example rows written by an older version without an `organizationId` or
+ * `createdBy`. Declared per model, so the engine stays product-neutral.
+ */
+export interface AutoFillRule {
+    /** Field name on the model (e.g. `'organizationId'`, `'createdBy'`). */
+    field: string;
+    /** Where to read the replacement value from on the sync client. */
+    from: AutoFillSource;
+}
+/** A complete model definition: Zod shape + fields metadata + relations + options */
+export interface ModelDef<Shape extends z.ZodRawShape = z.ZodRawShape, R extends RelationRecord = RelationRecord, C extends ComputedRecord = ComputedRecord> {
+    /** The Zod object schema for this model's fields */
+    readonly schema: z.ZodObject<Shape>;
+    /** The raw shape (for type inference) */
+    readonly shape: Shape;
+    /**
+     * Runtime metadata for each field, keyed by field name.
+     *
+     * Populated automatically from `field.*()` builders. Fields defined
+     * with raw Zod (e.g., `z.string()`) get a fallback metadata entry
+     * with type inferred from Zod's `_def.typeName`.
+     *
+     * Used by the CLI (`npx ablo migrate`), admin panels, and any tooling
+     * that needs to introspect the schema without parsing Zod internals.
+     */
+    readonly fields: Record<string, FieldMeta>;
+    /** Relations to other models */
+    readonly relations: R;
+    /** Load strategy */
+    readonly load: LoadStrategy;
+    /** Max records to bootstrap */
+    readonly bootstrapLimit?: number;
+    /** Sort order for bootstrap */
+    readonly bootstrapOrderBy?: string;
+    /**
+     * The wire type name (`__typename`) for this model. When left unset in
+     * {@link ModelOptions}, it falls back to the schema key when the schema is
+     * assembled. See {@link ModelOptions.typename}.
+     */
+    readonly typename?: string;
+    /** IndexedDB persistence hints. See {@link PersistOptions}. */
+    readonly persist?: PersistOptions;
+    /** The database table this model maps to. See {@link ModelOptions.tableName}. */
+    readonly tableName?: string;
+    /** The canonical tenancy descriptor for this model, normalized from the `policy`
+     *  option at build time. See {@link ModelOptions.policy}. */
+    readonly tenancy: Tenancy;
+    /** Which database this model's rows live in — `tenant` (default) can be a
+     *  customer's own database; `control` is Ablo's. See {@link ModelOptions.plane}. */
+    readonly plane?: ModelResidency;
+    /** Scope-root marker. See {@link ModelOptions.groups}. */
+    readonly scope?: boolean | string;
+    /** Membership edge granting an identity access to a scope root. See {@link ModelOptions.groups}. */
+    readonly grants?: GrantsRef;
+    /** Explicit record-to-group roles, normalized to an array. See {@link ModelOptions.groups}. */
+    readonly entityRoles?: readonly EntityRole[];
+    /** The write-conflict disposition per committer kind, carried as plain data. See
+     *  {@link ModelOptions.conflict}. */
+    readonly conflict?: ConflictAxis;
+    /** Whether wire-level CREATE/UPDATE/DELETE is allowed. See {@link ModelOptions.mutable}. */
+    readonly mutable?: boolean;
+    /** Defer MobX setup until first observer access. See {@link ModelOptions.lazyObservable}. */
+    readonly lazyObservable?: boolean;
+    /** Computed getters for the dynamic model class. See {@link ModelOptions.computed}. */
+    readonly computed?: C;
+    /** Auto-fill rules for IDB self-healing. See {@link ModelOptions.autoFill}. */
+    readonly autoFill?: readonly AutoFillRule[];
+    /** Fields whose absence orphans a row. See {@link ModelOptions.requiredFields}. */
+    readonly requiredFields?: readonly string[];
+}
+/**
+ * Defines a model from a Zod shape and its options. The row type is inferred from
+ * the shape; fields built with the {@link field} builders carry extra metadata,
+ * while plain Zod fields get metadata inferred from their Zod type. Everything else
+ * about the model — its {@link ModelOptions.relations}, its {@link LoadStrategy},
+ * the table it maps to — lives in the second argument, so a model that needs one
+ * setting never has to name the settings it does not use.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { model, relation } from '@abloatai/transaction/schema';
+ *
+ * // Fields alone
+ * const tags = model({ label: z.string() });
+ *
+ * // Loaded at bootstrap (the default), with an edge to its project
+ * const tasks = model({
+ *   title: z.string(),
+ *   status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *   projectId: z.string().optional(),
+ * }, {
+ *   relations: { project: relation.belongsTo('projects', 'projectId') },
+ * });
+ *
+ * // Loaded on first access
+ * const blocks = model({ sectionId: z.string(), type: z.string() }, {
+ *   relations: { section: relation.belongsTo('sections', 'sectionId') },
+ *   load: 'lazy',
+ * });
+ * ```
+ */
+export declare function model<Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, options?: ModelOptions & {
+    relations?: R;
+    computed?: C;
+}): ModelDef<Shape, R, C>;
+/**
+ * Returns the sync-group kind a scope-root model produces, or `undefined` when the
+ * model is not a scope root. `scope: true` derives the kind from the lowercased
+ * typename (`ReportSection` → `reportsection`); `scope: 'section'` sets it explicitly, which
+ * you use when the wire kind must differ from the typename. This is the single place
+ * that decides a record's own group, so every layer that reads it agrees.
+ */
+export declare function scopeKindOf(def: {
+    scope?: boolean | string;
+    typename?: string;
+}, fallbackKey: string): string | undefined;
+//# sourceMappingURL=model.d.ts.map

package/dist/schema/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/schema/model.ts"],"names":[],"mappings":"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"}