rip-lang 3.15.0 → 3.15.2

package/docs/extensions/duckdb/manifest.json

@@ -1,7 +1,7 @@
 {
   "extension": "ripdb",
   "base_url": "https://shreeve.github.io/rip-lang/extensions/duckdb",
-  "updated_at": "2026-04-27T04:14:31Z",
+  "updated_at": "2026-04-27T06:24:32Z",
   "versions": {
     "v1.5.2": [
       "linux_amd64",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.15.0",
+  "version": "3.15.2",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -17,9 +17,6 @@
     },
     "./loader": "./rip-loader.js"
   },
-  "dependencies": {
-    "@rip-lang/schema": "0.1.0"
-  },
   "bin": {
     "rip": "bin/rip"
   },
@@ -27,6 +24,7 @@
     "bin/",
     "src/",
     "docs/",
+    "scripts/postinstall.js",
     "scripts/serve.js",
     "rip-loader.js",
     "README.md",
@@ -39,16 +37,16 @@
     "gallery": "bun scripts/gallery.js",
     "bundle:demo": "bun scripts/bundle-app.js docs/demo -o docs/example/index.json -t 'Rip App Demo'",
     "parser": "bun src/grammar/solar.rip -o src/parser.js src/grammar/grammar.rip",
-    "postinstall": "bun scripts/link-local.js --quiet && bun scripts/link-check.js --quiet",
+    "postinstall": "node scripts/postinstall.js --quiet",
     "link-local": "bun scripts/link-local.js",
     "link-global": "bun scripts/link-global.js",
     "link-check": "bun scripts/link-check.js",
     "serve": "bun scripts/serve.js",
     "test": "bun test/runner.js",
     "test:types": "bun test/types/runner.js",
-    "test:schema": "bun run --cwd packages/schema test",
-    "test:schema-fresh": "bun run --cwd packages/schema test:runtime-fresh",
-    "build:schema-runtime": "bun run --cwd packages/schema build:runtime",
+    "test:schema": "bun test/schema/singleton.test.js && bun test/schema/errors.test.js && bun test/schema/modes.test.js && bun test/schema/build.test.js",
+    "test:schema-fresh": "bun scripts/build-schema-runtime.js --check",
+    "build:schema-runtime": "bun scripts/build-schema-runtime.js",
     "test:bundle": "bun test/bundle.test.js",
     "test:graph": "bun scripts/check-bundle-graph.js",
     "test:server": "./bin/rip packages/server/tests/runner.rip",

package/scripts/postinstall.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// scripts/postinstall.js — workspace-only postinstall hook.
+//
+// `link-local.js` and `link-check.js` rewrite `node_modules/.bun/` and
+// `node_modules/rip-lang/` to point at the workspace's source tree.
+// That's exactly what we want during dev, but it's meaningless — and
+// would error — for consumers running `npm install rip-lang` from
+// outside this repo (no `packages/` sibling, possibly no `bun` binary).
+//
+// This dispatcher checks for the workspace markers first and exits 0
+// otherwise. Uses Node only (every npm install has Node; not every
+// consumer has Bun). Tolerates missing files / non-zero subprocess
+// exits — postinstall is best-effort, never fatal for consumers.
+
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+if (!existsSync('packages') || !existsSync('scripts/link-local.js')) process.exit(0);
+
+const args = process.argv.slice(2);
+const run = (script) => {
+  const r = spawnSync('bun', ['scripts/' + script, ...args], { stdio: 'inherit' });
+  return r.status ?? 0;
+};
+
+run('link-local.js');
+run('link-check.js');

package/src/AGENTS.md

@@ -1,6 +1,6 @@
 # Compiler Subsystem — Agent Guide
 
-This covers `compiler.js`, `lexer.js`, `components.js`, `browser.js`, `types.js`, `types-emit.js`, `app.rip`, `typecheck.js`, and the `grammar/` directory. The schema feature lives in `packages/schema/` (entry point `packages/schema/src/schema.js`, imported here as `@rip-lang/schema`); see `packages/schema/README.md` for its layout.
+This covers `compiler.js`, `lexer.js`, `components.js`, `browser.js`, `types.js`, `types-emit.js`, `app.rip`, `typecheck.js`, the `schema/` subdirectory, and the `grammar/` directory. The schema feature lives in `src/schema/` (entry `src/schema/schema.js`, imported via relative paths like `./schema/schema.js` from sibling modules).
 
 ---
 
@@ -16,22 +16,22 @@ The browser bundle (`docs/dist/rip.min.js`) is built from `src/browser.js` plus
 | `src/lexer.js` | yes | tokenizer + rewriter pipeline |
 | `src/compiler.js` | yes | codegen + reactive runtime + component runtime + `compileToJS` + `setTypesEmitter` hook + `emitEnum` |
 | `src/components.js` | yes | render rewriter + component runtime |
-| `packages/schema/src/schema.js` | yes (via `@rip-lang/schema`) | lexer rewrite + body parser + emitSchema codegen + `setSchemaRuntimeProvider` hook (no fragment imports) |
-| `packages/schema/src/loader-browser.js` | yes (browser only, via `@rip-lang/schema/loader-browser`) | imports validate + browser-stubs fragments; eager-installs browser runtime; registers provider |
-| `packages/schema/src/loader-server.js` | **no** (CLI / server / tests, via `@rip-lang/schema/loader-server`) | imports all five fragments; eager-installs migration runtime; registers provider |
-| `packages/schema/src/runtime.generated.js` | yes (browser uses 2 of 5 exports) | autogen from `runtime-*.js` fragments; CI staleness check via `bun run test:schema-fresh` |
-| `packages/schema/src/runtime-validate.js` | source for the `validate` fragment (universal) |
-| `packages/schema/src/runtime-db-naming.js` | source for `db-naming` fragment (server + migration) |
-| `packages/schema/src/runtime-orm.js` | source for `orm` fragment (server + migration) |
-| `packages/schema/src/runtime-ddl.js` | source for `ddl` fragment (migration only) |
-| `packages/schema/src/runtime-browser-stubs.js` | source for `browser-stubs` fragment (browser only) |
+| `src/schema/schema.js` | yes (via `./schema/schema.js`) | lexer rewrite + body parser + emitSchema codegen + `setSchemaRuntimeProvider` hook (no fragment imports) |
+| `src/schema/loader-browser.js` | yes (browser only, via `./schema/loader-browser.js`) | imports validate + browser-stubs fragments; eager-installs browser runtime; registers provider |
+| `src/schema/loader-server.js` | **no** (CLI / server / tests, via `./schema/loader-server.js`) | imports all five fragments; eager-installs migration runtime; registers provider |
+| `src/schema/runtime.generated.js` | yes (browser uses 2 of 5 exports) | autogen from `runtime-*.js` fragments; CI staleness check via `bun run test:schema-fresh` |
+| `src/schema/runtime-validate.js` | source for the `validate` fragment (universal) |
+| `src/schema/runtime-db-naming.js` | source for `db-naming` fragment (server + migration) |
+| `src/schema/runtime-orm.js` | source for `orm` fragment (server + migration) |
+| `src/schema/runtime-ddl.js` | source for `ddl` fragment (migration only) |
+| `src/schema/runtime-browser-stubs.js` | source for `browser-stubs` fragment (browser only) |
 | `src/types.js` | yes | only `installTypeSupport(Lexer)` — token-stream type stripper |
 | `src/error.js` | yes | runtime error formatting |
 | `src/sourcemaps.js` | yes | inline source-map generation |
 | `src/generated/dom-tags.js` | yes | HTML/SVG tag set for render-block tag detection |
 | `src/generated/dom-events.js` | yes | event-name set for `onClick`/`onKeydown` auto-wire |
 | `src/types-emit.js` | **no** | `.d.ts` emitter + intrinsic decl tables — CLI / typecheck only |
-| `packages/schema/src/dts-emit.js` | **no** | schema `.d.ts` emitter — CLI / typecheck only |
+| `src/schema/dts-emit.js` | **no** | schema `.d.ts` emitter — CLI / typecheck only |
 | `src/typecheck.js` | **no** | TypeScript LSP integration — CLI only |
 | `src/repl.js` | **no** | interactive CLI REPL |
 
@@ -60,7 +60,7 @@ The browser bundle never imports `types-emit.js`, so the emitter stays null and
 
 **Failure mode to remember:** If you write code that calls `compile(source, { types: 'emit' })` and inspects `result.dts`, you **must** import `src/types-emit.js` (directly or indirectly) somewhere in that code path. Without it, `result.dts` is `null` regardless of source content. Symptom: types emission "silently does nothing" — no error, no warning, just empty output. The fix is one line: `import '../src/types-emit.js';`.
 
-The schema runtime uses an analogous hook: `packages/schema/src/schema.js` exports `setSchemaRuntimeProvider(fn)`, default null. `packages/schema/src/loader-server.js` and `packages/schema/src/loader-browser.js` are the two providers. CLI / tests / server side-effect-import `@rip-lang/schema/loader-server` (full migration runtime, all four modes). The browser bundle (`src/browser.js`) side-effect-imports `@rip-lang/schema/loader-browser` (validate + browser-stubs only). Same failure mode applies — call `getSchemaRuntime()` without registering a provider and you get a clear error pointing at which loader to import.
+The schema runtime uses an analogous hook: `src/schema/schema.js` exports `setSchemaRuntimeProvider(fn)`, default null. `src/schema/loader-server.js` and `src/schema/loader-browser.js` are the two providers. CLI / tests / server side-effect-import `./schema/loader-server.js` (full migration runtime, all four modes). The browser bundle (`src/browser.js`) side-effect-imports `./schema/loader-browser.js` (validate + browser-stubs only). Same failure mode applies — call `getSchemaRuntime()` without registering a provider and you get a clear error pointing at which loader to import.
 
 The mode matrix exposed by `getSchemaRuntime({ mode })`:
 
@@ -71,7 +71,7 @@ The mode matrix exposed by `getSchemaRuntime({ mode })`:
 | `server` | VALIDATE + DB_NAMING + ORM | `@rip-lang/server` and friends |
 | `migration` | VALIDATE + DB_NAMING + ORM + DDL | CLI / migration tool / tests (default) |
 
-Edits to `packages/schema/src/runtime-*.js` require running `bun run build:schema-runtime` (delegates to the schema package) to regenerate `runtime.generated.js`. CI fails (`bun run test:schema-fresh`) if the generated file is stale.
+Edits to `src/schema/runtime-*.js` require running `bun run build:schema-runtime` to regenerate `runtime.generated.js`. CI fails (`bun run test:schema-fresh`) if the generated file is stale.
 
 ---
 
@@ -643,29 +643,31 @@ Types are processed at the token layer before parsing.
 ## Schema System
 
 Inline schemas are a compiler sidecar that parallels `types.js` and
-`components.js`, but unlike those two it lives in its own workspace
-package — `packages/schema/`, imported here as `@rip-lang/schema`. The
-implementation is split across several files by execution context:
-
-- `packages/schema/src/schema.js` (browser + server) — lexer rewrite,
+`components.js` — a feature of the rip-lang compiler, just organized
+into its own subdirectory `src/schema/` because of its size. Schema
+mutates the host parser's lexer to re-parse `@ensure` predicate
+bodies, so it isn't a clean separable package; the subdirectory is
+purely for source organization. The implementation is split across
+several files by execution context:
+
+- `src/schema/schema.js` (browser + server) — lexer rewrite,
   body parsers, `emitSchema` codegen, and `setSchemaRuntimeProvider`
   hook. The runtime body itself is **not** here; this file imports zero
   fragments so the bundler can decide per-entry which fragments to include.
-- `packages/schema/src/runtime-{validate,db-naming,orm,ddl,browser-stubs}.js`
-  (sources) and `packages/schema/src/runtime.generated.js` (autogen) —
+- `src/schema/runtime-{validate,db-naming,orm,ddl,browser-stubs}.js`
+  (sources) and `src/schema/runtime.generated.js` (autogen) —
   five runtime fragments composed at call time by `getSchemaRuntime({ mode })`.
   Edit a source fragment, run `bun run build:schema-runtime` to refresh
   the generated file, commit. CI's `test:schema-fresh` fails on staleness.
-- `@rip-lang/schema/loader-server` and `@rip-lang/schema/loader-browser`
+- `src/schema/loader-server.js` and `src/schema/loader-browser.js`
   — the import boundary that decides which fragments end up in which
   bundle. Server loader pulls all five; browser loader pulls only
   validate + browser-stubs. Bun's tree-shaker uses these import sets to
   omit server-only fragments from `docs/dist/rip.min.js`.
-- `@rip-lang/schema/dts-emit` (CLI/LSP only) — `emitSchemaTypes` walks
+- `src/schema/dts-emit.js` (CLI/LSP only) — `emitSchemaTypes` walks
   parsed schema s-expressions and emits `declare const Foo: Schema<...>`
   lines for the TypeScript language service. Imported only by
-  `types-emit.js` and `typecheck.js`. Lives inside `packages/schema/src/`
-  so all schema-related code is colocated; the `dts-emit` name signals
+  `types-emit.js` and `typecheck.js`. The `dts-emit` name signals
   that this is a compile-time `.d.ts` emitter, not a `runtime-*` fragment.
 
 ### Lexer path
@@ -765,7 +767,7 @@ signatures both enforce this.
   `@ensure` entirely (trusted data). Runtime method name
   `_applyEnsures` mirrors the directive (parallel to
   `_applyTransforms` for `-> transform` and `_applyEagerDerived` for
-  `!> derived`). See `packages/schema/src/schema.js`.
+  `!> derived`). See `src/schema/schema.js`.
 
 ### Shadow TS
 

package/src/browser.js

@@ -5,7 +5,7 @@
 // Pulls in only the validate + browser-stubs fragments; tree-shakes
 // db-naming, orm, and ddl fragments out of the bundle. Must be the
 // first import so any later module-load eager-installs see it.
-import '@rip-lang/schema/loader-browser';
+import './schema/loader-browser.js';
 
 export { Lexer } from './lexer.js';
 export { parser } from './parser.js';

package/src/compiler.js

@@ -16,7 +16,7 @@ import { installComponentSupport } from './components.js';
 // so _typesEmitter stays null and .d.ts output is silently skipped.
 let _typesEmitter = null;
 export function setTypesEmitter(fn) { _typesEmitter = fn; }
-import { installSchemaSupport } from '@rip-lang/schema';
+import { installSchemaSupport } from './schema/schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { RipError, toRipError } from './error.js';
 

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 (packages/schema/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/lexer.js

@@ -40,7 +40,7 @@
 // ==========================================================================
 
 import { installTypeSupport } from './types.js';
-import { installSchemaSupport } from '@rip-lang/schema';
+import { installSchemaSupport } from './schema/schema.js';
 
 // ==========================================================================
 // Token Category Sets

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 {}
+}