rip-lang 3.16.0 → 3.16.2

package/docs/ui/hljs-rip.js

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

package/docs/ui/index.html

@@ -103,7 +103,7 @@ export WidgetGallery = component
     return unless entry
     sourceName = entry.name
     sourceLines = entry.lines
-    src = window.__RIP__?.components?.read("components/#{id}.rip")
+    src = window.__RIP__?.components?.read("_pkg/ui/#{id}.rip")
     return unless src
     sourceCode = src
   _closeSource: -> sourceCode = null

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "rip-lang",
-  "version": "3.16.0",
+  "version": "3.16.2",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",
   "workspaces": [
+    "examples/*",
     "packages/*"
   ],
+  "catalog": {
+    "typescript": "5.9.3"
+  },
   "browser": "docs/dist/rip.min.js",
   "exports": {
     ".": {
@@ -35,8 +39,8 @@
     "bump": "bun scripts/bump.js",
     "gen:dom": "bun scripts/gen-dom.js",
     "gallery": "bun scripts/gallery.js",
-    "bundle:demo": "bun scripts/bundle-app.js docs/demo -o docs/example/index.json -t 'Rip App Demo'",
-    "bundle:ui": "bun scripts/bundle-app.js packages/ui/browser -o docs/ui/bundle.json -t 'Rip UI'",
+    "bundle:demo": "bun scripts/bundle-app.js docs/demo/routes --prefix _route --css docs/demo/css -o docs/example/index.json -t 'Rip App Demo'",
+    "bundle:ui": "bun scripts/bundle-app.js packages/ui/browser/components --prefix _pkg/ui -o docs/ui/bundle.json -t 'Rip UI'",
     "parser": "bun src/grammar/solar.rip -o src/parser.js src/grammar/grammar.rip",
     "postinstall": "node scripts/postinstall.js --quiet",
     "link-local": "bun scripts/link-local.js",
@@ -45,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",
@@ -86,7 +93,8 @@
   "homepage": "https://github.com/shreeve/rip-lang#readme",
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
   "license": "MIT",
-  "devDependencies": {
-    "typescript": "5.9.3"
+  "dependencies": {
+    "@types/bun": "1.3.14",
+    "typescript": "catalog:"
   }
 }

package/rip-loader.js

@@ -2,6 +2,8 @@
 
 import { plugin } from "bun";
 import { fileURLToPath } from "url";
+import { dirname, resolve as resolvePath } from "path";
+import { readFileSync, existsSync } from "fs";
 import { compileToJS, formatError } from "./src/compiler.js";
 // Register the full schema runtime provider so .rip files containing
 // `schema :model` blocks compile correctly inside spawned workers.
@@ -9,11 +11,65 @@ import { compileToJS, formatError } from "./src/compiler.js";
 // would call compileToJS without ever registering a provider.
 import "./src/schema/loader-server.js";
 
+// ── Undeclared-import diagnostic ────────────────────────────────────────
+// Walk up from an importer to its nearest package.json, then verify that any
+// `@rip-lang/<pkg>` specifier is declared in dependencies/devDependencies/
+// peerDependencies/optionalDependencies (or is the package's own self-import).
+//
+// Throws a clear error before `import.meta.resolve` is even attempted, so
+// "works on my machine" failures rooted in link-global rescue surface loudly
+// instead of silently shipping.
+const declarationCache = new Map(); // importerDir → { pkgName, declared } | null
+
+function getDeclarationInfo(importerPath) {
+  const start = dirname(importerPath);
+  if (declarationCache.has(start)) return declarationCache.get(start);
+  let cur = start;
+  let info = null;
+  while (true) {
+    const pkgPath = resolvePath(cur, 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        info = {
+          pkgName: pkg.name || null,
+          declared: new Set([
+            ...Object.keys(pkg.dependencies || {}),
+            ...Object.keys(pkg.devDependencies || {}),
+            ...Object.keys(pkg.peerDependencies || {}),
+            ...Object.keys(pkg.optionalDependencies || {}),
+          ]),
+        };
+      } catch {
+        info = { pkgName: null, declared: new Set() };
+      }
+      break;
+    }
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  declarationCache.set(start, info);
+  return info;
+}
+
+export function assertDeclaredRipImport(importerPath, specifier) {
+  const m = specifier.match(/^(@rip-lang\/[^\/]+)/);
+  if (!m) return;
+  const pkgKey = m[1];
+  const info = getDeclarationInfo(importerPath);
+  if (!info) return; // ad-hoc script outside any package — don't block
+  if (info.pkgName === pkgKey) return; // self-import
+  if (info.declared.has(pkgKey)) return;
+  throw new Error(
+    `Import of '${pkgKey}' is not declared in package.json. ` +
+    `Run \`bun add ${pkgKey}\` (or use \`workspace:*\` inside this monorepo).`
+  );
+}
+
 await plugin({
   name: "rip-loader",
   async setup(build) {
-    const { readFileSync } = await import("fs");
-
     // Handle .rip files
     build.onLoad({ filter: /\.rip$/ }, async (args) => {
       try {
@@ -25,6 +81,7 @@ await plugin({
         // is broken in plugin handlers — so we use import.meta.resolve, which
         // resolves from this file's location (inside the global node_modules tree).
         js = js.replace(/(from\s+|import\s*\()(['"])(@rip-lang\/[^'"]+)\2/g, (match, prefix, quote, specifier) => {
+          assertDeclaredRipImport(args.path, specifier);
           try {
             return `${prefix}${quote}${fileURLToPath(import.meta.resolve(specifier))}${quote}`;
           } catch {

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,20 +239,44 @@ 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:
 
 - `.pre` — whitespace count before token
-- `.data` — metadata like `{ await, predicate, quote, invert, parsedValue }`
+- `.data` — metadata like `{ await, optional, quote, invert, parsedValue }`
 - `.loc` — `{ r, c, n }`
 - `.spaced` — sugar for `.pre > 0`
 - `.newLine` — whether preceded by newline
 
 Identifier suffixes:
 
-- `!` sets `.data.await = true`
-- `?` sets `.data.predicate = true`
+- `!` sets `.data.bang = true` — a neutral "trailing `!`" flag resolved by context downstream: dammit/`await` at a call site (`fetch!` → `await fetch()`), or the void marker at a function definition (`foo! = ->`, `def foo!` → no implicit return). Void-ness is stamped onto the function node as `isVoid` by `applyVoidMarker` and read locally by the arrow emitters; `def` reads `meta(name, 'bang')` directly.
+- `?` sets `.data.optional = true` (existence check on values; optional marker on prop/type-field names)
 - `as!` in loops emits `FORASAWAIT` for `for await`
 
 Tagged template bridge:
@@ -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:
 
@@ -415,7 +442,7 @@ Block factories need locals and `ctx.member` references instead of `this._elN` a
 - `_factoryVars` — variables that need local `let` declarations
 - `_fragChildren` — fragment-to-children tracking for removals
 - `_pushEffect(body)` — emits `__effect(...)` or `disposers.push(__effect(...))`
-- `_loopVarStack` — threads loop variables through nested factories
+- `_loopVarStack` — threads loop variables through nested factories. Each frame is `{ itemVar, indexVar, reactiveSource }`; `reactiveSource` is computed once when the loop is emitted (via `hasReactiveDeps(collection)`) and tells `hasReactiveDeps` to treat direct member access rooted at `itemVar`/`indexVar` (`item.foo`, `item[0]`, `item.a.b`) as reactive. Alias and destructuring forms are not tracked.
 
 Factory mode is entered in `emitConditionBranch` and `emitTemplateLoop` via save/restore of `[_createLines, _setupLines, _factoryMode, _factoryVars]`.
 
@@ -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 `expandSuffixes`, `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/browser.js

@@ -48,6 +48,40 @@ const dedent = s => {
 const sanitizeSourceURL = (url) =>
   String(url).replace(/[\r\n]/g, '').replace(/\s+$/g, '');
 
+// Rewrite `import { … } from '@rip-lang/<pkg>'` into a `globalThis`
+// destructure. The browser bundle copies every function export from
+// `@rip-lang/app` (and friends) onto `globalThis` at startup (see
+// `_entry.js` in scripts/build.js), so consumers can import them by name
+// in source while the runtime form is a plain destructure. Named imports
+// only — default / namespace forms warn and pass through.
+function rewriteRipPkgImports(js) {
+  const re = /^(\s*)import\s+([^'"]+?)\s+from\s+['"](@rip-lang\/[^'"]+)['"];?\s*$/gm;
+  return js.replace(re, (full, indent, clause, spec) => {
+    const trimmed = clause.trim();
+    if (trimmed.startsWith('type ')) return `${indent}// type-only import erased: ${spec}`;
+    const open = trimmed.indexOf('{');
+    const close = trimmed.lastIndexOf('}');
+    if (open < 0 || close <= open) {
+      console.warn(`[Rip] Skipping non-named import from ${spec}; only \`import { … } from '@rip-lang/*'\` is supported in browser bundles.`);
+      return full;
+    }
+    const inside = trimmed.slice(open + 1, close);
+    const parts = [];
+    for (let raw of inside.split(',')) {
+      let name = raw.trim().replace(/^type\s+/, '');
+      if (!name) continue;
+      if (/\s+as\s+/.test(name)) {
+        const [orig, alias] = name.split(/\s+as\s+/).map(s => s.trim());
+        parts.push(`${orig}: ${alias}`);
+      } else {
+        parts.push(name);
+      }
+    }
+    if (parts.length === 0) return `${indent}// import erased: ${spec}`;
+    return `${indent}const { ${parts.join(', ')} } = globalThis;`;
+  });
+}
+
 // Insert `//# sourceURL=<name>` BEFORE the existing `//# sourceMappingURL=...`
 // comment (or append at end if none). NEVER prepend — that would shift every
 // generated-line mapping by 1 line, breaking line-only source maps.
@@ -127,15 +161,17 @@ async function processRipScripts() {
   let lastBundle;
 
   // Step 1: Collect data-src URLs from the runtime script tag
-  // When data-src is omitted, default to '/app' (auto-scanned bundle from serve middleware).
+  // When data-src is omitted, default to '/app' (auto-scanned bundle from
+  // serve middleware). The default is silent on failure — only explicit
+  // data-src URLs warn — so static / file:// pages aren't noisy.
   const runtimeTag = document.querySelector('script[src$="rip.min.js"], script[src$="rip.js"]');
   const dataSrc = runtimeTag?.getAttribute('data-src');
   if (dataSrc !== null && dataSrc !== undefined) {
     for (const url of dataSrc.trim().split(/\s+/)) {
       if (url) sources.push({ url });
     }
-  } else if (runtimeTag) {
-    sources.push({ url: '/app' });
+  } else if (runtimeTag && /^https?:$/.test(location.protocol)) {
+    sources.push({ url: '/app', optional: true });
   }
 
   // Step 2: Collect all <script type="text/rip"> tags (inline and external)
@@ -161,8 +197,11 @@ async function processRipScripts() {
         s.bundle = bundle;
       }
     }));
-    for (const r of results) {
-      if (r.status === 'rejected') console.warn('Rip: fetch failed:', r.reason.message);
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      if (r.status === 'rejected' && !sources[i].optional) {
+        console.warn('Rip: fetch failed:', r.reason.message);
+      }
     }
 
     // Separate bundles from individual sources
@@ -209,7 +248,7 @@ async function processRipScripts() {
           ? { ...baseOpts, sourceMap: 'inline', filename: ripName }
           : baseOpts;
         let js;
-        try { js = compileToJS(s.code, opts); }
+        try { js = rewriteRipPkgImports(compileToJS(s.code, opts)); }
         catch (e) { console.error(_formatError(e, { source: s.code, file: ripName, color: false })); continue; }
         try { await (0, eval)(debug ? wrapForEval(js, ripName) : `(async()=>{\n${js}\n})()`); }
         catch (e) { console.error(`Rip runtime error in ${ripName}:`, e); }
@@ -227,7 +266,8 @@ async function processRipScripts() {
       // No routing — expand bundles into individual sources, compile everything
       const expanded = [];
       for (const b of bundles) {
-        for (const [name, code] of Object.entries(b.components || {})) {
+        const mods = b.modules || b.components || {};
+        for (const [name, code] of Object.entries(mods)) {
           expanded.push({ code, url: name });
         }
         if (b.data) {
@@ -247,7 +287,8 @@ async function processRipScripts() {
       if (bundles.length > 0 && typeof globalThis.createComponents === 'function') {
         const sourceStore = globalThis.createComponents();
         for (const b of bundles) {
-          if (b.components) sourceStore.load(b.components);
+          const mods = b.modules || b.components;
+          if (mods) sourceStore.load(mods);
         }
         if (typeof window !== 'undefined') {
           if (!window.__RIP__) window.__RIP__ = {};
@@ -280,7 +321,7 @@ async function processRipScripts() {
           ? { ...baseOpts, sourceMap: 'inline', filename: ripName }
           : baseOpts;
         try {
-          const js = compileToJS(s.code, opts);
+          const js = rewriteRipPkgImports(compileToJS(s.code, opts));
           compiled.push({ js, url: ripName });
         } catch (e) {
           console.error(_formatError(e, { source: s.code, file: ripName, color: false }));
@@ -289,7 +330,7 @@ async function processRipScripts() {
 
       // Create app stash
       if (!globalThis.__ripApp && runtimeTag) {
-        const stashFn = globalThis.stash;
+        const stashFn = globalThis.createStash;
         if (stashFn) {
           let initial = {};
           const stateAttr = runtimeTag.getAttribute('data-state');
@@ -414,7 +455,7 @@ export async function importRip(url) {
     if (!r.ok) throw new Error(`importRip: ${url} (${r.status})`);
     return r.text();
   });
-  const js = compileToJS(source);
+  const js = rewriteRipPkgImports(compileToJS(source));
   const header = `// ${url}\n`;
   const blob = new Blob([header + js], { type: 'application/javascript' });
   const blobUrl = URL.createObjectURL(blob);