@abloatai/ablo 0.5.1 → 0.7.0

package/dist/schema/diff.js

@@ -0,0 +1,280 @@
+/**
+ * Schema diff + migration planning — the pure core of the managed-migration loop.
+ *
+ * Given two serialized schemas (the active one and the one being pushed), produce
+ * an ordered list of {@link MigrationStep}s describing how to evolve the database,
+ * and a {@link MigrationClassification} splitting the risky parts into *warnings*
+ * (execute but may lose/risk data) and *unexecutable* steps (fail on a non-empty
+ * table without a backfill/default). SQL emission and execution live elsewhere
+ * (server-side, where the type map + RLS live); this module is intentionally pure
+ * and DB-free so it is exhaustively unit-testable and reusable by the CLI.
+ *
+ * Design borrowed from mature tools:
+ *  - **Drizzle Kit**: keep the differ pure and inject RENAME decisions as data
+ *    (the {@link RenameHints} resolver seam) rather than guessing — the same
+ *    engine is then headless-testable and drivable by an interactive prompt.
+ *  - **Prisma migration engine**: a two-tier destructive classification
+ *    (warning vs unexecutable) and a type-change sub-tier
+ *    (safe / risky / not-castable) that decides in-place `ALTER TYPE` vs a
+ *    lossy drop-and-recreate.
+ *  - **Atlas**: a single `alter_field` step carrying *which* facets changed
+ *    (type / nullability / enum / index) instead of N discrete alter steps.
+ *
+ * Step ordering is the expand→contract sequence (add before drop, widen before
+ * narrow): create models → rename → add columns (always nullable) → alter →
+ * drop columns → drop models. NOT NULL is never set on add — it is an
+ * `alter_field` nullability change that a backfill must precede.
+ */
+// ── Cast safety matrix ────────────────────────────────────────────────────────
+// Keyed `${from}->${to}` over the 6 sync field types. Targets that map to TEXT
+// (`string`) accept any scalar losslessly; tightening into an `enum` adds a CHECK
+// that existing rows may violate (risky); narrowing into number/bool/date/json
+// is risky (USING cast can fail per-row) or impossible (notCastable).
+const CAST = {
+    // → string (TEXT): always safe
+    'number->string': 'safe', 'boolean->string': 'safe', 'date->string': 'safe',
+    'enum->string': 'safe', 'json->string': 'safe',
+    // → enum (TEXT + CHECK): constraint over existing data is risky
+    'string->enum': 'risky', 'number->enum': 'risky', 'boolean->enum': 'risky',
+    'date->enum': 'risky', 'json->enum': 'notCastable',
+    // → number (DOUBLE PRECISION)
+    'string->number': 'risky', 'enum->number': 'risky', 'boolean->number': 'notCastable',
+    'date->number': 'notCastable', 'json->number': 'notCastable',
+    // → boolean
+    'string->boolean': 'risky', 'enum->boolean': 'risky', 'number->boolean': 'risky',
+    'date->boolean': 'notCastable', 'json->boolean': 'notCastable',
+    // → date (TIMESTAMPTZ)
+    'string->date': 'risky', 'enum->date': 'risky', 'number->date': 'notCastable',
+    'boolean->date': 'notCastable', 'json->date': 'notCastable',
+    // → json (JSONB)
+    'string->json': 'risky', 'enum->json': 'risky', 'number->json': 'notCastable',
+    'boolean->json': 'notCastable', 'date->json': 'notCastable',
+};
+export function classifyCast(from, to) {
+    if (from === to)
+        return 'safe';
+    return CAST[`${from}->${to}`] ?? 'notCastable';
+}
+// ── Diff ──────────────────────────────────────────────────────────────────────
+function diffEnumValues(from, to) {
+    const a = new Set(from ?? []);
+    const b = new Set(to ?? []);
+    const added = [...b].filter((v) => !a.has(v));
+    const removed = [...a].filter((v) => !b.has(v));
+    if (added.length === 0 && removed.length === 0)
+        return undefined;
+    return { added, removed };
+}
+function camelToSnake(identifier) {
+    return identifier.replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`);
+}
+function columnNameOf(fieldName, meta) {
+    return meta.column ?? camelToSnake(fieldName);
+}
+function diffField(prevFieldName, nextFieldName, prev, next) {
+    const changes = {};
+    const prevColumn = columnNameOf(prevFieldName, prev);
+    const nextColumn = columnNameOf(nextFieldName, next);
+    if (prevColumn !== nextColumn) {
+        changes.column = { from: prevColumn, to: nextColumn };
+    }
+    if (prev.type !== next.type) {
+        changes.type = { from: prev.type, to: next.type, cast: classifyCast(prev.type, next.type) };
+    }
+    if (prev.isOptional !== next.isOptional) {
+        changes.nullability = { fromOptional: prev.isOptional, toOptional: next.isOptional };
+    }
+    // Enum value drift only matters while the field is (still) an enum; a type
+    // change away from enum is already captured by `type`.
+    if (prev.type === 'enum' && next.type === 'enum') {
+        const ev = diffEnumValues(prev.enumValues, next.enumValues);
+        if (ev)
+            changes.enumValues = ev;
+    }
+    if (prev.isIndexed !== next.isIndexed) {
+        changes.indexed = { from: prev.isIndexed, to: next.isIndexed };
+    }
+    return Object.keys(changes).length === 0 ? null : changes;
+}
+function tableNameOf(model, key) {
+    return model.tableName ?? key;
+}
+function diffModelFields(model, prev, next, fieldRenames) {
+    const steps = [];
+    const renameByNewName = new Map(fieldRenames.map((r) => [r.to, r.from]));
+    const renamedFromNames = new Set(fieldRenames.map((r) => r.from));
+    // Renames first (so subsequent alter steps reference the new name).
+    for (const { from, to } of fieldRenames) {
+        if (from in prev.fields && to in next.fields) {
+            steps.push({ kind: 'rename_field', model, from, to });
+        }
+    }
+    // Added (present in next, not in prev, and not the target of a rename).
+    for (const [name, meta] of Object.entries(next.fields)) {
+        if (name in prev.fields)
+            continue;
+        if (renameByNewName.has(name))
+            continue;
+        steps.push({ kind: 'add_field', model, field: name, meta });
+    }
+    // Altered: every field present in both (directly or via rename).
+    for (const [name, nextMeta] of Object.entries(next.fields)) {
+        const prevName = renameByNewName.get(name) ?? name;
+        const prevMeta = prev.fields[prevName];
+        if (!prevMeta)
+            continue;
+        const changes = diffField(prevName, name, prevMeta, nextMeta);
+        if (changes?.column && renameByNewName.has(name)) {
+            // A hinted logical field rename already emits `rename_field`, whose
+            // lowering renames the physical column when needed. Do not emit a
+            // second `alter_field.column` for the same transition.
+            delete changes.column;
+        }
+        if (changes && Object.keys(changes).length > 0) {
+            steps.push({ kind: 'alter_field', model, field: name, changes });
+        }
+    }
+    // Dropped (present in prev, not in next, and not renamed away).
+    for (const name of Object.keys(prev.fields)) {
+        if (name in next.fields)
+            continue;
+        if (renamedFromNames.has(name))
+            continue;
+        steps.push({ kind: 'drop_field', model, field: name });
+    }
+    return steps;
+}
+/**
+ * Diff two serialized schemas into an ordered, expand→contract migration plan.
+ * `prev` is the active schema (`null` for a first push → all creates). Rename
+ * decisions are supplied via {@link RenameHints}; anything not hinted reads as
+ * drop+add.
+ */
+export function diffSchema(prev, next, hints = {}) {
+    if (!prev) {
+        // First push: every model is created, with its fields carried in the
+        // create (no per-field add steps — the table is born with them).
+        return Object.entries(next.models).map(([model, def]) => ({
+            kind: 'create_model',
+            model,
+            tableName: tableNameOf(def, model),
+        }));
+    }
+    const modelRenames = hints.models ?? [];
+    const renameByNewModel = new Map(modelRenames.map((r) => [r.to, r.from]));
+    const renamedFromModels = new Set(modelRenames.map((r) => r.from));
+    const fieldHints = hints.fields ?? [];
+    const creates = [];
+    const renames = [];
+    const fieldSteps = [];
+    const drops = [];
+    // New + renamed models, and per-model field diffs.
+    for (const [model, nextDef] of Object.entries(next.models)) {
+        const prevModelKey = renameByNewModel.get(model) ?? model;
+        const prevDef = prev.models[prevModelKey];
+        if (!prevDef) {
+            creates.push({ kind: 'create_model', model, tableName: tableNameOf(nextDef, model) });
+            continue;
+        }
+        if (renameByNewModel.has(model)) {
+            renames.push({ kind: 'rename_model', from: prevModelKey, to: model });
+        }
+        const myFieldRenames = fieldHints
+            .filter((f) => f.model === model)
+            .map((f) => ({ from: f.from, to: f.to }));
+        fieldSteps.push(...diffModelFields(model, prevDef, nextDef, myFieldRenames));
+    }
+    // Dropped models (in prev, not in next, not renamed away).
+    for (const [model, prevDef] of Object.entries(prev.models)) {
+        if (model in next.models)
+            continue;
+        if (renamedFromModels.has(model))
+            continue;
+        drops.push({ kind: 'drop_model', model, tableName: tableNameOf(prevDef, model) });
+    }
+    // Expand → contract ordering. Within fieldSteps the per-model helper already
+    // emits rename → add → alter → drop_field, which preserves the same invariant.
+    return [...creates, ...renames, ...fieldSteps, ...drops];
+}
+/**
+ * Classify a plan's steps into Prisma-style warnings vs unexecutable. The IR
+ * carries no per-field default, so a non-optional `add_field` is conservatively
+ * unexecutable (a backfill or default resolves it) — we cannot prove a default
+ * exists. Classification is rule-based (schema-derived); the runtime layer can
+ * downgrade a signal to a no-op when the target table is empty.
+ */
+export function classifyMigration(steps) {
+    const warnings = [];
+    const unexecutable = [];
+    for (const step of steps) {
+        switch (step.kind) {
+            case 'drop_model':
+                warnings.push({ code: 'drop_model', model: step.model, detail: `drops table for "${step.model}" (data loss)` });
+                break;
+            case 'drop_field':
+                warnings.push({ code: 'drop_field', model: step.model, field: step.field, detail: `drops column "${step.field}" (data loss)` });
+                break;
+            case 'add_field':
+                if (!step.meta.isOptional) {
+                    unexecutable.push({
+                        code: 'required_field_added',
+                        model: step.model,
+                        field: step.field,
+                        detail: `adds required column "${step.field}" — needs a default or backfill on a non-empty table`,
+                    });
+                }
+                break;
+            case 'alter_field': {
+                const { changes } = step;
+                if (changes.nullability && changes.nullability.fromOptional && !changes.nullability.toOptional) {
+                    unexecutable.push({
+                        code: 'made_required',
+                        model: step.model,
+                        field: step.field,
+                        detail: `makes "${step.field}" required — fails if existing rows are NULL`,
+                    });
+                }
+                if (changes.type) {
+                    if (changes.type.cast === 'risky') {
+                        warnings.push({ code: 'risky_cast', model: step.model, field: step.field, detail: `${changes.type.from} → ${changes.type.to} may fail per-row` });
+                    }
+                    else if (changes.type.cast === 'notCastable') {
+                        warnings.push({ code: 'lossy_recreate', model: step.model, field: step.field, detail: `${changes.type.from} → ${changes.type.to} requires drop-and-recreate (data loss)` });
+                    }
+                }
+                if (changes.enumValues && changes.enumValues.removed.length > 0) {
+                    warnings.push({
+                        code: 'enum_value_removed',
+                        model: step.model,
+                        field: step.field,
+                        detail: `removes enum value(s) ${changes.enumValues.removed.join(', ')} — rows using them violate the new CHECK`,
+                    });
+                }
+                break;
+            }
+            // create_model, rename_model, rename_field, add optional field: non-destructive.
+            default:
+                break;
+        }
+    }
+    return { warnings, unexecutable };
+}
+/** Convenience: a plan is safe to auto-apply iff it has no unexecutable steps. */
+export function isAutoApplicable(classification) {
+    return classification.unexecutable.length === 0;
+}
+/**
+ * Does a provided backfill resolve this blocker? Only the two row-dependent
+ * blockers (`required_field_added`, `made_required`) are backfill-resolvable; a
+ * data-loss *warning* is not — that always needs `force`.
+ */
+export function isBlockerResolved(signal, backfills) {
+    if (signal.code !== 'required_field_added' && signal.code !== 'made_required')
+        return false;
+    return backfills.some((b) => b.model === signal.model && b.field === signal.field);
+}
+/** The unexecutable signals NOT covered by a supplied backfill. Empty → the push
+ *  can proceed (modulo the separate `warnings`/`force` gate). */
+export function unresolvedBlockers(classification, backfills) {
+    return classification.unexecutable.filter((s) => !isBlockerResolved(s, backfills));
+}

package/dist/schema/field.d.ts

@@ -31,6 +31,11 @@ export interface FieldMeta {
     isOptional: boolean;
     /** Whether the field was marked indexed via `.indexed()`. */
     isIndexed: boolean;
+    /**
+     * Physical database column name override. When absent, SQL layers derive
+     * the column from the field name using the active casing convention.
+     */
+    column?: string;
     /** For enums: the allowed values. */
     enumValues?: readonly string[];
 }
@@ -73,27 +78,21 @@ export declare function inferFieldMetaFromZod(schema: z.ZodType): FieldMeta;
  * `model.ts:inferMetaFromZod`.
  */
 export declare function resolveFieldMeta(schema: z.ZodType): FieldMeta;
+export type FieldBuilder<T extends z.ZodType> = T & {
+    indexed(): FieldBuilder<T>;
+    from(column: string): FieldBuilder<T>;
+};
 export declare const field: {
     /** String field */
-    readonly string: () => z.ZodString & {
-        indexed(): z.ZodString;
-    };
+    readonly string: () => FieldBuilder<z.ZodString>;
     /** Number field */
-    readonly number: () => z.ZodNumber & {
-        indexed(): z.ZodNumber;
-    };
+    readonly number: () => FieldBuilder<z.ZodNumber>;
     /** Boolean field */
-    readonly boolean: () => z.ZodBoolean & {
-        indexed(): z.ZodBoolean;
-    };
+    readonly boolean: () => FieldBuilder<z.ZodBoolean>;
     /** Date field */
-    readonly date: () => z.ZodDate & {
-        indexed(): z.ZodDate;
-    };
+    readonly date: () => FieldBuilder<z.ZodDate>;
     /** Enum field with constrained string values */
-    readonly enum: <const T extends readonly [string, ...string[]]>(values: T) => z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never> & {
-        indexed(): z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never>;
-    };
+    readonly enum: <const T extends readonly [string, ...string[]]>(values: T) => FieldBuilder<z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
     /**
      * JSON field. Three call shapes:
      *
@@ -124,11 +123,9 @@ export declare const field: {
      * deck.metadataJson.icon  // 'presentation' (typed, with default)
      * ```
      */
-    readonly json: <T extends z.ZodType = z.ZodUnknown>(schemaOrShape?: T | z.ZodRawShape) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
-        indexed(): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-    };
+    readonly json: <T extends z.ZodType = z.ZodUnknown>(schemaOrShape?: T | z.ZodRawShape) => FieldBuilder<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     /** Indexed string field (shorthand for `field.string().indexed()`). */
-    readonly id: () => z.ZodString;
+    readonly id: () => FieldBuilder<z.ZodString>;
 };
 /** Mark a Zod schema as indexed for fast lookups (function form). */
 export declare function indexed<T extends z.ZodType>(schema: T): T;

package/dist/schema/field.js

@@ -142,7 +142,15 @@ export function inferFieldMetaFromZod(schema) {
         current instanceof z.ZodArray ||
         current instanceof z.ZodRecord ||
         current instanceof z.ZodUnion ||
-        current instanceof z.ZodUnknown) {
+        current instanceof z.ZodUnknown ||
+        // `z.custom<T>()` is an opaque, structurally-uninspectable blob —
+        // by construction the engine can't see its shape, which is exactly
+        // the JSON-blob pattern (ProseMirror docs, LayerData/LayerStyle maps,
+        // chart specs). Classifying it as `'string'` (the fallthrough default)
+        // gave these fields deep MobX observability instead of the intended
+        // `observable.ref` (see Ablo.ts registerProperty), producing the
+        // microtask-storm + nested-reactivity-drift bug on live updates.
+        current instanceof z.ZodCustom) {
         type = 'json';
     }
     return { type, isOptional, isIndexed: false, enumValues };
@@ -169,39 +177,44 @@ export function resolveFieldMeta(schema) {
         return attached;
     return inferFieldMetaFromZod(schema);
 }
-// ── Chainable field builders ──────────────────────────────────────────────
-//
-// Each builder returns the underlying Zod schema (so `z.object(shape)` still
-// works) with `.indexed()` added as a chainable method. `.optional()` and
-// `.nullable()` still come from Zod itself and preserve the description.
-/** Add `.indexed()` to a Zod schema without disturbing its type. */
-function withIndexed(schema, baseMeta) {
-    const described = schema.describe(encodeMeta({ ...baseMeta, isIndexed: false }));
-    described.indexed = () => {
-        return schema.describe(encodeMeta({ ...baseMeta, isIndexed: true }));
+function assertColumnName(column) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(column)) {
+        throw new Error(`field.from(): invalid column identifier ${JSON.stringify(column)}`);
+    }
+}
+/** Add sync-engine chain methods to a Zod schema without disturbing its type. */
+function withFieldMethods(schema, meta) {
+    const described = schema.describe(encodeMeta(meta));
+    described.indexed = () => withFieldMethods(schema, { ...meta, isIndexed: true });
+    described.from = (column) => {
+        assertColumnName(column);
+        return withFieldMethods(schema, { ...meta, column });
     };
     return described;
 }
+function buildField(schema, baseMeta) {
+    return withFieldMethods(schema, { ...baseMeta, isIndexed: false });
+}
 export const field = {
     /** String field */
     string() {
-        return withIndexed(z.string(), { type: 'string' });
+        return buildField(z.string(), { type: 'string' });
     },
     /** Number field */
     number() {
-        return withIndexed(z.number(), { type: 'number' });
+        return buildField(z.number(), { type: 'number' });
     },
     /** Boolean field */
     boolean() {
-        return withIndexed(z.boolean(), { type: 'boolean' });
+        return buildField(z.boolean(), { type: 'boolean' });
     },
     /** Date field */
     date() {
-        return withIndexed(z.date(), { type: 'date' });
+        return buildField(z.date(), { type: 'date' });
     },
     /** Enum field with constrained string values */
     enum(values) {
-        return withIndexed(z.enum(values), { type: 'enum', enumValues: values });
+        return buildField(z.enum(values), { type: 'enum', enumValues: values });
     },
     /**
      * JSON field. Three call shapes:
@@ -245,7 +258,7 @@ export const field = {
             // Plain object shape → wrap in z.object() for the sub-property pattern
             inner = z.object(schemaOrShape);
         }
-        return withIndexed(inner, { type: 'json' });
+        return buildField(inner, { type: 'json' });
     },
     /** Indexed string field (shorthand for `field.string().indexed()`). */
     id() {

package/dist/schema/generate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Schema → TypeScript type emission — the `generate` half of the loop (the
+ * counterpart to `diff`/migrate). Lowers a serialized schema to a `.ts` file of
+ * row interfaces + an `AbloSchema` map, so a consumer's app is typed against the
+ * exact schema that the database and sync layer enforce. Pure (returns source
+ * text); the CLI writes it to disk.
+ *
+ * This is the SDK's front door: the developer writes ONE `defineSchema`, pushes
+ * it (which migrates the DB), and generates types FROM the same schema — so the
+ * types they code against, the rows the DB stores, and the entities sync moves
+ * are provably the same thing.
+ *
+ * v1 emits the row shape (base columns + declared fields, enums as literal
+ * unions). Relations are resolved by the runtime SDK's typed accessors and are
+ * not expanded here.
+ */
+import type { SchemaJSON } from './serialize.js';
+/** Emit a TypeScript module of row interfaces + the `AbloSchema` map. */
+export declare function generateTypes(schema: SchemaJSON): string;

package/dist/schema/generate.js

@@ -0,0 +1,87 @@
+/**
+ * Schema → TypeScript type emission — the `generate` half of the loop (the
+ * counterpart to `diff`/migrate). Lowers a serialized schema to a `.ts` file of
+ * row interfaces + an `AbloSchema` map, so a consumer's app is typed against the
+ * exact schema that the database and sync layer enforce. Pure (returns source
+ * text); the CLI writes it to disk.
+ *
+ * This is the SDK's front door: the developer writes ONE `defineSchema`, pushes
+ * it (which migrates the DB), and generates types FROM the same schema — so the
+ * types they code against, the rows the DB stores, and the entities sync moves
+ * are provably the same thing.
+ *
+ * v1 emits the row shape (base columns + declared fields, enums as literal
+ * unions). Relations are resolved by the runtime SDK's typed accessors and are
+ * not expanded here.
+ */
+/** The base columns every model carries (mirrors `baseFieldsSchema`). */
+const BASE_FIELDS = ['id', 'createdAt', 'updatedAt', 'organizationId', 'createdBy'];
+function tsType(meta) {
+    switch (meta.type) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'date':
+            // `baseFieldsSchema` uses `z.date()` and the driver hydrates timestamptz
+            // to Date — declared date fields match.
+            return 'Date';
+        case 'json':
+            return 'unknown';
+        case 'enum':
+            return meta.enumValues && meta.enumValues.length > 0
+                ? meta.enumValues.map((v) => `'${v.replace(/'/g, "\\'")}'`).join(' | ')
+                : 'string';
+        default:
+            return 'unknown';
+    }
+}
+/** A valid PascalCase TS identifier from a model's typename (or its key). */
+function interfaceName(model, key) {
+    const raw = model.typename && model.typename.trim() ? model.typename : key;
+    const id = raw
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+    return /^[A-Za-z_]/.test(id) ? id : `Model${id}`;
+}
+/** Emit a TypeScript module of row interfaces + the `AbloSchema` map. */
+export function generateTypes(schema) {
+    const lines = [
+        '// Generated by `ablo generate` — do not edit by hand.',
+        '// Re-run `ablo generate` after pushing a schema change.',
+        '',
+    ];
+    const nameByKey = new Map();
+    for (const [key, model] of Object.entries(schema.models)) {
+        nameByKey.set(key, interfaceName(model, key));
+    }
+    for (const [key, model] of Object.entries(schema.models)) {
+        lines.push(`export interface ${nameByKey.get(key)} {`);
+        lines.push('  id: string;');
+        lines.push('  createdAt: Date;');
+        lines.push('  updatedAt: Date;');
+        lines.push('  organizationId?: string;');
+        lines.push('  createdBy?: string;');
+        for (const [fieldName, meta] of Object.entries(model.fields)) {
+            // A model that redeclares a base column doesn't double-emit it.
+            if (BASE_FIELDS.includes(fieldName))
+                continue;
+            lines.push(`  ${fieldName}${meta.isOptional ? '?' : ''}: ${tsType(meta)};`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    // The model map — parameterize the Ablo client with this for typed access.
+    lines.push('export interface AbloSchema {');
+    for (const key of Object.keys(schema.models)) {
+        lines.push(`  ${JSON.stringify(key)}: ${nameByKey.get(key)};`);
+    }
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/schema/index.d.ts

@@ -21,9 +21,15 @@
  * ```
  */
 export { z } from 'zod';
-export { field, indexed, getFieldMeta, type FieldMeta } from './field.js';
+export { field, indexed, getFieldMeta, type FieldBuilder, type FieldMeta } from './field.js';
 export { relation, type RelationDef, type RelationType } from './relation.js';
-export { model, type ModelDef, type ModelOptions, type LoadStrategy, type PersistOptions, type RelationRecord, } from './model.js';
+export { tenancySchema, scopedViaRefSchema, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, type Tenancy, type ScopedViaRef, type TenancyInput, } from './tenancy.js';
+export { model, scopeKindOf, type ModelDef, type ModelOptions, type LoadStrategy, type PersistOptions, type RelationRecord, type GrantsRef, } from './model.js';
 export { mutable, readOnly, type SugarOptions } from './sugar.js';
-export { defineSchema, composeIdentitySyncGroups, type Schema, type SchemaRecord, type InferModel, type InferCreate, type InferModelNames, type BaseModelFields, type InsertValue, type UpsertValue, type UpdateValue, type DeleteId, type DefineSchemaOptions, type Casing, type CasingConvention, type CasingFn, type IdentityRole, type IdentityContext, } from './schema.js';
+export { defineSchema, composeIdentitySyncGroups, type Schema, type SchemaRecord, type InferModel, type InferCreate, type InferModelNames, type BaseModelFields, type InsertValue, type UpsertValue, type UpdateValue, type DeleteId, type DefineSchemaOptions, type Casing, type CasingConvention, type CasingFn, composeEntitySyncGroups, type IdentityRole, type IdentityContext, type IdentityRoleSource, type EntityRole, type EntityContext, type EntityRoleSource, type RoleSource, type RoleContext, type SyncGroup, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, } from './schema.js';
+export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, type SchemaJSON, type ModelJSON, type RelationJSON, } from './serialize.js';
+export { selectModels } from './select.js';
+export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSnake, q, sqlType, type ProvisionPlan, type MigrationPlan, } from './ddl.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';

package/dist/schema/index.js

@@ -26,13 +26,25 @@ export { z } from 'zod';
 export { field, indexed, getFieldMeta } from './field.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, resolveTenancy, tenancyColumn, DEFAULT_ORG_COLUMN, } from './tenancy.js';
 // Model builder
-export { model, } from './model.js';
+export { model, scopeKindOf, } from './model.js';
 // Intent-first shorthand: `mutable.lazy({...})` and friends. Read the
 // safety posture and load shape off the verb tokens; everything else
 // falls back to sensible defaults. See sugar.ts for the full pattern.
 export { mutable, readOnly } from './sugar.js';
 // Schema definition + type inference
-export { defineSchema, composeIdentitySyncGroups, } from './schema.js';
+export { defineSchema, composeIdentitySyncGroups, composeEntitySyncGroups, identityRole, entityRole, extractIdentityIds, extractEntityIds, syncGroup, syncGroupSchema, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, } from './schema.js';
+// Schema ⇄ JSON (control-plane transport for hosted multi-tenant)
+export { serializeSchema, parseSchema, toSchemaJSON, fromSchemaJSON, schemaHash, } from './serialize.js';
+// Schema projection — derive an app's subset from one canonical schema.
+export { selectModels } from './select.js';
+// Schema → Postgres DDL (pure; shared by the hosted server and the CLI)
+export { generateProvisionPlan, generateMigrationPlan, appSchemaName, camelToSnake, q, sqlType, } from './ddl.js';
+// Schema diff + migration planning (pure; SQL emission lowered by ddl.ts)
+export { diffSchema, classifyMigration, classifyCast, isAutoApplicable, isBlockerResolved, unresolvedBlockers, } from './diff.js';
+// Schema → TypeScript type emission (the `generate` half; pure)
+export { generateTypes } from './generate.js';
 // Query definition DSL + type inference
 export { query, defineQueries, } from './queries.js';