rip-lang 3.16.0 → 3.16.1

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.1",
   "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",
@@ -87,6 +91,7 @@
   "author": "Steve Shreeve <steve.shreeve@gmail.com>",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "5.9.3"
+    "@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

@@ -241,15 +241,15 @@ Complete node reference:
 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:
@@ -415,7 +415,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 +653,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)` 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()`.
 
 `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.
 

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);