rip-lang 3.16.1 → 3.16.2

package/docs/extensions/vscode/rip/index.html

@@ -32,7 +32,8 @@ cursor --install-extension ./rip-latest.vsix
 
 <h2>Versions</h2>
 <ul>
-    <li><a href="./rip-0.5.15.vsix"><code>rip-0.5.15.vsix</code></a></li>
+    <li><a href="./vscode-rip-0.6.0.vsix"><code>vscode-rip-0.6.0.vsix</code></a></li>
+      <li><a href="./rip-0.5.15.vsix"><code>rip-0.5.15.vsix</code></a></li>
 </ul>
 
 <footer>← <a href="../../">all rip-lang extensions</a></footer>

package/docs/index.html

@@ -634,7 +634,7 @@
       typeKeywords: ['number', 'string', 'boolean', 'void', 'any', 'never', 'unknown', 'object', 'symbol', 'bigint'],
 
       operators: [
-        '|>', '::', ':=', '~=', '~>', '<=>', '=!', '!?', '=~', '??', '?.', '...',
+        '::', ':=', '~=', '~>', '<=>', '=!', '!?', '=~', '??', '?.', '...',
         '..', '**', '//', '%%', '++', '--', '&&', '||', '===', '!==', '==', '!=',
         '<=', '>=', '=>', '->', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=',
         '??=', '<<=', '>>=', '>>>=', '&=', '|=', '^=', '>>>', '>>', '<<',

package/docs/ui/hljs-rip.js

@@ -165,7 +165,7 @@ export default function(hljs) {
 
   const OPERATORS = {
     className: 'operator',
-    begin: /\|>|::|:=|~=|~>|<=>|\.=|=!|!\?|\?!|=~|\?\?=|\?\?|\?\.|\.\.\.|\.\.|=>|->|\*\*|\/\/|%%|===|!==|==|!=|<=|>=|&&|\|\||[+\-*\/%&|^~<>=!?]/,
+    begin: /::|:=|~=|~>|<=>|\.=|=!|!\?|\?!|=~|\?\?=|\?\?|\?\.|\.\.\.|\.\.|=>|->|\*\*|\/\/|%%|===|!==|==|!=|<=|>=|&&|\|\||[+\-*\/%&|^~<>=!?]/,
     relevance: 0,
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.16.1",
+  "version": "3.16.2",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
@@ -49,14 +49,17 @@
     "serve": "bun scripts/serve.js",
     "test": "bun test/runner.js",
     "test:types": "bun test/types/runner.js",
-    "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": "bun test/schema/singleton.test.js && bun test/schema/errors.test.js && bun test/schema/modes.test.js && bun test/schema/build.test.js && bun test/schema/extract.test.js && bun test/schema/infer.test.js",
     "test:schema-fresh": "bun scripts/build-schema-runtime.js --check",
+    "test:docs": "bun scripts/doctest.js",
     "build:schema-runtime": "bun scripts/build-schema-runtime.js",
     "test:bundle": "bun test/bundle.test.js",
+    "test:loader": "bun test/loader-reexport.test.js",
     "test:graph": "bun scripts/check-bundle-graph.js",
     "test:server": "./bin/rip packages/server/tests/runner.rip",
     "test:time": "bun run --cwd packages/time test",
-    "test:all": "bun run test && bun run test:types && bun run test:schema && bun run test:schema-fresh && bun run test:graph && bun run test:bundle && bun run test:server && bun run test:time",
+    "test:validate": "./bin/rip packages/validate/test.rip",
+    "test:all": "bun run test && bun run test:types && bun run test:schema && bun run test:schema-fresh && bun run test:docs && bun run test:loader && bun run test:graph && bun run test:bundle && bun run test:server && bun run test:time && bun run test:validate",
     "test:ui": "bun run --cwd packages/ui test:e2e",
     "test:ui:chromium": "bun run --cwd packages/ui test:e2e:chromium",
     "test:ui:axe": "bun run --cwd packages/ui test:e2e:axe",
@@ -90,7 +93,7 @@
   "homepage": "https://github.com/shreeve/rip-lang#readme",
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
   "license": "MIT",
-  "devDependencies": {
+  "dependencies": {
     "@types/bun": "1.3.14",
     "typescript": "catalog:"
   }

package/src/AGENTS.md

@@ -27,6 +27,7 @@ The browser bundle (`docs/dist/rip.min.js`) is built from `src/browser.js` plus
 | `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-migrate.js` | source for `migrate` fragment (migration only) — introspection, differ, status/make/migrate |
 | `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 |
@@ -40,6 +41,8 @@ The browser bundle (`docs/dist/rip.min.js`) is built from `src/browser.js` plus
 
 The forbidden list in `scripts/check-bundle-graph.js` enforces this. If a code change would put a forbidden module on the browser graph, `bun run build` aborts before the bundler runs.
 
+**Decision record — "core Rip" vs "type-enabled Rip" (June 2026):** this module graph *is* the split. Tier 0 is the erasure core (everything reachable from `src/browser.js` — types stripped, never checked); tier 1 adds `.d.ts` emission (`dts.js`, registered via `setTypesEmitter`); tier 2 adds type checking (`typecheck.js` + the TypeScript service, loaded only by `rip check`). A package-level split (`@rip-lang/core` + a typed variant) was considered and rejected: it would add publishing and versioning friction to express a boundary the import graph and the bundle-graph guard already enforce mechanically. Don't re-propose the package split; if the boundary needs strengthening, extend the forbidden list or route new type-aware behavior through a registration hook instead.
+
 ### Registration-hook pattern (`setTypesEmitter`, `setSchemaRuntimeProvider`)
 
 The same pattern is used twice — once for `.d.ts` emission, once for the schema runtime body. Both make the bundler's tree-shaker keep CLI/server-only code out of the browser bundle.
@@ -72,7 +75,7 @@ The mode matrix exposed by `getSchemaRuntime({ mode })`:
 | `validate` | VALIDATE | isomorphic validate-only contexts |
 | `browser` | VALIDATE + BROWSER_STUBS | the `<script type="text/rip">` runtime |
 | `server` | VALIDATE + DB_NAMING + ORM | `@rip-lang/server` and friends |
-| `migration` | VALIDATE + DB_NAMING + ORM + DDL | CLI / migration tool / tests (default) |
+| `migration` | VALIDATE + DB_NAMING + ORM + DDL + MIGRATE | CLI / migration tool / tests (default) |
 
 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.
 
@@ -236,6 +239,30 @@ Complete node reference:
 ['render', body]
 ```
 
+## Rewriter Pipeline (canonical order)
+
+The single source of truth is `rewrite()` in `src/lexer.js`. Current order, with
+the passes contributed by sidecar files marked:
+
+1. `removeLeadingNewlines`
+2. `rewriteDottedPicks` — must run before `rewriteMapLiterals` so pick bodies see raw `{` `}` for depth counting
+3. `rewriteMapLiterals`
+4. `closeMergeAssignments`
+5. `closeOpenCalls`
+6. `closeOpenIndexes`
+7. `rewriteTypes` — installed by `types.js`; must run before `normalizeLines`, otherwise a type-arrow `=>` inside `(...) => T` is treated as a single-liner function and wrapped in spurious INDENT/OUTDENT, derailing the type collector
+8. `normalizeLines`
+9. `rewriteRender?.()` — installed by `components.js` (optional sidecar)
+10. `rewriteSchema?.()` — installed by `schema/schema.js` (optional sidecar)
+11. `tagPostfixConditionals`
+12. `rewriteTaggedTemplates`
+13. `addImplicitBracesAndParens`
+14. `addImplicitCallCommas`
+
+When pass order changes in `rewrite()`, update this list — other sections of
+this file describe pass positions relative to their neighbors and assume this
+listing is accurate.
+
 ## Lexer Token Format
 
 Tokens are `[tag, val]` arrays with extra properties:
@@ -356,7 +383,7 @@ The component system is a compiler sidecar. `installComponentSupport(CodeEmitter
 
 ### Render Rewriter
 
-`rewriteRender()` runs after `normalizeLines` and before `tagPostfixConditionals`.
+`rewriteRender()` runs after `normalizeLines` and before `rewriteSchema()` (see "Rewriter Pipeline" above for the full order).
 
 Inside `render` blocks it rewrites template syntax into function-call syntax:
 
@@ -653,7 +680,7 @@ enum Status
 Type emission is split across two files by execution context:
 
 - `types.js` (browser-side, ~21 KB) — `installTypeSupport(Lexer)` adds `rewriteTypes()` to strip type annotations from the token stream so user-typed Rip parses. This is the only thing the browser needs from type machinery.
-- `dts.js` (CLI/LSP only, ~38 KB) — `emitTypes(tokens, sexpr, source)` generates `.d.ts`, plus `tsType`, `emitComponentTypes`, and the intrinsic declaration tables (`INTRINSIC_TYPE_DECLS`, `SIGNAL_*`, `COMPUTED_*`, `EFFECT_*`, etc.). Registers itself with the compiler at module load via `setTypesEmitter()`.
+- `dts.js` (CLI/LSP only, ~38 KB) — `emitTypes(tokens, sexpr, source, schemaBehavior)` generates `.d.ts`, plus `tsType`, `emitComponentTypes`, and the intrinsic declaration tables (`INTRINSIC_TYPE_DECLS`, `SIGNAL_*`, `COMPUTED_*`, `EFFECT_*`, etc.). Registers itself with the compiler at module load via `setTypesEmitter()`. `schemaBehavior` (the generator's per-compile buffer of compiled `~>`/`!>` bodies, populated only in `inlineTypes`/shadow mode) drives computed/derived return-type inference.
 
 `emitEnum` (runtime JS for `enum` blocks) lives in `compiler.js` next to the rest of the codegen dispatch — it's not type machinery, it's real runtime emission.
 
@@ -700,8 +727,10 @@ several files by execution context:
 ### Lexer path
 
 - `installSchemaSupport(Lexer, CodeEmitter)` adds `rewriteSchema()` to the
-  Lexer prototype. It runs between `rewriteRender()` and `rewriteTypes()` in
-  the rewriter pipeline.
+  Lexer prototype. It runs immediately after `rewriteRender()` and before
+  `tagPostfixConditionals()` in the rewriter pipeline (see "Rewriter
+  Pipeline" earlier in this file for the full order; note `rewriteTypes()`
+  is not adjacent — it runs much earlier, before `normalizeLines()`).
 - `rewriteSchema()` detects a contextual `schema` identifier at expression-
   start positions followed by either a `:kind` SYMBOL or a direct INDENT.
   The matching INDENT...OUTDENT range is parsed by a schema-specific
@@ -798,9 +827,11 @@ signatures both enforce this.
 
 ### Shadow TS
 
-`emitSchemaTypes(sexpr, lines)` walks the parsed s-expression for named
-schema declarations, emits mixins first so intersections resolve, then
-emits type aliases and `declare const` per kind:
+`emitSchemaTypes(sexpr, lines, schemaBehavior)` walks the parsed s-expression
+for named schema declarations, emits mixins first so intersections resolve, then
+emits type aliases and `declare const` per kind (`schemaBehavior`, when set in
+shadow mode, anchors computed/derived members to
+`ReturnType<typeof __<Name>__behavior.field>`):
 
 - `:input` → `Schema<ValueType, ValueType>`
 - `:shape` → `Schema<ShapeInstance, ShapeData>` (or `Schema<Data, Data>` when

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 './schema/schema.js';
+import { installSchemaSupport, foldDerivedSchemas } from './schema/schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { stringify, getStdlibCode } from './stdlib.js';
 import { RipError, toRipError } from './error.js';
@@ -220,6 +220,7 @@ export class CodeEmitter {
     'computed': 'emitComputed',
     'readonly': 'emitReadonly',
     'effect': 'emitEffect',
+    'gate': 'emitGate',
 
     // Control flow — simple
     'break': 'emitBreak',
@@ -227,7 +228,6 @@ export class CodeEmitter {
     '?': 'emitExistential',
     'presence': 'emitPresence',
     '?:': 'emitTernary',
-    '|>': 'emitPipe',
     'loop': 'emitLoop',
     'loop-n': 'emitLoopN',
     'await': 'emitAwait',
@@ -309,6 +309,11 @@ export class CodeEmitter {
     this.functionVars = new Map();
     this.helpers = new Set();
     this.scopeStack = [];  // Track enclosing function scopes for proper variable hoisting
+    // Opt-in projection folding: rewrite foldable `X = Base.pick(...)` derived
+    // schemas into self-contained schema literals before emit (and before DTS,
+    // which reads the same s-expr). Off by default — the browser-bundle
+    // extractor enables it so projections can cross the client boundary.
+    if (this.options.foldProjections) foldDerivedSchemas(sexpr);
     this.collectProgramVariables(sexpr);
     let code = this.emit(sexpr);
 
@@ -1075,9 +1080,9 @@ export class CodeEmitter {
 
     if (this.usesTemplates && !skip) {
       if (skipRT) {
-        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __gateBind, __Component } = globalThis.__ripComponent;\n';
       } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
-        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __gateBind, __Component } = globalThis.__ripComponent;\n';
       } else {
         code += this.getComponentRuntime();
       }
@@ -1128,19 +1133,35 @@ export class CodeEmitter {
         return `${this.emit(left, 'value')}.repeat(${this.emit(right, 'value')})`;
       }
     }
-    // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c))
-    let COMPARE_OPS = new Set(['<', '>', '<=', '>=']);
-    if (COMPARE_OPS.has(op) && Array.isArray(left)) {
+    // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c)).
+    // All COMPARE-level ops chain, including equality — otherwise
+    // a == b < c silently compares a boolean to c. Recursing through
+    // the left side handles chains of any length.
+    let COMPARE_OPS = new Set(['<', '>', '<=', '>=', '==', '===', '!=', '!==']);
+    if (COMPARE_OPS.has(op) && Array.isArray(left) && !left.parenthesized) {
       let leftOp = left[0]?.valueOf?.() ?? left[0];
       if (COMPARE_OPS.has(leftOp)) {
-        let a = this.emit(left[1], 'value');
+        let jsOp = (o) => o === '==' ? '===' : o === '!=' ? '!==' : o;
+        let leftCode = this.emit(left, 'value');
         let b = this.emit(left[2], 'value');
         let c = this.emit(right, 'value');
-        return `((${a} ${leftOp} ${b}) && (${b} ${op} ${c}))`;
+        return `(${leftCode} && (${b} ${jsOp(op)} ${c}))`;
       }
     }
     if (op === '==') op = '===';
     if (op === '!=') op = '!==';
+    // JS requires the base of ** to be an UpdateExpression: a bare unary
+    // (typeof x ** 2, !a ** b, await f() ** 2) is a SyntaxError unless
+    // parenthesized. Wrap unary-headed left operands that emit bare.
+    if (op === '**' && Array.isArray(left)) {
+      let UNARY_HEADS = new Set(['!', '~', 'typeof', 'void', 'delete', 'await', 'not', '+', '-']);
+      let leftHead = left[0]?.valueOf?.() ?? left[0];
+      if (UNARY_HEADS.has(leftHead)) {
+        let lc = this.emit(left, 'value');
+        if (!lc.startsWith('(')) lc = `(${lc})`;
+        return `(${lc} ** ${this.emit(right, 'value')})`;
+      }
+    }
     return `(${this.emit(left, 'value')} ${op} ${this.emit(right, 'value')})`;
   }
 
@@ -1607,6 +1628,12 @@ export class CodeEmitter {
     return `const ${str(name) ?? name} = ${this.emit(expr, 'value')}`;
   }
 
+  // The component macro consumes 'gate' statements before generator dispatch,
+  // so reaching this generator means the binding sits outside a component body.
+  emitGate(head, rest, context, sexpr) {
+    this.error(`'<~' (render-ready gate) is only valid at the top of a component body`, sexpr);
+  }
+
   emitEffect(head, rest) {
     let [target, body] = rest;
     this.usesReactivity = true;
@@ -1660,31 +1687,63 @@ export class CodeEmitter {
     return `(${this.unwrap(this.emit(cond, 'value'))} ? ${this.emit(then_, 'value')} : ${this.emit(else_, 'value')})`;
   }
 
-  emitPipe(head, rest) {
-    let [left, right] = rest;
-    let leftCode = this.emit(left, 'value');
-    // Detect function calls: [fn, ...args] where fn is an identifier or accessor
-    if (Array.isArray(right) && right.length > 1) {
-      let fn = right[0];
-      let isCall = Array.isArray(fn) || (typeof fn === 'string' && /^[a-zA-Z_$]/.test(fn));
-      if (isCall) {
-        let fnCode = this.emit(fn, 'value');
-        let args = right.slice(1).map(a => this.emit(a, 'value'));
-        return `${fnCode}(${leftCode}, ${args.join(', ')})`;
-      }
-    }
-    // Simple reference or property access — call with left as sole arg
-    return `${this.emit(right, 'value')}(${leftCode})`;
-  }
-
-  emitLoop(head, rest) {
+  emitLoop(head, rest, context) {
+    if (context === 'value') return this.emitLoopAsValue('while (true)', rest[0]);
     return `while (true) ${this.emitLoopBody(rest[0])}`;
   }
 
-  emitLoopN(head, rest) {
+  emitLoopN(head, rest, context) {
     let [count, body] = rest;
     let n = this.emit(count, 'value');
-    return `for (let it = 0; it < ${n}; it++) ${this.emitLoopBody(body)}`;
+    let header = `for (let it = 0; it < ${n}; it++)`;
+    if (context === 'value') return this.emitLoopAsValue(header, body);
+    return `${header} ${this.emitLoopBody(body)}`;
+  }
+
+  // Loops used as expressions collect each iteration's last body value into
+  // an array (CoffeeScript semantics): x = (f() while c) → x = [f(), ...].
+  // Mirrors emitForIn's value-context routing through comprehensions.
+  emitLoopAsValue(header, body, guard) {
+    let hasAwait = this.containsAwait(body) || (guard != null && this.containsAwait(guard));
+    let code = this.asyncIIFEOpen(hasAwait) + '\n';
+    this.indentLevel++;
+    code += this.indent() + 'const result = [];\n';
+    code += this.indent() + header + ' {\n';
+    this.indentLevel++;
+    if (guard != null) {
+      code += this.indent() + `if (!(${this.unwrap(this.emit(guard, 'value'))})) continue;\n`;
+    }
+
+    let stmts;
+    if (!Array.isArray(body)) stmts = [body];
+    else if (body[0] === 'block') stmts = body.slice(1);
+    else if (Array.isArray(body[0])) stmts = body;
+    else stmts = [body];
+
+    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'loop'];
+    let hasCtrl = (node) => {
+      if (typeof node === 'string' && (node === 'break' || node === 'continue')) return true;
+      if (!Array.isArray(node)) return false;
+      if (['break', 'continue', 'return', 'throw'].includes(node[0])) return true;
+      if (node[0] === 'if') return node.slice(1).some(hasCtrl);
+      return node.some(hasCtrl);
+    };
+
+    for (let i = 0; i < stmts.length; i++) {
+      let s = stmts[i], isLast = i === stmts.length - 1;
+      if (!isLast || hasCtrl(s) || (Array.isArray(s) && loopStmts.includes(s[0]))) {
+        code += this.indent() + this.addSemicolon(s, this.emit(s, 'statement')) + '\n';
+      } else {
+        code += this.indent() + `result.push(${this.emit(s, 'value')});\n`;
+      }
+    }
+
+    this.indentLevel--;
+    code += this.indent() + '}\n';
+    code += this.indent() + 'return result;\n';
+    this.indentLevel--;
+    code += this.indent() + '})()';
+    return code;
   }
 
   emitAwait(head, rest) { return `await ${this.emit(rest[0], 'value')}`; }
@@ -1923,10 +1982,11 @@ export class CodeEmitter {
     return code;
   }
 
-  emitWhile(head, rest) {
+  emitWhile(head, rest, context) {
     let cond = rest[0], guard = rest.length === 3 ? rest[1] : null, body = rest[rest.length - 1];
-    let code = `while (${this.unwrap(this.emit(cond, 'value'))}) `;
-    return code + (guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body));
+    let header = `while (${this.unwrap(this.emit(cond, 'value'))})`;
+    if (context === 'value') return this.emitLoopAsValue(header, body, guard);
+    return header + ' ' + (guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body));
   }
 
   emitRange(head, rest) {
@@ -4577,7 +4637,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 && _typesEmitter) dts = _typesEmitter(typeTokens, ['program'], source);
-      return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
+      return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {}, gates: [] };
     }
 
     // Step 3: Parse — shim adapter wraps token values with metadata
@@ -4656,6 +4716,8 @@ export class Compiler {
       // the user might call any schema feature including .toSQL(). The browser
       // bundle build script overrides to 'browser' for size reduction.
       schemaMode: this.options.schemaMode,
+      // Opt-in: fold derived projection schemas to self-contained literals.
+      foldProjections: this.options.foldProjections,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -4682,12 +4744,14 @@ export class Compiler {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
-    // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
+    // Step 5: Emit .d.ts from annotated tokens + parsed s-expression. The
+    // generator's `_schemaBehavior` buffer (populated during codegen, shadow-TS
+    // mode only) lets the type emitter infer computed/derived return types.
     if (typeTokens && _typesEmitter) {
-      dts = _typesEmitter(typeTokens, sexpr, source);
+      dts = _typesEmitter(typeTokens, sexpr, source, generator._schemaBehavior, generator._schemaAnon);
     }
 
-    return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
+    return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars, gates: generator._gateDecls || [] };
   }
 
   compileToJS(source) { return this.compile(source).code; }
@@ -4754,6 +4818,126 @@ export function emit(sexpr, options = {}) {
   return new CodeEmitter(options).compile(sexpr);
 }
 
+// =============================================================================
+// Client projection extraction (browser bundle boundary)
+// =============================================================================
+//
+// When a browser-bundled module imports a binding from a server-only file
+// (e.g. `import { UserView } from '../api/models.rip'`), that file can't ship
+// to the browser — it carries the model's ORM/DDL. This lifts ONLY the named
+// bindings, and only when each is a self-contained schema, into a synthetic
+// shared module the browser can compile.
+//
+// The source is compiled with projection folding ON, so a derived schema
+// (`UserView = User.pick(...)`) becomes a source-free `__schema({...})` literal.
+// A binding is shippable iff it's such a literal AND not a :model AND carries
+// no behavior (methods/computed/transforms — which compile to functions that
+// could close over server-only imports). Anything else is refused with a
+// reason, keeping server code out of the browser by construction.
+//
+// Returns { ok: true, source } where `source` is synthetic .rip the browser can
+// compile, or { ok: false, error } listing every binding that can't be shipped.
+
+function skipJsString(code, i, quote) {
+  i++;
+  while (i < code.length && code[i] !== quote) {
+    if (code[i] === '\\') i += 2; else i++;
+  }
+  return i + 1;
+}
+
+// Locate a top-level `NAME = __schema(...)` binding in compiled JS and return
+// { text, isModel, hasBehavior } — or null when NAME isn't bound to a __schema
+// literal (an unfolded `Model.pick(x)` call, a function, a plain value, or
+// absent). Balanced extraction skips nested parens/brackets/braces and strings.
+function findSchemaLiteral(code, name) {
+  // `name` is a schema identifier, but `$` is both a valid identifier char and
+  // a regex metacharacter, so escape before interpolating into the pattern.
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`(?:^|\\n)\\s*(?:export\\s+const\\s+)?${escaped}\\s*=\\s*__schema\\(`, 'g');
+  const m = re.exec(code);
+  if (!m) return null;
+  let i = m.index + m[0].length; // just past the opening '('
+  const start = i;
+  let depth = 1;
+  while (i < code.length && depth > 0) {
+    const c = code[i];
+    if (c === '"' || c === "'" || c === '`') { i = skipJsString(code, i, c); continue; }
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    i++;
+  }
+  if (depth !== 0) return null;
+  const argText = code.slice(start, i - 1);
+  // Behavior is detected structurally, not by scanning for the word "function":
+  // a callable entry surfaces as `tag: "computed"|...`, and a field transform as
+  // `transform: (function…)`. A bare `\bfunction\b` would also match a literal
+  // VALUE like `kind! "function" | "class"` and wrongly refuse a plain shape.
+  return {
+    text: `__schema(${argText})`,
+    isModel: /^\s*\{\s*kind:\s*"model"/.test(argText),
+    hasBehavior: /\btransform:/.test(argText) || /tag:\s*"(?:computed|method|hook|ensure|derived)"/.test(argText),
+  };
+}
+
+export function extractClientProjections(source, names, { filename } = {}) {
+  let compiled;
+  try {
+    compiled = new Compiler({
+      filename,
+      foldProjections: true,
+      skipPreamble: true,
+      skipRuntimes: true,
+      skipDataPart: true,
+      skipImports: true,
+    }).compile(source);
+  } catch (e) {
+    return { ok: false, error: `failed to compile ${filename || 'module'}: ${e.message}` };
+  }
+  const code = compiled.code || '';
+  // Every schema bound in this source — lets us tell a nested *schema-typed*
+  // field (`items! OrderItem[]` → `typeName: "OrderItem"`) apart from a
+  // primitive (`typeName: "string"`).
+  const defined = new Set();
+  for (const m of code.matchAll(/(?:^|\n)\s*(?:export\s+const\s+)?(\w+)\s*=\s*__schema\(/g)) defined.add(m[1]);
+
+  const lines = [];
+  const errors = [];
+  const where = filename ? ` from '${filename}'` : '';
+  const requested = new Set(names);
+  const seen = new Set();
+  // Process requested names, then transitively any schema they reference by a
+  // field type — otherwise the shared module ships a shape whose nested type
+  // isn't registered in the browser, and that field's validation is *silently*
+  // skipped. A pulled-in dependency that isn't itself shippable is a hard error.
+  const queue = [...names];
+  while (queue.length) {
+    const name = queue.shift();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const lit = findSchemaLiteral(code, name);
+    const isDep = !requested.has(name);
+    const tag = isDep ? `'${name}'${where} (a nested type of a shipped projection)` : `'${name}'${where}`;
+    if (!lit) {
+      errors.push(isDep
+        ? `${tag} isn't a shippable schema, so the projection referencing it can't cross to the browser`
+        : `${tag} isn't a shippable schema — only a schema or a folded projection (e.g. ${name} = Model.pick(...)) can cross to the browser`);
+    } else if (lit.isModel) {
+      errors.push(`${tag} is a :model — ship a projection like ${name}.pick(...)/.omit(...) instead of the model (which carries ORM/DDL)`);
+    } else if (lit.hasBehavior) {
+      errors.push(`${tag} carries behavior (methods/computed/transforms) that may close over server-only code — project it to plain fields before importing it client-side`);
+    } else {
+      lines.push(`export ${name} = ${lit.text}`);
+      for (const tm of lit.text.matchAll(/typeName:\s*"(\w+)"/g)) {
+        const dep = tm[1];
+        if (defined.has(dep) && !seen.has(dep)) queue.push(dep);
+      }
+    }
+  }
+  if (errors.length) return { ok: false, error: errors.join('; ') };
+  return { ok: true, source: lines.join('\n') + '\n' };
+}
+
 export function getReactiveRuntime() {
   return new CodeEmitter({}).getReactiveRuntime();
 }