@weave-framework/cli 0.2.0 → 0.2.107

package/README.md

@@ -0,0 +1,21 @@
+# @weave-framework/cli
+
+The Weave CLI — `weave build`, `weave dev` (watch + live-reload), `weave check`, `weave routes`.
+
+Part of **[Weave](https://weave-framework.github.io/weave/)** — a fine-grained reactive, signal-native UI framework: no Virtual DOM, zero third-party runtime dependencies.
+
+```bash
+npm install -D @weave-framework/cli
+```
+
+Scaffolded apps already include it (with scripts wired up):
+
+```bash
+npm create weave@latest my-app
+```
+
+📚 **Guides + full API reference:** [weave-framework.github.io/weave](https://weave-framework.github.io/weave/)
+
+## License
+
+MIT

package/dist/cli.js

@@ -411,13 +411,7 @@ var Parser = class {
     return this.src[this.pos];
   }
   readInterp() {
-    this.pos += 2;
-    const start = this.pos;
-    const end = this.src.indexOf("}}", this.pos);
-    if (end === -1) throw new ParseError("Unclosed {{ interpolation");
-    this.pos = end + 2;
-    const raw = this.src.slice(start, end);
-    return { expr: raw.trim(), offset: start + (raw.length - raw.trimStart().length) };
+    return this.readDoubleBracedExpr();
   }
   skipComment() {
     const end = this.src.indexOf("-->", this.pos);
@@ -684,19 +678,76 @@ function rewrite(expr, scope, ctxRef = "ctx") {
   };
   while (i < n) {
     const c = expr[i];
-    if (c === '"' || c === "'" || c === "`") {
+    if (c === '"' || c === "'") {
       const end = scanString(expr, i);
       copy(i, expr.slice(i, end));
       i = end;
       continue;
     }
+    if (c === "`") {
+      copy(i, "`");
+      let k = i + 1;
+      while (k < n) {
+        const ch = expr[k];
+        if (ch === "\\") {
+          copy(k, expr.slice(k, k + 2));
+          k += 2;
+          continue;
+        }
+        if (ch === "`") {
+          copy(k, "`");
+          k++;
+          break;
+        }
+        if (ch === "$" && expr[k + 1] === "{") {
+          copy(k, "${");
+          k += 2;
+          const exprStart = k;
+          let depth = 1;
+          while (k < n && depth > 0) {
+            const mc = expr[k];
+            if (mc === '"' || mc === "'" || mc === "`") {
+              k = scanString(expr, k);
+              continue;
+            }
+            if (mc === "{") depth++;
+            else if (mc === "}") {
+              depth--;
+              if (depth === 0) break;
+            }
+            k++;
+          }
+          const sub = rewrite(expr.slice(exprStart, k), scope, ctxRef);
+          if (sub.reactive) reactive = true;
+          flush();
+          const genStart = out.length;
+          for (const s of sub.segments) segments.push({ src: exprStart + s.src, gen: genStart + s.gen, len: s.len });
+          out += sub.code;
+          if (expr[k] === "}") {
+            copy(k, "}");
+            k++;
+          }
+          continue;
+        }
+        copy(k, ch);
+        k++;
+      }
+      i = k;
+      continue;
+    }
     if (ID_START.test(c)) {
       let j = i + 1;
       while (j < n && ID_CHAR.test(expr[j])) j++;
       const name = expr.slice(i, j);
       const isProperty = lastNonSpace(out) === ".";
       const binding = scope.get(name);
-      if (binding && !isProperty) {
+      const prev = lastNonSpace(out);
+      const next = firstNonSpaceFrom(expr, j);
+      const isObjectKey = (prev === "{" || prev === ",") && next === ":";
+      if (binding && !isProperty && !isObjectKey) {
+        if (binding.kind !== "local") {
+          if ((prev === "{" || prev === ",") && (next === "," || next === "}")) insert(`${name}: `);
+        }
         if (binding.kind === "ctx") {
           insert(`${ctxRef}.`);
           copy(i, name);
@@ -736,6 +787,12 @@ function lastNonSpace(s) {
   }
   return "";
 }
+function firstNonSpaceFrom(s, from) {
+  for (let i = from; i < s.length; i++) {
+    if (!/\s/.test(s[i])) return s[i];
+  }
+  return "";
+}
 var NON_CTX = /* @__PURE__ */ new Set([
   // literals / keywords
   "true",
@@ -842,16 +899,56 @@ function freeIdentifiers(expr) {
   const n = expr.length;
   while (i < n) {
     const c = expr[i];
-    if (c === '"' || c === "'" || c === "`") {
+    if (c === '"' || c === "'") {
       i = scanString(expr, i);
       continue;
     }
+    if (c === "`") {
+      let k = i + 1;
+      while (k < n) {
+        const ch = expr[k];
+        if (ch === "\\") {
+          k += 2;
+          continue;
+        }
+        if (ch === "`") {
+          k++;
+          break;
+        }
+        if (ch === "$" && expr[k + 1] === "{") {
+          k += 2;
+          const start = k;
+          let depth = 1;
+          while (k < n && depth > 0) {
+            const mc = expr[k];
+            if (mc === '"' || mc === "'" || mc === "`") {
+              k = scanString(expr, k);
+              continue;
+            }
+            if (mc === "{") depth++;
+            else if (mc === "}") {
+              depth--;
+              if (depth === 0) break;
+            }
+            k++;
+          }
+          for (const id of freeIdentifiers(expr.slice(start, k))) out.add(id);
+          continue;
+        }
+        k++;
+      }
+      i = k;
+      continue;
+    }
     if (ID_START.test(c)) {
       let j = i + 1;
       while (j < n && ID_CHAR.test(expr[j])) j++;
       const name = expr.slice(i, j);
-      const isProperty = lastNonSpace(expr.slice(0, i)) === ".";
-      if (!isProperty && !NON_CTX.has(name) && !params.has(name)) out.add(name);
+      const prev = lastNonSpace(expr.slice(0, i));
+      const next = firstNonSpaceFrom(expr, j);
+      const isProperty = prev === ".";
+      const isObjectKey = (prev === "{" || prev === ",") && next === ":";
+      if (!isProperty && !isObjectKey && !NON_CTX.has(name) && !params.has(name)) out.add(name);
       i = j;
       continue;
     }
@@ -885,6 +982,8 @@ var Gen = class {
   // @weave-framework/runtime/dom helpers
   usedCore = /* @__PURE__ */ new Set();
   // @weave-framework/runtime primitives (computed, …)
+  usedComponents = /* @__PURE__ */ new Set();
+  // PascalCase child tags referenced in module mode
   templates = [];
   tplN = 0;
   fnN = 0;
@@ -896,8 +995,14 @@ var Gen = class {
     this.usedCore.add(name);
     return this.mode === "function" ? `rt.${name}` : name;
   }
-  /** Reference a child component: from the `_c` map in function mode, bare (imported) in module mode. */
+  /**
+   * Reference a child component: from the `_c` map in function mode, bare (imported)
+   * in module mode. In module mode the bare identifier must be in the emitted module's
+   * scope — the loader resolves each recorded tag to a real `import` (see the plugin's
+   * child-import injection), or the component's own `<script>` imports it explicitly.
+   */
   Comp(name) {
+    this.usedComponents.add(name);
     return this.mode === "function" ? `_c.${name}` : name;
   }
   tpl(html) {
@@ -915,15 +1020,23 @@ function compileTemplate(input, options = {}) {
   const gen = new Gen(mode, options.scopeAttr, options.hostAttr);
   const ast = parseTemplate(input);
   const render = compileFragment(gen, ast, ctxScope(options.scope ?? []), "render", "ctx, slots", true);
+  const components = [...gen.usedComponents];
   if (mode === "function") {
     const body = [...gen.templates, render, "return render(ctx, {});"].join("\n");
-    return { code: body };
+    return { code: body, components };
   }
   const domImport = `import { ${[...gen.used].sort().join(", ")} } from ${JSON.stringify(runtimeImport)};`;
   const coreImport = gen.usedCore.size ? `import { ${[...gen.usedCore].sort().join(", ")} } from "@weave-framework/runtime";
 ` : "";
   const code = [domImport + "\n" + coreImport, ...gen.templates, `export default ${render}`].join("\n");
-  return { code };
+  return { code, components };
+}
+function pascalToKebab(tag) {
+  return tag.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function childImportCandidates(tag) {
+  const k = pascalToKebab(tag);
+  return [`../${k}/${k}`, `./${k}`, `./${k}/${k}`];
 }
 function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
   const top = trimTop(nodes);
@@ -1123,6 +1236,7 @@ function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
     html += "<!---->";
     const anchorVar = nodeExpr(path);
     const props = [];
+    const eventKeys = [];
     for (const attr of node.attrs) {
       switch (attr.type) {
         case "static":
@@ -1131,13 +1245,17 @@ function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
         case "attr":
           props.push(`get ${propKey(attr.name)}() { return ${rewrite(attr.expr, sc).code}; }`);
           break;
-        case "event":
-          props.push(`${propKey(onProp(attr.name))}: ${rewrite(attr.expr, sc).code}`);
+        case "event": {
+          const k = onProp(attr.name);
+          props.push(`${propKey(k)}: ${rewrite(attr.expr, sc).code}`);
+          eventKeys.push(k);
           break;
+        }
         default:
           throw new Error(`'${attr.type}' binding on <${node.tag}> is not supported yet (M5: props + on:event only)`);
       }
     }
+    if (eventKeys.length) props.push(`'$events': [${eventKeys.map((k) => JSON.stringify(k)).join(", ")}]`);
     const groups = /* @__PURE__ */ new Map();
     for (const child of node.children) {
       let target = child;
@@ -1620,89 +1738,120 @@ function skipString(s, start) {
 
 // packages/compiler/src/infer.ts
 var FOR_VARS = ["$index", "$count", "$first", "$last", "$even", "$odd"];
+function childLists(node) {
+  switch (node.type) {
+    case "element":
+    case "snippet":
+    case "key":
+      return [node.children];
+    case "if":
+      return node.branches.map((b) => b.children);
+    case "for":
+      return node.empty ? [node.children, node.empty] : [node.children];
+    case "switch":
+      return node.cases.map((c) => c.children);
+    case "defer":
+      return node.placeholder ? [node.children, node.placeholder] : [node.children];
+    case "await": {
+      const lists = [];
+      if (node.pending) lists.push(node.pending);
+      if (node.then) lists.push(node.then.children);
+      if (node.catch) lists.push(node.catch.children);
+      return lists;
+    }
+    default:
+      return [];
+  }
+}
 function inferCtxNames(nodes) {
   const used = /* @__PURE__ */ new Set();
-  const declared = /* @__PURE__ */ new Set();
-  const add = (expr) => {
-    if (expr) for (const id of freeIdentifiers(expr)) used.add(id);
+  const snippetNames = /* @__PURE__ */ new Set();
+  const collectSnippets = (list) => {
+    for (const node of list) {
+      if (node.type === "snippet") snippetNames.add(node.name);
+      for (const cl of childLists(node)) collectSnippets(cl);
+    }
+  };
+  collectSnippets(nodes);
+  const add = (expr, declared) => {
+    if (!expr) return;
+    for (const id of freeIdentifiers(expr)) {
+      if (!declared.has(id) && !snippetNames.has(id)) used.add(id);
+    }
   };
-  const walk2 = (list) => {
+  const walk2 = (list, parentDeclared) => {
+    let declared = parentDeclared;
     for (const node of list) {
       switch (node.type) {
         case "text":
           break;
         case "interp":
-          add(node.expr);
+          add(node.expr, declared);
           break;
         case "let":
-          add(node.expr);
-          declared.add(node.name);
+          add(node.expr, declared);
+          declared = new Set(declared).add(node.name);
           break;
         case "element":
           for (const attr of node.attrs) {
-            if (attr.type === "use") add(attr.name);
-            if (attr.type === "transition") add(attr.name);
-            if (attr.type !== "static") add(attr.expr);
+            if (attr.type === "use") add(attr.name, declared);
+            if (attr.type === "transition") add(attr.name, declared);
+            if (attr.type !== "static") add(attr.expr, declared);
           }
-          walk2(node.children);
+          walk2(node.children, declared);
           break;
         case "if":
           for (const br of node.branches) {
-            add(br.cond);
-            if (br.alias) declared.add(br.alias);
-            walk2(br.children);
+            add(br.cond, declared);
+            walk2(br.children, br.alias ? new Set(declared).add(br.alias) : declared);
           }
           break;
-        case "for":
-          add(node.list);
-          add(node.track);
-          declared.add(node.item);
-          for (const v of FOR_VARS) declared.add(v);
-          walk2(node.children);
-          if (node.empty) walk2(node.empty);
+        case "for": {
+          add(node.list, declared);
+          const inner = new Set(declared).add(node.item);
+          for (const v of FOR_VARS) inner.add(v);
+          add(node.track, inner);
+          walk2(node.children, inner);
+          if (node.empty) walk2(node.empty, declared);
           break;
+        }
         case "switch":
-          add(node.expr);
+          add(node.expr, declared);
           for (const c of node.cases) {
-            add(c.test);
-            walk2(c.children);
+            add(c.test, declared);
+            walk2(c.children, declared);
           }
           break;
         case "defer":
-          if (node.trigger.kind === "when") add(node.trigger.expr);
-          if (node.trigger.kind === "timer") add(node.trigger.ms);
-          walk2(node.children);
-          if (node.placeholder) walk2(node.placeholder);
+          if (node.trigger.kind === "when") add(node.trigger.expr, declared);
+          if (node.trigger.kind === "timer") add(node.trigger.ms, declared);
+          walk2(node.children, declared);
+          if (node.placeholder) walk2(node.placeholder, declared);
           break;
         case "await":
-          add(node.expr);
-          if (node.pending) walk2(node.pending);
-          if (node.then) {
-            if (node.then.alias) declared.add(node.then.alias);
-            walk2(node.then.children);
-          }
-          if (node.catch) {
-            if (node.catch.alias) declared.add(node.catch.alias);
-            walk2(node.catch.children);
-          }
+          add(node.expr, declared);
+          if (node.pending) walk2(node.pending, declared);
+          if (node.then) walk2(node.then.children, node.then.alias ? new Set(declared).add(node.then.alias) : declared);
+          if (node.catch) walk2(node.catch.children, node.catch.alias ? new Set(declared).add(node.catch.alias) : declared);
           break;
-        case "snippet":
-          declared.add(node.name);
-          for (const p of node.params) declared.add(p);
-          walk2(node.children);
+        case "snippet": {
+          const inner = new Set(declared);
+          for (const p of node.params) inner.add(p);
+          walk2(node.children, inner);
           break;
+        }
         case "render":
-          add(node.expr);
+          add(node.expr, declared);
           break;
         case "key":
-          add(node.expr);
-          walk2(node.children);
+          add(node.expr, declared);
+          walk2(node.children, declared);
           break;
       }
     }
   };
-  walk2(nodes);
-  return [...used].filter((n) => !declared.has(n)).sort();
+  walk2(nodes, /* @__PURE__ */ new Set());
+  return [...used].sort();
 }
 
 // packages/compiler/src/component.ts
@@ -1723,7 +1872,7 @@ function compileComponent(src, opts = {}) {
     renderBody,
     `export default defineComponent(${setupArg});`
   ].filter(Boolean).join("\n\n");
-  return { code, css, hash };
+  return { code, css, hash, components: compiled.components };
 }
 function parseSfcLoc(source) {
   const script = locateBlock(source, "script");
@@ -1787,7 +1936,7 @@ function extractBlock(source, tag) {
 }
 
 // packages/compiler/src/sources.ts
-var DECL = /export\s+const\s+(template|styles)\s*(?::[^=]+)?=\s*/g;
+var DECL = /export\s+const\s+(template|styles)\s*(?::[^=\n]+)?=\s*/g;
 function extractSources(script) {
   let template;
   let templateRange;
@@ -1819,10 +1968,30 @@ function extractSources(script) {
 function parseLiteral(src, i, kind) {
   i = skipWs(src, i);
   const c = src[i];
-  if (c === '"' || c === "'" || c === "`") return parseString(src, i);
+  if (c === '"' || c === "'" || c === "`") return parseConcat(src, i);
   if (c === "[") return parseArray(src, i);
   throw new Error(`weave: \`${kind}\` must be a static string${kind === "styles" ? " or array of strings" : ""}`);
 }
+function parseConcat(src, i) {
+  const first = parseString(src, i);
+  let value = first.value;
+  let end = first.end;
+  let single = true;
+  for (; ; ) {
+    const plus = skipWs(src, end);
+    if (src[plus] !== "+") break;
+    const nextStart = skipWs(src, plus + 1);
+    const c = src[nextStart];
+    if (c !== '"' && c !== "'" && c !== "`") {
+      throw new Error("weave: `template`/`styles` must be a static string \u2014 `+` may only join string literals");
+    }
+    const next = parseString(src, nextStart);
+    value += next.value;
+    end = next.end;
+    single = false;
+  }
+  return single ? { value, end, innerStart: first.innerStart, innerEnd: first.innerEnd } : { value, end };
+}
 function parseString(src, i) {
   const quote = src[i];
   const innerStart = i + 1;
@@ -1854,7 +2023,7 @@ function parseArray(src, i) {
       j++;
       continue;
     }
-    const str = parseString(src, j);
+    const str = parseConcat(src, j);
     items.push(str.value);
     j = str.end;
   }
@@ -1899,15 +2068,18 @@ function langFromExt(file) {
   if (file.endsWith(".sass")) return "sass";
   return "css";
 }
+function pkgImporters(sass) {
+  return [new sass.NodePackageImporter()];
+}
 async function compileStyleFile(path) {
   if (langFromExt(path) === "css") return readFile(path, "utf8");
   const sass = await import("sass");
-  return sass.compile(path).css;
+  return sass.compile(path, { importers: pkgImporters(sass) }).css;
 }
 async function compileStyleFileTracked(path) {
   if (langFromExt(path) === "css") return { css: await readFile(path, "utf8"), files: [path] };
   const sass = await import("sass");
-  const result = sass.compile(path);
+  const result = sass.compile(path, { importers: pkgImporters(sass) });
   const files = result.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath(u));
   return { css: result.css, files };
 }
@@ -1916,15 +2088,24 @@ async function compileStyleSource(source, lang, fromDir) {
   const sass = await import("sass");
   return sass.compileString(source, {
     syntax: lang === "sass" ? "indented" : "scss",
-    loadPaths: fromDir ? [fromDir] : []
+    loadPaths: fromDir ? [fromDir] : [],
+    importers: pkgImporters(sass)
   }).css;
 }
 
 // packages/cli/src/plugin.ts
+function styleId(css) {
+  let h = 5381;
+  for (let i = 0; i < css.length; i++) h = Math.imul(h, 33) ^ css.charCodeAt(i) | 0;
+  return "w-css-" + (h >>> 0).toString(36);
+}
 function cssInjector(css) {
   if (!css) return "";
+  const id = styleId(css);
   return `
-;(()=>{const s=document.createElement("style");s.textContent=${JSON.stringify(
+;(()=>{const id=${JSON.stringify(
+    id
+  )};if(document.getElementById(id))return;const s=document.createElement("style");s.id=id;s.textContent=${JSON.stringify(
     css
   )};document.head.appendChild(s);})();
 `;
@@ -1971,6 +2152,78 @@ async function resolveStyles(decl, tsPath, dir, styleLang) {
   const compiled = await compileStyleFileTracked(siblingStyle);
   return { css: compiled.css, files: compiled.files };
 }
+function stripComments(code) {
+  let out = "";
+  let i = 0;
+  const n = code.length;
+  while (i < n) {
+    const c = code[i];
+    const d = code[i + 1];
+    if (c === '"' || c === "'" || c === "`") {
+      const quote = c;
+      out += c;
+      i++;
+      while (i < n) {
+        const ch = code[i];
+        if (ch === "\\") {
+          out += ch + (code[i + 1] ?? "");
+          i += 2;
+          continue;
+        }
+        out += ch;
+        i++;
+        if (ch === quote) break;
+      }
+      continue;
+    }
+    if (c === "/" && d === "/") {
+      while (i < n && code[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && d === "*") {
+      i += 2;
+      while (i < n && !(code[i] === "*" && code[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function importsBinding(script, name) {
+  if (!script) return false;
+  const code = stripComments(script);
+  const word = new RegExp(`\\b${name}\\b`);
+  const IMPORT = /import\s+([^;]*?)\s+from\s+['"][^'"]+['"]/g;
+  let m;
+  while ((m = IMPORT.exec(code)) !== null) {
+    if (word.test(m[1])) return true;
+  }
+  return false;
+}
+function resolveChildModule(tag, dir) {
+  for (const cand of childImportCandidates(tag)) {
+    for (const ext of [".ts", ".weave"]) {
+      if (existsSync(resolve(dir, cand + ext))) return cand;
+    }
+  }
+  return null;
+}
+function injectChildImports(code, components, dir, script, filename) {
+  const imports = [];
+  for (const tag of components) {
+    if (importsBinding(script, tag)) continue;
+    const cand = resolveChildModule(tag, dir);
+    if (cand === null) {
+      throw new Error(
+        `weave: ${filename} composes <${tag}> but no import for it was found. Import it in the component's script, or place its module at ${childImportCandidates(tag).map((c) => `${c}.ts`).join(" / ")} (relative to the component).`
+      );
+    }
+    imports.push(`import ${tag} from ${JSON.stringify(cand + ".js")};`);
+  }
+  return imports.length ? imports.join("\n") + "\n" + code : code;
+}
 function weave(state, options = {}) {
   const styleLang = options.styleLang ?? "css";
   const dev2 = options.dev ?? false;
@@ -1989,8 +2242,9 @@ function weave(state, options = {}) {
         const source = await readFile2(args.path, "utf8");
         const src = parseSfc(source);
         const styles = src.styles ? await compileStyleSource(src.styles, styleLang, dirname(args.path)) : void 0;
-        const { code, css } = compileComponent({ ...src, styles }, { filename: args.path });
-        return emit2(code, css, dirname(args.path));
+        const { code, css, components } = compileComponent({ ...src, styles }, { filename: args.path });
+        const wired = injectChildImports(code, components, dirname(args.path), src.script, args.path);
+        return emit2(wired, css, dirname(args.path));
       });
       build2.onLoad({ filter: /\.ts$/ }, async (args) => {
         if (args.path.includes("node_modules")) return void 0;
@@ -2013,11 +2267,12 @@ function weave(state, options = {}) {
           dir,
           styleLang
         );
-        const { code, css } = compileComponent(
+        const { code, css, components } = compileComponent(
           { script: decl.script, template: template.text, styles: styles.css },
           { filename: args.path }
         );
-        return { ...emit2(code, css, dir), watchFiles: [...template.files, ...styles.files] };
+        const wired = injectChildImports(code, components, dir, decl.script, args.path);
+        return { ...emit2(wired, css, dir), watchFiles: [...template.files, ...styles.files] };
       });
     }
   };
@@ -2180,7 +2435,7 @@ async function build(config) {
 import { context } from "esbuild";
 import { createServer } from "node:http";
 import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile4 } from "node:fs/promises";
-import { join as join3, extname, relative as relative2, sep as sep2 } from "node:path";
+import { join as join3, extname, relative as relative2, sep as sep2, isAbsolute } from "node:path";
 var RELOAD_PATH = "/__weave_reload";
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -2207,7 +2462,7 @@ async function devInMemory(config) {
     const css = (await Promise.all(config.styles.map(compileStyleFile))).join("\n");
     if (css)
       banner = {
-        js: `(()=>{const s=document.createElement("style");s.textContent=${JSON.stringify(
+        js: `(()=>{const id="w-global-styles";if(document.getElementById(id))return;const s=document.createElement("style");s.id=id;s.textContent=${JSON.stringify(
           css
         )};document.head.appendChild(s);})();`
       };
@@ -2272,8 +2527,15 @@ async function handleRequest(req, res, config, outputs, clients) {
     return;
   }
   if (extname(url)) {
+    const target = join3(config.servedir, url);
+    const rel = relative2(config.servedir, target);
+    if (rel === ".." || rel.startsWith(".." + sep2) || isAbsolute(rel)) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
     try {
-      const buf = await readFile4(join3(config.servedir, url));
+      const buf = await readFile4(target);
       res.writeHead(200, { "content-type": mime(url) });
       res.end(buf);
     } catch {
@@ -2475,7 +2737,7 @@ function generateRoutes(dir, opts = {}) {
 import { build as esbuildBuild } from "esbuild";
 import { existsSync as existsSync4 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { resolve as resolve2, dirname as dirname2, join as join5, isAbsolute } from "node:path";
+import { resolve as resolve2, dirname as dirname2, join as join5, isAbsolute as isAbsolute2 } from "node:path";
 function defineConfig(config) {
   return config;
 }
@@ -2519,7 +2781,7 @@ async function importConfigModule(file) {
   return mod.default ?? mod;
 }
 function resolveConfig(raw, root) {
-  const abs = (p) => isAbsolute(p) ? p : resolve2(root, p);
+  const abs = (p) => isAbsolute2(p) ? p : resolve2(root, p);
   if (!raw.root && !raw.entry) {
     throw new Error("weave: config must declare either `root` (generated bootstrap) or `entry` (hand-written)");
   }

package/dist/styles.d.ts

@@ -10,7 +10,7 @@
 export type StyleLang = 'css' | 'scss' | 'sass';
 /** The style language implied by a file extension (defaults to plain CSS). */
 export declare function langFromExt(file: string): StyleLang;
-/** Compile a style FILE to CSS — `@use`/`@import` resolve relative to it. */
+/** Compile a style FILE to CSS — `@use`/`@import` resolve relative to it (+ `pkg:` packages). */
 export declare function compileStyleFile(path: string): Promise<string>;
 /**
  * Like {@link compileStyleFile} but also reports every file the compile pulled in —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-framework/cli",
-  "version": "0.2.0",
+  "version": "0.2.107",
   "description": "Weave CLI — `weave build`, `weave dev` (watch + live-reload), `weave check`, `weave routes`.",
   "type": "module",
   "bin": {