rip-lang 3.16.0 → 3.16.2

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/shreeve/rip-lang/commits/main"><img src="https://img.shields.io/badge/version-3.16.0-blue.svg" alt="Version"></a>
+  <a href="https://github.com/shreeve/rip-lang/commits/main"><img src="https://img.shields.io/badge/version-3.16.1-blue.svg" alt="Version"></a>
   <a href="#zero-dependencies"><img src="https://img.shields.io/badge/dependencies-ZERO-brightgreen.svg" alt="Dependencies"></a>
   <a href="#"><img src="https://img.shields.io/badge/tests-1%2C436%2F1%2C436-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
@@ -38,7 +38,7 @@ get '/users/:id' ->                 # RESTful API endpoint, comma-less
 
 **What makes Rip different:**
 - **Modern output** — ES2022 with native classes, `?.`, `??`, modules
-- **New operators** — `!`, `//`, `%%`, `=~`, `|>`, `.new()`, and more
+- **New operators** — `!`, `//`, `%%`, `=~`, `.new()`, and more
 - **Reactive operators** — `:=`, `~=`, `~>` as language syntax
 - **Optional types** — `::` annotations, `type` aliases, `.d.ts` emission
 - **Zero dependencies** — everything included, even the parser generator
@@ -262,7 +262,6 @@ All use `globalThis` with `??=` — override any by redeclaring locally.
 | `[-n]` (negative index) | `arr[-1]` | Last element via `.at()` |
 | `*` (string repeat) | `"-" * 40` | String repeat via `.repeat()` |
 | `<` `<=` (chained) | `1 < x < 10` | Chained comparisons |
-| `\|>` (pipe) | `x \|> fn` or `x \|> fn(y)` | Pipe operator (first-arg insertion) |
 | `not in` | `x not in arr` | Negated membership test |
 | `not of` | `k not of obj` | Negated key existence |
 | `.=` (method assign) | `x .= trim()` | `x = x.trim()` — compound method assignment |
@@ -341,7 +340,7 @@ Status = schema
 # DB-backed model
 User = schema :model
   name!   string
-  email!# email
+  email! email @unique
   @timestamps
   @has_many Order
   beforeValidation: -> @email = @email.toLowerCase()

package/bin/rip

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 
-import { readFileSync, readdirSync, writeFileSync, existsSync, statSync, unlinkSync } from 'fs';
+import { readFileSync, readdirSync, writeFileSync, existsSync, statSync, unlinkSync, lstatSync, readlinkSync, rmSync, mkdirSync, symlinkSync, realpathSync } from 'fs';
 import { execSync, spawnSync, spawn } from 'child_process';
 import { fileURLToPath } from 'url';
-import { dirname, basename, join } from 'path';
+import { dirname, basename, join, resolve, relative } from 'path';
 import { Compiler, formatError } from '../src/compiler.js';
 // Side-effect imports — register CLI-side runtime providers. The browser
 // bundle imports a different schema loader so server-only fragments
@@ -60,7 +60,12 @@ Options:
 
 Subcommands:
   rip check [dir]               Type-check all .rip files in directory
-  rip check --strict [dir]      Require type annotations in all .rip files
+  rip check --audit [pkgDir]    Audit a typed package's public API surface for 'any' leaks
+  rip check --sourcemap [dir]   Verify source-map round-trip for every identifier
+                                (hover/go-to-def integrity). Useful for compiler work.
+  rip link [--quiet]            After 'bun install', symlink @rip-lang/* deps to
+                                local source (opt-in, for framework devs;
+                                undo with 'bun install --force')
   rip <name> [args]             Run rip-<name> (repo bin/, node_modules, or PATH)
 
   Configure via rip.json or package.json:
@@ -95,6 +100,121 @@ Shebang support:
 `);
 }
 
+// `rip link` — opt-in override for framework maintainers, layered on top of a
+// normal install. The canonical setup for any rip project is `bun install`
+// (published packages, lockfile, transitive deps); `rip link` then redirects
+// the @rip-lang/* deps to this CLI's own source checkout, by symlinking them
+// into ./node_modules/@rip-lang/* (plus matching .bin shims). The `rip-lang`
+// compiler/toolchain is pointed at source too, so the loader and VS Code LSP
+// load the matching toolchain instead of a shadowing published tarball. Lets
+// you edit framework source live without publishing.
+//
+// Requires `bun install` first — it overrides an existing install, it is not a
+// substitute for one. Reversible: the symlinks live in node_modules (gitignored)
+// and package.json stays clean semver, so `bun install --force` restores the
+// published packages (a plain `bun install` sees the lockfile as satisfied and
+// leaves the symlinks in place). No-op when no source tree is found (e.g. `rip`
+// installed from npm without a dev checkout) — projects then just use installed
+// packages.
+//
+// Source is this CLI's repo root (so it Just Works after `link-global`),
+// overridable via RIP_SRC.
+function ripLink(args) {
+  const quiet = args.includes('--quiet');
+  const log = (msg) => { if (!quiet) console.log(`[rip] link: ${msg}`); };
+
+  const rawSrc = process.env.RIP_SRC || join(__dirname, '..');
+  if (!existsSync(join(rawSrc, 'packages'))) {
+    log(`no rip-lang source at ${rawSrc} — using installed packages (set RIP_SRC to override)`);
+    return;
+  }
+  const src = realpathSync(rawSrc);
+
+  const cwd = process.cwd();
+  const pkgPath = join(cwd, 'package.json');
+  if (!existsSync(pkgPath)) {
+    console.error('[rip] link: no package.json in current directory');
+    process.exit(1);
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const deps = Object.keys(pkg.dependencies || {}).filter((d) => d.startsWith('@rip-lang/'));
+  if (deps.length === 0) {
+    log('no @rip-lang/* dependencies declared — nothing to link');
+    return;
+  }
+
+  const nodeModules = join(cwd, 'node_modules');
+  if (!existsSync(nodeModules)) {
+    console.error('[rip] link: no node_modules found — run `bun install` first, then `rip link`.');
+    process.exit(1);
+  }
+  const binDir = join(nodeModules, '.bin');
+
+  const linkTo = (path, target, type = 'dir') => {
+    try {
+      if (lstatSync(path).isSymbolicLink() && readlinkSync(path) === target) return false;
+      rmSync(path, { recursive: true, force: true });
+    } catch {}
+    mkdirSync(dirname(path), { recursive: true });
+    symlinkSync(target, path, type);
+    return true;
+  };
+
+  const linked = [];   // { dep, bins: [names] } for each resolved package
+  let changed = false;
+
+  for (const dep of deps) {
+    const short = dep.slice('@rip-lang/'.length);
+    const target = join(src, 'packages', short);
+    if (!existsSync(target)) { log(`skip ${dep} — not found at ${target}`); continue; }
+    if (linkTo(join(nodeModules, '@rip-lang', short), target)) changed = true;
+
+    // Re-create .bin shims from the package's own `bin` field so `rip server`
+    // and friends resolve source binaries from this project's node_modules.
+    let meta = {};
+    try { meta = JSON.parse(readFileSync(join(target, 'package.json'), 'utf-8')); } catch {}
+    const binMap = typeof meta.bin === 'string' ? { [short]: meta.bin } : (meta.bin || {});
+    const bins = [];
+    for (const [name, rel] of Object.entries(binMap)) {
+      const binTarget = join(target, rel);
+      if (!existsSync(binTarget)) continue;
+      if (linkTo(join(binDir, name), binTarget, 'file')) changed = true;
+      bins.push(name);
+    }
+    linked.push({ dep, bins });
+  }
+
+  // The compiler/toolchain itself. Every @rip-lang/* package depends on it,
+  // and the loader + VS Code LSP resolve it from the project's node_modules —
+  // so it must point at source too, otherwise a published `rip-lang` tarball
+  // shadows it (e.g. the LSP loading a typecheck.js without the latest API).
+  if (existsSync(join(nodeModules, 'rip-lang'))) {
+    if (linkTo(join(nodeModules, 'rip-lang'), src)) changed = true;
+    linked.push({ dep: 'rip-lang', bins: [], label: 'compiler' });
+  }
+
+  if (quiet || linked.length === 0) {
+    if (linked.length === 0) log('no @rip-lang/* packages resolved to source');
+    return;
+  }
+
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const tilde = (p) => home && p.startsWith(home) ? '~' + p.slice(home.length) : p;
+  const tty = process.stdout.isTTY;
+  const dim = (s) => tty ? `\x1b[2m${s}\x1b[0m` : s;
+  const bold = (s) => tty ? `\x1b[1m${s}\x1b[0m` : s;
+
+  const n = linked.length;
+  const verb = changed ? 'linked' : 'already linked';
+  console.log(`${bold('rip link')} ${dim('·')} ${verb} ${n} package${n === 1 ? '' : 's'} ${dim('→ ' + tilde(src))}`);
+  const width = Math.max(...linked.map((l) => l.dep.length));
+  for (const { dep, bins, label } of linked) {
+    const tag = label || (bins.length ? `bin: ${bins.join(', ')}` : '');
+    const line = tag ? `${dep.padEnd(width)}${dim(`  ${tag}`)}` : dep;
+    console.log(`  ${dim('•')} ${line}`);
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -125,12 +245,21 @@ async function main() {
       const home = process.env.HOME || process.env.USERPROFILE;
       const scopeDir = join(home, '.bun', 'install', 'global', 'node_modules', '@rip-lang');
       if (existsSync(scopeDir) && statSync(scopeDir).isDirectory()) {
-        console.log();
-        for (const name of readdirSync(scopeDir).sort()) {
-          try {
-            const pkg = JSON.parse(readFileSync(join(scopeDir, name, 'package.json'), 'utf-8'));
+        // Sort by the displayed package name (e.g. `@rip-lang/ui`,
+        // `vscode-rip`) rather than the on-disk directory entry — most
+        // entries match either way, but a package whose `name` field
+        // diverges from its directory (the VS Code extension lives in
+        // packages/vscode/ but publishes as `vscode-rip`) would
+        // otherwise sort by its directory and look misplaced.
+        const pkgs = readdirSync(scopeDir)
+          .map((name) => { try { return JSON.parse(readFileSync(join(scopeDir, name, 'package.json'), 'utf-8')); } catch { return null; } })
+          .filter(Boolean)
+          .sort((a, b) => a.name.localeCompare(b.name));
+        if (pkgs.length) {
+          console.log();
+          for (const pkg of pkgs) {
             console.log(`  ${pkg.name.padEnd(24)} ${pkg.version}`);
-          } catch {}
+          }
         }
       }
     } catch {}
@@ -140,14 +269,27 @@ async function main() {
   // --- Built-in subcommands ---
 
   if (args[0] === 'check') {
-    const { runCheck } = await import('../src/typecheck.js');
     const checkArgs = args.slice(1);
+    const VALID_FLAGS = new Set(['--audit', '--sourcemap']);
+    const unknown = checkArgs.filter(a => a.startsWith('-') && !VALID_FLAGS.has(a));
+    if (unknown.length > 0) {
+      console.error(`rip check: unknown flag${unknown.length === 1 ? '' : 's'}: ${unknown.join(', ')}`);
+      console.error(`Valid flags: ${[...VALID_FLAGS].join(', ')}`);
+      process.exit(2);
+    }
     const dir = checkArgs.find(a => !a.startsWith('-')) || '.';
-    const exitCode = await runCheck(dir, {
-      quiet: checkArgs.includes('-q') || checkArgs.includes('--quiet'),
-      strict: checkArgs.includes('--strict'),
-    });
-    process.exit(exitCode);
+    const wantAudit     = checkArgs.includes('--audit');
+    const wantSourcemap = checkArgs.includes('--sourcemap');
+    const { runCheck, runAudit } = await import('../src/typecheck.js');
+    const checkCode = await runCheck(dir, { sourceMapAudit: wantSourcemap });
+    if (!wantAudit) process.exit(checkCode);
+    const auditCode = await runAudit(dir);
+    process.exit(checkCode || auditCode);
+  }
+
+  if (args[0] === 'link') {
+    ripLink(args.slice(1));
+    process.exit(0);
   }
 
   // --- Subcommand dispatch: rip <name> → rip-<name> ---
@@ -158,6 +300,15 @@ async function main() {
       const name = candidate;
       const subArgs = args.slice(scriptFileIndex + 1);
 
+      // 0. Sibling subcommand in this CLI's own bin/ — works from any
+      // cwd (getRepoRoot below resolves the CWD's git checkout, which
+      // is unrelated when running `rip schema …` inside an app dir).
+      const selfSibling = join(__dirname, `rip-${name}`);
+      if (existsSync(selfSibling)) {
+        const r = spawnSync(selfSibling, subArgs, { stdio: 'inherit', env: process.env });
+        process.exit(r.status ?? 1);
+      }
+
       const repoRoot = getRepoRoot();
       if (repoRoot) {
         // 1. Repo package: bin/rip-<name>
@@ -197,13 +348,32 @@ async function main() {
         }
       }
 
-      // 5. Global PATH: rip-<name>
+      // 5. Nearest node_modules/.bin walking up from the cwd. `getRepoRoot`
+      // uses `git rev-parse --show-toplevel`, which returns the OUTERMOST git
+      // repo — wrong when a project lives in a subdirectory of a larger git
+      // repo: step 4 then probes the outer repo's node_modules and misses the
+      // project's own declared bins. Resolve the bin the way Node resolves a
+      // dependency — nearest node_modules up the tree from the cwd — which is
+      // correct for nested projects and standalone consumers alike.
+      let nmDir = process.cwd();
+      while (true) {
+        const nmBin = join(nmDir, 'node_modules', '.bin', `rip-${name}`);
+        if (existsSync(nmBin)) {
+          const r = spawnSync(nmBin, subArgs, { stdio: 'inherit', env: process.env });
+          process.exit(r.status ?? 1);
+        }
+        const parent = dirname(nmDir);
+        if (parent === nmDir) break;
+        nmDir = parent;
+      }
+
+      // 6. Global PATH: rip-<name>
       const pathResult = spawnSync(`rip-${name}`, subArgs, { stdio: 'inherit', env: process.env });
       if (pathResult.error?.code !== 'ENOENT') {
         process.exit(pathResult.status ?? 1);
       }
 
-      // 6. Not found
+      // 7. Not found
       console.error(`rip: unknown command '${name}'\n\nRun 'rip --help' for usage.`);
       process.exit(1);
     }
@@ -335,8 +505,21 @@ async function main() {
     }
 
     if (showShadow) {
-      const { compileForCheck } = await import('../src/typecheck.js');
-      const entry = compileForCheck(inputFile || '<stdin>', source, new Compiler());
+      const { compileForCheck, readProjectConfig, globToRegex } = await import('../src/typecheck.js');
+      // Honor the project's `rip` config so the shadow matches what `rip
+      // check` actually does. Without `checkAll`, an unannotated file gets a
+      // `// @ts-nocheck` it wouldn't get under the project's real settings.
+      const config = readProjectConfig(inputFile ? dirname(resolve(inputFile)) : process.cwd());
+      const checkAll = config.checkAll === true;
+      // An excluded file is skipped entirely — surface that, since the shadow
+      // below reflects nocheck logic that never runs for excluded files.
+      if (inputFile && config._configDir && Array.isArray(config.exclude)) {
+        const rel = relative(config._configDir, resolve(inputFile));
+        if (config.exclude.map(globToRegex).some(p => p.test(rel)) && !quiet) {
+          console.log(`// NOTE: ${rel} matches rip.exclude — \`rip check\` skips this file entirely.\n`);
+        }
+      }
+      const entry = compileForCheck(inputFile || '<stdin>', source, new Compiler(), { checkAll });
       if (!quiet) console.log(`// == Shadow TypeScript (what \`rip check\` sees) == //\n`);
       console.log(entry.tsContent);
     }

package/bin/rip-schema

@@ -0,0 +1,175 @@
+#!/usr/bin/env bun
+//
+// rip-schema — schema evolution CLI (`rip schema …`).
+//
+//   rip schema status  [entry.rip] [--dir DIR]
+//   rip schema plan    [entry.rip]
+//   rip schema make <name> [entry.rip] [--dir DIR] [--allow-lossy] [--allow-destructive]
+//   rip schema migrate [entry.rip] [--dir DIR] [--repair]
+//
+// `entry.rip` is a file whose import registers every :model schema
+// (your models file — it may also call connect() to point the adapter
+// at the database). When omitted, conventional locations are tried.
+//
+// Database connection comes from the entry file's own connect() call,
+// or from RIP_DB_URL / RIP_DB_TOKEN for the default duckdb-harbor
+// adapter.
+//
+// Migration files are plain SQL — numbered, hand-editable, checked into
+// git (default directory: ./migrations). `make` writes them from the
+// model-vs-database diff; `migrate` applies pending ones in order and
+// records (version, name, checksum) in the `_rip_migrations` table.
+
+// Registers the .rip module loader AND the full (migration-mode) schema
+// runtime — globalThis.schema gains plan/status/make/migrate/introspect.
+import '../rip-loader.js';
+
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+
+const ENTRY_CANDIDATES = [
+  'models.rip', 'api/models.rip', 'app/models.rip', 'db/models.rip', 'src/models.rip',
+];
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+if (!cmd || cmd === '--help' || cmd === '-h') {
+  usage(0);
+} else if (!['status', 'plan', 'make', 'migrate'].includes(cmd)) {
+  console.error(`rip schema: unknown subcommand '${cmd}'\n`);
+  usage(1);
+}
+
+const rest = args.slice(1);
+const flags = {
+  dir: 'migrations',
+  allowLossy: false,
+  allowDestructive: false,
+  repair: false,
+};
+const positional = [];
+for (let i = 0; i < rest.length; i++) {
+  const a = rest[i];
+  if (a === '--dir') flags.dir = rest[++i];
+  else if (a === '--allow-lossy') flags.allowLossy = true;
+  else if (a === '--allow-destructive') flags.allowDestructive = true;
+  else if (a === '--repair') flags.repair = true;
+  else if (a.startsWith('-')) die(`unknown flag: ${a}`);
+  else positional.push(a);
+}
+
+// `make` takes a migration name first; every command takes an optional
+// models entry. Disambiguate by file existence: a positional that names
+// an existing file is the entry, anything else (for make) is the name.
+let name = null;
+let entry = null;
+for (const p of positional) {
+  if (existsSync(p) && /\.(rip|js|ts)$/.test(p)) entry = p;
+  else if (cmd === 'make' && !name) name = p;
+  else die(`unexpected argument: ${p} (no such file)`);
+}
+if (cmd === 'make' && !name) die("usage: rip schema make <name> [entry.rip] — a migration name is required");
+if (!entry) entry = ENTRY_CANDIDATES.find(c => existsSync(c)) || null;
+if (!entry) {
+  die(
+    'no models entry found. Pass one explicitly (rip schema ' + cmd + ' [name] path/to/models.rip)\n' +
+    'or create one of: ' + ENTRY_CANDIDATES.join(', '));
+}
+
+// Importing the entry registers every :model it declares (directly or
+// transitively) and runs any connect() it performs.
+await import(resolve(entry));
+
+const schema = globalThis.schema;
+if (!schema || typeof schema.plan !== 'function') {
+  die('schema runtime did not load — does the entry file declare or import any schemas?');
+}
+
+const color = (c, s) => process.stdout.isTTY ? `\x1b[${c}m${s}\x1b[0m` : s;
+const dim = (s) => color('2', s);
+const CLASS_COLOR = { safe: '32', lossy: '33', destructive: '31', blocked: '31;1' };
+const tag = (cls) => color(CLASS_COLOR[cls] || '0', `[${cls}]`);
+
+function printSteps(steps) {
+  if (!steps.length) {
+    console.log(color('32', '✓ database matches the declared models — no changes'));
+    return;
+  }
+  for (const s of steps) {
+    console.log(`${tag(s.class)} ${s.kind} ${s.table}`);
+    for (const n of s.notes) console.log(dim(`    ${n}`));
+    for (const line of s.sql) console.log(`    ${line}`);
+  }
+  const counts = {};
+  for (const s of steps) counts[s.class] = (counts[s.class] || 0) + 1;
+  console.log('\n' + Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(', '));
+}
+
+try {
+  if (cmd === 'plan') {
+    printSteps(await schema.plan());
+
+  } else if (cmd === 'status') {
+    const st = await schema.status({ dir: flags.dir });
+    console.log(`applied:  ${st.applied.length ? st.applied.map(a => a.version + '_' + a.name).join(', ') : '(none)'}`);
+    console.log(`pending:  ${st.pending.length ? st.pending.map(f => f.version + '_' + f.name).join(', ') : '(none)'}`);
+    if (st.mismatched.length) {
+      console.log(color('31', `edited after apply: ${st.mismatched.join(', ')} — restore the files or migrate --repair`));
+    }
+    console.log('');
+    if (st.steps.length && !st.pending.length && (st.applied.length || st.files.length)) {
+      console.log(color('33', 'drift: the database differs from the models in ways no pending migration explains'));
+    }
+    printSteps(st.steps);
+
+  } else if (cmd === 'make') {
+    const out = await schema.make(name, {
+      dir: flags.dir,
+      allowLossy: flags.allowLossy,
+      allowDestructive: flags.allowDestructive,
+    });
+    if (!out) {
+      console.log(color('32', '✓ no changes — nothing to write'));
+    } else {
+      printSteps(out.steps);
+      console.log(`\nwrote ${out.file}`);
+      console.log(dim('review the file, then apply with: rip schema migrate'));
+    }
+
+  } else if (cmd === 'migrate') {
+    const out = await schema.migrate({ dir: flags.dir, repair: flags.repair });
+    if (!out.ran.length) console.log(color('32', '✓ no pending migrations'));
+    else for (const r of out.ran) console.log(`applied ${r}`);
+  }
+  process.exit(0);
+} catch (e) {
+  die(e?.message || String(e));
+}
+
+function usage(code) {
+  console.log(`\
+rip schema — diff declared :model schemas against the database and manage migrations.
+
+Usage:
+  rip schema status  [entry.rip] [--dir DIR]        applied / pending / drift + the current plan
+  rip schema plan    [entry.rip]                    print the classified diff (no files touched)
+  rip schema make <name> [entry.rip] [--dir DIR]    write migrations/NNNN_<name>.sql from the diff
+                     [--allow-lossy] [--allow-destructive]
+  rip schema migrate [entry.rip] [--dir DIR]        apply pending migration files in order
+                     [--repair]
+
+entry.rip       file that declares/imports every :model (default: ${ENTRY_CANDIDATES.join(' | ')})
+--dir DIR       migrations directory (default: migrations)
+--allow-lossy   include steps that may lose data on existing rows (type changes, SET NOT NULL)
+--allow-destructive   include DROP TABLE / DROP COLUMN steps
+--repair        re-record checksums for applied migrations whose files changed
+
+Connection: the entry's connect() call, or RIP_DB_URL / RIP_DB_TOKEN.`);
+  process.exit(code);
+}
+
+function die(msg) {
+  console.error(`rip schema: ${msg}`);
+  process.exit(1);
+}

package/docs/AGENTS.md

@@ -38,6 +38,6 @@ App.mount()
 - `demo.html` and `charts.html` — dashboard demos
 - `sierpinski.html` — CDN demo
 - `example/index.html` and `results/index.html` — app launchers / examples. `example/index.json` is generated from `docs/demo/` via `bun run bundle:demo` (the source-of-truth lives in `docs/demo/`, the JSON is the deployable artifact).
-- `ui/index.html` — widget gallery. `ui/bundle.json` is generated from `packages/ui/browser/components/` via `bun run bundle:ui` (auto-runs as part of `bun run build`). The source-of-truth is the workspace package; the JSON is the deployable artifact. The gallery loads the bundle at boot via `data-src="bundle.json"` and reads view-source text synchronously from the in-memory components store (`window.__RIP__.components.read("components/<id>.rip")`) — no per-component fetches.
+- `ui/index.html` — widget gallery. `ui/bundle.json` is generated from `packages/ui/browser/components/` via `bun run bundle:ui` (auto-runs as part of `bun run build`). The source-of-truth is the workspace package; the JSON is the deployable artifact. The gallery loads the bundle at boot via `data-src="bundle.json"` and reads view-source text synchronously from the in-memory components store (`window.__RIP__.components.read("_pkg/ui/<id>.rip")`) — no per-component fetches.
 
 Static demos can be opened via `file://`. The playground and example app require `bun run serve`.