@vesk/vesk-cli 0.2.50 → 0.2.51

package/dist/cli.js

@@ -199,6 +199,42 @@ var init_errors = __esm({
        * - `value` — `ns.max` read as a value. Component tags resolve; plain value
        *   reads do not, because nothing binds `ns` at runtime.
        */
+      /**
+       * An imported `.ts`/`.js` module could not be parsed.
+       *
+       * This used to be silent, and that is the whole point of the diagnostic. A
+       * parse failure meant the module's RAW, untranspiled source was substituted,
+       * so TypeScript syntax reached `new Function` and the module blew up much
+       * later with a bare `Unexpected token ':'` — attributed to no file, at a
+       * point in the build far from the code that caused it. It also poisoned the
+       * whole shared module graph: one unparseable module left its exports
+       * undefined, so unrelated consumers failed with `X is not iterable`.
+       *
+       * Two real constructs hit this: a parameter annotation that survived the
+       * stripper only when the parameter also had a default value, and a generic
+       * arrow's type parameter list, which the JSX tokenizer cannot read at all.
+       * Both are fixed; this error exists so the NEXT such gap is reported at the
+       * right file with the right line instead of surfacing three modules later.
+       */
+      static moduleParseFailed(context = {}) {
+        return new _VeskError(
+          `Could not parse an imported module${context.reason ? `: ${context.reason}` : "."}`,
+          {
+            ...context,
+            code: context.code || "V0901",
+            suggestions: [
+              "Check the line the ^ marker points at \u2014 it is the construct the parser stopped on.",
+              "If it is TypeScript syntax the stripper does not handle, simplifying it here fixes every module that imports this file.",
+              "This is a bug in the compiler, not in your code, if the construct is ordinary TypeScript \u2014 please report it with the source line."
+            ],
+            nextSteps: [
+              "A module that fails to parse is substituted with its raw source, so every type annotation it contains becomes a runtime SyntaxError.",
+              "The failure is reported here, at the offending file and line, rather than as an `Unexpected token` in whichever module happened to import it."
+            ],
+            tip: "Ordinary TypeScript should parse; if this fires on valid TS, the parser is missing a construct."
+          }
+        );
+      }
       static vskNamespaceMember(context = {}) {
         const nested = context.form === "nested";
         return new _VeskError(
@@ -3569,7 +3605,13 @@ function flattenLayoutChain(tree, pathParts, result = []) {
   for (let i = 0; i < tree.length; i++) {
     const node = tree[i];
     if (node.isGroup) {
+      const before = result.length;
       flattenLayoutChain(node.children || [], pathParts, result);
+      if (result.length > before) continue;
+      if (node.page && (pathParts.length === 0 || pathParts.every((p) => p === ""))) {
+        result.push(node);
+        break;
+      }
       continue;
     }
     const part = pathParts[0];
@@ -3591,6 +3633,11 @@ function flattenLayoutChain(tree, pathParts, result = []) {
       if (node.standalone) result.length = 0;
       result.push(node);
       if (isLeaf2) {
+        if (!node.page && (node.children || []).length > 0) {
+          const before = result.length;
+          flattenLayoutChain(node.children || [], remaining, result);
+          if (result.length > before) break;
+        }
         break;
       } else if ((node.children || []).length > 0) {
         flattenLayoutChain(node.children || [], remaining, result);
@@ -18773,6 +18820,162 @@ function preprocessForClauses(source) {
   }
   return { code: chars.join(""), annotations };
 }
+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];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      let j2 = i + 1;
+      while (j2 < source.length) {
+        if (source[j2] === "\\") {
+          j2 += 2;
+          continue;
+        }
+        if (source[j2] === quote) {
+          j2++;
+          break;
+        }
+        if (quote === "`" && source[j2] === "$" && source[j2 + 1] === "{") {
+          let depth = 1;
+          j2 += 2;
+          while (j2 < source.length && depth > 0) {
+            if (source[j2] === "{") depth++;
+            else if (source[j2] === "}") depth--;
+            j2++;
+          }
+          continue;
+        }
+        j2++;
+      }
+      i = j2;
+      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;
+    }
+    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;
+    }
+    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;
+}
+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++;
+  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;
+      if (tdepth === 0 && (ch === ";" || ch === "\n")) return false;
+      i++;
+    }
+    return false;
+  }
+  return source[i] === "=" && source[i + 1] === ">";
+}
+function isSpaceChar(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
 function createBaseParser() {
   return Parser.extend(tsPlugin({}), VeskParserPlugin());
 }
@@ -18785,7 +18988,7 @@ function parseGeneratedJs(source) {
 }
 function parse4(source, options = {}) {
   const ParserClass = createBaseParser();
-  const { code, annotations } = preprocessForClauses(blankComments(source));
+  const { code, annotations } = preprocessForClauses(blankGenericArrowTypeParams(blankComments(source)));
   const vskSource = !options.filename || String(options.filename).endsWith(".vsk");
   const specifierExports = vskSource ? findSpecifierExports(code).filter((e) => !hasTopLevelValueDeclaration(code, e.local)) : [];
   let parseable = code;
@@ -18987,13 +19190,33 @@ function stripTsTypes(ast) {
     }
   });
 }
+function stripParamTypes(p) {
+  if (!p) return;
+  if (p.typeAnnotation) p.typeAnnotation = null;
+  if (p.optional) p.optional = false;
+  switch (p.type) {
+    case "AssignmentPattern":
+      stripParamTypes(p.left);
+      break;
+    case "RestElement":
+      stripParamTypes(p.argument);
+      break;
+    case "ObjectPattern":
+      for (const prop of p.properties || []) {
+        stripParamTypes(prop.value || prop.argument || prop);
+      }
+      break;
+    case "ArrayPattern":
+      for (const el of p.elements || []) if (el) stripParamTypes(el);
+      break;
+    default:
+      break;
+  }
+}
 function stripFunctionTypes(node) {
   if (node.returnType) node.returnType = null;
   if (node.typeParameters) node.typeParameters = null;
-  for (const p of node.params || []) {
-    if (p.typeAnnotation) p.typeAnnotation = null;
-    if (p.optional) p.optional = false;
-  }
+  for (const p of node.params || []) stripParamTypes(p);
 }
 function stripCodeTypes(code) {
   let ast;
@@ -19171,6 +19394,7 @@ function loadSsrModule(absPath) {
       }
     } else {
       const src2 = readSsrSource(absPath);
+      if (src2?.parseError) throw src2.parseError;
       const body = src2?.ast?.body || [];
       if (src2 && isPureReexportBarrel(body)) {
         exportsObj = createLazyBarrelExports(buildBarrelSpec(body), dirname2(absPath));
@@ -19247,13 +19471,19 @@ function readSsrSource(absPath) {
     return null;
   }
   const raw2 = cachedRaw;
-  let ast = null;
   try {
-    ast = parse4(raw2, { filename: absPath });
-  } catch {
-    ast = null;
+    return { raw: raw2, ast: parse4(raw2, { filename: absPath }) };
+  } catch (e) {
+    const err = e;
+    let parseError;
+    if (err instanceof VeskError) {
+      parseError = err;
+      if (err.code === void 0) err.code = "V0901";
+    } else {
+      parseError = VeskError.moduleParseFailed({ file: absPath, reason: e?.message });
+    }
+    return { raw: raw2, ast: null, parseError };
   }
-  return { raw: raw2, ast };
 }
 function isPureReexportBarrel(body) {
   for (const stmt of body) {
@@ -19319,7 +19549,7 @@ function createLazyBarrelExports(spec, dir) {
   const loadSource = (source) => {
     let target = targets.get(source);
     if (!target) {
-      target = resolveSsrModule(source, dir) ?? "";
+      target = (isCompilerOwnedTarget(source) ? resolveCompilerOwnedModule(source) : resolveSsrModule(source, dir)) ?? "";
       if (!target) return null;
       targets.set(source, target);
     }
@@ -19404,6 +19634,7 @@ function evaluateModuleFile(absPath, exportsObj, src2) {
   let ast;
   if (src2) {
     ast = src2.ast;
+    if (!ast && src2.parseError) throw src2.parseError;
   } else {
     try {
       ast = parse4(raw2, { filename: absPath });
@@ -19477,8 +19708,25 @@ function scanUnsupportedNode(node, inFunction = false) {
   }
   return null;
 }
+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) => {
+    if (isCompilerOwnedTarget(specifier)) {
+      const resolved2 = resolveCompilerOwnedModule(specifier);
+      if (resolved2) {
+        const native = nativeRequireFallback(resolved2);
+        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}'`);
     for (const frame of depStack) frame.add(resolved);
@@ -20026,6 +20274,7 @@ function collectModuleBundled(absPath, collector) {
   } else {
     const src2 = readSsrSource(absPath);
     if (!src2 || !src2.ast) {
+      if (src2?.parseError) throw src2.parseError;
       const raw2 = src2 ? src2.raw : "// unreadable during build\nmodule.exports = {};";
       collector.modules.push({ key, code: raw2, dir, deps: {} });
       return key;
@@ -20072,6 +20321,7 @@ var init_module_imports = __esm({
     init_parser();
     init_strip_ts();
     init_tokens();
+    init_errors();
     RUNTIME_PREFIXES = ["@vesk/runtime/", "@vesk/reactivity/", "@vesk/types", "@vesk/"];
     EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".jsx", ".json"];
     BUILTIN_PREFIX = "\0builtin:";
@@ -20541,6 +20791,22 @@ function jsxTagDepth(nameNode) {
   }
   return depth;
 }
+function unwrapHelperBody(node) {
+  let body = node;
+  if (body?.type === "ArrowFunctionExpression" || body?.type === "FunctionExpression") body = body.body;
+  if (body?.type === "BlockStatement") {
+    const stmts = (body.body || []).filter((s) => s.type !== "EmptyStatement");
+    if (stmts.length !== 1) return null;
+    body = stmts[0];
+  }
+  if (body?.type === "ReturnStatement") body = body.argument;
+  if (!body) return null;
+  if (body.type !== "CallExpression") return null;
+  if (body.callee?.type !== "Identifier") return null;
+  const args2 = body.arguments || [];
+  if (args2.length === 0 || args2[0]?.type !== "ObjectExpression") return null;
+  return body;
+}
 function collectVskNamespaceLocals(ast) {
   const namespaceLocals = /* @__PURE__ */ new Map();
   for (const node of ast.body || []) {
@@ -20574,6 +20840,34 @@ function markShadowedBindings(node, namespaceLocals) {
     markShadowedBindings(node[key], namespaceLocals);
   }
 }
+function collectFileValueBindings(ast) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of ast.body || []) {
+    if (node.type === "ComponentDeclaration") continue;
+    if (node.type === "ImportDeclaration") continue;
+    const target = node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+    if (!target) continue;
+    if (target.type === "VariableDeclaration") {
+      for (const d of target.declarations || []) for (const n of declaredBindingNames(d)) names.add(n);
+      continue;
+    }
+    for (const n of declaredBindingNames(target)) names.add(n);
+  }
+  return names;
+}
+function collectComponentValueNames(compNode) {
+  const names = /* @__PURE__ */ new Set();
+  if (!compNode) return names;
+  for (const p of compNode.params || []) for (const n of declaredBindingNames(p)) names.add(n);
+  for (const stmt of compNode.body?.body || []) {
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations || []) for (const n of declaredBindingNames(d)) names.add(n);
+      continue;
+    }
+    for (const n of declaredBindingNames(stmt)) names.add(n);
+  }
+  return names;
+}
 function declaredBindingNames(node) {
   const out = [];
   const pushPattern = (id) => {
@@ -20643,9 +20937,149 @@ function findNamespaceValueUse(node, locals2) {
   }
   return null;
 }
+function collectComponentCallHelpers(source, ast) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of ast.body || []) {
+    const decl = node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+    if (!decl) continue;
+    let name = null;
+    let fn = null;
+    if (decl.type === "VariableDeclaration" && decl.declarations?.length === 1) {
+      const d = decl.declarations[0];
+      if (d.id?.type === "Identifier") {
+        name = d.id.name;
+        fn = d.init;
+      }
+    } else if (decl.type === "FunctionDeclaration" && decl.id?.name) {
+      name = decl.id.name;
+      fn = decl;
+    }
+    if (!name || !fn) continue;
+    if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" && fn.type !== "FunctionDeclaration") continue;
+    const params = fn.params || [];
+    if (params.some((p) => p.type !== "Identifier")) continue;
+    const body = unwrapHelperBody(fn);
+    if (body === null) continue;
+    const args2 = body.arguments || [];
+    const propsObj = args2[0];
+    const props = [];
+    const spreadProps = [];
+    const slots = [];
+    for (const prop of propsObj.properties || []) {
+      if (prop.type === "SpreadElement") {
+        spreadProps.push(prop.argument);
+        continue;
+      }
+      const pname = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+      if (prop.value.type === "JSXElement" || prop.value.type === "JSXFragment") {
+        slots.push({ name: pname, nodes: exprToIR(source, prop.value) });
+        continue;
+      }
+      props.push({ name: pname, value: prop.value });
+    }
+    const paramNames = params.map((p) => p.name);
+    out.set(name, { props, spreadProps, slots, paramNames, componentName: body.callee.name });
+  }
+  return out;
+}
+function substituteHelperParams(node, bindings) {
+  if (!node || typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    const out2 = [];
+    for (const child of node) {
+      const next = substituteHelperParams(child, bindings);
+      if (next === null) return null;
+      out2.push(next);
+    }
+    return out2;
+  }
+  if (typeof node.type !== "string") return node;
+  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") return null;
+  if (node.type === "Identifier" && bindings.has(node.name)) {
+    const bound = bindings.get(node.name);
+    return bound === null ? null : bound;
+  }
+  const out = {};
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "range" || key === "start" || key === "end") {
+      out[key] = node[key];
+      continue;
+    }
+    const next = substituteHelperParams(node[key], bindings);
+    if (next === null) return null;
+    out[key] = next;
+  }
+  return out;
+}
+function helperCallToIR(source, helper, args2) {
+  const compName = helper.componentName;
+  const bindings = /* @__PURE__ */ new Map();
+  helper.paramNames.forEach((param, i) => bindings.set(param, args2[i] ?? null));
+  for (const bound of bindings.values()) if (bound === null) return null;
+  const props = [];
+  for (const p of helper.props) {
+    const substituted = substituteHelperParams(p.value, bindings);
+    if (substituted === null) return null;
+    props.push({ name: p.name, value: toExpression(source, substituted) });
+  }
+  const spreadProps = [];
+  for (const sp of helper.spreadProps) {
+    const substituted = substituteHelperParams(sp, bindings);
+    if (substituted === null) return null;
+    spreadProps.push(toExpression(source, substituted));
+  }
+  return [new ComponentCall(compName, props, helper.slots.flatMap((s) => [new PropSlot(s.name, s.nodes)]), spreadProps, -1, componentValueCallee(compName))];
+}
 function isHTMLTag(name) {
   return name.length > 0 && name[0] === name[0].toLowerCase();
 }
+function componentValueCallee(tagName) {
+  if (!currentComponentValues || !currentComponentValues.has(tagName)) return null;
+  return tagName;
+}
+function componentCallInExpression(expr) {
+  if (!expr || expr.type !== "CallExpression") return null;
+  const callee = expr.callee;
+  if (!callee || callee.type !== "Identifier") return null;
+  if (!isComponentValueName(callee.name)) return null;
+  const args2 = expr.arguments || [];
+  if (args2.length === 0 || !args2[0] || args2[0].type !== "ObjectExpression") return null;
+  return expr;
+}
+function isComponentValueName(name) {
+  if (currentFileComponentNames?.has(name)) return true;
+  if (currentComponentValues?.has(name)) return true;
+  return currentFileValueBindings?.has(name) || currentImportedNames?.has(name) || false;
+}
+function componentCallToIR(source, expr) {
+  const calleeName = expr.callee.name;
+  const args2 = expr.arguments || [];
+  const propsArg = args2[0];
+  const props = [];
+  const spreadProps = [];
+  const slots = [];
+  for (const prop of propsArg.properties || []) {
+    if (prop.type === "SpreadElement") {
+      spreadProps.push(toExpression(source, prop.argument));
+      continue;
+    }
+    const name = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+    if (prop.value.type === "JSXElement" || prop.value.type === "JSXFragment") {
+      slots.push(new PropSlot(name, exprToIR(source, prop.value)));
+      continue;
+    }
+    props.push({ name, value: toExpression(source, prop.value) });
+  }
+  const children = args2.length > 1 ? [new RuntimeStatement(`/* [vesk] extra arguments to a component call are ignored */ ${getSource(source, args2[1])}`)] : [];
+  return [new ComponentCall(
+    calleeName,
+    props,
+    [...children, ...slots],
+    spreadProps,
+    expr.start ?? -1,
+    componentValueCallee(calleeName)
+  )];
+}
 function isMapCall(expr) {
   return expr.type === "CallExpression" && expr.callee.type === "MemberExpression" && expr.callee.property.name === "map" && expr.arguments.length === 1 && expr.arguments[0].type === "ArrowFunctionExpression";
 }
@@ -20914,7 +21348,7 @@ function processJSXChildren(source, children) {
           continue;
         }
       }
-      result.push(new DynamicBinding(toExpression(source, expr)));
+      result.push(...exprToIR(source, expr));
       i++;
     } else if (child.type === "JSXElement") {
       result.push(...processJSXElement(source, child));
@@ -20960,6 +21394,12 @@ function exprToIR(source, expr) {
     return [new MapRegion(arrayExpr, itemVar, bodyNodes, keyExpr, indexVar)];
   }
   if (expr.type === "ParenthesizedExpression") return exprToIR(source, expr.expression);
+  if (componentCallInExpression(expr) !== null) return componentCallToIR(source, expr);
+  if (expr?.type === "CallExpression" && currentComponentCallHelpers?.has(expr.callee?.name)) {
+    const helper = currentComponentCallHelpers.get(expr.callee.name);
+    const inlined = helperCallToIR(source, helper, expr.arguments || []);
+    if (inlined !== null) return inlined;
+  }
   if (expr.type === "ConditionalExpression") {
     const condExpr = toExpression(source, expr.test);
     const consequent = exprToIR(source, expr.consequent);
@@ -21027,12 +21467,12 @@ function processJSXElement(source, element) {
   }
   if (!isHTMLTag(tagName) && selfClosing) {
     const { props, spreadProps, slots } = extractProps(source, element);
-    return [new ComponentCall(tagName, props, slots.map((s) => new PropSlot(s.name, s.nodes)), spreadProps, element.start)];
+    return [new ComponentCall(tagName, props, slots.map((s) => new PropSlot(s.name, s.nodes)), spreadProps, element.start, componentValueCallee(tagName))];
   }
   if (!isHTMLTag(tagName)) {
     const { props, spreadProps, slots } = extractProps(source, element);
     const children2 = processJSXChildren(source, element.children || []);
-    return [new ComponentCall(tagName, props, [...children2, ...slots.map((s) => new PropSlot(s.name, s.nodes))], spreadProps, element.start)];
+    return [new ComponentCall(tagName, props, [...children2, ...slots.map((s) => new PropSlot(s.name, s.nodes))], spreadProps, element.start, componentValueCallee(tagName))];
   }
   const attributes = element.openingElement.attributes.filter((attr) => attr.type !== "JSXSpreadAttribute").map((attr) => processAttribute(source, attr));
   const staticAttrs = [];
@@ -21445,6 +21885,17 @@ function generateIR(ast, source, filename) {
   const vskNamespaceLocals = collectVskNamespaceLocals(ast);
   const prevNamespaceLocals = currentVskNamespaceLocals;
   const prevSourceFile = currentSourceFile;
+  const fileValueBindings = collectFileValueBindings(ast);
+  currentComponentCallHelpers = collectComponentCallHelpers(source, ast);
+  const prevFileComponentNames = currentFileComponentNames;
+  const prevFileValueBindings = currentFileValueBindings;
+  const prevImportedNames = currentImportedNames;
+  const fileComponentNames = new Set(
+    (ast.body || []).map((n) => n.type === "ExportNamedDeclaration" || n.type === "ExportDefaultDeclaration" ? n.declaration : n).filter((n) => n?.type === "ComponentDeclaration").map((n) => n.id.name)
+  );
+  currentFileComponentNames = fileComponentNames;
+  currentFileValueBindings = fileValueBindings;
+  currentImportedNames = importedNames;
   currentVskNamespaceLocals = vskNamespaceLocals;
   currentSourceFile = file;
   try {
@@ -21550,61 +22001,68 @@ function generateIR(ast, source, filename) {
       }
       const name = inner.id.name;
       const paramNames = getParamNames(inner.params, source);
-      const firstParam = inner.params?.[0];
-      const propsAlias = firstParam && firstParam.type === "Identifier" ? firstParam.name : null;
-      const propsType = getPropsType(inner.params, source);
-      const bodyStmts = inner.body.body;
-      const isClientComp = !!inner.client;
-      const prevSlotProps = __slotProps;
-      __slotProps = slotPropNamesFromType(propsType);
-      __propsParam = propsAlias || null;
-      if (isStatementMode(bodyStmts)) {
-        const raw2 = processStatementModeBody(source, bodyStmts, file);
-        const { body, css } = extractStyle(raw2);
-        validateBlocks(name, isClientComp, body, file, source);
-        const comp = new ComponentIR(name, paramNames, body, { mode: "statement", exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
-        comp.style = css;
-        components.push(comp);
-        __slotProps = prevSlotProps;
-      } else {
-        const guardClauses = [];
-        let mainReturn = null;
-        const preamble = [];
-        for (const stmt of bodyStmts) {
-          if (stmt.type === "VeskBlock") {
-            const innerBody = processStatementModeBody(source, stmt.body, file);
-            if (stmt.tag === "server") {
-              preamble.push(new ServerBlock(innerBody));
-            } else if (stmt.tag === "client") {
-              preamble.push(new ClientBlock(innerBody));
-            }
-          } else if (stmt.type === "ReturnStatement") {
-            mainReturn = stmt;
-          } else if (isTrackDeclaration(stmt)) {
-            const elements = stmt.declarations[0].id.elements;
-            const trackName = elements[0]?.name;
-            const rawName = elements.length > 1 ? elements[1]?.name : null;
-            const init = getSource(source, stmt.declarations[0].init);
-            if (trackName) preamble.push(new TrackDecl(trackName, init, rawName));
-            const refName = getComponentRefName(stmt);
-            if (refName) preamble.push(new ComponentRef(refName));
-          } else if (stmt.type === "IfStatement" && !mainReturn && stmt.consequent.type !== "ThrowStatement") {
-            guardClauses.push(stmt);
-          } else if (stmt.type === "ClassDeclaration") {
-            const { line, column } = offsetToLineCol2(source, stmt.start ?? 0);
-            throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
-          } else {
-            const raw2 = getSource(source, stmt);
-            if (raw2) preamble.push(new RuntimeStatement(raw2, stmt, source));
+      const valueNames = collectComponentValueNames(inner);
+      const prevComponentValues = currentComponentValues;
+      currentComponentValues = new Set([...valueNames].filter((n) => !fileComponentNames.has(n)));
+      try {
+        const firstParam = inner.params?.[0];
+        const propsAlias = firstParam && firstParam.type === "Identifier" ? firstParam.name : null;
+        const propsType = getPropsType(inner.params, source);
+        const bodyStmts = inner.body.body;
+        const isClientComp = !!inner.client;
+        const prevSlotProps = __slotProps;
+        __slotProps = slotPropNamesFromType(propsType);
+        __propsParam = propsAlias || null;
+        if (isStatementMode(bodyStmts)) {
+          const raw2 = processStatementModeBody(source, bodyStmts, file);
+          const { body, css } = extractStyle(raw2);
+          validateBlocks(name, isClientComp, body, file, source);
+          const comp = new ComponentIR(name, paramNames, body, { mode: "statement", exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
+          comp.style = css;
+          components.push(comp);
+          __slotProps = prevSlotProps;
+        } else {
+          const guardClauses = [];
+          let mainReturn = null;
+          const preamble = [];
+          for (const stmt of bodyStmts) {
+            if (stmt.type === "VeskBlock") {
+              const innerBody = processStatementModeBody(source, stmt.body, file);
+              if (stmt.tag === "server") {
+                preamble.push(new ServerBlock(innerBody));
+              } else if (stmt.tag === "client") {
+                preamble.push(new ClientBlock(innerBody));
+              }
+            } else if (stmt.type === "ReturnStatement") {
+              mainReturn = stmt;
+            } else if (isTrackDeclaration(stmt)) {
+              const elements = stmt.declarations[0].id.elements;
+              const trackName = elements[0]?.name;
+              const rawName = elements.length > 1 ? elements[1]?.name : null;
+              const init = getSource(source, stmt.declarations[0].init);
+              if (trackName) preamble.push(new TrackDecl(trackName, init, rawName));
+              const refName = getComponentRefName(stmt);
+              if (refName) preamble.push(new ComponentRef(refName));
+            } else if (stmt.type === "IfStatement" && !mainReturn && stmt.consequent.type !== "ThrowStatement") {
+              guardClauses.push(stmt);
+            } else if (stmt.type === "ClassDeclaration") {
+              const { line, column } = offsetToLineCol2(source, stmt.start ?? 0);
+              throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
+            } else {
+              const raw2 = getSource(source, stmt);
+              if (raw2) preamble.push(new RuntimeStatement(raw2, stmt, source));
+            }
           }
+          const guardBody = buildGuardChain(source, guardClauses, mainReturn);
+          const { body, css } = extractStyle([...preamble, ...guardBody]);
+          validateBlocks(name, isClientComp, body, file, source);
+          const comp = new ComponentIR(name, paramNames, body, { exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
+          comp.style = css;
+          components.push(comp);
+          __slotProps = prevSlotProps;
         }
-        const guardBody = buildGuardChain(source, guardClauses, mainReturn);
-        const { body, css } = extractStyle([...preamble, ...guardBody]);
-        validateBlocks(name, isClientComp, body, file, source);
-        const comp = new ComponentIR(name, paramNames, body, { exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
-        comp.style = css;
-        components.push(comp);
-        __slotProps = prevSlotProps;
+      } finally {
+        currentComponentValues = prevComponentValues;
       }
     }
     const asyncNames = new Set(components.filter((c) => c.isAsync || c.ssrAwait).map((c) => c.name));
@@ -21701,9 +22159,13 @@ function generateIR(ast, source, filename) {
   } finally {
     currentVskNamespaceLocals = prevNamespaceLocals;
     currentSourceFile = prevSourceFile;
+    currentFileComponentNames = prevFileComponentNames;
+    currentFileValueBindings = prevFileValueBindings;
+    currentImportedNames = prevImportedNames;
+    currentComponentCallHelpers = null;
   }
 }
-var __vskAnnotations, __slotProps, __propsParam, currentVskNamespaceLocals, currentSourceFile;
+var __vskAnnotations, __slotProps, __propsParam, currentVskNamespaceLocals, currentSourceFile, currentComponentValues, currentFileComponentNames, currentFileValueBindings, currentImportedNames, currentComponentCallHelpers;
 var init_ir_generator = __esm({
   "../compiler/src/ir-generator.ts"() {
     "use strict";
@@ -21719,6 +22181,11 @@ var init_ir_generator = __esm({
     __slotProps = null;
     __propsParam = null;
     currentVskNamespaceLocals = null;
+    currentComponentValues = null;
+    currentFileComponentNames = null;
+    currentFileValueBindings = null;
+    currentImportedNames = null;
+    currentComponentCallHelpers = null;
   }
 });
 
@@ -21727,6 +22194,7 @@ var server_utils_exports = {};
 __export(server_utils_exports, {
   CorsResponse: () => CorsResponse,
   DEFAULT_MAX_BODY_BYTES: () => DEFAULT_MAX_BODY_BYTES,
+  VOID_ELEMENTS: () => VOID_ELEMENTS2,
   __vskForceClaim: () => __vskForceClaim,
   __vskHydrate: () => __vskHydrate,
   __vskId: () => __vskId,
@@ -32203,7 +32671,7 @@ function componentMarker(compName) {
 }
 function irNodeToJS(node, importedNames, isAsync = false, tracked2) {
   importedNames = importedNames || __vskImportedNames;
-  if (node instanceof StaticNode) return staticNodeToJS(node, isAsync, tracked2);
+  if (node instanceof StaticNode) return staticNodeToJS(node, isAsync, tracked2, __inForeignContent);
   if (node instanceof TextNode) {
     if (!node.value) return "";
     return `__out.push(${JSON.stringify(escapeHtml(node.value))});`;
@@ -32281,7 +32749,7 @@ function exprJSX(node, tracked2) {
   }
   return exprJS(transformTracked({ ...node, ast: lowered }, tracked2 || /* @__PURE__ */ new Map()));
 }
-function staticNodeToJS(node, isAsync = false, tracked2) {
+function staticNodeToJS(node, isAsync = false, tracked2, inForeign = false) {
   const lines = [];
   const dynAttrTargets = /* @__PURE__ */ new Set();
   for (const child of node.children) {
@@ -32307,17 +32775,19 @@ function staticNodeToJS(node, isAsync = false, tracked2) {
     }
   }
   if (node.selfClosing) {
-    let tag = openTag + " />";
+    const voidOrForeign = VOID_ELEMENTS2.has(node.tag) || inForeign;
+    const tail = voidOrForeign ? " />" : `></${node.tag}>`;
     if (hasDynamicAttrs) {
-      let expr = JSON.stringify(tag);
+      let expr = JSON.stringify(openTag);
       for (const child of node.children) {
         if (child instanceof DynamicBinding && child.kind === "attribute" && child.target !== "ref" && !isEvent(child.target)) {
           expr += ` + __attr(${JSON.stringify(child.target)}, ${exprJSX(child.expression, tracked2)})`;
         }
       }
+      expr += ` + ${JSON.stringify(tail)}`;
       lines.push(`__out.push(${expr});`);
     } else {
-      lines.push(`__out.push(${JSON.stringify(tag)});`);
+      lines.push(`__out.push(${JSON.stringify(openTag + tail)});`);
     }
     return lines.join("\n");
   }
@@ -32336,10 +32806,13 @@ function staticNodeToJS(node, isAsync = false, tracked2) {
   } else {
     lines.push(`__out.push(${JSON.stringify(openTag + ">")});`);
   }
+  const prevForeign = __inForeignContent;
+  if (FOREIGN_ROOTS.has(node.tag)) __inForeignContent = true;
   for (const child of childNodes) {
     const code = irNodeToJS(child, null, isAsync, tracked2);
     if (code) lines.push(code);
   }
+  __inForeignContent = prevForeign;
   lines.push(`__out.push(${JSON.stringify("</" + node.tag + ">")});`);
   return lines.join("\n");
 }
@@ -32736,7 +33209,7 @@ ${entry.source}
   }
   return map;
 }
-var __currentCompName;
+var __currentCompName, __inForeignContent, FOREIGN_ROOTS;
 var init_server_jsgen = __esm({
   "../compiler/src/server-jsgen.ts"() {
     "use strict";
@@ -32748,6 +33221,8 @@ var init_server_jsgen = __esm({
     init_server_jsx_lowering();
     init_vsk_imports();
     __currentCompName = "";
+    __inForeignContent = false;
+    FOREIGN_ROOTS = /* @__PURE__ */ new Set(["svg", "math"]);
   }
 });
 
@@ -38733,6 +39208,39 @@ var init_errors2 = __esm({
        * - `value` — `ns.max` read as a value. Component tags resolve; plain value
        *   reads do not, because nothing binds `ns` at runtime.
        */
+      /**
+       * An imported `.ts`/`.js` module could not be parsed.
+       *
+       * This used to be silent, and that is the whole point of the diagnostic. A
+       * parse failure meant the module's RAW, untranspiled source was substituted,
+       * so TypeScript syntax reached `new Function` and the module blew up much
+       * later with a bare `Unexpected token ':'` — attributed to no file, at a
+       * point in the build far from the code that caused it. It also poisoned the
+       * whole shared module graph: one unparseable module left its exports
+       * undefined, so unrelated consumers failed with `X is not iterable`.
+       *
+       * Two real constructs hit this: a parameter annotation that survived the
+       * stripper only when the parameter also had a default value, and a generic
+       * arrow's type parameter list, which the JSX tokenizer cannot read at all.
+       * Both are fixed; this error exists so the NEXT such gap is reported at the
+       * right file with the right line instead of surfacing three modules later.
+       */
+      static moduleParseFailed(context = {}) {
+        return new _VeskError(`Could not parse an imported module${context.reason ? `: ${context.reason}` : "."}`, {
+          ...context,
+          code: context.code || "V0901",
+          suggestions: [
+            "Check the line the ^ marker points at \u2014 it is the construct the parser stopped on.",
+            "If it is TypeScript syntax the stripper does not handle, simplifying it here fixes every module that imports this file.",
+            "This is a bug in the compiler, not in your code, if the construct is ordinary TypeScript \u2014 please report it with the source line."
+          ],
+          nextSteps: [
+            "A module that fails to parse is substituted with its raw source, so every type annotation it contains becomes a runtime SyntaxError.",
+            "The failure is reported here, at the offending file and line, rather than as an `Unexpected token` in whichever module happened to import it."
+          ],
+          tip: "Ordinary TypeScript should parse; if this fires on valid TS, the parser is missing a construct."
+        });
+      }
       static vskNamespaceMember(context = {}) {
         const nested = context.form === "nested";
         return new _VeskError(nested ? "A `.vsk` namespace is flat, so `<ns.Sub.Icon />` cannot be resolved." : "A `.vsk` namespace resolves component tags only, so `ns.value` is not available.", {
@@ -46239,12 +46747,182 @@ function preprocessForClauses2(source) {
   }
   return { code: chars.join(""), annotations };
 }
+function blankGenericArrowTypeParams2(source) {
+  let changed = false;
+  const chars = source.split("");
+  let i = 0;
+  const isSpace = (ch) => isSpaceChar2(ch);
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      let j2 = i + 1;
+      while (j2 < source.length) {
+        if (source[j2] === "\\") {
+          j2 += 2;
+          continue;
+        }
+        if (source[j2] === quote) {
+          j2++;
+          break;
+        }
+        if (quote === "`" && source[j2] === "$" && source[j2 + 1] === "{") {
+          let depth = 1;
+          j2 += 2;
+          while (j2 < source.length && depth > 0) {
+            if (source[j2] === "{")
+              depth++;
+            else if (source[j2] === "}")
+              depth--;
+            j2++;
+          }
+          continue;
+        }
+        j2++;
+      }
+      i = j2;
+      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;
+    }
+    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;
+    }
+    if (!isArrowParameterList2(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;
+}
+function isArrowParameterList2(source, from) {
+  let i = from;
+  while (i < source.length && isSpaceChar2(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 && isSpaceChar2(source[i]))
+    i++;
+  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;
+      if (tdepth === 0 && (ch === ";" || ch === "\n"))
+        return false;
+      i++;
+    }
+    return false;
+  }
+  return source[i] === "=" && source[i + 1] === ">";
+}
+function isSpaceChar2(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
 function createBaseParser2() {
   return Parser.extend(tsPlugin2({}), VeskParserPlugin());
 }
 function parse5(source, options = {}) {
   const ParserClass = createBaseParser2();
-  const { code, annotations } = preprocessForClauses2(blankComments(source));
+  const { code, annotations } = preprocessForClauses2(blankGenericArrowTypeParams2(blankComments(source)));
   const vskSource = !options.filename || String(options.filename).endsWith(".vsk");
   const specifierExports = vskSource ? findSpecifierExports(code).filter((e) => !hasTopLevelValueDeclaration(code, e.local)) : [];
   let parseable = code;
@@ -49189,12 +49867,26 @@ ${entry.code}
             write: false,
             logLevel: "silent",
             loader: { ".js": "tsx" },
+            // Bundled dependencies (lucide-vesk above all) carry a license
+            // banner per module, and a barrel import pulls in hundreds of
+            // them. Those banners were ~339 KB of a 350 KB chunk, which is
+            // what kept a barrel import from being usable at all. Attribution
+            // for a dependency stays in its own package; shipping every
+            // module's header inside our own chunk adds nothing.
+            legalComments: "none",
             ...appTsconfig ? { tsconfig: appTsconfig } : {}
           });
           finalCode = result.outputFiles[0].text;
         } catch (e) {
           const err = e;
-          console.error("[vesk] chunk bundle failed", entry.name, err?.errors?.map((x) => x.text).join(" | ") || err?.message || String(e));
+          const detail = err?.errors?.map((x) => {
+            const at2 = x.location?.file ? ` (${x.location.file}${x.location.line ? `:${x.location.line}` : ""})` : "";
+            return x.text + at2;
+          }).join(" | ") || err?.message || String(e);
+          console.error("[vesk] chunk bundle failed", entry.name, detail);
+          if (options?.strict) {
+            throw new Error(`[vesk] chunk bundle failed: ${entry.name} \u2014 ${detail}`);
+          }
           const stripped = demoteExports(removeCompiledNodes(entry.code, isAnyImport));
           finalCode = chunkIIFE(nativeLibraryImportStubs(entry.code) + stripped);
         } finally {
@@ -50378,6 +51070,8 @@ async function build2(appDir, options) {
     bundleOpts.codeSplit = true;
   if (options?.hmr)
     bundleOpts.hmr = true;
+  if (options?.strict)
+    bundleOpts.strict = true;
   if (options?.routeDataCache !== void 0)
     bundleOpts.routeDataCache = options.routeDataCache;
   if (pluginsPipelines.length > 0)
@@ -50756,17 +51450,41 @@ function stripTsTypes2(ast) {
     }
   });
 }
+function stripParamTypes2(p) {
+  if (!p)
+    return;
+  if (p.typeAnnotation)
+    p.typeAnnotation = null;
+  if (p.optional)
+    p.optional = false;
+  switch (p.type) {
+    case "AssignmentPattern":
+      stripParamTypes2(p.left);
+      break;
+    case "RestElement":
+      stripParamTypes2(p.argument);
+      break;
+    case "ObjectPattern":
+      for (const prop of p.properties || []) {
+        stripParamTypes2(prop.value || prop.argument || prop);
+      }
+      break;
+    case "ArrayPattern":
+      for (const el of p.elements || [])
+        if (el)
+          stripParamTypes2(el);
+      break;
+    default:
+      break;
+  }
+}
 function stripFunctionTypes2(node) {
   if (node.returnType)
     node.returnType = null;
   if (node.typeParameters)
     node.typeParameters = null;
-  for (const p of node.params || []) {
-    if (p.typeAnnotation)
-      p.typeAnnotation = null;
-    if (p.optional)
-      p.optional = false;
-  }
+  for (const p of node.params || [])
+    stripParamTypes2(p);
 }
 function stripCodeTypes2(code) {
   let ast;
@@ -53546,6 +54264,10 @@ function matchUrl(tree, pathname) {
             pushWithStandalone(node);
           return true;
         }
+        if (partIndex >= parts.length && node.page && node.fullPath === "/" + parts.join("/")) {
+          pushWithStandalone(node);
+          return true;
+        }
         continue;
       }
       if (node.fullPath === "/") {
@@ -55115,12 +55837,26 @@ ${entry.code}
             write: false,
             logLevel: "silent",
             loader: { ".js": "tsx" },
+            // Bundled dependencies (lucide-vesk above all) carry a license
+            // banner per module, and a barrel import pulls in hundreds of
+            // them. Those banners were ~339 KB of a 350 KB chunk, which is
+            // what kept a barrel import from being usable at all. Attribution
+            // for a dependency stays in its own package; shipping every
+            // module's header inside our own chunk adds nothing.
+            legalComments: "none",
             ...appTsconfig ? { tsconfig: appTsconfig } : {}
           });
           finalCode = result.outputFiles[0].text;
         } catch (e) {
           const err = e;
-          console.error("[vesk] chunk bundle failed", entry.name, err?.errors?.map((x) => x.text).join(" | ") || err?.message || String(e));
+          const detail = err?.errors?.map((x) => {
+            const at2 = x.location?.file ? ` (${x.location.file}${x.location.line ? `:${x.location.line}` : ""})` : "";
+            return x.text + at2;
+          }).join(" | ") || err?.message || String(e);
+          console.error("[vesk] chunk bundle failed", entry.name, detail);
+          if (options?.strict) {
+            throw new Error(`[vesk] chunk bundle failed: ${entry.name} \u2014 ${detail}`);
+          }
           const stripped = demoteExports2(removeCompiledNodes2(entry.code, isAnyImport2));
           finalCode = chunkIIFE(nativeLibraryImportStubs2(entry.code) + stripped);
         } finally {
@@ -63558,7 +64294,7 @@ if (cmd === "build") {
   const config = rawConfig;
   const plugins = config.plugins || [];
   const mdCfg = config.md;
-  const opts = { outDir, publicDir, plugins, seo, strictSeo: strict, codeSplit: !restArgs.includes("--skip-split"), target };
+  const opts = { outDir, publicDir, plugins, seo, strictSeo: strict, strict, codeSplit: !restArgs.includes("--skip-split"), target };
   if (mdCfg) opts.md = mdCfg;
   if (config.routeDataCache !== void 0) opts.routeDataCache = config.routeDataCache;
   if (platform) opts.platform = platform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vesk/vesk-cli",
-  "version": "0.2.50",
+  "version": "0.2.51",
   "type": "module",
   "description": "Vesk — compiler-first framework for the post-VDOM web. vesk dev, vesk build.",
   "bin": {
@@ -8,10 +8,10 @@
   },
   "main": "./dist/cli.js",
   "dependencies": {
-    "@vesk/adapter": "^0.2.50",
-    "@vesk/compiler": "^0.2.50",
-    "@vesk/plugin-tailwind": "^0.2.50",
-    "@vesk/runtime": "^0.2.50",
+    "@vesk/adapter": "^0.2.51",
+    "@vesk/compiler": "^0.2.51",
+    "@vesk/plugin-tailwind": "^0.2.51",
+    "@vesk/runtime": "^0.2.51",
     "esrap": "^2.3.0",
     "typescript": "^5.8.0",
     "ws": "^8.18.0",