@abloatai/ablo 0.34.1 → 0.36.0

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,57 @@ 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) {
+        // Assigned rather than spread, and for the reason the merge form below
+        // assigns too: what carries forward is the dispositions, which are own
+        // enumerable properties. The chaining methods live on the prototype and the
+        // constructor puts them back, so a chain accumulates nothing but data.
+        return new CoordinationAxis(Object.assign({}, 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 +108,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,22 @@
  * ```
  */
 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 { isFieldRef, type FieldRef } from '../transaction/schema/fieldRef.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';

package/dist/schema/index.js

@@ -23,31 +23,31 @@
 // 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';
+export { field, indexed, getFieldMeta } from '../transaction/schema/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 { isFieldRef } from '../transaction/schema/fieldRef.js';
 // Relation builders
-export { relation } from './relation.js';
+export { relation } from '../transaction/schema/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';
+export { tenancySchema, scopedViaRefSchema, policyInputSchema, resolvePolicy, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, } from '../transaction/schema/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, 
-// Deliberate back-compat re-export of the deprecated aliases:
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-planeSchema, 
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-DEFAULT_PLANE, } from './residency.js';
+export { residencySchema, DEFAULT_RESIDENCY, } from '../transaction/schema/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, deltaProvenanceSchema, syncDeltaRowSchema, participantKindSchema, confirmationStateSchema, backfillProvenanceSchema, DELTA_DATA_CLASSIFICATION, DELTA_PHYSICAL_STORAGE, 
-// Deliberate back-compat re-export; physical storage is the precise name.
-// eslint-disable-next-line @typescript-eslint/no-deprecated
-DELTA_RESIDENCY, } from './syncDeltaRow.js';
+export { syncDeltaCoreSchema, deltaAttributionSchema, syncDeltaRowSchema, participantKindSchema, confirmationStateSchema, backfillProvenanceSchema, DELTA_DATA_CLASSIFICATION, DELTA_PHYSICAL_STORAGE, } from './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';
+export { syncDeltaActionSchema, wireDeltaDataSchema, participantRefSchema, syncDeltaWireCoreSchema, clientSyncDeltaSchema, serverSyncDeltaSchema, } from '../transaction/wire/delta.js';
 // Model builder
-export { model, scopeKindOf, } from './model.js';
+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 '../transaction/schema/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';
@@ -56,9 +56,9 @@ export { coordination, humansOverwrite, humansReject, humansNotify, agentsOverwr
 // 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';
+export { defineSchema, composeIdentitySyncGroups, composeEntitySyncGroups, intersectRequestedWithAllowed, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, RESERVED_SESSION_SETTINGS, } from '../transaction/schema/schema.js';
 // Schema ⇄ JSON — serialize a schema for transport and rebuild it on the far side.
-export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, } from './serialize.js';
+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.
@@ -73,4 +73,8 @@ export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlocke
 export { generateTypes } from './generate.js';
 // Query definition DSL + type inference
 export { query, defineQueries, } from './queries.js';
-export { schemaToOpenApi } from './openapi.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 '../transaction/schema/openapi.js';

package/dist/schema/queries.d.ts

@@ -13,27 +13,27 @@
  *   } from '@abloatai/ablo/schema';
  *
  *   const schema = defineSchema({
- *     slideLayer: model(
- *       { slideId: z.string(), type: z.string() },
- *       { slide: relation.belongsTo('slides', 'slideId') },
- *       { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *     block: model(
+ *       { sectionId: z.string(), type: z.string() },
+ *       { section: relation.belongsTo('sections', 'sectionId') },
+ *       { load: 'lazy', typename: 'Block', persist: {} },
  *     ),
  *   });
  *
  *   const queries = defineQueries(schema, {
- *     slideLayersByDeck: query({
- *       input:   z.object({ deckId: z.string() }),
- *       returns: 'slideLayer',   // ← type-checked against schema.models
+ *     blocksByReport: query({
+ *       input:   z.object({ reportId: z.string() }),
+ *       returns: 'block',   // ← type-checked against schema.models
  *     }),
  *   });
  *
- *   type Input  = InferQueryInput<typeof queries.queries.slideLayersByDeck>;
- *   //    ^? { deckId: string }
+ *   type Input  = InferQueryInput<typeof queries.queries.blocksByReport>;
+ *   //    ^? { reportId: string }
  *   type Result = InferQueryResult<
  *     typeof schema,
- *     typeof queries.queries.slideLayersByDeck
+ *     typeof queries.queries.blocksByReport
  *   >;
- *   //    ^? Array<SlideLayer>
+ *   //    ^? Array<Block>
  *
  * Design notes:
  *
@@ -55,7 +55,7 @@
  *    `schema.models[queryDef.returns]` lookup.
  */
 import { z } from 'zod';
-import type { Schema, InferModel, InferModelNames } from './schema.js';
+import type { Schema, InferModel, InferModelNames } from '../transaction/schema/schema.js';
 /**
  * A single query definition: a zod input shape, the schema key of the
  * model it returns, and (after assembly) the name it was registered
@@ -97,15 +97,15 @@ interface QuerySpec<TInput extends z.ZodType, TReturns extends string> {
  * Define a query.
  *
  * `TReturns` is a `const` generic so TypeScript preserves the literal
- * type of the `returns` value at call time (e.g., `'slideLayer'`
+ * type of the `returns` value at call time (e.g., `'block'`
  * instead of widening to `string`). This is what lets `defineQueries`
  * type-check `returns` against the schema's model keys without
  * requiring the consumer to write `as const` manually.
  *
  * ```ts
- * const slideLayersByDeck = query({
- *   input:   z.object({ deckId: z.string() }),
- *   returns: 'slideLayer',
+ * const blocksByReport = query({
+ *   input:   z.object({ reportId: z.string() }),
+ *   returns: 'block',
  * });
  * ```
  */
@@ -133,8 +133,8 @@ export interface Queries<S extends Schema, Q extends QueryRecord<S>> {
  * Infer the input type of a query from its zod schema.
  *
  * ```ts
- * type Input = InferQueryInput<typeof queries.queries.slideLayersByDeck>;
- * // { deckId: string }
+ * type Input = InferQueryInput<typeof queries.queries.blocksByReport>;
+ * // { reportId: string }
  * ```
  */
 export type InferQueryInput<Q extends QueryDef> = z.infer<Q['input']>;
@@ -151,9 +151,9 @@ export type InferQueryInput<Q extends QueryDef> = z.infer<Q['input']>;
  * ```ts
  * type Result = InferQueryResult<
  *   typeof schema,
- *   typeof queries.queries.slideLayersByDeck
+ *   typeof queries.queries.blocksByReport
  * >;
- * // Array<SlideLayer>
+ * // Array<Block>
  * ```
  */
 export type InferQueryResult<S extends Schema, Q extends QueryDef> = Q extends QueryDef<z.ZodType, infer R> ? R extends InferModelNames<S> ? InferModel<S, R>[] : never : never;
@@ -176,23 +176,23 @@ export type InferQueryResult<S extends Schema, Q extends QueryDef> = Q extends Q
  * exist" error deep inside the loader.
  *
  * Each resolved query gets its `name` populated from the record key:
- * `queries.slideLayersByDeck.name === 'slideLayersByDeck'`. Dispatch and
+ * `queries.blocksByReport.name === 'blocksByReport'`. Dispatch and
  * lookup code read `queryDef.name` directly rather than re-deriving it from
  * the surrounding record.
  *
  * ```ts
  * const schema = defineSchema({
- *   slideLayer: model(
- *     { slideId: z.string() },
+ *   block: model(
+ *     { sectionId: z.string() },
  *     {},
- *     { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *     { load: 'lazy', typename: 'Block', persist: {} },
  *   ),
  * });
  *
  * const queries = defineQueries(schema, {
- *   slideLayersByDeck: query({
- *     input:   z.object({ deckId: z.string() }),
- *     returns: 'slideLayer',   // ← type-checked
+ *   blocksByReport: query({
+ *     input:   z.object({ reportId: z.string() }),
+ *     returns: 'block',   // ← type-checked
  *   }),
  * });
  * ```

package/dist/schema/queries.js

@@ -13,27 +13,27 @@
  *   } from '@abloatai/ablo/schema';
  *
  *   const schema = defineSchema({
- *     slideLayer: model(
- *       { slideId: z.string(), type: z.string() },
- *       { slide: relation.belongsTo('slides', 'slideId') },
- *       { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *     block: model(
+ *       { sectionId: z.string(), type: z.string() },
+ *       { section: relation.belongsTo('sections', 'sectionId') },
+ *       { load: 'lazy', typename: 'Block', persist: {} },
  *     ),
  *   });
  *
  *   const queries = defineQueries(schema, {
- *     slideLayersByDeck: query({
- *       input:   z.object({ deckId: z.string() }),
- *       returns: 'slideLayer',   // ← type-checked against schema.models
+ *     blocksByReport: query({
+ *       input:   z.object({ reportId: z.string() }),
+ *       returns: 'block',   // ← type-checked against schema.models
  *     }),
  *   });
  *
- *   type Input  = InferQueryInput<typeof queries.queries.slideLayersByDeck>;
- *   //    ^? { deckId: string }
+ *   type Input  = InferQueryInput<typeof queries.queries.blocksByReport>;
+ *   //    ^? { reportId: string }
  *   type Result = InferQueryResult<
  *     typeof schema,
- *     typeof queries.queries.slideLayersByDeck
+ *     typeof queries.queries.blocksByReport
  *   >;
- *   //    ^? Array<SlideLayer>
+ *   //    ^? Array<Block>
  *
  * Design notes:
  *
@@ -55,21 +55,21 @@
  *    `schema.models[queryDef.returns]` lookup.
  */
 import { z } from 'zod';
-import { AbloValidationError } from '../errors.js';
+import { AbloValidationError } from '../transaction/errors.js';
 // ── query() factory ───────────────────────────────────────────────────────
 /**
  * Define a query.
  *
  * `TReturns` is a `const` generic so TypeScript preserves the literal
- * type of the `returns` value at call time (e.g., `'slideLayer'`
+ * type of the `returns` value at call time (e.g., `'block'`
  * instead of widening to `string`). This is what lets `defineQueries`
  * type-check `returns` against the schema's model keys without
  * requiring the consumer to write `as const` manually.
  *
  * ```ts
- * const slideLayersByDeck = query({
- *   input:   z.object({ deckId: z.string() }),
- *   returns: 'slideLayer',
+ * const blocksByReport = query({
+ *   input:   z.object({ reportId: z.string() }),
+ *   returns: 'block',
  * });
  * ```
  */
@@ -99,23 +99,23 @@ export function query(spec) {
  * exist" error deep inside the loader.
  *
  * Each resolved query gets its `name` populated from the record key:
- * `queries.slideLayersByDeck.name === 'slideLayersByDeck'`. Dispatch and
+ * `queries.blocksByReport.name === 'blocksByReport'`. Dispatch and
  * lookup code read `queryDef.name` directly rather than re-deriving it from
  * the surrounding record.
  *
  * ```ts
  * const schema = defineSchema({
- *   slideLayer: model(
- *     { slideId: z.string() },
+ *   block: model(
+ *     { sectionId: z.string() },
  *     {},
- *     { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *     { load: 'lazy', typename: 'Block', persist: {} },
  *   ),
  * });
  *
  * const queries = defineQueries(schema, {
- *   slideLayersByDeck: query({
- *     input:   z.object({ deckId: z.string() }),
- *     returns: 'slideLayer',   // ← type-checked
+ *   blocksByReport: query({
+ *     input:   z.object({ reportId: z.string() }),
+ *     returns: 'block',   // ← type-checked
  *   }),
  * });
  * ```

package/dist/schema/select.d.ts

@@ -12,8 +12,8 @@
  * import { schema as full } from './schema';
  * import { selectModels } from '@abloatai/ablo/schema';
  *
- * // Subscribe to identity and dataroom content only.
- * export const schema = selectModels(full, ['users', 'organizations', 'datarooms', 'folders', 'files']);
+ * // Subscribe to identity and document content only.
+ * export const schema = selectModels(full, ['users', 'organizations', 'workspaces', 'folders', 'files']);
  * ```
  *
  * Relations whose target falls outside the selected set are dropped, so the
@@ -21,7 +21,7 @@
  * scope-inheritance throws instead, because silently losing it would mis-route
  * a record's fan-out — the selected set must be closed under `parent` edges.
  */
-import type { Schema, SchemaRecord } from './schema.js';
+import type { Schema, SchemaRecord } from '../transaction/schema/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

package/dist/schema/select.js

@@ -12,8 +12,8 @@
  * import { schema as full } from './schema';
  * import { selectModels } from '@abloatai/ablo/schema';
  *
- * // Subscribe to identity and dataroom content only.
- * export const schema = selectModels(full, ['users', 'organizations', 'datarooms', 'folders', 'files']);
+ * // Subscribe to identity and document content only.
+ * export const schema = selectModels(full, ['users', 'organizations', 'workspaces', 'folders', 'files']);
  * ```
  *
  * Relations whose target falls outside the selected set are dropped, so the
@@ -21,7 +21,8 @@
  * scope-inheritance throws instead, because silently losing it would mis-route
  * a record's fan-out — the selected set must be closed under `parent` edges.
  */
-import { AbloValidationError } from '../errors.js';
+import { buildFieldRefs } from '../transaction/schema/schema.js';
+import { AbloValidationError } from '../transaction/errors.js';
 import { schemaHash } from './serialize.js';
 export function selectModels(schema, keys) {
     const keep = new Set(keys);
@@ -50,6 +51,8 @@ export function selectModels(schema, keys) {
     }
     return {
         models: models,
+        // References for exactly the models this projection kept.
+        fields: buildFieldRefs(models),
         validators: validators,
         identityRoles: schema.identityRoles,
         sessionSettings: schema.sessionSettings,