@vesk/compiler 0.2.50-canary.9 → 0.2.51

package/dist/module-imports.js

@@ -7,6 +7,7 @@ import { walk } from 'zimmerframe';
 import { parse } from '@vesk/compiler/src/parser';
 import { stripTsTypes, hasTsSyntax, isTypeOnlyStatement } from '@vesk/compiler/src/strip-ts';
 import { importModuleTarget } from '@vesk/compiler/src/tokens';
+import { VeskError } from '@vesk/compiler/src/errors';
 // =============================================================
 // SSR module-value imports.
 //
@@ -246,6 +247,12 @@ export function loadSsrModule(absPath) {
             // transitive closure on every cold load (tens of seconds dev, too slow to
             // ship in prod).
             const src = readSsrSource(absPath);
+            // Report here, before any fallback can run. `nativeRequireFallback` and
+            // the raw-source substitution both "succeed" in the sense that they
+            // return something, which is how an unparseable module used to keep
+            // going and fail somewhere else entirely.
+            if (src?.parseError)
+                throw src.parseError;
             const body = (src?.ast?.body || []);
             if (src && isPureReexportBarrel(body)) {
                 exportsObj = createLazyBarrelExports(buildBarrelSpec(body), dirname(absPath));
@@ -365,14 +372,31 @@ export function readSsrSource(absPath) {
         return null;
     }
     const raw = cachedRaw;
-    let ast = null;
     try {
-        ast = parse(raw, { filename: absPath });
-    }
-    catch {
-        ast = null;
+        return { raw, ast: parse(raw, { filename: absPath }) };
+    }
+    catch (e) {
+        // A parse failure is a BUILD FAILURE, not a fallback. It used to return
+        // `ast: null` silently, and the caller then substituted the raw source — so
+        // the file's TypeScript syntax reached `new Function` and surfaced as a
+        // bare `Unexpected token ':'` in whichever module imported it, with no
+        // file, no line, and (because the module's exports came back undefined) a
+        // trail of unrelated `X is not iterable` failures behind it.
+        const err = e;
+        let parseError;
+        if (err instanceof VeskError) {
+            // `parse()` already produced a located diagnostic for this file. Keep its
+            // message, frame and position — they are strictly better than a wrapper's
+            // — and add the code so the failure is identifiable in build logs.
+            parseError = err;
+            if (err.code === undefined)
+                err.code = 'V0901';
+        }
+        else {
+            parseError = VeskError.moduleParseFailed({ file: absPath, reason: e?.message });
+        }
+        return { raw, ast: null, parseError };
     }
-    return { raw, ast };
 }
 /** True when every statement in a module body is a re-export (or a type-only /
  *  directive statement). Such "pure barrels" carry no computation of their own,
@@ -481,7 +505,11 @@ function createLazyBarrelExports(spec, dir) {
     const loadSource = (source) => {
         let target = targets.get(source);
         if (!target) {
-            target = resolveSsrModule(source, dir) ?? '';
+            // Compiler-owned sources resolve through their package `exports` map, not
+            // the project's tsconfig `paths` (see `createModuleRequire`).
+            target = (isCompilerOwnedTarget(source)
+                ? resolveCompilerOwnedModule(source)
+                : resolveSsrModule(source, dir)) ?? '';
             if (!target)
                 return null;
             targets.set(source, target);
@@ -590,6 +618,11 @@ function evaluateModuleFile(absPath, exportsObj, src) {
     let ast;
     if (src) {
         ast = src.ast;
+        // Report the parse failure at the file that caused it rather than letting
+        // the raw source reach `new Function` and fail as a SyntaxError nobody can
+        // trace back.
+        if (!ast && src.parseError)
+            throw src.parseError;
     }
     else {
         try {
@@ -684,8 +717,59 @@ function scanUnsupportedNode(node, inFunction = false) {
     return null;
 }
 /** Recursive `require` used inside evaluated modules, rooted at their dir. */
+/**
+ * Resolve a compiler-owned (`@vesk/*`) specifier WITHOUT consulting tsconfig
+ * `paths`. The package's own `exports` map is the authority for its own
+ * subpaths — and it points at built JavaScript.
+ */
+function resolveCompilerOwnedModule(specifier) {
+    const viaExports = resolveViaPackageExports(specifier, process.cwd());
+    if (viaExports)
+        return viaExports;
+    const viaModuleField = resolveViaPackageModuleField(specifier, process.cwd());
+    if (viaModuleField)
+        return viaModuleField;
+    const native = nativeResolve(specifier, process.cwd());
+    if (native && !isBuiltinPath(native))
+        return native;
+    return null;
+}
 function createModuleRequire(fromDir) {
     return (specifier) => {
+        // `@vesk/*` is compiler-owned, and it is BUILT JavaScript by the time it
+        // ships (`@vesk/runtime` → `dist/index-client.js`). It must not go through
+        // this loader at all, which parses with the `.vsk` grammar.
+        //
+        // Both halves of that were wrong, and together they took down any module
+        // that imported BOTH a `@vesk/*` package and a relative module:
+        //
+        //  1. Resolution used the project's tsconfig `paths`, which map
+        //     `@vesk/runtime/*` to `packages/runtime/src/*`, while the package's own
+        //     `exports` map sends the same specifier to `dist/*.js`. The alias won,
+        //     so the loader was handed raw TypeScript.
+        //  2. The built runtime entry is itself a re-export barrel, so it became a
+        //     lazy Proxy. Reading any name resolved a source file and parsed it
+        //     with the `.vsk` grammar — which rejects `component` as a reserved
+        //     word, so even `dist/ripple-runtime.js` failed.
+        //
+        // The resulting throw escaped the proxy read and propagated out of the
+        // IMPORTING module's evaluation, so every one of its exports came back
+        // `undefined` and any `track(...)` cell in it threw
+        // `Cannot read properties of undefined (reading 'get')`.
+        //
+        // Native `require` is the right loader here: these packages ship plain JS
+        // with a real `exports` map, exactly what Node is for. The bare-only and
+        // relative-only cases each happened to recover via `nativeRequireFallback`,
+        // which is why each looked fine in isolation and only the combination broke.
+        if (isCompilerOwnedTarget(specifier)) {
+            const resolved = resolveCompilerOwnedModule(specifier);
+            if (resolved) {
+                const native = nativeRequireFallback(resolved);
+                if (native)
+                    return native;
+            }
+            throw new Error(`Cannot load module '${specifier}'`);
+        }
         const resolved = resolveSsrModule(specifier, fromDir);
         if (!resolved)
             throw new Error(`Cannot find module '${specifier}'`);
@@ -1454,6 +1538,11 @@ export function collectModuleBundled(absPath, collector) {
     else {
         const src = readSsrSource(absPath);
         if (!src || !src.ast) {
+            // A module we could not parse is a hard failure. Substituting the raw
+            // source (the historical behavior) pushes every type annotation in this
+            // file into `new Function` and blames some unrelated module later.
+            if (src?.parseError)
+                throw src.parseError;
             const raw = src ? src.raw : '// unreadable during build\nmodule.exports = {};';
             collector.modules.push({ key, code: raw, dir, deps: {} });
             return key;

package/dist/parser.d.ts

@@ -33,6 +33,35 @@ export declare function preprocessForClauses(source: string): {
     code: string;
     annotations: VeskAnnotation[];
 };
+/**
+ * Blanks the type parameter list of a GENERIC ARROW function:
+ *
+ *   const read = <T,>(key: string, fallback: T): T => fallback;
+ *
+ * The list is type-only information the TS stripper deletes anyway, and it is
+ * unrepresentable in the tokenizer this parser uses: a `<` in expression
+ * position is read as `jsxTagStart`, and inside it the tokenizer emits
+ * `jsxName` / `jsxTagEnd` — never type tokens. So the construct could not be
+ * parsed at all, while `function f<T>(…)` and `async <T,>(…)` both could.
+ *
+ * That failure was silent rather than loud. `readSsrSource` treats a parse
+ * error as "not a module we understand" and substitutes the RAW, untranspiled
+ * source, so the parse error surfaced much later as
+ * `Unexpected token ':'` while the emitted module was being evaluated.
+ *
+ * Blanked IN PLACE — same character length, so every source offset, and
+ * therefore every AST node position, is preserved. This runs alongside the
+ * `{#clause}` and specifier-export passes for the same reason.
+ *
+ * The disambiguation is structural, not textual: the `>` must be followed by the
+ * arrow's PARAMETER list and then (after an optional return type) by `=>`. That
+ * is what separates `const f = <T,>(k: T): T => k` from the JSX
+ * `const a = <div>(hi)</div>`, where the `>` is also followed by `(` but never
+ * by `=>`. Type arguments (`f<T>(x)`) and comparisons fail the same test, so
+ * they are left untouched. A `<` inside a string, template or comment is
+ * skipped by the lexical scan before any of this runs.
+ */
+export declare function blankGenericArrowTypeParams(source: string): string;
 export declare function createBaseParser(): typeof acorn.Parser;
 /**
  * Parse GENERATED JavaScript with plain acorn — no TypeScript plugin, no

package/dist/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAOtC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA0BD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,cAAc,EAAE,CAAA;CAAE,CA4LpG;AAED,wBAAgB,gBAAgB,IAAI,OAAO,KAAK,CAAC,MAAM,CAEtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAM/D;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAuEzE"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAOtC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA0BD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,cAAc,EAAE,CAAA;CAAE,CA4LpG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwFlE;AA2DD,wBAAgB,gBAAgB,IAAI,OAAO,KAAK,CAAC,MAAM,CAEtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAM/D;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAuEzE"}

package/dist/parser.js

@@ -253,6 +253,226 @@ export function preprocessForClauses(source) {
     }
     return { code: chars.join(''), annotations };
 }
+/**
+ * Blanks the type parameter list of a GENERIC ARROW function:
+ *
+ *   const read = <T,>(key: string, fallback: T): T => fallback;
+ *
+ * The list is type-only information the TS stripper deletes anyway, and it is
+ * unrepresentable in the tokenizer this parser uses: a `<` in expression
+ * position is read as `jsxTagStart`, and inside it the tokenizer emits
+ * `jsxName` / `jsxTagEnd` — never type tokens. So the construct could not be
+ * parsed at all, while `function f<T>(…)` and `async <T,>(…)` both could.
+ *
+ * That failure was silent rather than loud. `readSsrSource` treats a parse
+ * error as "not a module we understand" and substitutes the RAW, untranspiled
+ * source, so the parse error surfaced much later as
+ * `Unexpected token ':'` while the emitted module was being evaluated.
+ *
+ * Blanked IN PLACE — same character length, so every source offset, and
+ * therefore every AST node position, is preserved. This runs alongside the
+ * `{#clause}` and specifier-export passes for the same reason.
+ *
+ * The disambiguation is structural, not textual: the `>` must be followed by the
+ * arrow's PARAMETER list and then (after an optional return type) by `=>`. That
+ * is what separates `const f = <T,>(k: T): T => k` from the JSX
+ * `const a = <div>(hi)</div>`, where the `>` is also followed by `(` but never
+ * by `=>`. Type arguments (`f<T>(x)`) and comparisons fail the same test, so
+ * they are left untouched. A `<` inside a string, template or comment is
+ * skipped by the lexical scan before any of this runs.
+ */
+export function blankGenericArrowTypeParams(source) {
+    let changed = false;
+    const chars = source.split('');
+    let i = 0;
+    const isSpace = (ch) => isSpaceChar(ch);
+    while (i < source.length) {
+        const ch = source[i];
+        // Skip strings, templates and comments — the same lexical discipline the
+        // clause pass uses, so a `<T,>` inside a string or comment is never touched.
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const quote = ch;
+            let j = i + 1;
+            while (j < source.length) {
+                if (source[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (source[j] === quote) {
+                    j++;
+                    break;
+                }
+                if (quote === '`' && source[j] === '$' && source[j + 1] === '{') {
+                    let depth = 1;
+                    j += 2;
+                    while (j < source.length && depth > 0) {
+                        if (source[j] === '{')
+                            depth++;
+                        else if (source[j] === '}')
+                            depth--;
+                        j++;
+                    }
+                    continue;
+                }
+                j++;
+            }
+            i = j;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '/') {
+            while (i < source.length && source[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && source[i + 1] === '*') {
+            i += 2;
+            while (i < source.length && !(source[i] === '*' && source[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        if (ch !== '<') {
+            i++;
+            continue;
+        }
+        // A candidate `<` in expression position: find the matching `>`, tracking
+        // angle depth and skipping bracketed groups (a `>` inside `(…)`/`[…]`/`{…}`
+        // is a comparison or a nested type argument, never the terminator).
+        let j = i + 1;
+        let angle = 1;
+        let end = -1;
+        let bail = false;
+        while (j < source.length) {
+            const c = source[j];
+            if (c === '<') {
+                angle++;
+                j++;
+                continue;
+            }
+            if (c === '>') {
+                angle--;
+                j++;
+                if (angle === 0) {
+                    end = j;
+                    break;
+                }
+                continue;
+            }
+            if (c === '(' || c === '[' || c === '{') {
+                const close = c === '(' ? ')' : c === '[' ? ']' : '}';
+                let depth = 0;
+                while (j < source.length) {
+                    const d = source[j];
+                    if (d === c)
+                        depth++;
+                    else if (d === close) {
+                        depth--;
+                        if (depth === 0) {
+                            j++;
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                continue;
+            }
+            if (c === ';' || c === '\n') {
+                bail = true;
+                break;
+            }
+            j++;
+        }
+        if (bail || end < 0) {
+            i++;
+            continue;
+        }
+        // Must be an arrow: `>` then a parameter list, then an optional return
+        // type, then `=>`. Scanning to the `=>` is what distinguishes this from a
+        // JSX element that happens to be followed by a parenthesized text run.
+        if (!isArrowParameterList(source, end)) {
+            i = end;
+            continue;
+        }
+        for (let p = i; p < end; p++) {
+            if (chars[p] !== '\n')
+                chars[p] = ' ';
+        }
+        changed = true;
+        i = end;
+    }
+    return changed ? chars.join('') : source;
+}
+/**
+ * True when `source` continues from `from` with `( … )` — optionally followed
+ * by a `: ReturnType` — and then `=>`. Balances brackets so the arrow inside a
+ * default value (`(cb = () => 1) => …`) is not mistaken for the terminator.
+ */
+function isArrowParameterList(source, from) {
+    let i = from;
+    while (i < source.length && isSpaceChar(source[i]))
+        i++;
+    if (source[i] !== '(')
+        return false;
+    let depth = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === '(' || ch === '[' || ch === '{') {
+            depth++;
+            i++;
+            continue;
+        }
+        if (ch === ')' || ch === ']' || ch === '}') {
+            depth--;
+            i++;
+            if (depth === 0)
+                break;
+            continue;
+        }
+        i++;
+    }
+    if (depth !== 0)
+        return false;
+    while (i < source.length && isSpaceChar(source[i]))
+        i++;
+    // Optional return type: `: T` up to the `=>` at depth zero.
+    if (source[i] === ':') {
+        i++;
+        let tdepth = 0;
+        while (i < source.length) {
+            const ch = source[i];
+            if (ch === '(' || ch === '[' || ch === '{') {
+                tdepth++;
+                i++;
+                continue;
+            }
+            if (ch === ')' || ch === ']' || ch === '}') {
+                if (tdepth === 0)
+                    return false;
+                tdepth--;
+                i++;
+                continue;
+            }
+            if (tdepth === 0 && ch === '=' && source[i + 1] === '>')
+                return true;
+            // A statement boundary ends the scan ONLY at depth zero. An object
+            // LITERAL type is full of them and is perfectly legal inside a return
+            // annotation: `{ roles: R[]; changed: boolean }` has a `;` (and, when it
+            // wraps, a newline) inside the braces. Bailing on those is what made
+            // `<R extends { id: string }>(a: R[], b: R[]): { roles: R[]; changed:
+            // boolean } => a` the one generic-arrow shape that still failed — it needs
+            // a generic arrow AND a braced constraint AND a return annotation, which
+            // is why dropping any ONE of the three parsed cleanly.
+            if (tdepth === 0 && (ch === ';' || ch === '\n'))
+                return false;
+            i++;
+        }
+        return false;
+    }
+    return source[i] === '=' && source[i + 1] === '>';
+}
+function isSpaceChar(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f' || ch === '\v';
+}
 export function createBaseParser() {
     return acorn.Parser.extend(tsPlugin({}), VeskParserPlugin());
 }
@@ -283,7 +503,7 @@ export function parseGeneratedJs(source) {
 }
 export function parse(source, options = {}) {
     const ParserClass = createBaseParser();
-    const { code, annotations } = preprocessForClauses(blankComments(source));
+    const { code, annotations } = preprocessForClauses(blankGenericArrowTypeParams(blankComments(source)));
     // Acorn validates that every `export { X }` names a real top-level binding.
     // A `.vsk` component is a registry entry, not a binding, so acorn rejects
     // `export { MyComponent }`. Remove only those specifier lists — one whose

package/dist/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAM1D,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;GAMG;AACH,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAajD;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAqB3F;AAkDD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUnE;AAwED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,SAAS,EAAE,CAKjF;AAMD,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BzE;AA6HD,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBrE;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAoCnG;AAoBD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAmGhF"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAM1D,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;GAMG;AACH,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAajD;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAqB3F;AAkDD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUnE;AAwED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,SAAS,EAAE,CAKjF;AAMD,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BzE;AA6HD,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBrE;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAoCnG;AAoBD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAkHhF"}

package/dist/router.js

@@ -520,6 +520,21 @@ export function matchUrl(tree, pathname) {
                         pushWithStandalone(node);
                     return true;
                 }
+                // A group can also BE the page at this position: `app/(public)/page.vsk`
+                // serves `/`. The recursion above only ever considers the group's
+                // CHILDREN, and at `/` none of them match (they all carry a path
+                // segment), so the group was skipped entirely and the match fell
+                // through to the page-less root node — which produced a 404 for the
+                // zero-segment path while every nested route (`/about`, `/login`)
+                // matched fine.
+                //
+                // A group is transparent for PREFIX matching, and it has to be
+                // transparent here too: a group with no page at this position is not a
+                // match, a group WITH one is.
+                if (partIndex >= parts.length && node.page && node.fullPath === '/' + parts.join('/')) {
+                    pushWithStandalone(node);
+                    return true;
+                }
                 continue;
             }
             if (node.fullPath === '/') {

package/dist/scan.d.ts

@@ -93,6 +93,21 @@ export declare function hasTopLevelComma(text: string): boolean;
  * and `for (... in ...)` headers apart from classic `for` loops.
  */
 export declare function containsForOfIn(text: string): boolean;
+/**
+ * Reports whether `ident` appears in `text` as a CALLED identifier — i.e.
+ * followed by an optional TS generic clause and then `(`.
+ *
+ * This is a character-loop tokenizer, not a text match: it steps over
+ * whitespace, `//` and block comments, and quoted / template strings, so
+ * `track(` appearing inside a string, a comment or a property access
+ * (`obj.track(...)`) never counts. Template literals are skipped whole —
+ * including their `${...}` holes — because a `track(` in an interpolation is
+ * not a reliable enough signal to inject a runtime binding for.
+ *
+ * Used to decide which runtime helpers a raw statement needs without
+ * requiring the caller to have been lowered into a TrackDecl first.
+ */
+export declare function callsIdentifier(text: string, ident: string): boolean;
 /**
  * Extracts the argument text of a `track<...>(...)` call from an init
  * expression. Handles nested generics (`track<Map<string, number>>(...)`)

package/dist/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAItD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOzE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS5D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc9D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAY3D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmDlD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAkBvE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA2BjE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBtD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBrD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYpD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAcnE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAqB9D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAY3D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAexD"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAItD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOzE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS5D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc9D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAY3D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmDlD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAkBvE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA2BjE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBtD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkBrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAwDpE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYpD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAcnE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAqB9D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAY3D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAexD"}

package/dist/scan.js

@@ -408,6 +408,70 @@ export function containsForOfIn(text) {
     }
     return false;
 }
+/**
+ * Reports whether `ident` appears in `text` as a CALLED identifier — i.e.
+ * followed by an optional TS generic clause and then `(`.
+ *
+ * This is a character-loop tokenizer, not a text match: it steps over
+ * whitespace, `//` and block comments, and quoted / template strings, so
+ * `track(` appearing inside a string, a comment or a property access
+ * (`obj.track(...)`) never counts. Template literals are skipped whole —
+ * including their `${...}` holes — because a `track(` in an interpolation is
+ * not a reliable enough signal to inject a runtime binding for.
+ *
+ * Used to decide which runtime helpers a raw statement needs without
+ * requiring the caller to have been lowered into a TrackDecl first.
+ */
+export function callsIdentifier(text, ident) {
+    let i = 0;
+    const len = text.length;
+    // True when the previous significant character means the next identifier
+    // is a member access (`obj.track`) rather than a free call.
+    let afterDot = false;
+    while (i < len) {
+        const ch = text[i];
+        if (isWhitespaceChar(ch)) {
+            i++;
+            continue;
+        }
+        const commentEnd = skipComment(text, i);
+        if (commentEnd !== i) {
+            i = commentEnd;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            i = skipString(text, i);
+            afterDot = false;
+            continue;
+        }
+        if (ch === '.' || (ch === '?' && text[i + 1] === '.')) {
+            afterDot = true;
+            i += ch === '.' ? 1 : 2;
+            continue;
+        }
+        if (isIdentStartCode(ch.charCodeAt(0))) {
+            let j = i + 1;
+            while (j < len && isIdentCharCode(text.charCodeAt(j)))
+                j++;
+            const name = text.slice(i, j);
+            let k = skipWhitespace(text, j);
+            // A `name<T,>(...)` generic call — skip the balanced `<...>`.
+            if (text[k] === '<') {
+                k = skipTrackGeneric(text, k);
+                k = skipWhitespace(text, k);
+            }
+            if (name === ident && text[k] === '(' && !afterDot) {
+                return true;
+            }
+            afterDot = false;
+            i = j;
+            continue;
+        }
+        afterDot = false;
+        i++;
+    }
+    return false;
+}
 /**
  * Extracts the argument text of a `track<...>(...)` call from an init
  * expression. Handles nested generics (`track<Map<string, number>>(...)`)

package/dist/server-jsgen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-jsgen.d.ts","sourceRoot":"","sources":["../src/server-jsgen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAOzE,OAAO,EAAkG,KAAK,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAoDrK,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,GAAE,OAAe,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,MAAM,CAgEjJ;AA4XD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CAqD1F;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAkCzE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAYhG"}
+{"version":3,"file":"server-jsgen.d.ts","sourceRoot":"","sources":["../src/server-jsgen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAOzE,OAAO,EAAkG,KAAK,WAAW,EAAE,MAAM,mCAAmC,CAAC;AA6DrK,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,GAAE,OAAe,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,MAAM,CA4EjJ;AAobD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,CAwD1F;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAuFD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAkCzE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAYhG"}