rip-lang 3.15.0 → 3.15.2

package/src/schema/loader-server.js

@@ -0,0 +1,65 @@
+// Schema runtime loader — server / CLI / migration variant.
+//
+// Why this file exists (peer-review: "are loaders just picking which
+// fragments to concatenate, or doing real work?"):
+//
+//   The loader is the IMPORT BOUNDARY. By having loader-server.js
+//   import all five fragments and loader-browser.js import only
+//   validate + browser-stubs, Bun's tree-shaker can statically
+//   determine which fragment string constants reach which entry
+//   point. If the mode-switch logic lived in src/schema.js (which is
+//   reachable from BOTH browser and server entries), every fragment
+//   constant would be statically reachable from every entry, and
+//   tree-shaking couldn't remove anything. The two-loader split is
+//   what makes the bundle savings real.
+//
+// Side-effect import. Adds a runtime provider that supports all four
+// modes (validate / browser / server / migration) and eagerly installs
+// the migration runtime on globalThis at module load.
+//
+// Used by every Node-side caller of the compiler:
+//   - bin/rip                         (CLI)
+//   - test/runner.js, test/types/...  (test runner)
+//   - src/typecheck.js                (LSP / rip check)
+//   - any server-side code that imports src/compiler.js
+
+import {
+  SCHEMA_RUNTIME_WRAPPER_HEAD,
+  SCHEMA_RUNTIME_WRAPPER_TAIL,
+  SCHEMA_VALIDATE_RUNTIME,
+  SCHEMA_DB_NAMING_RUNTIME,
+  SCHEMA_ORM_RUNTIME,
+  SCHEMA_DDL_RUNTIME,
+  SCHEMA_BROWSER_STUBS_RUNTIME,
+} from './runtime.generated.js';
+import { setSchemaRuntimeProvider } from './schema.js';
+
+function provider({ mode = 'migration' } = {}) {
+  let body;
+  switch (mode) {
+    case 'validate':
+      body = SCHEMA_VALIDATE_RUNTIME;
+      break;
+    case 'browser':
+      body = SCHEMA_VALIDATE_RUNTIME + '\n' + SCHEMA_BROWSER_STUBS_RUNTIME;
+      break;
+    case 'server':
+      body = SCHEMA_VALIDATE_RUNTIME + '\n' + SCHEMA_DB_NAMING_RUNTIME + '\n' + SCHEMA_ORM_RUNTIME;
+      break;
+    case 'migration':
+      body = SCHEMA_VALIDATE_RUNTIME + '\n' + SCHEMA_DB_NAMING_RUNTIME + '\n' + SCHEMA_ORM_RUNTIME + '\n' + SCHEMA_DDL_RUNTIME;
+      break;
+    default:
+      throw new Error(`unknown schema runtime mode: ${mode}`);
+  }
+  return (SCHEMA_RUNTIME_WRAPPER_HEAD + body + SCHEMA_RUNTIME_WRAPPER_TAIL).trimStart();
+}
+
+setSchemaRuntimeProvider(provider);
+
+// Eagerly install migration runtime so test harnesses that emit with
+// skipRuntimes: true find {__schema, SchemaError} on globalThis.
+export const SCHEMA_RUNTIME = provider({ mode: 'migration' });
+if (typeof globalThis !== 'undefined' && !globalThis.__ripSchema) {
+  try { (0, eval)(SCHEMA_RUNTIME); } catch {}
+}

package/src/schema/runtime-browser-stubs.js

@@ -0,0 +1,51 @@
+// Schema runtime fragment: browser-stubs (browser only)
+//
+// This file is the source of truth for one slice of the schema runtime.
+// Edit here, then run `bun run build:schema-runtime` to regenerate
+// `src/schema/runtime.generated.js`. Tests pin the public surface via
+// test/schema/errors.test.js, test/schema/modes.test.js, and the source
+// schema test suite.
+//
+// Fragments are concatenated INSIDE one shared IIFE wrapper at build time.
+// They share scope; references like `__SchemaRegistry` resolve to bindings
+// defined in earlier-included fragments. Editor tooling (LSP / lint) may
+// not recognize cross-fragment references — that is expected; behavior is
+// pinned by the test suite.
+
+/* eslint-disable no-undef, no-unused-vars */
+// Browser stubs — throwing replacements for every ORM / DDL helper that
+// the validate fragment references but doesn't implement. Loaded ONLY
+// in browser mode.
+//
+// The validate fragment's `_makeClass`, `_normalize`, and
+// `__schemaNormalizeDirectiveRelation` reference helpers that live in
+// db-naming, orm, and ddl fragments at runtime. Browser mode doesn't
+// include those fragments, so we provide thin throwing stubs here so
+// browser-side schema declarations parse and validate cleanly while
+// any attempt to use server-only behavior fails with a helpful message.
+
+const __schemaBrowserStub = (api) => function() {
+  throw new Error(
+    "schema." + api + "() is not available in the browser. " +
+    "Import @rip-lang/db on the server."
+  );
+};
+
+// Static / class-level methods on __SchemaDef
+__SchemaDef.prototype.find    = __schemaBrowserStub('find');
+__SchemaDef.prototype.where   = __schemaBrowserStub('where');
+__SchemaDef.prototype.all     = __schemaBrowserStub('all');
+__SchemaDef.prototype.first   = __schemaBrowserStub('first');
+__SchemaDef.prototype.count   = __schemaBrowserStub('count');
+__SchemaDef.prototype.create  = __schemaBrowserStub('create');
+__SchemaDef.prototype.toSQL   = __schemaBrowserStub('toSQL');
+
+// Helpers referenced by the validate fragment that are otherwise
+// defined in db-naming / orm fragments. Kept inert (return safe
+// defaults or throw on use) so validate's _makeClass / _normalize
+// can run end-to-end in browser context.
+function __schemaSave()       { throw new Error("schema instance.save() is not available in the browser. Import @rip-lang/db on the server."); }
+function __schemaDestroy()    { throw new Error("schema instance.destroy() is not available in the browser. Import @rip-lang/db on the server."); }
+function __schemaTableName(m) { return null; } // returned only for :model normalize; never used downstream in browser
+function __schemaPluralize(w) { return w; }    // identity — relations work for type-resolution but never query
+function __schemaFkName(m)    { return ''; }   // ditto

package/src/schema/runtime-db-naming.js

@@ -0,0 +1,34 @@
+// Schema runtime fragment: db-naming (server + migration)
+//
+// This file is the source of truth for one slice of the schema runtime.
+// Edit here, then run `bun run build:schema-runtime` to regenerate
+// `src/schema/runtime.generated.js`. Tests pin the public surface via
+// test/schema/errors.test.js, test/schema/modes.test.js, and the source
+// schema test suite.
+//
+// Fragments are concatenated INSIDE one shared IIFE wrapper at build time.
+// They share scope; references like `__SchemaRegistry` resolve to bindings
+// defined in earlier-included fragments. Editor tooling (LSP / lint) may
+// not recognize cross-fragment references — that is expected; behavior is
+// pinned by the test suite.
+
+/* eslint-disable no-undef, no-unused-vars */
+const __SCHEMA_UNCOUNTABLE = new Set(['equipment','information','rice','money','species','series','fish','sheep','data']);
+
+const __SCHEMA_IRREGULAR = new Map([['person','people'],['man','men'],['woman','women'],['child','children'],['tooth','teeth'],['foot','feet'],['mouse','mice']]);
+
+function __schemaPluralize(w) {
+  const lw = w.toLowerCase();
+  if (__SCHEMA_UNCOUNTABLE.has(lw)) return w;
+  if (__SCHEMA_IRREGULAR.has(lw)) return __SCHEMA_IRREGULAR.get(lw);
+  // Preserve case of the input — pluralizer operates on the trailing form
+  // but keeps the rest unchanged, so orderItem becomes orderItems
+  // and User becomes Users.
+  if (/[^aeiouy]y$/i.test(w)) return w.slice(0, -1) + 'ies';
+  if (/(s|x|z|ch|sh)$/i.test(w)) return w + 'es';
+  return w + 's';
+}
+
+function __schemaTableName(model) { return __schemaPluralize(__schemaSnake(model)); }
+
+function __schemaFkName(model) { return __schemaSnake(model) + '_id'; }

package/src/schema/runtime-ddl.js

@@ -0,0 +1,124 @@
+// Schema runtime fragment: ddl (migration only)
+//
+// This file is the source of truth for one slice of the schema runtime.
+// Edit here, then run `bun run build:schema-runtime` to regenerate
+// `src/schema/runtime.generated.js`. Tests pin the public surface via
+// test/schema/errors.test.js, test/schema/modes.test.js, and the source
+// schema test suite.
+//
+// Fragments are concatenated INSIDE one shared IIFE wrapper at build time.
+// They share scope; references like `__SchemaRegistry` resolve to bindings
+// defined in earlier-included fragments. Editor tooling (LSP / lint) may
+// not recognize cross-fragment references — that is expected; behavior is
+// pinned by the test suite.
+
+/* eslint-disable no-undef, no-unused-vars */
+const __SCHEMA_SQL_TYPES = {
+  string: 'VARCHAR', text: 'TEXT', integer: 'INTEGER', number: 'DOUBLE',
+  boolean: 'BOOLEAN', date: 'DATE', datetime: 'TIMESTAMP', email: 'VARCHAR',
+  url: 'VARCHAR', uuid: 'UUID', phone: 'VARCHAR', zip: 'VARCHAR', json: 'JSON', any: 'JSON',
+};
+
+function __schemaToSQL(def, options) {
+  const opts = options || {};
+  const { dropFirst = false, header } = opts;
+  const norm = def._normalize();
+  const blocks = [];
+  if (header) blocks.push(header);
+
+  const table = norm.tableName;
+  const seq = table + '_seq';
+  if (dropFirst) {
+    blocks.push('DROP TABLE IF EXISTS ' + table + ' CASCADE;\nDROP SEQUENCE IF EXISTS ' + seq + ';');
+  }
+
+  // Sequence seed: explicit option wins over @idStart directive wins over 1.
+  // DuckDB 1.5.2 does not implement ALTER SEQUENCE ... RESTART WITH N, so the
+  // baseline has to be set at creation — hence the knob lives here, not in a
+  // post-create migration.
+  let idStart = 1;
+  for (const d of norm.directives) {
+    if (d.name === 'idStart' && d.args?.[0] && Number.isInteger(d.args[0].value)) {
+      idStart = d.args[0].value;
+    }
+  }
+  if (opts.idStart !== undefined) {
+    if (!Number.isInteger(opts.idStart)) {
+      throw new Error('schema.toSQL(): idStart must be an integer; got ' + String(opts.idStart));
+    }
+    idStart = opts.idStart;
+  }
+
+  const columns = [];
+  const indexes = [];
+  columns.push('  ' + norm.primaryKey + " INTEGER PRIMARY KEY DEFAULT nextval('" + seq + "')");
+
+  for (const [n, f] of norm.fields) {
+    columns.push(__schemaColumnDDL(n, f));
+    if (f.unique) {
+      indexes.push('CREATE UNIQUE INDEX idx_' + table + '_' + __schemaSnake(n) + ' ON ' + table + ' ("' + __schemaSnake(n) + '");');
+    }
+  }
+
+  for (const [, rel] of norm.relations) {
+    if (rel.kind !== 'belongsTo') continue;
+    const refTable = __schemaTableName(rel.target);
+    const notNull = rel.optional ? '' : ' NOT NULL';
+    columns.push('  ' + rel.foreignKey + ' INTEGER' + notNull + ' REFERENCES ' + refTable + '(id)');
+  }
+
+  if (norm.timestamps) {
+    columns.push('  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP');
+    columns.push('  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP');
+  }
+  if (norm.softDelete) {
+    columns.push('  deleted_at TIMESTAMP');
+  }
+
+  // @index directives
+  for (const d of norm.directives) {
+    if (d.name !== 'index') continue;
+    const ixArgs = d.args?.[0] || {};
+    const fields = (ixArgs.fields || []).map(__schemaSnake);
+    if (!fields.length) continue;
+    const u = ixArgs.unique ? 'UNIQUE ' : '';
+    indexes.push('CREATE ' + u + 'INDEX idx_' + table + '_' + fields.join('_') + ' ON ' + table + ' (' + fields.map(f => '"' + f + '"').join(', ') + ');');
+  }
+
+  blocks.push('CREATE SEQUENCE ' + seq + ' START ' + idStart + ';');
+  blocks.push('CREATE TABLE ' + table + ' (\n' + columns.join(',\n') + '\n);');
+  if (indexes.length) blocks.push(indexes.join('\n'));
+
+  return blocks.join('\n\n') + '\n';
+}
+
+function __schemaColumnDDL(name, field) {
+  let base = __SCHEMA_SQL_TYPES[field.typeName] || 'VARCHAR';
+  if (field.array) base = 'JSON';
+  if (base === 'VARCHAR' && field.constraints?.max != null) {
+    base = 'VARCHAR(' + field.constraints.max + ')';
+  }
+  const parts = ['  ' + __schemaSnake(name) + ' ' + base];
+  if (field.required) parts.push('NOT NULL');
+  if (field.unique) parts.push('UNIQUE');
+  if (field.constraints?.default !== undefined) {
+    parts.push('DEFAULT ' + __schemaSQLDefault(field.constraints.default));
+  }
+  return parts.join(' ');
+}
+
+function __schemaSQLDefault(v) {
+  if (v === true) return 'true';
+  if (v === false) return 'false';
+  if (v === null) return 'NULL';
+  if (typeof v === 'number') return String(v);
+  if (typeof v === 'string') return "'" + v.replace(/'/g, "''") + "'";
+  return "'" + String(v).replace(/'/g, "''") + "'";
+}
+
+// DDL prototype augmentation — added to __SchemaDef
+
+__SchemaDef.prototype.toSQL = function (options) {
+  this._assertModel('toSQL');
+  return __schemaToSQL(this, options);
+};

package/src/schema/runtime-orm.js

@@ -0,0 +1,294 @@
+// Schema runtime fragment: orm (server + migration)
+//
+// This file is the source of truth for one slice of the schema runtime.
+// Edit here, then run `bun run build:schema-runtime` to regenerate
+// `src/schema/runtime.generated.js`. Tests pin the public surface via
+// test/schema/errors.test.js, test/schema/modes.test.js, and the source
+// schema test suite.
+//
+// Fragments are concatenated INSIDE one shared IIFE wrapper at build time.
+// They share scope; references like `__SchemaRegistry` resolve to bindings
+// defined in earlier-included fragments. Editor tooling (LSP / lint) may
+// not recognize cross-fragment references — that is expected; behavior is
+// pinned by the test suite.
+
+/* eslint-disable no-undef, no-unused-vars */
+function __schemaDefaultAdapter() {
+  const url = (typeof process !== 'undefined' && process.env?.DB_URL) || 'http://localhost:4213';
+  return {
+    async query(sql, params) {
+      const body = params && params.length ? { sql, params } : { sql };
+      const res = await fetch(url + '/sql', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const data = await res.json();
+      if (data.error) throw new Error(data.error);
+      return data;
+    }
+  };
+}
+
+let __schemaAdapter = __schemaDefaultAdapter();
+
+function __schemaSetAdapter(a) { __schemaAdapter = a; }
+
+class __SchemaQuery {
+  constructor(def, opts = {}) {
+    this._def = def;
+    this._clauses = [];
+    this._params = [];
+    this._limit = null;
+    this._offset = null;
+    this._order = null;
+    this._includeDeleted = opts.includeDeleted === true;
+  }
+  where(cond, ...params) {
+    if (typeof cond === 'string') {
+      this._clauses.push(cond);
+      this._params.push(...params);
+    } else if (cond && typeof cond === 'object') {
+      for (const [k, v] of Object.entries(cond)) {
+        const col = __schemaSnake(k);
+        if (v === null || v === undefined) {
+          this._clauses.push('"' + col + '" IS NULL');
+        } else {
+          this._clauses.push('"' + col + '" = ?');
+          this._params.push(v);
+        }
+      }
+    }
+    return this;
+  }
+  limit(n) { this._limit = n; return this; }
+  offset(n) { this._offset = n; return this; }
+  order(spec) { this._order = spec; return this; }
+  orderBy(spec) { return this.order(spec); }
+  _buildSQL() {
+    const n = this._def._normalize();
+    const table = n.tableName;
+    const parts = ['SELECT * FROM "' + table + '"'];
+    const where = [...this._clauses];
+    if (!this._includeDeleted && n.softDelete) where.push('"deleted_at" IS NULL');
+    if (where.length) parts.push('WHERE ' + where.join(' AND '));
+    if (this._order) parts.push('ORDER BY ' + this._order);
+    if (this._limit != null) parts.push('LIMIT ' + this._limit);
+    if (this._offset != null) parts.push('OFFSET ' + this._offset);
+    return parts.join(' ');
+  }
+  async all() {
+    const sql = this._buildSQL();
+    const res = await __schemaAdapter.query(sql, this._params);
+    return (res.data || []).map(row => this._def._hydrate(res.columns, row));
+  }
+  async first() {
+    this._limit = 1;
+    const arr = await this.all();
+    return arr[0] || null;
+  }
+  async count() {
+    const n = this._def._normalize();
+    const parts = ['SELECT COUNT(*) FROM "' + n.tableName + '"'];
+    const where = [...this._clauses];
+    if (!this._includeDeleted && n.softDelete) where.push('"deleted_at" IS NULL');
+    if (where.length) parts.push('WHERE ' + where.join(' AND '));
+    const res = await __schemaAdapter.query(parts.join(' '), this._params);
+    return res.data?.[0]?.[0] || 0;
+  }
+}
+
+async function __schemaResolveRelation(def, inst, rel) {
+  const target = __SchemaRegistry.get(rel.target);
+  if (!target) throw new Error('schema: unknown relation target "' + rel.target + '" from ' + (def.name || 'anon'));
+  const pk = def._normalize().primaryKey;
+  if (rel.kind === 'belongsTo') {
+    const fk = inst[__schemaCamel(rel.foreignKey)];
+    return fk != null ? await target.find(fk) : null;
+  }
+  if (rel.kind === 'hasOne') {
+    return await target.where({ [rel.foreignKey]: inst[pk] }).first();
+  }
+  if (rel.kind === 'hasMany') {
+    return await target.where({ [rel.foreignKey]: inst[pk] }).all();
+  }
+  return null;
+}
+
+async function __schemaRunHook(def, inst, name) {
+  const fn = def._normalize().hooks.get(name);
+  if (fn) await fn.call(inst);
+}
+
+async function __schemaSave(def, inst) {
+  const norm = def._normalize();
+  const isNew = !inst._persisted;
+
+  await __schemaRunHook(def, inst, 'beforeValidation');
+  const errs = def._validateFields(inst, true);
+  if (errs.length) throw new SchemaError(errs, def.name, def.kind);
+  await __schemaRunHook(def, inst, 'afterValidation');
+
+  await __schemaRunHook(def, inst, 'beforeSave');
+  if (isNew) await __schemaRunHook(def, inst, 'beforeCreate');
+  else       await __schemaRunHook(def, inst, 'beforeUpdate');
+
+  if (isNew) {
+    const cols = [], placeholders = [], values = [];
+    for (const [n, f] of norm.fields) {
+      const v = inst[n];
+      if (v == null) continue;
+      cols.push('"' + __schemaSnake(n) + '"');
+      placeholders.push('?');
+      values.push(__schemaSerialize(v, f));
+    }
+    // Include relation FKs. belongsTo FKs are camelCase properties on
+    // the instance (e.g. organizationId for organization_id).
+    for (const [, rel] of norm.relations) {
+      if (rel.kind !== 'belongsTo') continue;
+      const fkCamel = __schemaCamel(rel.foreignKey);
+      const v = inst[fkCamel];
+      if (v != null) {
+        cols.push('"' + rel.foreignKey + '"');
+        placeholders.push('?');
+        values.push(v);
+      }
+    }
+    const sql = 'INSERT INTO "' + norm.tableName + '" (' + cols.join(', ') + ') VALUES (' + placeholders.join(', ') + ') RETURNING *';
+    const res = await __schemaAdapter.query(sql, values);
+    if (res.data?.[0] && res.columns) {
+      for (let i = 0; i < res.columns.length; i++) {
+        const snake = res.columns[i].name;
+        const key = __schemaCamel(snake);
+        if (!(key in inst)) {
+          Object.defineProperty(inst, key, { value: res.data[0][i], enumerable: true, writable: true, configurable: true });
+        } else {
+          inst[key] = res.data[0][i];
+        }
+        if (snake !== key && !(snake in inst)) {
+          Object.defineProperty(inst, snake, {
+            enumerable: false, configurable: true,
+            get() { return this[key]; },
+            set(v) { this[key] = v; },
+          });
+        }
+      }
+    }
+    // Now that the RETURNING columns (id, @timestamps, FKs) are on the
+    // instance, !> eager-derived fields can see them. Mirrors the hydrate
+    // path, which runs _applyEagerDerived once all declared fields are
+    // populated. Per-docs semantics ("materialize once, not reactive")
+    // still hold — we're firing once, at end of construction, not on
+    // subsequent mutations.
+    def._applyEagerDerived(inst);
+    inst._persisted = true;
+  } else {
+    const sets = [], values = [];
+    for (const [n, f] of norm.fields) {
+      sets.push('"' + __schemaSnake(n) + '" = ?');
+      values.push(__schemaSerialize(inst[n], f));
+    }
+    if (sets.length) {
+      const pk = norm.primaryKey;
+      values.push(inst[pk]);
+      const sql = 'UPDATE "' + norm.tableName + '" SET ' + sets.join(', ') + ' WHERE "' + pk + '" = ?';
+      await __schemaAdapter.query(sql, values);
+    }
+  }
+  inst._dirty.clear();
+
+  if (isNew) await __schemaRunHook(def, inst, 'afterCreate');
+  else       await __schemaRunHook(def, inst, 'afterUpdate');
+  await __schemaRunHook(def, inst, 'afterSave');
+  return inst;
+}
+
+async function __schemaDestroy(def, inst) {
+  if (!inst._persisted) return inst;
+  const norm = def._normalize();
+  await __schemaRunHook(def, inst, 'beforeDestroy');
+  if (norm.softDelete) {
+    const now = new Date().toISOString();
+    await __schemaAdapter.query('UPDATE "' + norm.tableName + '" SET "deleted_at" = ? WHERE "' + norm.primaryKey + '" = ?', [now, inst[norm.primaryKey]]);
+    inst.deletedAt = now;
+  } else {
+    await __schemaAdapter.query('DELETE FROM "' + norm.tableName + '" WHERE "' + norm.primaryKey + '" = ?', [inst[norm.primaryKey]]);
+    inst._persisted = false;
+  }
+  await __schemaRunHook(def, inst, 'afterDestroy');
+  return inst;
+}
+
+function __schemaSerialize(v, field) {
+  if (field && field.typeName === 'json' && v != null && typeof v === 'object') {
+    return JSON.stringify(v);
+  }
+  return v;
+}
+
+// ORM prototype augmentations — added to __SchemaDef
+
+__SchemaDef.prototype.find = async function (id) {
+  this._assertModel('find');
+  const norm = this._normalize();
+  const soft = norm.softDelete ? ' AND "deleted_at" IS NULL' : '';
+  const sql = 'SELECT * FROM "' + norm.tableName + '" WHERE "' + norm.primaryKey + '" = ?' + soft + ' LIMIT 1';
+  const res = await __schemaAdapter.query(sql, [id]);
+  if (!res.rows) return null;
+  return this._hydrate(res.columns, res.data[0]);
+};
+
+__SchemaDef.prototype.where = function (cond, ...params) {
+  this._assertModel('where');
+  return new __SchemaQuery(this).where(cond, ...params);
+};
+
+__SchemaDef.prototype.all = function () {
+  this._assertModel('all');
+  return new __SchemaQuery(this).all();
+};
+
+__SchemaDef.prototype.first = function () {
+  this._assertModel('first');
+  return new __SchemaQuery(this).first();
+};
+
+__SchemaDef.prototype.count = function () {
+  this._assertModel('count');
+  return new __SchemaQuery(this).count();
+};
+
+__SchemaDef.prototype.create = async function (data) {
+  this._assertModel('create');
+  // Input keys may be snake_case or camelCase; the runtime
+  // canonicalizes to camelCase so instance properties line up with
+  // declared field names.
+  const klass = this._getClass();
+  const canonical = {};
+  if (data && typeof data === 'object') {
+    for (const k of Object.keys(data)) canonical[__schemaCamel(k)] = data[k];
+  }
+  const inst = new klass(this._applyDefaults(canonical), false);
+  // FK columns like user_id canonicalize to userId and need to
+  // round-trip through the INSERT path, so attach them as own
+  // properties even though they aren't declared fields.
+  for (const [k, v] of Object.entries(canonical)) {
+    if (!(k in inst)) {
+      Object.defineProperty(inst, k, { value: v, enumerable: true, writable: true, configurable: true });
+    }
+  }
+  await __schemaSave(this, inst);
+  return inst;
+};
+
+__SchemaDef.prototype._assertModel = function (api) {
+  if (this.kind !== 'model') {
+    throw new Error('schema: .' + api + '() is :model-only (got :' + this.kind + ')');
+  }
+}
+
+// ---- Schema algebra (Phase 6) --------------------------------------------
+// Invariant: every algebra operation returns a :shape. Model algebra
+// strips ORM; :shape algebra drops behavior. Derived shapes preserve
+// field metadata (constraints, defaults, modifiers) from the source
+// normalized descriptor.