@vesk/compiler 0.1.14 → 0.2.9

package/dist/ir-generator.js

@@ -4,6 +4,7 @@ import { createBaseParser } from '@vesk/compiler/src/parser';
 import { skipWhitespace, findBalancedEnd, splitTopLevel, startsWithIdentifier, stripDeclKeyword, isWhitespaceChar, collapseNewlineWhitespace } from '@vesk/compiler/src/scan';
 import { stripCodeTypes } from '@vesk/compiler/src/strip-ts';
 import { stripTypeImport } from '@vesk/compiler/src/vsk-imports';
+import { importBindingPairs } from '@vesk/compiler/src/module-imports';
 import { collectCalledIdentifiers, extractImportNames, importModuleTarget } from '@vesk/compiler/src/tokens';
 let __vskAnnotations = [];
 function parseExprNode(text) {
@@ -89,11 +90,11 @@ function componentUsesFetch(nodes) {
                 return true;
         }
         else if (node instanceof RuntimeStatement) {
-            if (node.raw.includes('useFetch('))
+            if (node.raw.includes('useFetch(') || node.raw.includes('useFetch.'))
                 return true;
         }
         else if (node instanceof DynamicBinding) {
-            if (node.expression.raw.includes('useFetch('))
+            if (node.expression.raw.includes('useFetch(') || node.expression.raw.includes('useFetch.'))
                 return true;
         }
         else if (node instanceof MapRegion) {
@@ -238,6 +239,20 @@ function processAttribute(source, attr) {
     }
     return { name, value: '' };
 }
+/**
+ * Recognizes a statement-mode `if (cond)` opening among JSX children.
+ * Returns the condition source, or null when `text` does not open an if
+ * header (keyword + balanced parens).
+ */
+function extractIfHeader(text) {
+    if (!startsWithIdentifier(text, 'if'))
+        return null;
+    let i = skipWhitespace(text, 2);
+    if (text[i] !== '(')
+        return null;
+    const end = findBalancedEnd(text, i);
+    return text.slice(i + 1, end).trim();
+}
 function extractForHeader(text) {
     if (!startsWithIdentifier(text, 'for'))
         return null;
@@ -271,6 +286,67 @@ function processJSXChildren(source, children) {
                 i++;
                 continue;
             }
+            // ── statement-mode if / else-if / else among element children ──
+            const ifCond = extractIfHeader(trimmed);
+            const seqNext = children[i + 1];
+            if (ifCond !== null &&
+                seqNext !== undefined &&
+                seqNext.type === 'JSXExpressionContainer' &&
+                seqNext.expression.type !== 'JSXEmptyExpression') {
+                const links = [];
+                let alternate = null;
+                const containerToNodes = (container) => {
+                    const exprNode = container.expression;
+                    if (exprNode.type === 'JSXFragment') {
+                        const inner = [];
+                        for (const c of exprNode.children)
+                            inner.push(...processJSXChildren(source, [c]));
+                        return inner;
+                    }
+                    if (exprNode.type === 'JSXElement')
+                        return processJSXElement(source, exprNode);
+                    return exprToIR(source, exprNode);
+                };
+                links.push({
+                    cond: new Expression(ifCond, [], parseExprNode(ifCond), null),
+                    nodes: containerToNodes(seqNext),
+                });
+                let j = i + 2;
+                while (j < children.length) {
+                    const sep = children[j];
+                    if (sep === undefined || sep.type !== 'JSXText')
+                        break;
+                    const sv = sep.value.trim();
+                    const cont = children[j + 1];
+                    if (sv.startsWith('} else if') || sv.startsWith('else if')) {
+                        const ifIdx = sv.indexOf('if');
+                        const header = extractIfHeader(sv.slice(ifIdx));
+                        if (header === null || cont === undefined || cont.type !== 'JSXExpressionContainer')
+                            break;
+                        links.push({
+                            cond: new Expression(header, [], parseExprNode(header), null),
+                            nodes: containerToNodes(cont),
+                        });
+                        j += 2;
+                        continue;
+                    }
+                    if (sv.startsWith('} else') || sv === 'else') {
+                        if (cont === undefined || cont.type !== 'JSXExpressionContainer')
+                            break;
+                        alternate = containerToNodes(cont);
+                        j += 2;
+                    }
+                    break;
+                }
+                // Fold right-to-left: earlier conditions wrap later ones as alternate.
+                let tail = alternate || [];
+                for (let k = links.length - 1; k >= 0; k--) {
+                    tail = [new OpaqueDynamicRegion(links[k].cond, links[k].nodes, tail)];
+                }
+                result.push(...tail);
+                i = j;
+                continue;
+            }
             const forDecl = extractForHeader(trimmed);
             const nextChild = children[i + 1];
             if (forDecl !== null && nextChild !== undefined && (nextChild.type === 'JSXExpressionContainer' ||
@@ -392,6 +468,32 @@ function processJSXChildren(source, children) {
                 result.push(...processJSXChildren(source, [c]));
             i++;
         }
+        else if (child.type === 'ForOfStatement') {
+            let alternate = [];
+            let consumed = 1;
+            const emptyText = children[i + 1];
+            const emptyContainer = children[i + 2];
+            if (emptyText && emptyText.type === 'JSXText' &&
+                ['#empty', 'empty'].includes(emptyText.value.trim()) &&
+                emptyContainer && emptyContainer.type === 'JSXExpressionContainer' &&
+                emptyContainer.expression.type !== 'JSXEmptyExpression') {
+                alternate = exprToIR(source, emptyContainer.expression);
+                consumed = 3;
+            }
+            result.push(...processForStatement(source, child, alternate));
+            i += consumed;
+            continue;
+        }
+        else if (child.type === 'IfStatement' || child.type === 'ForStatement' ||
+            child.type === 'ForInStatement' ||
+            child.type === 'WhileStatement' || child.type === 'DoWhileStatement' ||
+            child.type === 'SwitchStatement' || child.type === 'TryStatement' ||
+            child.type === 'VariableDeclaration' || child.type === 'ExpressionStatement' ||
+            child.type === 'ReturnStatement' || child.type === 'WithStatement' ||
+            child.type === 'LabeledStatement') {
+            result.push(...processStatementModeBody(source, [child]));
+            i++;
+        }
         else {
             i++;
         }
@@ -434,6 +536,30 @@ function exprToIR(source, expr) {
     }
     return [new DynamicBinding(toExpression(source, expr))];
 }
+/**
+ * True when an `ExpressionStatement` expression is a pure value that should
+ * render as output (a bare reference, member access, literal, template,
+ * conditional, etc.) rather than a side-effecting statement (call, assignment,
+ * update, `new`, `await`, `yield`, tagged template, `delete`/`void`). Side
+ * effects stay as runtime statements; pure values become dynamic bindings.
+ */
+function isRenderableExpression(expr) {
+    const t = expr.type;
+    if (t === 'CallExpression' || t === 'NewExpression' ||
+        t === 'AssignmentExpression' || t === 'UpdateExpression' ||
+        t === 'AwaitExpression' || t === 'YieldExpression' ||
+        t === 'TaggedTemplateExpression' || t === 'ImportExpression' ||
+        t === 'MetaProperty') {
+        return false;
+    }
+    if (t === 'UnaryExpression') {
+        return expr.operator !== 'delete' && expr.operator !== 'void';
+    }
+    if (t === 'SequenceExpression') {
+        return isRenderableExpression(expr.expressions[expr.expressions.length - 1]);
+    }
+    return true;
+}
 function processJSXCallbackBody(source, body) {
     if (body.type === 'JSXElement')
         return processJSXElement(source, body);
@@ -531,12 +657,17 @@ function buildGuardChain(source, guardClauses, mainReturn) {
         const guard = guardClauses[i];
         const condExpr = toExpression(source, guard.test);
         const consequent = [];
-        if (guard.consequent.type === 'ReturnStatement' && guard.consequent.argument) {
-            if (guard.consequent.argument.type === 'JSXElement') {
-                consequent.push(...processJSXElement(source, guard.consequent.argument));
+        const guardReturn = getReturnArgument(guard.consequent);
+        if (guardReturn) {
+            if (guardReturn.type === 'JSXElement') {
+                consequent.push(...processJSXElement(source, guardReturn));
+            }
+            else if (guardReturn.type === 'JSXFragment') {
+                for (const c of guardReturn.children)
+                    consequent.push(...processJSXChildren(source, [c]));
             }
             else {
-                consequent.push(new DynamicBinding(toExpression(source, guard.consequent.argument)));
+                consequent.push(new DynamicBinding(toExpression(source, guardReturn)));
             }
         }
         currentAlternate = [new OpaqueDynamicRegion(condExpr, consequent, currentAlternate)];
@@ -580,7 +711,24 @@ function hasJSXInSubtree(node) {
     return false;
 }
 function isGuardClause(node) {
-    return node.type === 'IfStatement' && node.consequent.type === 'ReturnStatement' && hasJSXInSubtree(node.consequent);
+    return (node.type === 'IfStatement' &&
+        !node.alternate &&
+        getReturnArgument(node.consequent) !== null &&
+        hasJSXInSubtree(node.consequent));
+}
+/**
+ * Returns the `return` argument of a statement that represents an early
+ * return — either a bare `ReturnStatement` or a `BlockStatement` wrapping a
+ * single `ReturnStatement`. Returns `null` when the statement is not such a
+ * return (including `return null` / `return;`, whose argument is absent).
+ */
+function getReturnArgument(node) {
+    if (node.type === 'ReturnStatement')
+        return node.argument ?? null;
+    if (node.type === 'BlockStatement' && node.body.length === 1 && node.body[0].type === 'ReturnStatement') {
+        return node.body[0].argument ?? null;
+    }
+    return null;
 }
 function isStatementMode(bodyStmts) {
     if (bodyStmts.some((s) => s.type === 'JSXElement' || s.type === 'JSXExpressionContainer' || s.type === 'JSXFragment'))
@@ -767,6 +915,16 @@ function processStatementModeBody(source, bodyStmts) {
         else if (stmt.type === 'ForStatement') {
             nodes.push(...processForStatement(source, stmt));
         }
+        else if (stmt.type === 'ExpressionStatement') {
+            if (isRenderableExpression(stmt.expression)) {
+                nodes.push(...exprToIR(source, stmt.expression));
+            }
+            else {
+                const raw = getSource(source, stmt);
+                if (raw)
+                    nodes.push(new RuntimeStatement(raw, stmt, source));
+            }
+        }
         else if (stmt.type === 'ClassDeclaration') {
             throw VeskError.classDecl();
         }
@@ -835,6 +993,37 @@ function processEnum(node, source, exported) {
     const prefix = exported ? `export const ${name}` : `const ${name}`;
     return `${prefix} = { ${allPairs} };`;
 }
+/**
+ * Normalizes any `@vesk/runtime/<subpath>` import specifier to the bare
+ * `'@vesk/runtime'` form. The runtime resolves all subpaths onto the same
+ * module graph, and downstream consumers (client scope injection, chunk
+ * stripping) key off the canonical bare specifier. Char-scan based — no
+ * regex, per repo rule.
+ */
+function normalizeRuntimeSpecifier(stmt) {
+    const fromIdx = stmt.indexOf(' from ');
+    if (fromIdx === -1)
+        return stmt;
+    const q1 = idxOfQuote(stmt, fromIdx);
+    if (q1 === -1)
+        return stmt;
+    const quote = stmt[q1];
+    const q2 = stmt.indexOf(quote, q1 + 1);
+    if (q2 === -1)
+        return stmt;
+    const spec = stmt.slice(q1 + 1, q2);
+    if (spec === '@vesk/runtime' || !spec.startsWith('@vesk/runtime/'))
+        return stmt;
+    return stmt.slice(0, q1 + 1) + '@vesk/runtime' + stmt.slice(q2);
+}
+function idxOfQuote(s, from) {
+    for (let i = from; i < s.length; i++) {
+        const c = s[i];
+        if (c === "'" || c === '"')
+            return i;
+    }
+    return -1;
+}
 export function generateIR(ast, source) {
     __vskAnnotations = ast.__vskAnnotations ?? [];
     const components = [];
@@ -846,9 +1035,10 @@ export function generateIR(ast, source) {
     for (const node of ast.body) {
         if (node.type === 'ImportDeclaration') {
             const raw = getSource(source, node);
-            const cleaned = stripTypeImport(raw);
+            let cleaned = stripTypeImport(raw);
             if (cleaned === null)
                 continue;
+            cleaned = normalizeRuntimeSpecifier(cleaned);
             imports.push(cleaned);
             for (const spec of node.specifiers) {
                 if (spec.importKind === 'type')
@@ -991,6 +1181,7 @@ export function generateIR(ast, source) {
         'Link', 'NavLink', 'Outlet', 'Redirect',
         'Image', 'Portal',
         'Experiment',
+        'LoadingIndicator', 'useLoadingIndicator',
         'JsonLd', 'ArticleSchema', 'ProductSchema', 'FAQPageSchema', 'BreadcrumbListSchema',
         'OrganizationSchema', 'LocalBusinessSchema', 'VideoSchema',
         'effect', 'derived', 'untrack', 'peek', 'tick', 'flushSync', 'on_destroy',
@@ -1053,7 +1244,15 @@ export function generateIR(ast, source) {
             for (const n of extractImportNames(imp))
                 existing.add(n);
         }
-        const missing = [...usedFunctions].filter(f => !existing.has(f));
+        // A name already bound by the file's own imports (any target — including a
+        // local module with the same export) wins; never auto-import a duplicate
+        // binding. Mirrors client shadowing so SSR and client agree.
+        const boundLocally = new Set();
+        for (const imp of imports) {
+            for (const pair of importBindingPairs(imp))
+                boundLocally.add(pair.local);
+        }
+        const missing = [...usedFunctions].filter(f => !existing.has(f) && !boundLocally.has(f));
         if (missing.length > 0) {
             imports.push(`import { ${missing.join(', ')} } from '@vesk/runtime';`);
         }

package/dist/md-inline.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Rewrites static `content="<file>.md"` attributes on <Md> elements into
+ * inlined constants. Returns the transformed source; when nothing matches,
+ * the original string is returned untouched.
+ *
+ * `mdRoots` are candidate project roots for absolute-style specifiers
+ * ("/x.md"); each root is tried as <root>/public<x> and <root><x>.
+ */
+export declare function inlineMdContentAttrs(source: string, importerDir: string | null, mdRoots?: string[]): string;
+/**
+ * Candidate project roots for absolute-style specifiers: walks up from
+ * `dir` collecting directories that contain a package.json (bounded).
+ */
+export declare function guessProjectRoots(dir: string | null): string[];
+/** Convenience wrapper used by pipelines that already know the file dir. */
+export declare function inlineMdImportsFrom(source: string, importerFile: string | null, mdRoots?: string[]): string;
+//# sourceMappingURL=md-inline.d.ts.map

package/dist/md-inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md-inline.d.ts","sourceRoot":"","sources":["../src/md-inline.ts"],"names":[],"mappings":"AA2CA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,GAAE,MAAM,EAAO,GACpB,MAAM,CAoDR;AAoBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,EAAE,CAY9D;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,GAAE,MAAM,EAAO,GAAG,MAAM,CAG/G"}

package/dist/md-inline.js

@@ -0,0 +1,149 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+// =============================================================
+// Inline resolution of <Md content="path/to/file.md"> attributes.
+//
+// When a `content="..."` attribute on an <Md> element is a static string
+// ending in .md/.markdown, the file is read at COMPILE time and inlined
+// into the source as a module-level const, so SSR, client chunks, SSG and
+// production all work without runtime filesystem access.
+//
+// Resolution order for the specifier:
+//   - './x.md' / '../x.md'  → relative to the importing .vsk file
+//   - '/x.md'               → candidate roots (project dir / public),
+//                             tried as <root>/public/x.md then <root>/x.md
+// =============================================================
+const MD_EXT_MARKER = '.md';
+function looksLikeMarkdownPath(value) {
+    const v = value.trim();
+    if (v.length === 0 || v.length > 4096)
+        return false;
+    if (v.includes('\n') || v.includes('\r'))
+        return false;
+    const lower = v.toLowerCase();
+    return lower.endsWith(MD_EXT_MARKER) || lower.endsWith('.markdown');
+}
+function isRelativeSpecifier(v) {
+    return v.startsWith('./') || v.startsWith('../');
+}
+/** Walks up from `start` looking for the first directory containing `marker`. */
+function findUp(start, marker) {
+    let cur = start;
+    for (let i = 0; i < 32; i++) {
+        if (existsSync(join(cur, marker)))
+            return cur;
+        const parent = dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+    return null;
+}
+/**
+ * Rewrites static `content="<file>.md"` attributes on <Md> elements into
+ * inlined constants. Returns the transformed source; when nothing matches,
+ * the original string is returned untouched.
+ *
+ * `mdRoots` are candidate project roots for absolute-style specifiers
+ * ("/x.md"); each root is tried as <root>/public<x> and <root><x>.
+ */
+export function inlineMdContentAttrs(source, importerDir, mdRoots = []) {
+    if (!source.includes('content=') && !source.includes('content ='))
+        return source;
+    if (!importerDir && mdRoots.length === 0)
+        return source;
+    let out = '';
+    let i = 0;
+    const n = source.length;
+    let counter = 0;
+    const decls = [];
+    const prefix = 'content=';
+    while (i < n) {
+        if (source.startsWith(prefix, i)) {
+            // attribute position: ensure this is a JSX-ish attribute (preceded by whitespace/start)
+            const prev = i > 0 ? source[i - 1] : ' ';
+            if (prev === ' ' || prev === '\t' || prev === '\n' || prev === '\r') {
+                let j = i + prefix.length;
+                const quote = source[j];
+                if (quote === '"' || quote === "'") {
+                    j++;
+                    const valStart = j;
+                    while (j < n && source[j] !== quote)
+                        j++;
+                    if (j < n) {
+                        const value = source.slice(valStart, j);
+                        if (looksLikeMarkdownPath(value)) {
+                            const abs = resolveMdPath(value, importerDir, mdRoots);
+                            if (abs !== null) {
+                                let contents;
+                                try {
+                                    contents = readFileSync(abs, 'utf-8');
+                                }
+                                catch {
+                                    out += source[i];
+                                    i++;
+                                    continue;
+                                }
+                                const varName = `__vesk_md_${counter++}`;
+                                decls.push(`const ${varName} = ${JSON.stringify(contents)};`);
+                                out += `${prefix}{${varName}}`;
+                                i = j + 1;
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        out += source[i];
+        i++;
+    }
+    if (decls.length === 0)
+        return source;
+    return decls.join('\n') + '\n' + out;
+}
+function resolveMdPath(specifier, importerDir, roots) {
+    const spec = specifier.trim();
+    if (isRelativeSpecifier(spec)) {
+        if (!importerDir)
+            return null;
+        const abs = resolve(importerDir, spec);
+        return existsSync(abs) ? abs : null;
+    }
+    if (spec.startsWith('/')) {
+        for (const root of roots) {
+            const pub = join(root, 'public', spec);
+            if (existsSync(pub))
+                return pub;
+            const direct = join(root, spec);
+            if (existsSync(direct))
+                return direct;
+        }
+    }
+    return null;
+}
+/**
+ * Candidate project roots for absolute-style specifiers: walks up from
+ * `dir` collecting directories that contain a package.json (bounded).
+ */
+export function guessProjectRoots(dir) {
+    if (!dir)
+        return [];
+    const roots = [];
+    let cur = dir;
+    for (let i = 0; i < 6; i++) {
+        roots.push(cur);
+        if (existsSync(join(cur, 'package.json')))
+            break;
+        const parent = dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return roots;
+}
+/** Convenience wrapper used by pipelines that already know the file dir. */
+export function inlineMdImportsFrom(source, importerFile, mdRoots = []) {
+    const dir = importerFile ? dirname(importerFile) : null;
+    return inlineMdContentAttrs(source, dir, mdRoots.length > 0 ? mdRoots : [dir || process.cwd()]);
+}

package/dist/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAiC,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEtG,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,CAsE7G;AAED,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,CAevG;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,eAAe,EAAE,EACxB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC;IAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAoGzH"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAiC,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEtG,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,CAsE7G;AAED,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,CAiBvG;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,eAAe,EAAE,EACxB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC;IAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAkIzH"}

package/dist/middleware.js

@@ -75,7 +75,9 @@ export async function loadMiddleware(sourcePath) {
     }
     if (sourcePath.endsWith('.js') || sourcePath.endsWith('.ts')) {
         try {
-            const mod = await import(sourcePath);
+            const url = new URL('file://' + sourcePath);
+            url.searchParams.set('t', String(Date.now()) + Math.random().toString(36).slice(2));
+            const mod = await import(url.href);
             return (mod.middleware || mod.default || null);
         }
         catch {
@@ -132,21 +134,37 @@ export async function executeMiddlewareChain(chain, request, params, options = {
     }
     let rewriteUrl = null;
     if (chain.length === 0) {
+        if (onLast) {
+            const prev = globalThis.__vesk_request;
+            globalThis.__vesk_request = ctx;
+            try {
+                const loneResponse = await onLast(rewriteUrl, ctx);
+                return { response: loneResponse ?? null, redirected: !!loneResponse && loneResponse.status >= 300 && loneResponse.status < 400, locals, rewriteUrl };
+            }
+            finally {
+                globalThis.__vesk_request = prev;
+            }
+        }
         return { response: null, redirected: false, locals, rewriteUrl: null };
     }
     async function runMiddleware(index) {
         if (index >= chain.length) {
             if (onLast) {
-                return onLast(rewriteUrl);
+                return onLast(rewriteUrl, ctx);
             }
-            return new Response(null, { status: 204 });
+            return null;
         }
         const { sourcePath } = chain[index];
         const fn = await loadMiddleware(sourcePath);
         if (!fn) {
             return runMiddleware(index + 1);
         }
+        let nextCalled = false;
+        let nextResult = null;
         async function next(rewrite) {
+            if (nextCalled)
+                return null;
+            nextCalled = true;
             if (rewrite) {
                 rewriteUrl = rewrite;
                 try {
@@ -158,14 +176,21 @@ export async function executeMiddlewareChain(chain, request, params, options = {
                     ctx.url = new URL(rewrite, base.origin);
                 }
             }
-            return runMiddleware(index + 1);
+            nextResult = await runMiddleware(index + 1);
+            return nextResult;
         }
         try {
             const result = await fn(ctx, next);
             if (result instanceof Response) {
                 return result;
             }
-            return new Response(null, { status: 204 });
+            if (nextResult !== null && nextResult instanceof Response) {
+                return nextResult;
+            }
+            if (!nextCalled) {
+                return runMiddleware(index + 1);
+            }
+            return null;
         }
         catch (e) {
             const err = e;
@@ -178,6 +203,16 @@ export async function executeMiddlewareChain(chain, request, params, options = {
             throw e;
         }
     }
-    const response = await runMiddleware(0);
-    return { response, redirected: response?.status >= 300 && response?.status < 400, locals, rewriteUrl };
+    // Ensure the outermost ctx is available as __vesk_request during the chain,
+    // so that server locals / onLast rendering sees middleware locals.
+    const prevOuter = globalThis.__vesk_request;
+    globalThis.__vesk_request = ctx;
+    let response;
+    try {
+        response = await runMiddleware(0);
+    }
+    finally {
+        globalThis.__vesk_request = prevOuter;
+    }
+    return { response, redirected: !!response && response.status >= 300 && response.status < 400, locals, rewriteUrl };
 }

package/dist/module-imports.d.ts

@@ -0,0 +1,51 @@
+/**
+ * AST-driven extraction of the value bindings introduced by one import
+ * statement (`import { a as b } from 'm'` → `[{ local: 'b', imported: 'a' }]`;
+ * `import X from 'm'` → `[{ local: 'X', imported: 'default' }]`;
+ * `import * as X from 'm'` → `[{ local: 'X', imported: '*' }]`). Type-only
+ * specifiers are skipped. Side-effect imports return `[]`.
+ */
+export declare function importBindingPairs(imp: string): Array<{
+    local: string;
+    imported: string;
+}>;
+/** Local binding names imported from non-runtime, non-`.vsk` modules. */
+export declare function localValueImportNames(importStrs: string[]): string[];
+/** True when an import line should be SSR-loaded (non-runtime, non-empty, non-`.vsk`). */
+export declare function isLocalValueImport(imp: string): boolean;
+/**
+ * Loads every local value import and merges its exports into `__vesk` so SSR
+ * component bodies can reference them. Pure side-effect imports (`import './x'`)
+ * are also resolved and executed so their module-level setup runs client AND
+ * server. Resolution is relative to `sourcePath` (the importing `.vsk` file).
+ *
+ * Best-effort: unresolvable/unloadable modules warn and are skipped, matching
+ * how unresolvable `.vsk` imports are handled. Unsupported ESM constructs
+ * (import.meta/top-level await) THROW a specific error — loading them would
+ * silently yield `undefined` at render.
+ */
+export declare function applyLocalModuleImports(__vesk: Record<string, unknown>, importStrs: string[], sourcePath: string | undefined): void;
+/**
+ * Loads (and caches) a module's export object. Cache entries track both the
+ * module's own mtime and the mtimes of everything it transitively resolved,
+ * so a change to any dependency invalidates every module that pulls it in.
+ * Builtin markers load through Node and are cached separately (never stale).
+ */
+export declare function loadSsrModule(absPath: string): Record<string, unknown> | null;
+/**
+ * Resolves a specifier to an absolute file path (or a `BUILTIN_PREFIX` marker
+ * for Node builtins). Relative/absolute localities use extension probing;
+ * bare specifiers (`npm-package`, `pkg/subpath`, `node:fs`, `fs`) prefer
+ * Node's own resolver — which understands `exports` maps, conditions, scoped
+ * packages and builtins — and fall back to a `node_modules` walk-up.
+ *
+ * Every resolved file path is normalized through `realpathSync` so two
+ * specifiers pointing at the same physical file (e.g. pnpm/yarn symlinked
+ * `node_modules`) share one cache entry and one module instance.
+ */
+export declare function resolveSsrModule(specifier: string, fromDir: string): string | null;
+/** Rewrites an ESM program body (imports/exports removed) into CJS statements. */
+export declare function esmToCjs(body: Array<{
+    type: string;
+} & Record<string, unknown>>): string;
+//# sourceMappingURL=module-imports.d.ts.map

package/dist/module-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-imports.d.ts","sourceRoot":"","sources":["../src/module-imports.ts"],"names":[],"mappings":"AAmGA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgC1F;AAED,yEAAyE;AACzE,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAQpE;AAED,0FAA0F;AAC1F,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,IAAI,CAuBN;AAiBD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAqD7E;AAqJD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBlF;AAoJD,kFAAkF;AAClF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAiGxF"}