@abloatai/ablo 0.36.0 → 0.37.1

package/dist/schema/index.js

@@ -1,80 +0,0 @@
-/**
- * @abloatai/ablo/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/ablo/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 '../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 '../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 '../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, } 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, 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 '../transaction/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 '../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';
-// 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 '../transaction/schema/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 '../transaction/schema/openapi.js';

package/dist/schema/queries.d.ts

@@ -1,201 +0,0 @@
-/**
- * Query definitions for a schema.
- *
- * A query pairs a Zod input schema with the name of the model it returns.
- * Input types flow through `z.infer` and result types through `InferModel`,
- * the same inference path `model` and `relation` use, so there is no separate
- * type system to learn.
- *
- * Usage:
- *   import { z } from 'zod';
- *   import {
- *     defineSchema, defineQueries, model, query, relation,
- *   } from '@abloatai/ablo/schema';
- *
- *   const schema = defineSchema({
- *     block: model(
- *       { sectionId: z.string(), type: z.string() },
- *       { section: relation.belongsTo('sections', 'sectionId') },
- *       { load: 'lazy', typename: 'Block', persist: {} },
- *     ),
- *   });
- *
- *   const queries = defineQueries(schema, {
- *     blocksByReport: query({
- *       input:   z.object({ reportId: z.string() }),
- *       returns: 'block',   // ← type-checked against schema.models
- *     }),
- *   });
- *
- *   type Input  = InferQueryInput<typeof queries.queries.blocksByReport>;
- *   //    ^? { reportId: string }
- *   type Result = InferQueryResult<
- *     typeof schema,
- *     typeof queries.queries.blocksByReport
- *   >;
- *   //    ^? Array<Block>
- *
- * Design notes:
- *
- *  - `query()` accepts any string for `returns`. The check that the string
- *    names a real model runs when the query passes through
- *    `defineQueries(schema, ...)`, the same way
- *    `relation.belongsTo('projects', 'projectId')` takes a plain string at
- *    the factory and defers the cross-reference check to schema assembly.
- *
- *  - A query carries no `name` until `defineQueries()` assigns one from its
- *    record key — the same pattern `defineSchema({ tasks: model(...) })`
- *    uses, where the model's name is the record key rather than a field on
- *    the factory.
- *
- *  - Every query returns an array of a single model type. To fetch several
- *    model types at once, run several queries in one batch rather than
- *    declaring a combined shape. Each `QueryDef` therefore points at exactly
- *    one model, and the loader hydrates results through a single
- *    `schema.models[queryDef.returns]` lookup.
- */
-import { z } from 'zod';
-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
- * under.
- *
- * `name` is filled in by `defineQueries()` from the record key. It is
- * optional on the type so `query()` can return a value without one —
- * downstream code should only read `name` after the query has been
- * passed through `defineQueries()`.
- */
-export interface QueryDef<TInput extends z.ZodType = z.ZodType, TReturns extends string = string> {
-    /** Zod schema for the query's input arguments. */
-    readonly input: TInput;
-    /**
-     * The schema key of the model this query returns. Narrowed by
-     * `defineQueries()` to `InferModelNames<S>` via the `Q` generic, so
-     * a query whose `returns` does not match a known model fails at
-     * compile time.
-     */
-    readonly returns: TReturns;
-    /**
-     * The name under which the query is registered. {@link defineQueries}
-     * fills this in from the record key; you do not set it directly. It lives
-     * on the definition itself so dispatch and lookup code can read the name
-     * straight off a {@link QueryDef} without carrying the surrounding
-     * {@link Queries} object.
-     */
-    readonly name?: string;
-}
-/**
- * The raw spec accepted by `query()`. Internal type — consumers never
- * reference this directly, they call `query({ input, returns })`.
- */
-interface QuerySpec<TInput extends z.ZodType, TReturns extends string> {
-    readonly input: TInput;
-    readonly returns: TReturns;
-}
-/**
- * Define a query.
- *
- * `TReturns` is a `const` generic so TypeScript preserves the literal
- * 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 blocksByReport = query({
- *   input:   z.object({ reportId: z.string() }),
- *   returns: 'block',
- * });
- * ```
- */
-export declare function query<TInput extends z.ZodType, const TReturns extends string>(spec: QuerySpec<TInput, TReturns>): QueryDef<TInput, TReturns>;
-/**
- * A record of query names → query definitions, parameterized by a
- * schema so each query's `returns` must reference a known model.
- *
- * This is the constraint type used by `defineQueries()` — it's what
- * turns "any string" into "a model in this schema" without touching
- * the `query()` factory itself.
- */
-export type QueryRecord<S extends Schema> = Record<string, QueryDef<z.ZodType, InferModelNames<S>>>;
-/**
- * The object returned by `defineQueries()`. Holds a reference back to
- * the schema (so the loader can resolve `queryDef.returns` to
- * a `ModelDef` at runtime via `schema.models[def.returns]`) and the
- * resolved record of queries, each with its `name` field filled in.
- */
-export interface Queries<S extends Schema, Q extends QueryRecord<S>> {
-    readonly schema: S;
-    readonly queries: Q;
-}
-/**
- * Infer the input type of a query from its zod schema.
- *
- * ```ts
- * type Input = InferQueryInput<typeof queries.queries.blocksByReport>;
- * // { reportId: string }
- * ```
- */
-export type InferQueryInput<Q extends QueryDef> = z.infer<Q['input']>;
-/**
- * Infer the result type of a query by looking up its `returns` model
- * in the schema.
- *
- * Returns `Array<InferModel<S, returns>>` — all queries return a
- * collection at this layer. Single-entity fetches use
- * `ids: [singleId]` and the caller picks `result[0]`; this avoids a
- * second `scope: 'single'` shape in the DSL for a case that can be
- * expressed with the collection form.
- *
- * ```ts
- * type Result = InferQueryResult<
- *   typeof schema,
- *   typeof queries.queries.blocksByReport
- * >;
- * // 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;
-/**
- * Define a typed query set against a schema.
- *
- * Each entry's `returns` field is constrained to the schema's model
- * names at compile time via the `Q` generic bound to `QueryRecord<S>`.
- * A query whose `returns` does not match a known model will fail at
- * the `defineQueries` call site with a TypeScript error, not at
- * runtime.
- *
- * The factory also performs a runtime validation of the same
- * invariant. This catches the edge case where the schema and the
- * queries live in separate modules that drift out of sync — for
- * example, when a developer removes a model from the schema without
- * updating the queries that referenced it. The runtime error points
- * at the specific offending query and lists the available models,
- * which is a nicer failure mode than a generic "property does not
- * exist" error deep inside the loader.
- *
- * Each resolved query gets its `name` populated from the record key:
- * `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({
- *   block: model(
- *     { sectionId: z.string() },
- *     {},
- *     { load: 'lazy', typename: 'Block', persist: {} },
- *   ),
- * });
- *
- * const queries = defineQueries(schema, {
- *   blocksByReport: query({
- *     input:   z.object({ reportId: z.string() }),
- *     returns: 'block',   // ← type-checked
- *   }),
- * });
- * ```
- */
-export declare function defineQueries<S extends Schema, const Q extends QueryRecord<S>>(schema: S, queries: Q): Queries<S, Q>;
-export {};

package/dist/schema/queries.js

@@ -1,144 +0,0 @@
-/**
- * Query definitions for a schema.
- *
- * A query pairs a Zod input schema with the name of the model it returns.
- * Input types flow through `z.infer` and result types through `InferModel`,
- * the same inference path `model` and `relation` use, so there is no separate
- * type system to learn.
- *
- * Usage:
- *   import { z } from 'zod';
- *   import {
- *     defineSchema, defineQueries, model, query, relation,
- *   } from '@abloatai/ablo/schema';
- *
- *   const schema = defineSchema({
- *     block: model(
- *       { sectionId: z.string(), type: z.string() },
- *       { section: relation.belongsTo('sections', 'sectionId') },
- *       { load: 'lazy', typename: 'Block', persist: {} },
- *     ),
- *   });
- *
- *   const queries = defineQueries(schema, {
- *     blocksByReport: query({
- *       input:   z.object({ reportId: z.string() }),
- *       returns: 'block',   // ← type-checked against schema.models
- *     }),
- *   });
- *
- *   type Input  = InferQueryInput<typeof queries.queries.blocksByReport>;
- *   //    ^? { reportId: string }
- *   type Result = InferQueryResult<
- *     typeof schema,
- *     typeof queries.queries.blocksByReport
- *   >;
- *   //    ^? Array<Block>
- *
- * Design notes:
- *
- *  - `query()` accepts any string for `returns`. The check that the string
- *    names a real model runs when the query passes through
- *    `defineQueries(schema, ...)`, the same way
- *    `relation.belongsTo('projects', 'projectId')` takes a plain string at
- *    the factory and defers the cross-reference check to schema assembly.
- *
- *  - A query carries no `name` until `defineQueries()` assigns one from its
- *    record key — the same pattern `defineSchema({ tasks: model(...) })`
- *    uses, where the model's name is the record key rather than a field on
- *    the factory.
- *
- *  - Every query returns an array of a single model type. To fetch several
- *    model types at once, run several queries in one batch rather than
- *    declaring a combined shape. Each `QueryDef` therefore points at exactly
- *    one model, and the loader hydrates results through a single
- *    `schema.models[queryDef.returns]` lookup.
- */
-import { z } from 'zod';
-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., `'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 blocksByReport = query({
- *   input:   z.object({ reportId: z.string() }),
- *   returns: 'block',
- * });
- * ```
- */
-export function query(spec) {
-    return {
-        input: spec.input,
-        returns: spec.returns,
-    };
-}
-// ── defineQueries() factory ───────────────────────────────────────────────
-/**
- * Define a typed query set against a schema.
- *
- * Each entry's `returns` field is constrained to the schema's model
- * names at compile time via the `Q` generic bound to `QueryRecord<S>`.
- * A query whose `returns` does not match a known model will fail at
- * the `defineQueries` call site with a TypeScript error, not at
- * runtime.
- *
- * The factory also performs a runtime validation of the same
- * invariant. This catches the edge case where the schema and the
- * queries live in separate modules that drift out of sync — for
- * example, when a developer removes a model from the schema without
- * updating the queries that referenced it. The runtime error points
- * at the specific offending query and lists the available models,
- * which is a nicer failure mode than a generic "property does not
- * exist" error deep inside the loader.
- *
- * Each resolved query gets its `name` populated from the record key:
- * `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({
- *   block: model(
- *     { sectionId: z.string() },
- *     {},
- *     { load: 'lazy', typename: 'Block', persist: {} },
- *   ),
- * });
- *
- * const queries = defineQueries(schema, {
- *   blocksByReport: query({
- *     input:   z.object({ reportId: z.string() }),
- *     returns: 'block',   // ← type-checked
- *   }),
- * });
- * ```
- */
-export function defineQueries(schema, queries) {
-    // Rebuild the queries record with `name` populated per entry. Same
-    // shallow-spread strategy `defineSchema` uses for `typename` / `persist`
-    // defaults — preserves input references, avoids mutating `readonly`
-    // fields in place, and keeps each resolved `QueryDef` immutable from
-    // construction onward.
-    const resolvedQueries = {};
-    for (const [name, def] of Object.entries(queries)) {
-        if (!(def.returns in schema.models)) {
-            throw new AbloValidationError(`defineQueries: query "${name}" declares returns: "${def.returns}", ` +
-                `which is not a model in the schema. ` +
-                `Available models: ${Object.keys(schema.models).join(', ') || '(none)'}`, { code: 'query_returns_unknown_model' });
-        }
-        resolvedQueries[name] = { ...def, name };
-    }
-    return {
-        schema,
-        // Cast back to Q: the rebuild only added `name` (already optional on
-        // QueryDef) to each entry, so the shape is structurally unchanged.
-        queries: resolvedQueries,
-    };
-}

package/dist/schema/select.d.ts

@@ -1,40 +0,0 @@
-/**
- * `selectModels` projects a schema down to a subset of its models.
- *
- * It lets one canonical schema serve several apps, each subscribing only to the
- * models it needs. Rather than re-declare a model's fields in a second schema —
- * which you would then have to keep identical by hand — an app selects the
- * models it wants from the canonical schema. Field shapes, resolved foreign-key
- * columns, computed getters, typenames, and identity roles all come from the
- * source, so a subset cannot drift from the canonical definition.
- *
- * ```ts
- * import { schema as full } from './schema';
- * import { selectModels } from '@abloatai/ablo/schema';
- *
- * // 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
- * subset sees only its own models. Dropping a relation that carries `parent`
- * 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 '../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
- * the named ones. Use it when an app is the general case and a separate app
- * owns the omitted models — the suite shell drops a specialized store that the
- * standalone app selects for itself:
- *
- * ```ts
- * export const schema = omitModels(full, ['reports', 'reportSections']);
- * ```
- *
- * 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

@@ -1,90 +0,0 @@
-/**
- * `selectModels` projects a schema down to a subset of its models.
- *
- * It lets one canonical schema serve several apps, each subscribing only to the
- * models it needs. Rather than re-declare a model's fields in a second schema —
- * which you would then have to keep identical by hand — an app selects the
- * models it wants from the canonical schema. Field shapes, resolved foreign-key
- * columns, computed getters, typenames, and identity roles all come from the
- * source, so a subset cannot drift from the canonical definition.
- *
- * ```ts
- * import { schema as full } from './schema';
- * import { selectModels } from '@abloatai/ablo/schema';
- *
- * // 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
- * subset sees only its own models. Dropping a relation that carries `parent`
- * 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 { 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);
-    const models = {};
-    const validators = {};
-    for (const key of keys) {
-        const def = schema.models[key];
-        if (!def) {
-            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.
-        const relations = {};
-        for (const [relName, rel] of Object.entries(def.relations)) {
-            if (keep.has(rel.target)) {
-                relations[relName] = rel;
-                continue;
-            }
-            if (rel.options?.parent) {
-                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 };
-        validators[key] = schema.validators[key];
-    }
-    return {
-        models: models,
-        // References for exactly the models this projection kept.
-        fields: buildFieldRefs(models),
-        validators: validators,
-        identityRoles: schema.identityRoles,
-        sessionSettings: schema.sessionSettings,
-        // Record the full source's hash so the drift check can recognize this subset
-        // as current against a server running that full schema. Prefer the source's
-        // OWN `sourceSchemaHash` when it is itself a projection, so a subset-of-a-
-        // subset still points at the original full schema rather than an intermediate
-        // one. `schemaHash` ignores this field, so re-projecting stays deterministic.
-        sourceSchemaHash: schema.sourceSchemaHash ?? schemaHash(schema),
-    };
-}
-/**
- * `omitModels` is `selectModels` from the other side: keep every model EXCEPT
- * the named ones. Use it when an app is the general case and a separate app
- * owns the omitted models — the suite shell drops a specialized store that the
- * standalone app selects for itself:
- *
- * ```ts
- * export const schema = omitModels(full, ['reports', 'reportSections']);
- * ```
- *
- * 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/schema/serialize.d.ts

@@ -1,115 +0,0 @@
-/**
- * Schema ⇄ JSON.
- *
- * A `Schema` is fully serializable apart from its client-only closures — the
- * Zod validators and computed getters. {@link serializeSchema} emits the
- * plain-data JSON form and {@link parseSchema} reconstructs a working `Schema`
- * from it: one `Schema` type with two representations.
- *
- * A hosted, multi-tenant server loads a tenant's schema with `parseSchema(json)`
- * rather than importing it in process. The JSON is what `ablo push` sends and
- * what the server stores per tenant and version.
- *
- * What round-trips:
- *   - all model routing and scoping metadata: typename, tableName, load,
- *     mutable, the `tenancy` descriptor, bootstrap hints, scope, grants,
- *     entityRoles, the `conflict` disposition map, persist, autoFill,
- *     requiredFields, and lazyObservable. The authoring shorthands (`policy`
- *     and `groups`) are normalized into these canonical fields when the model
- *     is built, so only the canonical fields cross here.
- *   - relations, including the resolved `foreignKeyColumn`
- *   - field metadata (names and type tags), from which validators are rebuilt
- *   - identity roles
- *
- * What does not round-trip, because the server never needs it:
- *   - computed getters, which are closures and are dropped
- *   - exact Zod refinements, which are rebuilt as permissive validators from
- *     {@link FieldMeta}; the server does no field-shape validation
- */
-import type { FieldMeta } from '../transaction/schema/field.js';
-import type { Tenancy } from '../transaction/schema/tenancy.js';
-import type { ModelResidency } from '../transaction/schema/residency.js';
-import type { GrantsRef, LoadStrategy, PersistOptions, AutoFillRule, ConflictAxis } from '../transaction/schema/model.js';
-import type { RelationType } from '../transaction/schema/relation.js';
-import { type Schema, type IdentityRole, type EntityRole, type SessionSettings } from '../transaction/schema/schema.js';
-/** Current schema-JSON envelope version. Bump this on a breaking change to the
- * JSON shape itself — not to a user's schema. */
-declare const SCHEMA_JSON_VERSION: 3;
-/** A relation in JSON form. Mirrors the serializable members of {@link RelationDef}. */
-export interface RelationJSON {
-    readonly type: RelationType;
-    readonly target: string;
-    readonly foreignKey: string;
-    readonly foreignKeyColumn: string;
-    readonly options?: Record<string, boolean>;
-    readonly orderBy?: string;
-}
-/** A model in JSON form. Everything on {@link ModelDef} except closures. */
-export interface ModelJSON {
-    readonly fields: Record<string, FieldMeta>;
-    readonly relations: Record<string, RelationJSON>;
-    readonly load: LoadStrategy;
-    readonly typename: string;
-    readonly tableName?: string;
-    readonly tenancy: Tenancy;
-    /** The database plane the model's rows live in. Optional for backward
-     *  compatibility: when absent (an artifact written before this field existed)
-     *  it reads as `tenant`, the default. See {@link ModelResidency}. */
-    readonly plane?: ModelResidency;
-    readonly scope?: boolean | string;
-    readonly grants?: GrantsRef;
-    readonly entityRoles?: readonly EntityRole[];
-    /** The declared write-conflict disposition per committer kind. When absent,
-     *  the engine falls back to its default. */
-    readonly conflict?: ConflictAxis;
-    readonly bootstrapLimit?: number;
-    readonly bootstrapOrderBy?: string;
-    readonly mutable?: boolean;
-    readonly lazyObservable?: boolean;
-    readonly persist?: PersistOptions;
-    readonly autoFill?: readonly AutoFillRule[];
-    readonly requiredFields?: readonly string[];
-}
-/** The JSON form of a {@link Schema}. The `ablo push` payload. */
-export interface SchemaJSON {
-    readonly v: typeof SCHEMA_JSON_VERSION;
-    readonly models: Record<string, ModelJSON>;
-    readonly identityRoles: readonly IdentityRole[];
-    /** Optional so schemas pushed before ADR 0011 still parse (defaults to `{}`). */
-    readonly sessionSettings?: SessionSettings;
-}
-/**
- * Project a `Schema` to its JSON form. Drops the client-only closures
- * (validators, `computed`); keeps everything the server and a faithful
- * rebuild need. The result is plain data — `JSON.stringify`-safe.
- */
-export declare function toSchemaJSON(schema: Schema): SchemaJSON;
-/** Serialize a `Schema` to a JSON string (the `ablo push` payload). */
-export declare function serializeSchema(schema: Schema): string;
-/**
- * Reconstruct a working `Schema` from its JSON form. Validators are rebuilt
- * permissively from field metadata (the server never validates field shapes);
- * `computed` getters are absent. Everything the server reads — routing,
- * scoping, relations, identity roles — is restored exactly.
- */
-export declare function fromSchemaJSON(json: SchemaJSON): Schema;
-/** Parse a `Schema` from a JSON string (inverse of {@link serializeSchema}). */
-export declare function parseSchema(json: string): Schema;
-/**
- * Stable content hash of a `Schema`'s JSON form. FNV-1a over a canonical
- * (sorted-key) encoding — deterministic across runs and order-invariant, no
- * `crypto` dependency. Used for connect-time version gating: the client sends
- * the hash it was built against, the server compares it to the tenant's
- * active schema hash. Not a security primitive.
- */
-export declare function schemaHash(schema: Schema): string;
-/**
- * Content hash of ONE serialized model — the unit of the semantic drift check.
- * Two schemas agree on a model exactly when these match, which is what lets a
- * client compare only the models it declares instead of welding itself to the
- * whole-schema hash (where any additive push reads as drift). Computed over the
- * model's `SchemaJSON` entry with the same canonicalization and hash as
- * {@link schemaHash}, on both the client and the server's `GET /api/schema`.
- */
-export declare function modelHash(modelJson: unknown): string;
-export {};