rip-lang 3.14.5 → 3.15.1

package/src/compiler.js

@@ -11,8 +11,12 @@
 import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
-import { emitTypes, emitEnum } from './types.js';
-import { installSchemaSupport } from './schema.js';
+// Type emission is CLI/editor-only. types-emit.js registers itself via
+// setTypesEmitter() at module load. The browser never imports types-emit,
+// so _typesEmitter stays null and .d.ts output is silently skipped.
+let _typesEmitter = null;
+export function setTypesEmitter(fn) { _typesEmitter = fn; }
+import { installSchemaSupport } from './schema/schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { RipError, toRipError } from './error.js';
 
@@ -2045,7 +2049,22 @@ export class CodeEmitter {
   emitComprehension(head, rest, context) {
     let [expr, iterators, guards] = rest;
     if (context === 'statement') return this.emitComprehensionAsLoop(expr, iterators, guards);
-    if (this.comprehensionTarget) return this.emitComprehensionWithTarget(expr, iterators, guards, this.comprehensionTarget);
+    if (this.comprehensionTarget) {
+      // Consume-and-clear: the auto-return-loop logic sets comprehensionTarget
+      // expecting ONE consumer (the direct value-context comprehension being
+      // routed to the named target). Without clearing here, nested
+      // comprehensions inside this comprehension's body (call args, RHS
+      // expressions) would inherit the target and skip their own IIFE,
+      // producing malformed JS or wrong semantics. The body's own emit calls
+      // see comprehensionTarget = null and correctly produce IIFEs.
+      let target = this.comprehensionTarget;
+      this.comprehensionTarget = null;
+      try {
+        return this.emitComprehensionWithTarget(expr, iterators, guards, target);
+      } finally {
+        this.comprehensionTarget = target;
+      }
+    }
 
     // Enclosed: expr, iterators (iterable expressions), guards
     let hasAwait = this.containsAwait(expr) || iterators.some(i => this.containsAwait(i)) || guards.some(g => this.containsAwait(g));
@@ -2614,6 +2633,21 @@ export class CodeEmitter {
               code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
               return;
             }
+            // Auto-return-loop: only for-in/for-of/for-as auto-collect into
+            // _result, because emitForIn/emitForOf/emitForAs at value-context
+            // wrap themselves in a comprehension that consumes
+            // comprehensionTarget. `loop` and `while` have no such wrapping —
+            // emitLoop/emitWhile just emit `while(...) { body }` and any
+            // comprehensionTarget set here would LEAK into nested
+            // expression-context comprehensions inside the body (causing
+            // them to be routed to the wrong target and skip their own
+            // IIFE). Loops with explicit `return X` inside their body
+            // already work correctly; emit them as plain statements.
+            let isCollectibleLoop = h === 'for-in' || h === 'for-of' || h === 'for-as';
+            if (!isCollectibleLoop) {
+              code += this.indent() + this.addSemicolon(stmt, this.emit(stmt, 'statement')) + '\n';
+              return;
+            }
             code += this.indent() + 'const _result = [];\n';
             this.comprehensionTarget = '_result';
             let saved = this._skipCompTargetInit;
@@ -3689,7 +3723,7 @@ export class Compiler {
 
     // If only terminators remain (type-only source), emit types and return early
     if (tokens.every(t => t[0] === 'TERMINATOR')) {
-      if (typeTokens) dts = emitTypes(typeTokens, ['program'], source);
+      if (typeTokens && _typesEmitter) dts = _typesEmitter(typeTokens, ['program'], source);
       return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
     }
 
@@ -3759,6 +3793,11 @@ export class Compiler {
       skipDataPart: this.options.skipDataPart,
       stubComponents: this.options.stubComponents,
       reactiveVars: this.options.reactiveVars,
+      // Schema runtime mode: 'browser' / 'validate' / 'server' / 'migration'.
+      // Default 'migration' covers the common case (CLI, server, tests) where
+      // the user might call any schema feature including .toSQL(). The browser
+      // bundle build script overrides to 'browser' for size reduction.
+      schemaMode: this.options.schemaMode,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -3766,15 +3805,28 @@ export class Compiler {
     let map = sourceMap ? sourceMap.toJSON() : null;
     let reverseMap = sourceMap ? sourceMap.toReverseMap() : null;
     if (map && this.options.sourceMap === 'inline') {
-      let b64 = typeof Buffer !== 'undefined' ? Buffer.from(map).toString('base64') : btoa(map);
+      // map is already a JSON string (sourceMaps.toJSON() stringifies). UTF-8
+      // safe encode: btoa() only handles Latin-1, so pre-encode non-ASCII via
+      // TextEncoder before base64 in browsers. Bun's Buffer handles utf-8
+      // directly. Source files containing emoji, em-dashes, accented chars,
+      // etc. would otherwise break with `Failed to execute 'btoa'`.
+      let b64;
+      if (typeof Buffer !== 'undefined') {
+        b64 = Buffer.from(map, 'utf8').toString('base64');
+      } else {
+        const bytes = new TextEncoder().encode(map);
+        let bin = '';
+        for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+        b64 = btoa(bin);
+      }
       code += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
     } else if (map && this.options.filename) {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
     // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
-    if (typeTokens) {
-      dts = emitTypes(typeTokens, sexpr, source);
+    if (typeTokens && _typesEmitter) {
+      dts = _typesEmitter(typeTokens, sexpr, source);
     }
 
     return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
@@ -3791,10 +3843,36 @@ export class Compiler {
 installComponentSupport(CodeEmitter, Lexer);
 
 // =============================================================================
-// Type Support (enum generator)
+// Enum Codegen (CodeEmitter method)
 // =============================================================================
+// `enum` blocks compile to a runtime JavaScript object that maps both
+// forward (key → value) and reverse (value → key). This is real codegen,
+// not type machinery, so it lives with the rest of the emitter dispatch.
+
+CodeEmitter.prototype.emitEnum = function emitEnum(head, rest, context) {
+  let [name, body] = rest;
+  let enumName = name?.valueOf?.() ?? name;
+
+  let pairs = [];
+  if (Array.isArray(body)) {
+    let items = body[0] === 'block' ? body.slice(1) : [body];
+    for (let item of items) {
+      if (Array.isArray(item)) {
+        if (item[0]?.valueOf?.() === '=') {
+          let key = item[1]?.valueOf?.() ?? item[1];
+          let val = item[2]?.valueOf?.() ?? item[2];
+          pairs.push([key, val]);
+        }
+      }
+    }
+  }
+
+  if (pairs.length === 0) return `const ${enumName} = {}`;
 
-CodeEmitter.prototype.emitEnum = emitEnum;
+  let forward = pairs.map(([k, v]) => `${k}: ${v}`).join(', ');
+  let reverse = pairs.map(([k, v]) => `${v}: "${k}"`).join(', ');
+  return `const ${enumName} = {${forward}, ${reverse}}`;
+};
 
 // =============================================================================
 // Schema Support (prototype installation)

package/src/grammar/grammar.rip

@@ -808,7 +808,7 @@ grammar =
   # Schema
   # ============================================================================
   # `schema [:kind] INDENT ... OUTDENT` is parsed entirely by the schema
-  # sub-parser at lexer-rewrite time (src/schema.js). The rewriter emits
+  # sub-parser at lexer-rewrite time (src/schema/schema.js). The rewriter emits
   # a synthetic SCHEMA_BODY token whose .data carries the full descriptor
   # (kind, entries, per-entry loc). The main grammar only sees these two
   # terminals, which keeps schema body syntax (`name! type`, `@directive`,

package/src/grammar/solar.rip

@@ -154,7 +154,6 @@ class Generator
       for handle in handles
         [symbols, action, precedence] = @_parseHandle handle
 
-        # Add symbols to grammar
         addSymbol symbol for symbol in symbols
 
         # Process semantic actions

package/src/lexer.js

@@ -40,7 +40,7 @@
 // ==========================================================================
 
 import { installTypeSupport } from './types.js';
-import { installSchemaSupport } from './schema.js';
+import { installSchemaSupport } from './schema/schema.js';
 
 // ==========================================================================
 // Token Category Sets
@@ -174,6 +174,15 @@ let TAGGABLE = new Set(['IDENTIFIER', 'PROPERTY', ')', 'CALL_END', ']', 'INDEX_E
 // Control flow tokens that don't end implicit calls/objects
 let CONTROL_IN_IMPLICIT = new Set(['IF', 'TRY', 'FINALLY', 'CATCH', 'CLASS', 'SWITCH', 'COMPONENT', 'FOR']);
 
+// Tokens that complete an expression value. Used to detect postfix-position
+// for keywords that exist in both prefix and postfix forms (FOR has no
+// dedicated POST_FOR token like POST_IF, so we infer it from context).
+let VALUE_END_TAGS = new Set([
+  'IDENTIFIER', 'PROPERTY', 'NUMBER', 'STRING', 'STRING_END', 'REGEX', 'REGEX_END',
+  ')', 'CALL_END', ']', 'INDEX_END', '}', 'MAP_END', 'PICK_END',
+  'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', 'SUPER', 'THIS', '@', 'SYMBOL',
+]);
+
 // Single-liner keywords that get implicit INDENT/OUTDENT
 let SINGLE_LINERS = new Set(['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN']);
 
@@ -1782,8 +1791,21 @@ export class Lexer {
         i += 1;
       };
 
-      // Don't end implicit on INDENT for control flow inside implicit
-      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag)) {
+      // Don't end implicit on INDENT for control flow inside implicit.
+      //
+      // Special case: FOR is the only entry in CONTROL_IN_IMPLICIT that can
+      // appear in postfix position (no POST_FOR token exists, unlike
+      // POST_IF / POST_UNLESS). When FOR follows a value-completing token
+      // on the same line (e.g. `addSymbol s for s in xs`), it's a postfix
+      // comprehension that should END the implicit call so the comprehension
+      // wraps the call rather than becoming the call's argument. Detect
+      // postfix FOR by: not at the start of a new line, AND the previous
+      // token is a value-completing token (IDENTIFIER, ), ], literal, etc.).
+      // Prefix FOR (after `:`, `=`, `->`, comma, etc.) keeps the existing
+      // CONTROL behaviour. Falling through lets the IMPLICIT_END handler
+      // below close the implicit call.
+      let isPostfixFor = tag === 'FOR' && !token.newLine && VALUE_END_TAGS.has(prevTag);
+      if ((inImplicitCall() || inImplicitObject()) && CONTROL_IN_IMPLICIT.has(tag) && !isPostfixFor) {
         stack.push(['CONTROL', i, {ours: true}]);
         return forward(1);
       }

package/src/parser.js

@@ -256,16 +256,16 @@ const parserInstance = {
     }
   },
   parse(input) {
-    let EOF, TERROR, action, errStr, expected, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, vals;
+    let EOF, TERROR, action, errStr, expected, k, len, lex, lexer, loc, locs, newState, p, parseTable, preErrorSymbol, r, recovering, rv, sharedState, state, stk, symbol, tokenLen, tokenLine, tokenLoc, tokenText, v, vals;
     [stk, vals, locs] = [[0], [null], []];
     [parseTable, tokenText, tokenLine, tokenLen, recovering] = [this.parseTable, "", 0, 0, 0];
     [TERROR, EOF] = [2, 1];
     lexer = Object.create(this.lexer);
     sharedState = { ctx: {} };
-    for (const k in this.ctx) {
+    for (let k in this.ctx) {
       if (!Object.hasOwn(this.ctx, k))
         continue;
-      const v = this.ctx[k];
+      let v = this.ctx[k];
       sharedState.ctx[k] = v;
     }
     lexer.setInput(input, sharedState.ctx);
@@ -294,7 +294,7 @@ const parserInstance = {
         if (!recovering)
           expected = (() => {
             const result = [];
-            for (const p in parseTable[state]) {
+            for (let p in parseTable[state]) {
               if (!Object.hasOwn(parseTable[state], p))
                 continue;
               if (this.tokenNames[p] && p > TERROR)

package/src/schema/dts-emit.js

@@ -0,0 +1,329 @@
+// Schema .d.ts emission — CLI / typecheck only.
+//
+// This module is a CLI/editor-only sidecar that walks parsed schema
+// s-expressions and emits TypeScript declarations for the LSP and
+// `rip check`. The browser bundle must NOT import this module — see
+// scripts/check-bundle-graph.js.
+//
+// SCHEMA_INTRINSIC_DECLS holds the Schema<Out, In> / SchemaIssue /
+// SchemaSafeResult / SchemaQuery / ModelSchema interface declarations
+// that prepend a schema-using compilation. emitSchemaTypes() walks
+// the parsed s-expression, builds per-schema descriptors, and emits
+// `declare const Foo: Schema<...>` / ModelSchema / etc. lines.
+//
+// All the runtime (parsing, validation, ORM, DDL, registry) lives in
+// ./schema.js and the runtime-*.js fragments in this same directory,
+// shared between browser and server. The `runtime-*` files are concatenated
+// at build into runtime.generated.js and execute at runtime; THIS file is
+// orthogonal — it runs at compile time and never reaches runtime.
+
+// ============================================================================
+// Shadow TypeScript — Phase 3.5
+// ============================================================================
+//
+// Emits virtual `.d.ts` / `.ts` declarations for :input, :shape, and :enum
+// schemas so the TS language service can offer autocomplete and catch
+// AST-shape mistakes before Phase 4 layers in :model/ORM/algebra. Written
+// to mirror `emitComponentTypes()` in src/types.js — same prototype:
+// `emitSchemaTypes(sexpr, lines)` returns true when any schema declaration
+// was found (drives preamble injection), mutates `lines` with declarations.
+//
+// Type surface (locked with peer AI):
+//
+//   interface Schema<T> {
+//     parse(data: unknown): T;
+//     safe(data: unknown): SchemaSafeResult<T>;
+//     ok(data: unknown): boolean;
+//   }
+//
+// `:input`  emits  declare const Foo: Schema<FooValue>;
+// `:shape`  emits  declare const Foo: Schema<FooInstance>;   where
+//                  FooInstance = FooData & {methods/readonly getters}.
+// `:enum`   emits  declare const Role: { parse(...): Role; ok(d): d is Role; ... }
+//
+// Methods are typed `(...args: any[]) => unknown`. Computed are
+// `readonly name: unknown`. Body inference is out of scope for 3.5.
+
+export const SCHEMA_INTRINSIC_DECLS = [
+  'interface SchemaIssue { field: string; error: string; message: string; }',
+  'type SchemaSafeResult<T> = { ok: true; value: T; errors: null } | { ok: false; value: null; errors: SchemaIssue[] };',
+  // Base Schema interface. `Out` is the parsed value type; `In` is the
+  // data shape (defaults to unknown). Algebra methods are parameterized
+  // over `In` so chained operations on a typed :shape or :model derive
+  // correctly; when `In` defaults to unknown, `keyof In` is `never` and
+  // algebra methods don't autocomplete — which is the right behavior
+  // for :input schemas where the input shape isn't statically known.
+  'interface Schema<Out, In = unknown> {',
+  '  parse(data: In): Out;',
+  '  safe(data: In): SchemaSafeResult<Out>;',
+  '  ok(data: unknown): boolean;',
+  '  pick<K extends keyof In>(...keys: K[]): Schema<Pick<In, K>, Pick<In, K>>;',
+  '  omit<K extends keyof In>(...keys: K[]): Schema<Omit<In, K>, Omit<In, K>>;',
+  '  partial(): Schema<Partial<In>, Partial<In>>;',
+  '  required<K extends keyof In>(...keys: K[]): Schema<Omit<In, K> & Required<Pick<In, K>>, Omit<In, K> & Required<Pick<In, K>>>;',
+  '  extend<U>(other: Schema<U>): Schema<In & U, In & U>;',
+  '}',
+  // Chainable query builder for :model.
+  'interface SchemaQuery<T> {',
+  '  all(): Promise<T[]>;',
+  '  first(): Promise<T | null>;',
+  '  count(): Promise<number>;',
+  '  limit(n: number): SchemaQuery<T>;',
+  '  offset(n: number): SchemaQuery<T>;',
+  '  order(spec: string): SchemaQuery<T>;',
+  '}',
+  // ModelSchema extends the base schema surface with ORM methods. Algebra
+  // over `Data` (not `Instance`) so derived shapes reflect runtime
+  // behavior-dropping semantics.
+  'interface ModelSchema<Instance, Data = unknown> extends Schema<Instance, Data> {',
+  '  find(id: unknown): Promise<Instance | null>;',
+  '  findMany(ids: unknown[]): Promise<Instance[]>;',
+  '  where(cond: Record<string, unknown> | string, ...params: unknown[]): SchemaQuery<Instance>;',
+  '  all(limit?: number): Promise<Instance[]>;',
+  '  first(): Promise<Instance | null>;',
+  '  count(cond?: Record<string, unknown>): Promise<number>;',
+  '  create(data: Partial<Data>): Promise<Instance>;',
+  '  toSQL(options?: { dropFirst?: boolean; header?: string; idStart?: number }): string;',
+  '}',
+];
+
+const RIP_TYPE_TO_TS = {
+  string:   'string',
+  text:     'string',
+  email:    'string',
+  url:      'string',
+  uuid:     'string',
+  phone:    'string',
+  zip:      'string',
+  number:   'number',
+  integer:  'number',
+  boolean:  'boolean',
+  date:     'Date',
+  datetime: 'Date',
+  json:     'unknown',
+  any:      'any',
+};
+
+function mapFieldType(entry) {
+  if (entry.typeName === 'literal-union' && entry.literals?.length) {
+    return entry.literals.map(l => JSON.stringify(l)).join(' | ');
+  }
+  let base = RIP_TYPE_TO_TS[entry.typeName] ?? entry.typeName;
+  return entry.array ? `${base}[]` : base;
+}
+
+// Extract descriptor from a SCHEMA_BODY s-expr node. Grammar reduces
+// `['schema', SCHEMA_BODY_VAL]` where the value is the String wrapper
+// carrying `.descriptor` via the metadata bridge.
+function descriptorFromSchemaNode(schemaNode) {
+  if (!Array.isArray(schemaNode)) return null;
+  let head = schemaNode[0]?.valueOf?.() ?? schemaNode[0];
+  if (head !== 'schema') return null;
+  let body = schemaNode[1];
+  if (!body || typeof body !== 'object') return null;
+  if (body.descriptor) return body.descriptor;
+  if (body.data?.descriptor) return body.data.descriptor;
+  return null;
+}
+
+// Walk the parsed s-expression collecting every named schema declaration.
+// Mixins are emitted first so subsequent :shape/:model type aliases can
+// reference them in `& Timestamps`-style intersections. Within a group,
+// source order is preserved. Returns true when at least one schema was
+// found (drives intrinsic preamble injection).
+export function emitSchemaTypes(sexpr, lines) {
+  const collected = [];
+  collectSchemas(sexpr, collected);
+  if (!collected.length) return false;
+
+  // Set of locally-known schema names (for relation-accessor type
+  // resolution — same-file targets get typed, unknown targets degrade).
+  const known = new Set(collected.map(c => c.name));
+  const byName = new Map(collected.map(c => [c.name, c]));
+
+  // Mixin types first so type aliases down-file can reference them.
+  for (const c of collected) {
+    if (c.descriptor.kind === 'mixin') emitOneSchemaType(c, byName, known, lines);
+  }
+  for (const c of collected) {
+    if (c.descriptor.kind !== 'mixin') emitOneSchemaType(c, byName, known, lines);
+  }
+  return true;
+}
+
+function collectSchemas(sexpr, out) {
+  if (!Array.isArray(sexpr)) return;
+  const head = sexpr[0]?.valueOf?.() ?? sexpr[0];
+  let exported = false;
+  let assignNode = null;
+  if (head === 'export' && Array.isArray(sexpr[1])) {
+    const inner = sexpr[1];
+    const innerHead = inner[0]?.valueOf?.() ?? inner[0];
+    if (innerHead === '=') { exported = true; assignNode = inner; }
+    else collectSchemas(sexpr[1], out);
+  } else if (head === '=') {
+    assignNode = sexpr;
+  } else if (head === 'program' || head === 'block') {
+    for (let i = 1; i < sexpr.length; i++) {
+      if (Array.isArray(sexpr[i])) collectSchemas(sexpr[i], out);
+    }
+  }
+  if (assignNode && Array.isArray(assignNode[2])) {
+    const name = assignNode[1]?.valueOf?.() ?? assignNode[1];
+    const descriptor = descriptorFromSchemaNode(assignNode[2]);
+    if (typeof name === 'string' && descriptor) {
+      out.push({ name, descriptor, exported });
+    }
+  }
+}
+
+function emitOneSchemaType(collected, byName, known, lines) {
+  const { name, descriptor, exported } = collected;
+  const exp = exported ? 'export ' : '';
+  const decl = exported ? '' : 'declare ';
+
+  if (descriptor.kind === 'enum') {
+    const members = [];
+    for (const e of descriptor.entries) {
+      if (e.tag !== 'enum-member') continue;
+      const v = e.value !== undefined ? e.value : e.name;
+      members.push(typeof v === 'string' ? JSON.stringify(v) : String(v));
+    }
+    const union = members.length ? members.join(' | ') : 'never';
+    lines.push(`${exp}type ${name} = ${union};`);
+    lines.push(`${exp}${decl}const ${name}: { parse(data: unknown): ${name}; safe(data: unknown): SchemaSafeResult<${name}>; ok(data: unknown): data is ${name}; };`);
+    return;
+  }
+
+  if (descriptor.kind === 'mixin') {
+    // :mixin is declaration-time-only; expose it as a field type alias
+    // so hosts that `@mixin Foo` can intersect it into their Data type.
+    // No value declaration — mixins aren't user-facing runtime values.
+    const fieldProps = fieldPropList(descriptor);
+    lines.push(`${exp}type ${name} = { ${fieldProps.join('; ')} };`);
+    return;
+  }
+
+  const fieldProps = fieldPropList(descriptor);
+  const mixinRefs = mixinIntersections(descriptor, byName);
+  const methods = [];
+  const computed = [];
+  for (const e of descriptor.entries) {
+    if (e.tag === 'method') {
+      methods.push(`${e.name}: (...args: any[]) => unknown`);
+    } else if (e.tag === 'computed') {
+      computed.push(`readonly ${e.name}: unknown`);
+    }
+    // hooks are intentionally omitted — they fire automatically and
+    // shouldn't appear in autocomplete.
+  }
+
+  const dataBase = `{ ${fieldProps.join('; ')} }`;
+  const dataType = mixinRefs.length ? `${dataBase} & ${mixinRefs.join(' & ')}` : dataBase;
+
+  if (descriptor.kind === 'model') {
+    const dataName = `${name}Data`;
+    const instName = `${name}Instance`;
+    const relationAccessors = modelRelationAccessors(descriptor, known);
+    const instanceExtras = [
+      ...computed,
+      ...methods,
+      ...relationAccessors,
+      `save(): Promise<${instName}>`,
+      `destroy(): Promise<${instName}>`,
+      `ok(): boolean`,
+      `errors(): SchemaIssue[]`,
+      `toJSON(): ${dataName}`,
+    ];
+    lines.push(`${exp}type ${dataName} = ${dataType};`);
+    lines.push(`${exp}type ${instName} = ${dataName} & { ${instanceExtras.join('; ')} };`);
+    lines.push(`${exp}${decl}const ${name}: ModelSchema<${instName}, ${dataName}>;`);
+    return;
+  }
+
+  if (descriptor.kind === 'shape') {
+    const dataName = `${name}Data`;
+    const instName = `${name}Instance`;
+    const hasBehavior = methods.length + computed.length > 0;
+    lines.push(`${exp}type ${dataName} = ${dataType};`);
+    if (hasBehavior) {
+      lines.push(`${exp}type ${instName} = ${dataName} & { ${[...computed, ...methods].join('; ')} };`);
+      lines.push(`${exp}${decl}const ${name}: Schema<${instName}, ${dataName}>;`);
+    } else {
+      lines.push(`${exp}${decl}const ${name}: Schema<${dataName}, ${dataName}>;`);
+    }
+    return;
+  }
+
+  // :input — parse returns the Data shape directly (no behavior).
+  const valueName = `${name}Value`;
+  lines.push(`${exp}type ${valueName} = ${dataType};`);
+  lines.push(`${exp}${decl}const ${name}: Schema<${valueName}, ${valueName}>;`);
+}
+
+// Return an array of mixin type-reference strings for `& Foo & Bar` joins.
+function mixinIntersections(descriptor, byName) {
+  const refs = [];
+  for (const e of descriptor.entries) {
+    if (e.tag !== 'directive' || e.name !== 'mixin') continue;
+    const args = e.args;
+    const target = args && args[0] && args[0].target;
+    if (!target) continue;
+    const known = byName && byName.get(target);
+    if (known && known.descriptor.kind === 'mixin') {
+      refs.push(target);
+    }
+  }
+  return refs;
+}
+
+// Emit relation accessor type declarations for :model instances. For
+// targets declared in the same file we emit a typed Promise; for
+// unknown (cross-file) targets we degrade to `Promise<unknown>` rather
+// than emit an unresolved bare name.
+function modelRelationAccessors(descriptor, known) {
+  const out = [];
+  for (const e of descriptor.entries) {
+    if (e.tag !== 'directive') continue;
+    const args = e.args;
+    if (!args || !args[0]) continue;
+    const target = args[0].target;
+    if (!target) continue;
+    const optional = args[0].optional === true;
+    const targetLc = target[0].toLowerCase() + target.slice(1);
+    const instName = `${target}Instance`;
+    const isKnown = known && known.has(target);
+    if (e.name === 'belongs_to') {
+      const retT = isKnown ? (optional ? `${instName} | null` : `${instName} | null`) : 'unknown';
+      out.push(`${targetLc}(): Promise<${retT}>`);
+    } else if (e.name === 'has_one' || e.name === 'one') {
+      const retT = isKnown ? `${instName} | null` : 'unknown';
+      out.push(`${targetLc}(): Promise<${retT}>`);
+    } else if (e.name === 'has_many' || e.name === 'many') {
+      const retT = isKnown ? `${instName}[]` : 'unknown[]';
+      const pluralLc = __schemaClientPluralize(targetLc);
+      out.push(`${pluralLc}(): Promise<${retT}>`);
+    }
+  }
+  return out;
+}
+
+// Minimal pluralizer for accessor names. Keep in sync with the runtime
+// __schemaPluralize rules (same surface for declaration parity).
+function __schemaClientPluralize(w) {
+  const lw = w.toLowerCase();
+  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 fieldPropList(descriptor) {
+  const props = [];
+  for (const e of descriptor.entries) {
+    if (e.tag !== 'field') continue;
+    const required = e.modifiers.includes('!');
+    const mark = required ? '' : '?';
+    props.push(`${e.name}${mark}: ${mapFieldType(e)}`);
+  }
+  return props;
+}

package/src/schema/loader-browser.js

@@ -0,0 +1,55 @@
+// Schema runtime loader — browser variant.
+//
+// Why this file exists: this is the IMPORT BOUNDARY for the browser
+// bundle. By only importing validate + browser-stubs fragments here,
+// Bun's tree-shaker can omit db-naming / orm / ddl from the bundle.
+// If the mode-switch lived in src/schema.js (reachable from every
+// entry), the bundler couldn't statically prove the unused fragments
+// were unreachable and would keep them. The loader split is the lever
+// that makes the bundle savings real.
+//
+// See loader-server.js for the corresponding server / CLI variant
+// that imports all five fragments.
+//
+// Side-effect import. Adds a runtime provider that supports validate
+// and browser modes only. Eagerly installs the browser runtime on
+// globalThis at module load.
+
+import {
+  SCHEMA_RUNTIME_WRAPPER_HEAD,
+  SCHEMA_RUNTIME_WRAPPER_TAIL,
+  SCHEMA_VALIDATE_RUNTIME,
+  SCHEMA_BROWSER_STUBS_RUNTIME,
+} from './runtime.generated.js';
+import { setSchemaRuntimeProvider } from './schema.js';
+
+function provider({ mode = 'browser' } = {}) {
+  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':
+    case 'migration':
+      throw new Error(
+        "schema runtime mode '" + mode + "' is not available in the browser. " +
+        "ORM and DDL features require side-effect-importing loader-server.js."
+      );
+    default:
+      throw new Error(`unknown schema runtime mode: ${mode}`);
+  }
+  return (SCHEMA_RUNTIME_WRAPPER_HEAD + body + SCHEMA_RUNTIME_WRAPPER_TAIL).trimStart();
+}
+
+setSchemaRuntimeProvider(provider);
+
+// Eagerly install browser runtime so user code compiled with
+// skipRuntimes: true (the typical case in browser bundles) finds
+// {__schema, SchemaError} on globalThis.
+export const SCHEMA_RUNTIME = provider({ mode: 'browser' });
+if (typeof globalThis !== 'undefined' && !globalThis.__ripSchema) {
+  try { (0, eval)(SCHEMA_RUNTIME); } catch {}
+}