@lightspeed-js/core 0.2.0 → 0.3.1

package/dist/ssg.js

@@ -1292,10 +1292,13 @@ function findMarkerEnd(nodes, start) {
   }
   return -1;
 }
+function isSlotStash(node) {
+  return node.nodeType === 1 && node.tagName === "TEMPLATE" && node.hasAttribute("data-lsp-slot");
+}
 function slotNodesFor(payload, between) {
   if (!payload.ssr)
     return between;
-  const stash = between.find((node) => node.nodeType === 1 && node.tagName === "TEMPLATE" && node.hasAttribute("data-lsp-slot"));
+  const stash = between.find(isSlotStash);
   return stash ? Array.from(stash.content.childNodes) : [];
 }
 
@@ -2084,7 +2087,7 @@ class Mounter {
     return islands;
   }
   async mountRange(range, props, slotNodes) {
-    const child = await this.mount(range.payload.c, null, props, slotNodes, undefined, range.payload.ssr ? nodesBetween(range.start, range.end) : undefined, range.payload.ssr ? () => this.rescueRendered(range) : undefined);
+    const child = await this.mount(range.payload.c, null, props, slotNodes, undefined, range.payload.ssr ? nodesBetween(range.start, range.end).filter((node) => !isSlotStash(node)) : undefined, range.payload.ssr ? () => this.rescueRendered(range) : undefined);
     if (!child)
       return null;
     const root = child.rootNodes.find((node) => node.nodeType === 1);
@@ -2333,6 +2336,17 @@ function componentsForPage(pageHtml, manifest) {
   }
   return dynamic ? Object.keys(manifest.components) : [...reachable];
 }
+function manifestForPage(pageHtml, manifest) {
+  const components = {};
+  for (const id of componentsForPage(pageHtml, manifest)) {
+    const entry = manifest.components[id];
+    if (!entry)
+      continue;
+    const { css, ...rest } = entry;
+    components[id] = rest;
+  }
+  return { version: manifest.version, runtime: manifest.runtime, components };
+}
 
 // src/runtime/dom/StyleManager.ts
 var PENDING_STYLES = `
@@ -3428,9 +3442,1292 @@ function serialiseBetween(start, end) {
   }
   return html;
 }
+// src/compile/expressions.ts
+function expressionKey(expr, params) {
+  return `${params.join(",")}|${expr}`;
+}
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var NODE = /<!--lsp ([\s\S]*?)-->|(<!--[\s\S]*?-->)|<\/?([a-zA-Z][\w-]*)((?:"[^"]*"|'[^']*'|[^>"'])*)\/?>/g;
+var ATTR = /([a-zA-Z@:$][\w:@.-]*)\s*=\s*"([^"]*)"/g;
+function parseForExpression2(value) {
+  const match = value.match(/^\s*(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s+in\s+([\s\S]+)$/);
+  if (!match)
+    return { items: value.trim() };
+  const alias = (match[1] ?? match[2] ?? "").split(",")[0].trim();
+  return { alias: alias || undefined, items: match[3].trim() };
+}
+function extractExpressions(template, options = {}) {
+  const chains = new Map;
+  const found = [];
+  const seen = new Set;
+  const stack = [];
+  const add = (expr, params, kind, writable = false) => {
+    const trimmed = expr.trim();
+    if (!trimmed)
+      return;
+    const key = `${kind}|${expressionKey(trimmed, params)}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    found.push({ expr: trimmed, params: [...params], kind, writable });
+  };
+  const aliases = () => stack.map((frame) => frame.alias).filter((alias) => !!alias);
+  const flushChain = (depth) => {
+    const chain = chains.get(depth);
+    if (!chain)
+      return;
+    chains.delete(depth);
+    add(composeBranchExpression(chain.branches), chain.params, "branch");
+  };
+  NODE.lastIndex = 0;
+  let match;
+  while ((match = NODE.exec(template)) !== null) {
+    const [raw, markerPayload, comment, tag, attrText = ""] = match;
+    if (markerPayload !== undefined) {
+      addMarkerBinds(markerPayload, aliases(), add);
+      continue;
+    }
+    if (comment !== undefined)
+      continue;
+    if (raw.startsWith("</")) {
+      for (let i = stack.length - 1;i >= 0; i--) {
+        if (stack[i].tag === tag) {
+          stack.length = i;
+          break;
+        }
+      }
+      continue;
+    }
+    const outer = aliases();
+    let alias;
+    const forMatch = attrText.match(/\sdata-bind-for\s*=\s*"([^"]*)"/);
+    if (forMatch) {
+      const parsed = parseForExpression2(forMatch[1]);
+      add(parsed.items, outer, "for");
+      alias = parsed.alias;
+    }
+    const inner = alias ? [...outer, alias] : outer;
+    ATTR.lastIndex = 0;
+    let attr;
+    while ((attr = ATTR.exec(attrText)) !== null) {
+      const [, name, value] = attr;
+      if (name === "data-bind-for")
+        continue;
+      if (name === "data-text")
+        add(value, inner, "text");
+      else if (name === "data-bind-model")
+        add(value, inner, "model", true);
+      else if (name === "data-bind-key")
+        add(value, inner, "key");
+      else if (name.startsWith("data-on-")) {
+        if (/^[A-Za-z_$][\w$]*$/.test(value.trim()))
+          continue;
+        const handlers = (options.handlers ?? []).filter((handler) => !inner.includes(handler));
+        add(value, [...inner, ...handlers, "$event"], "event");
+      } else if (name.startsWith("data-bind-")) {
+        const kind = name.slice("data-bind-".length);
+        if (kind === "else" || kind === "hydrate" || kind === "needs")
+          continue;
+        add(value, inner, kind);
+      }
+    }
+    const depth = stack.length;
+    const ifAttr = attrText.match(/\sdata-bind-if\s*=\s*"([^"]*)"/);
+    const elseIf = attrText.match(/\sdata-bind-else-if\s*=\s*"([^"]*)"/);
+    const hasElse = /\sdata-bind-else(?![-\w])/.test(attrText);
+    if (ifAttr) {
+      flushChain(depth);
+      chains.set(depth, { params: outer, branches: [{ condition: ifAttr[1] }] });
+    } else if (elseIf && chains.has(depth)) {
+      chains.get(depth).branches.push({ condition: elseIf[1] });
+    } else if (hasElse && chains.has(depth)) {
+      chains.get(depth).branches.push({ condition: null });
+      flushChain(depth);
+    } else {
+      flushChain(depth);
+    }
+    const selfClosing = raw.endsWith("/>") || VOID_ELEMENTS.has(tag.toLowerCase());
+    if (!selfClosing)
+      stack.push({ tag, alias });
+  }
+  for (const depth of [...chains.keys()])
+    flushChain(depth);
+  return found;
+}
+function buildExpressionTable(found) {
+  const expressions = {};
+  const writers = {};
+  for (const one of found) {
+    const signature = ["state", "props", "shared", "pending", ...one.params];
+    const key = expressionKey(one.expr, one.params);
+    try {
+      expressions[key] = new Function(...signature, `return (${one.expr});`);
+      if (one.writable) {
+        writers[key] = new Function("state", "props", "shared", "pending", "$value", ...one.params, `${one.expr} = $value;`);
+      }
+    } catch {
+    }
+  }
+  return { expressions, writers };
+}
+function addMarkerBinds(payload, params, add) {
+  let parsed;
+  try {
+    parsed = JSON.parse(payload.trim());
+  } catch {
+    return;
+  }
+  for (const expr of Object.values(parsed?.bind ?? {})) {
+    if (typeof expr === "string")
+      add(expr, params, "prop");
+  }
+  if (typeof parsed?.dyn === "string")
+    add(parsed.dyn, params, "dynamic");
+}
+
+// src/project/component-ids.ts
+function componentIdOf(file) {
+  const name = file.split(/[\\/]/).pop() ?? file;
+  return name.replace(/\.lsp$/, "").toLowerCase();
+}
+function resolveComponentIds(found, declaredOverrides = []) {
+  const declared = new Set(declaredOverrides.map((id) => id.toLowerCase()));
+  const files = new Map;
+  const rootOf = new Map;
+  const result = { files, overrides: [], conflicts: [], unusedOverrides: [] };
+  const used = new Set;
+  for (const { file, root } of found) {
+    const id = componentIdOf(file);
+    const kept = files.get(id);
+    if (kept === undefined) {
+      files.set(id, file);
+      rootOf.set(id, root);
+      continue;
+    }
+    if (rootOf.get(id) === root) {
+      result.conflicts.push({ kind: "same-root", id, kept, other: file });
+    } else if (declared.has(id)) {
+      used.add(id);
+      result.overrides.push({ id, kept, replaced: file });
+    } else {
+      result.conflicts.push({ kind: "undeclared-override", id, kept, other: file });
+    }
+  }
+  result.unusedOverrides = [...declared].filter((id) => !used.has(id)).sort();
+  return result;
+}
+function describeConflict(conflict, rel) {
+  const kept = rel(conflict.kept);
+  const other = rel(conflict.other);
+  if (conflict.kind === "same-root") {
+    return `${conflict.id}: ${kept} and ${other} both answer to <${conflict.id}>. ` + `A component's name is its filename, lowercased, across every component directory. Rename one of them.`;
+  }
+  return `${conflict.id}: ${kept} replaces ${other}. ` + `If that is deliberate, add "${conflict.id}" to lightspeedPlugin({ overrides }); otherwise rename one of them.`;
+}
+
+// src/project/components.ts
+import { readFile, readdir } from "fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2, join, relative as relative2, resolve as resolve2 } from "path";
+
+// src/specifiers.ts
+var PACKAGE_NAME = "@lightspeed-js/core";
+var LEGACY_NAME = "lightspeed";
+var RUNTIME_SPECIFIERS = [PACKAGE_NAME, LEGACY_NAME];
+var SPECIFIER_PATTERN = "(?:@lightspeed-js\\/core|lightspeed)";
+
+// src/compile/logic.ts
+var CONTEXT_KEYS = [
+  "_componentInstance",
+  "__lightspeedRuntime",
+  "_getComponent",
+  "_addHandler"
+];
+var LIGHTSPEED_NAMED = new RegExp(`^import\\s*\\{([^}]+)\\}\\s*from\\s*['"]${SPECIFIER_PATTERN}['"]\\s*;?\\s*$`);
+var DEFAULT_IMPORT = /^import\s+([A-Za-z_$][\w$]*)\s+from\s*['"]([^'"]+)['"]\s*;?\s*$/;
+var ANY_IMPORT = /^import\s.+from\s*['"][^'"]+['"]\s*;?\s*$|^import\s*['"][^'"]+['"]\s*;?\s*$/;
+function componentIdFrom(path) {
+  const file = path.split("/").pop() ?? path;
+  return file.replace(/\.lsp$/, "").toLowerCase();
+}
+function joinWrappedImports(logic) {
+  const out = [];
+  let pending = [];
+  const STARTS = /^import\s+[^(]/;
+  const ENDS = /from\s*['"][^'"]*['"]\s*;?$|^import\s*['"][^'"]*['"]\s*;?$/;
+  for (const line of logic.split(`
+`)) {
+    const trimmed = line.trim();
+    if (pending.length) {
+      pending.push(trimmed);
+      if (ENDS.test(trimmed)) {
+        out.push(pending.join(" "), ...pending.slice(1).map(() => ""));
+        pending = [];
+      }
+      continue;
+    }
+    if (STARTS.test(trimmed) && !ANY_IMPORT.test(trimmed)) {
+      pending.push(trimmed);
+      continue;
+    }
+    out.push(line);
+  }
+  out.push(...pending);
+  return out.join(`
+`);
+}
+function compileLogic(logic) {
+  const imports = [];
+  const bindings = [];
+  const components = [];
+  const prelude = [];
+  const rest = [];
+  for (const line of joinWrappedImports(logic).split(`
+`)) {
+    const trimmed = line.trim();
+    const named = trimmed.match(LIGHTSPEED_NAMED);
+    if (named) {
+      for (const raw of named[1].split(",")) {
+        const name = raw.trim();
+        if (!name)
+          continue;
+        const [source, local = source] = name.split(/\s+as\s+/).map((s) => s.trim());
+        prelude.push(`const ${local} = __lightspeedRuntime.${source};`);
+      }
+      continue;
+    }
+    const asDefault = trimmed.match(DEFAULT_IMPORT);
+    if (asDefault && asDefault[2].endsWith(".lsp")) {
+      const id = componentIdFrom(asDefault[2]);
+      components.push(id);
+      prelude.push(`const ${asDefault[1]} = _getComponent(${JSON.stringify(id)});`);
+      continue;
+    }
+    if (ANY_IMPORT.test(trimmed)) {
+      imports.push(trimmed);
+      bindings.push(parseImport(trimmed));
+      continue;
+    }
+    rest.push(line);
+  }
+  const body = [
+    `const { ${CONTEXT_KEYS.join(", ")} } = __ctx;`,
+    ...prelude,
+    "",
+    ...rest,
+    "",
+    captureEpilogue(declaredNames(logic))
+  ].join(`
+`);
+  return { imports, bindings, body, components };
+}
+function declaredNames(logic) {
+  const names = new Set;
+  const patterns = [
+    /^(?:export\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/gm,
+    /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/gm
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(logic)) !== null)
+      names.add(match[1]);
+  }
+  return [...names];
+}
+function captureEpilogue(names) {
+  const handlers = names.map((name) => `  if (typeof ${name} === "function") _addHandler(${JSON.stringify(name)}, ${name});`).join(`
+`);
+  return [
+    "// Hand the component's state and handlers to the runtime. Captured after",
+    "// the body runs rather than rewritten in place: a regex over an",
+    "// initialiser could not survive nested braces, which is exactly what a",
+    "// list of objects is.",
+    'if (typeof state !== "undefined") _componentInstance.state = state;',
+    handlers
+  ].join(`
+`);
+}
+function parseImport(statement) {
+  const source = statement.match(/from\s*['"]([^'"]+)['"]/)?.[1] ?? statement.match(/^import\s*['"]([^'"]+)['"]/)?.[1] ?? "";
+  const names = [];
+  const clause = statement.match(/^import\s+([\s\S]+?)\s+from/)?.[1]?.trim();
+  if (clause) {
+    const star = clause.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+    if (star) {
+      names.push({ local: star[1], imported: "*" });
+    } else {
+      const braced = clause.match(/\{([^}]*)\}/)?.[1];
+      const bare = clause.replace(/\{[^}]*\}/, "").replace(/,/g, "").trim();
+      if (bare)
+        names.push({ local: bare, imported: "default" });
+      for (const raw of (braced ?? "").split(",")) {
+        const entry = raw.trim();
+        if (!entry)
+          continue;
+        const [imported, local = imported] = entry.split(/\s+as\s+/).map((s) => s.trim());
+        names.push({ local, imported });
+      }
+    }
+  }
+  return { source, names, statement };
+}
+async function buildSetup(logic, options = {}) {
+  if (!logic.trim())
+    return;
+  const compiled = compileLogic(options.transpile ? options.transpile(logic) : logic);
+  const locals = [];
+  const values = [];
+  for (const binding of compiled.bindings) {
+    if (!binding.names.length)
+      continue;
+    if (!options.load) {
+      throw new Error(`[lightspeed] Component logic imports "${binding.source}", but this ` + `build has no way to load project modules.`);
+    }
+    const namespace = await options.load(binding.source);
+    for (const name of binding.names) {
+      locals.push(name.local);
+      values.push(name.imported === "*" ? namespace : namespace[name.imported]);
+    }
+  }
+  const fn = new Function(...locals, "__ctx", compiled.body);
+  return (ctx) => fn(...values, ctx);
+}
+var RESERVED = new Set(["state", "props", "shared", "pending"]);
+function handlerParams(logic) {
+  return declaredNames(logic).filter((name) => !RESERVED.has(name));
+}
+
+// src/parser/lsp.ts
+function parseLSP(content, filename) {
+  const view = extractSection(content, "view");
+  const skeleton = extractSection(content, "skeleton");
+  const logic = extractSection(content, "logic");
+  const styles = extractStyles(content);
+  return {
+    view,
+    skeleton,
+    logic,
+    needs: extractSection(content, "needs").split(/[,\n]/).map((key) => key.trim()).filter(Boolean),
+    ...styles,
+    filename
+  };
+}
+function inlineStyleSources(component, read) {
+  const join = (sources, own) => {
+    if (!sources.length)
+      return own;
+    const shared = sources.map((source) => read(source, component.filename));
+    return [...shared, own].filter((block) => block.trim()).join(`
+
+`);
+  };
+  return {
+    ...component,
+    style: join(component.styleSources, component.style),
+    styleDeferred: join(component.styleDeferredSources, component.styleDeferred)
+  };
+}
+function extractSection(content, sectionName) {
+  const regex = new RegExp(`<${sectionName}[^>]*>([\\s\\S]*?)<\\/${sectionName}>`, "i");
+  const match = content.match(regex);
+  return match ? match[1].trim() : "";
+}
+function extractStyles(content) {
+  const blocks = content.matchAll(/<style([^>]*)>([\s\S]*?)<\/style>/gi);
+  const critical = [];
+  const deferred = [];
+  const criticalSources = [];
+  const deferredSources = [];
+  for (const [, attributes, body] of blocks) {
+    const isDeferred = /\bdeferred\b/i.test(attributes);
+    const src = attributes.match(/\bsrc\s*=\s*["']([^"']+)["']/i);
+    if (src)
+      (isDeferred ? deferredSources : criticalSources).push(src[1]);
+    (isDeferred ? deferred : critical).push(body.trim());
+  }
+  return {
+    style: critical.join(`
+
+`),
+    styleDeferred: deferred.join(`
+
+`),
+    styleSources: criticalSources,
+    styleDeferredSources: deferredSources
+  };
+}
+// src/parser/style-source-node.ts
+import { readFileSync } from "fs";
+import { dirname, relative, resolve } from "path";
+function nodeStyleReader() {
+  return (specifier, from) => {
+    const file = resolve(dirname(from), specifier);
+    try {
+      return readFileSync(file, "utf-8");
+    } catch {
+      throw new Error(`${relative(process.cwd(), from)}: <style src="${specifier}"> could not be read ` + `(looked in ${relative(process.cwd(), file)})`);
+    }
+  };
+}
+function styleSourcePaths(component) {
+  return [...component.styleSources, ...component.styleDeferredSources].map((specifier) => resolve(dirname(component.filename), specifier));
+}
+
+// src/parser/style.ts
+function scopeIdFor(componentId) {
+  let hash = 5381;
+  for (let i = 0;i < componentId.length; i++) {
+    hash = (hash << 5) + hash + componentId.charCodeAt(i) >>> 0;
+  }
+  return `lsp-${hash.toString(36)}`;
+}
+function scopeStyles(css, scopeId) {
+  if (!css.trim())
+    return css;
+  const attribute = `[data-lsp~="${scopeId}"]`;
+  const scopes = {
+    normal: `:where(${attribute})`,
+    deep: `${attribute}${attribute}`
+  };
+  const renames = collectKeyframeRenames(css, scopeId);
+  return transformRules(css, scopes, scopeId, renames);
+}
+function collectKeyframeRenames(css, scopeId) {
+  const renames = new Map;
+  const pattern = /@[-\w]*keyframes\s+([\w-]+)/gi;
+  let match;
+  while ((match = pattern.exec(css)) !== null) {
+    renames.set(match[1], `${match[1]}-${scopeId}`);
+  }
+  return renames;
+}
+var NESTED_AT_RULES = new Set([
+  "@media",
+  "@supports",
+  "@container",
+  "@layer",
+  "@scope"
+]);
+function transformRules(css, scopes, scopeId, renames) {
+  let out = "";
+  let i = 0;
+  while (i < css.length) {
+    const prelude = readPrelude(css, i);
+    i = prelude.end;
+    if (i >= css.length) {
+      out += prelude.text;
+      break;
+    }
+    if (css[i] === ";") {
+      out += `${prelude.text};`;
+      i++;
+      continue;
+    }
+    const bodyEnd = matchBrace(css, i);
+    const body = css.slice(i + 1, bodyEnd);
+    i = bodyEnd + 1;
+    const trimmed = prelude.text.trim();
+    if (trimmed.startsWith("@")) {
+      const name = trimmed.split(/[\s({]/)[0].toLowerCase();
+      if (name.endsWith("keyframes")) {
+        out += `${renameKeyframe(prelude.text, scopeId)}{${body}}`;
+      } else if (NESTED_AT_RULES.has(name)) {
+        out += `${prelude.text}{${transformRules(body, scopes, scopeId, renames)}}`;
+      } else {
+        out += `${prelude.text}{${body}}`;
+      }
+      continue;
+    }
+    out += `${scopeSelectorList(prelude.text, scopes)}{${rewriteAnimations(body, renames)}}`;
+  }
+  return out;
+}
+function renameKeyframe(prelude, scopeId) {
+  return prelude.replace(/(@[-\w]*keyframes\s+)([\w-]+)/i, (_match, keyword, name) => `${keyword}${name}-${scopeId}`);
+}
+function rewriteAnimations(body, renames) {
+  if (renames.size === 0)
+    return body;
+  return body.replace(/(animation(?:-name)?\s*:)([^;}]*)/gi, (_match, property, value) => {
+    let next = value;
+    for (const [from, to] of renames) {
+      next = next.replace(new RegExp(`\\b${escapeRegExp(from)}\\b`, "g"), to);
+    }
+    return property + next;
+  });
+}
+function readPrelude(css, start) {
+  let text = "";
+  let i = start;
+  let depth = 0;
+  while (i < css.length) {
+    const char = css[i];
+    if (char === "/" && css[i + 1] === "*") {
+      const close = css.indexOf("*/", i + 2);
+      const stop = close < 0 ? css.length : close + 2;
+      text += css.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const stop = skipString(css, i);
+      text += css.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (char === "(")
+      depth++;
+    if (char === ")")
+      depth--;
+    if (depth === 0 && (char === "{" || char === ";"))
+      break;
+    text += char;
+    i++;
+  }
+  return { text, end: i };
+}
+function skipString(css, start) {
+  const quote = css[start];
+  let i = start + 1;
+  while (i < css.length) {
+    if (css[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (css[i] === quote)
+      return i + 1;
+    i++;
+  }
+  return i;
+}
+function matchBrace(css, openIndex) {
+  let depth = 0;
+  let i = openIndex;
+  while (i < css.length) {
+    const char = css[i];
+    if (char === "/" && css[i + 1] === "*") {
+      const close = css.indexOf("*/", i + 2);
+      i = close < 0 ? css.length : close + 2;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      i = skipString(css, i);
+      continue;
+    }
+    if (char === "{")
+      depth++;
+    if (char === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  return css.length - 1;
+}
+function scopeSelectorList(selectors, scopes) {
+  const comments = [];
+  const bare = selectors.replace(/\/\*[\s\S]*?\*\//g, (comment) => {
+    comments.push(comment);
+    return "";
+  });
+  const scoped = splitTopLevel(bare, ",").map((selector) => scopeSelector(selector, scopes)).join(",");
+  return comments.join("") + scoped;
+}
+function scopeSelector(selector, scopes) {
+  const leading = selector.match(/^\s*/)?.[0] ?? "";
+  const trailing = selector.match(/\s*$/)?.[0] ?? "";
+  const trimmed = selector.trim();
+  if (!trimmed)
+    return selector;
+  const parts = splitCompounds(trimmed);
+  const deepIndex = parts.findIndex((part) => part.deep);
+  if (deepIndex >= 0) {
+    if (deepIndex === 0) {
+      const rendered3 = parts.map((part) => part.combinator + unwrap(part.text)).join("").trimStart();
+      return `${leading}${scopes.deep} ${rendered3}${trailing}`;
+    }
+    let anchor = -1;
+    for (let i = deepIndex - 1;i >= 0; i--) {
+      if (!parts[i].global) {
+        anchor = i;
+        break;
+      }
+    }
+    const rendered2 = parts.map((part, index) => {
+      const text = unwrap(part.text);
+      return part.combinator + (index === anchor ? insertScope(text, scopes.deep) : text);
+    });
+    return leading + rendered2.join("") + trailing;
+  }
+  let targetIndex = -1;
+  for (let i = parts.length - 1;i >= 0; i--) {
+    if (!parts[i].global) {
+      targetIndex = i;
+      break;
+    }
+  }
+  const rendered = parts.map((part, index) => {
+    const text = unwrap(part.text);
+    const scoped = index === targetIndex ? insertScope(text, scopes.normal) : text;
+    return part.combinator + scoped;
+  });
+  return leading + rendered.join("") + trailing;
+}
+function unwrap(text) {
+  return text.replace(/:(?:global|deep)\(\s*([\s\S]*?)\s*\)/g, "$1");
+}
+function insertScope(compound, attribute) {
+  let depth = 0;
+  for (let i = 0;i < compound.length; i++) {
+    const char = compound[i];
+    if (char === "(" || char === "[")
+      depth++;
+    if (char === ")" || char === "]")
+      depth--;
+    if (char === ":" && depth === 0) {
+      return compound.slice(0, i) + attribute + compound.slice(i);
+    }
+  }
+  return compound + attribute;
+}
+function splitCompounds(selector) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  let combinator = "";
+  let i = 0;
+  const push = () => {
+    if (!current)
+      return;
+    parts.push({
+      combinator,
+      text: current,
+      global: /^:global\(/.test(current.trim()),
+      deep: /^:deep\(/.test(current.trim())
+    });
+    current = "";
+    combinator = "";
+  };
+  while (i < selector.length) {
+    const char = selector[i];
+    if (char === "(" || char === "[")
+      depth++;
+    if (char === ")" || char === "]")
+      depth--;
+    if (depth === 0 && /[\s>+~]/.test(char)) {
+      let separator = "";
+      while (i < selector.length && /[\s>+~]/.test(selector[i]) && depth === 0) {
+        separator += selector[i];
+        i++;
+      }
+      push();
+      combinator = separator;
+      continue;
+    }
+    current += char;
+    i++;
+  }
+  push();
+  return parts;
+}
+function splitTopLevel(input, delimiter) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (char === '"' || char === "'") {
+      const stop = skipString(input, i);
+      current += input.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    if (char === "(" || char === "[")
+      depth++;
+    if (char === ")" || char === "]")
+      depth--;
+    if (char === delimiter && depth === 0) {
+      parts.push(current);
+      current = "";
+      i++;
+      continue;
+    }
+    current += char;
+    i++;
+  }
+  parts.push(current);
+  return parts;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/parser/template.ts
+function transformTemplate(template, componentId, componentRegistry) {
+  const comments = protectComments(template);
+  const verbatim = protectVerbatim(comments.text, componentRegistry);
+  let transformed = verbatim.text;
+  transformed = hoistBlockDirectives(transformed);
+  transformed = emitMountPlaceholders(transformed, componentRegistry);
+  for (const [stray] of transformed.matchAll(/\$cell:[\w.-]*="[^"]*"/g)) {
+    warn(`${stray} is only meaningful on a component tag - ` + `an element reads a cell with {{ shared['key'] }} or $attr="shared['key']".`);
+  }
+  transformed = transformed.replace(/@(\w+)="([^"]+)"/g, 'data-on-$1="$2"');
+  transformed = transformed.replace(/\$needs="([^"]*)"/g, 'data-lsp-needs="$1"');
+  transformed = transformed.replace(/\$shimmer="([^"]*)"/g, 'data-lsp-shimmer="$1"');
+  transformed = transformed.replace(/\$shimmer(?=[\s/>])/g, 'data-lsp-shimmer=""');
+  transformed = transformed.replace(/\$needs(?=[\s/>])/g, 'data-lsp-needs=""');
+  transformed = transformed.replace(/\$ref="([^"]+)"/g, 'data-lsp-ref="$1"');
+  transformed = transformed.replace(/\$text="([^"]+)"/g, 'data-text="$1"');
+  transformed = transformed.replace(/\$([\w-]+)="([^"]+)"/g, 'data-bind-$1="$2"');
+  transformed = transformed.replace(/\$else(?=[\s/>])/g, "data-bind-else");
+  transformed = transformed.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_match, expression) => `<span data-text="${expression.trim()}"></span>`);
+  return comments.restore(verbatim.restore(transformed));
+}
+function protectComments(template) {
+  const stash = [];
+  const text = template.replace(/<!--[\s\S]*?-->/g, (comment) => {
+    stash.push(comment);
+    return `<!--lsp-comment-${stash.length - 1}-->`;
+  });
+  return {
+    text,
+    restore: (html) => html.replace(/<!--lsp-comment-(\d+)-->/g, (_match, index) => stash[Number(index)])
+  };
+}
+var VERBATIM_TAGS = /<(pre|code)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+var RAW_SLOT = /<slot\b[^>]*\braw\b[^>]*>/i;
+function protectVerbatim(template, componentRegistry) {
+  const stash = [];
+  const hold = (value) => {
+    stash.push(value);
+    return `<!--lsp-verbatim-${stash.length - 1}-->`;
+  };
+  let text = template.replace(VERBATIM_TAGS, hold);
+  if (componentRegistry) {
+    text = text.replace(/<([A-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\s*>([\s\S]*?)<\/\1\s*>/g, (match, name, attributes, content) => {
+      const definition = componentRegistry[name.toLowerCase()];
+      if (!definition || !RAW_SLOT.test(definition.template ?? "")) {
+        return match;
+      }
+      return `<${name}${attributes}>${hold(content)}</${name}>`;
+    });
+  }
+  const restore = (html) => {
+    let result = html;
+    for (let pass = 0;pass < 10; pass++) {
+      const next = result.replace(/<!--lsp-verbatim-(\d+)-->/g, (_match, index) => stash[Number(index)] ?? "");
+      if (next === result)
+        return result;
+      result = next;
+    }
+    return result;
+  };
+  return { text, restore };
+}
+function hoistBlockDirectives(template) {
+  const wrap = (tag, attributes, rebuild) => {
+    const { block, rest } = splitBlockDirectives(attributes);
+    if (!block.length)
+      return tag;
+    return `<template ${block.join(" ")}>${rebuild(rest)}</template>`;
+  };
+  let result = template.replace(/<([A-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\s*\/>/g, (match, name, attributes) => wrap(match, attributes || "", (rest) => `<${name}${rest} />`));
+  result = result.replace(/<([A-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\s*>([\s\S]*?)<\/\1\s*>/g, (match, name, attributes, content) => wrap(match, attributes || "", (rest) => `<${name}${rest}>${content}</${name}>`));
+  return result;
+}
+function splitBlockDirectives(attributes) {
+  const block = [];
+  let rest = attributes;
+  for (const name of ["for", "if", "else-if"]) {
+    const pattern = new RegExp(`\\s\\$${name}="([^"]*)"`);
+    const match = rest.match(pattern);
+    if (!match)
+      continue;
+    block.push(`data-bind-${name}="${match[1]}"`);
+    rest = rest.replace(pattern, "");
+  }
+  const valueless = /\s\$else(?=[\s/>])/;
+  if (valueless.test(rest)) {
+    block.push("data-bind-else");
+    rest = rest.replace(valueless, "");
+  }
+  const key = /\s\$key="([^"]*)"/;
+  const keyMatch = rest.match(key);
+  if (keyMatch && block.length) {
+    block.push(`data-bind-key="${keyMatch[1]}"`);
+    rest = rest.replace(key, "");
+  }
+  return { block, rest };
+}
+function emitMountPlaceholders(template, componentRegistry, depth = 0) {
+  if (depth > 10) {
+    console.warn("Max nesting reached in component placeholders - possible circular reference");
+    return template;
+  }
+  const warnUnknown = (name) => {
+    if (name.toLowerCase() === "dynamic")
+      return;
+    if (componentRegistry && !componentRegistry[name.toLowerCase()]) {
+      console.warn(`Component not found: ${name}`);
+    }
+  };
+  let result = template;
+  result = result.replace(/<([A-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\s*\/>/g, (_match, name, attributes) => {
+    warnUnknown(name);
+    return buildPlaceholder(name, attributes || "", "", componentRegistry?.[name.toLowerCase()]?.needs);
+  });
+  result = result.replace(/<([A-Z][a-zA-Z0-9]*)((?:\s+[^>]*?)?)\s*>([\s\S]*?)<\/\1\s*>/g, (_match, name, attributes, content) => {
+    warnUnknown(name);
+    const inner = emitMountPlaceholders(content, componentRegistry, depth + 1);
+    return buildPlaceholder(name, attributes || "", inner, componentRegistry?.[name.toLowerCase()]?.needs);
+  });
+  return result;
+}
+function splitCellKeys(value) {
+  if (!value)
+    return [];
+  return value.split(",").map((key) => key.trim()).filter(Boolean);
+}
+var DYNAMIC_TAG = "dynamic";
+var CELL_PROP = "cell:";
+var BARE_CELL_READ = /^shared\s*(?:\[\s*(['"])([^'"]+)\1\s*\]|\.([A-Za-z_$][\w$]*))$/;
+var nudged = new Set;
+function nudgeCellProps(componentId, payload) {
+  for (const [name, expr] of Object.entries(payload.bind ?? {})) {
+    if (name === "class" || name === "style")
+      continue;
+    const match = BARE_CELL_READ.exec(expr.trim());
+    if (!match)
+      continue;
+    const key = match[2] ?? match[3];
+    const said = `${componentId}|${name}|${expr}`;
+    if (nudged.has(said))
+      continue;
+    nudged.add(said);
+    warn(`<${componentId} $${name}="${expr}"> is delivered by whoever mounts it. ` + `Write $cell:${name}="${key}" and the child subscribes to the cell itself.`);
+  }
+}
+function buildPlaceholder(name, attributes, content, declared) {
+  const payload = splitAttributes(name.toLowerCase(), attributes);
+  if (declared?.length) {
+    const seen = new Set(declared);
+    payload.needs = [
+      ...declared,
+      ...(payload.needs ?? []).filter((key) => !seen.has(key))
+    ];
+  }
+  nudgeCellProps(name.toLowerCase(), payload);
+  if (payload.c === DYNAMIC_TAG) {
+    const is = payload.bind?.is;
+    delete payload.bind?.is;
+    if (payload.bind && !Object.keys(payload.bind).length)
+      delete payload.bind;
+    if (!is) {
+      warn('<Dynamic> needs $is, e.g. <Dynamic $is="field.type" />');
+    }
+    payload.c = "";
+    payload.dyn = is ?? "";
+  }
+  return serializeMarker(payload) + content + MARKER_END;
+}
+function splitAttributes(componentId, attrString) {
+  const payload = { c: componentId };
+  if (!attrString.trim())
+    return payload;
+  const attrRegex = /([@$]?[A-Za-z_:][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  let match;
+  const put = (bag, key, value) => {
+    const target = payload[bag] ??= {};
+    target[key] = value;
+  };
+  while ((match = attrRegex.exec(attrString)) !== null) {
+    const [, name, doubleQuoted, singleQuoted, unquoted] = match;
+    const value = doubleQuoted ?? singleQuoted ?? unquoted;
+    if (name.startsWith("@")) {
+      put("on", name.slice(1), value ?? "");
+      continue;
+    }
+    if (name.startsWith("$")) {
+      const directive = name.slice(1);
+      if (directive === "hydrate")
+        payload.hydrate = value ?? "load";
+      else if (directive === "needs")
+        payload.needs = splitCellKeys(value);
+      else if (directive.startsWith(CELL_PROP)) {
+        const propName = directive.slice(CELL_PROP.length).trim();
+        const key = (value ?? "").trim();
+        if (!propName) {
+          warn(`<${componentId}> has $cell: with no prop name - e.g. $cell:count="ui:clicks"`);
+        } else if (!key) {
+          warn(`<${componentId}> $cell:${propName} needs a cell key, e.g. $cell:${propName}="ui:clicks"`);
+        } else {
+          put("cells", propName, key);
+        }
+      } else
+        put("bind", directive, value ?? "");
+      continue;
+    }
+    if (name === "class" || name === "style") {
+      put("attrs", name, value ?? "");
+      continue;
+    }
+    put("props", name, value === undefined ? true : value);
+  }
+  return payload;
+}
+
+// src/project/components.ts
+function createComponentProject(options) {
+  const rootOf = () => typeof options.root === "function" ? options.root() : options.root;
+  const extraComponentDirs = options.componentDirs ?? [];
+  const declaredOverrides = options.overrides ?? [];
+  const compiler = options.compiler ?? "esbuild";
+  const registry = new Map;
+  const files = new Map;
+  let conflicts = [];
+  const announced = new Set;
+  let rebuilding = null;
+  const projectModules = new Map;
+  function roots() {
+    const root = rootOf();
+    return [resolve2(root, "src"), ...extraComponentDirs.map((dir) => resolve2(root, dir))];
+  }
+  async function findComponentFiles() {
+    const found = [];
+    for (const dir of roots()) {
+      for (const file of await findLspFiles(dir))
+        found.push({ file, root: dir });
+    }
+    return found;
+  }
+  function announce(ids) {
+    const rel = (file) => relative2(rootOf(), file);
+    for (const conflict of ids.conflicts) {
+      const key = `${conflict.kind}\x00${conflict.kept}\x00${conflict.other}`;
+      if (announced.has(key))
+        continue;
+      announced.add(key);
+      console.warn(`⚠️  ${describeConflict(conflict, rel)}`);
+    }
+    for (const id of ids.unusedOverrides) {
+      const key = `unused\x00${id}`;
+      if (announced.has(key))
+        continue;
+      announced.add(key);
+      console.warn(`⚠️  overrides lists "${id}", but nothing replaces a component of that name. Remove it from lightspeedPlugin({ overrides }).`);
+    }
+  }
+  function rebuild() {
+    if (rebuilding)
+      return rebuilding;
+    rebuilding = (async () => {
+      const nextRegistry = new Map;
+      const nextFiles = new Map;
+      try {
+        const ids = resolveComponentIds(await findComponentFiles(), declaredOverrides);
+        conflicts = ids.conflicts;
+        announce(ids);
+        for (const [componentId, filePath] of ids.files) {
+          try {
+            const content = await readFile(filePath, "utf-8");
+            const parsed = withSharedStyles(parseLSP(content, filePath));
+            nextFiles.set(componentId, filePath);
+            nextRegistry.set(componentId, {
+              template: parsed.view,
+              skeleton: parsed.skeleton || "",
+              style: parsed.style || "",
+              styleDeferred: parsed.styleDeferred || "",
+              logic: parsed.logic || "",
+              needs: parsed.needs
+            });
+          } catch (error) {
+            console.warn(`Failed to parse ${filePath}:`, error);
+          }
+        }
+        registry.clear();
+        for (const [id, entry] of nextRegistry)
+          registry.set(id, entry);
+        files.clear();
+        for (const [id, file] of nextFiles)
+          files.set(id, file);
+      } catch (error) {
+        console.warn("Failed to rebuild component registry:", error);
+      } finally {
+        rebuilding = null;
+      }
+    })();
+    return rebuilding;
+  }
+  async function loadProjectModule(specifier, componentId) {
+    const root = rootOf();
+    const file = files.get(componentId);
+    const from = file ? dirname2(resolve2(root, file)) : root;
+    const cacheKey = `${from}|${specifier}`;
+    const cached = projectModules.get(cacheKey);
+    if (cached)
+      return cached;
+    try {
+      const esbuild = await import("esbuild");
+      const built = await esbuild.build({
+        entryPoints: [specifier.startsWith(".") ? join(from, specifier) : specifier],
+        absWorkingDir: from,
+        bundle: true,
+        write: false,
+        format: "cjs",
+        platform: "node",
+        target: "es2022",
+        logLevel: "silent",
+        external: RUNTIME_SPECIFIERS
+      });
+      const module = { exports: {} };
+      new Function("module", "exports", "require", built.outputFiles[0].text)(module, module.exports, createRequire2(import.meta.url));
+      projectModules.set(cacheKey, module.exports);
+      return module.exports;
+    } catch (error) {
+      throw new Error(`[lightspeed] ${componentId} imports "${specifier}", which could not be loaded for build-time rendering: ${error.message}`);
+    }
+  }
+  async function definitions() {
+    await rebuild();
+    const registryObj = Object.fromEntries(registry);
+    const out = [];
+    for (const [componentId, raw] of registry) {
+      const scopeId = scopeIdFor(componentId);
+      const source = raw.logic?.trim() ? await compileLogic2(raw.logic) : "";
+      const setup = await buildSetup(source, {
+        load: (specifier) => loadProjectModule(specifier, componentId)
+      });
+      out.push({
+        id: componentId,
+        ...raw.needs?.length ? { needs: raw.needs } : {},
+        template: transformTemplate(raw.template, componentId, registryObj),
+        skeleton: raw.skeleton ? transformTemplate(raw.skeleton, componentId, registryObj) : "",
+        style: scopeStyles(raw.style || "", scopeId),
+        styleDeferred: scopeStyles(raw.styleDeferred || "", scopeId),
+        setup,
+        handlers: handlerParams(raw.logic || ""),
+        ...buildExpressionTable([
+          ...extractExpressions(transformTemplate(raw.template, componentId, registryObj), {
+            handlers: handlerParams(raw.logic || "")
+          }),
+          ...extractExpressions(raw.skeleton ? transformTemplate(raw.skeleton, componentId, registryObj) : "", { handlers: handlerParams(raw.logic || "") })
+        ]),
+        scopeId
+      });
+    }
+    return out;
+  }
+  function compileLogic2(code) {
+    return compileTypeScriptAtBuildTime(code, compiler);
+  }
+  return {
+    registry,
+    files,
+    get conflicts() {
+      return conflicts;
+    },
+    roots,
+    rebuild,
+    definitions,
+    compileMarkup: (html, id = "index") => transformTemplate(html, id, Object.fromEntries(registry)),
+    compileLogic: compileLogic2
+  };
+}
+function withSharedStyles(parsed, watch) {
+  if (!parsed.styleSources.length && !parsed.styleDeferredSources.length) {
+    return parsed;
+  }
+  if (watch)
+    for (const file of styleSourcePaths(parsed))
+      watch(file);
+  return inlineStyleSources(parsed, nodeStyleReader());
+}
+async function findLspFiles(dir) {
+  const found = [];
+  try {
+    const entries = (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        found.push(...await findLspFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".lsp")) {
+        found.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return found;
+}
+async function compileTypeScriptAtBuildTime(code, compiler) {
+  try {
+    switch (compiler) {
+      case "tsc":
+        return await compileWithNodeTypeScript(code);
+      case "esbuild":
+        return await compileWithNodeEsbuild(code);
+      case "swc":
+        return await compileWithNodeSwc(code);
+      default:
+        throw new Error(`Unknown compiler: ${compiler}`);
+    }
+  } catch (error) {
+    console.warn(`${compiler} compilation failed, falling back to type stripping:`, error);
+    return stripTypeScriptTypes(code);
+  }
+}
+async function compileWithNodeTypeScript(code) {
+  try {
+    const ts = await import("typescript");
+    const result = ts.transpileModule(code, {
+      compilerOptions: {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.ESNext,
+        strict: false,
+        removeComments: false,
+        preserveConstEnums: false,
+        declaration: false,
+        noEmitHelpers: true,
+        importHelpers: false
+      }
+    });
+    return result.outputText;
+  } catch (error) {
+    throw new Error(`TypeScript compiler not available: ${error}`);
+  }
+}
+async function compileWithNodeEsbuild(code) {
+  try {
+    const esbuild = await import("esbuild");
+    const result = await esbuild.transform(code, {
+      loader: "ts",
+      target: "es2020",
+      format: "esm",
+      minify: false,
+      sourcemap: false
+    });
+    return result.code;
+  } catch (error) {
+    throw new Error(`esbuild not available: ${error}`);
+  }
+}
+async function compileWithNodeSwc(code) {
+  try {
+    const swc = await import("@swc/core");
+    const result = await swc.transform(code, {
+      jsc: {
+        parser: {
+          syntax: "typescript",
+          tsx: false,
+          decorators: false,
+          dynamicImport: true
+        },
+        target: "es2020",
+        loose: false
+      },
+      module: {
+        type: "es6"
+      },
+      minify: false,
+      sourceMaps: false
+    });
+    return result.code;
+  } catch (error) {
+    throw new Error(`SWC not available: ${error}`);
+  }
+}
+function stripTypeScriptTypes(code) {
+  code = code.replace(/const\s+(\w+):\s*\([^)]*\)\s*=>\s*\w+\s*=/g, "const $1 =");
+  code = code.replace(/const\s+(\w+):\s*[^=]+=/g, "const $1 =");
+  code = code.replace(/let\s+(\w+):\s*[^=]+=/g, "let $1 =");
+  code = code.replace(/var\s+(\w+):\s*[^=]+=/g, "var $1 =");
+  code = code.replace(/\(\s*(\w+):\s*[^)]+\s*\)/g, "($1)");
+  code = code.replace(/function\s+(\w+)\s*\(\s*([^)]*?):\s*[^),)]+/g, "function $1($2");
+  code = code.replace(/\):\s*[^{=]+\s*=>/g, ") =>");
+  code = code.replace(/\):\s*[^{]+\s*{/g, ") {");
+  code = code.replace(/^\s*interface\s+[^{]*{[^}]*}\s*$/gm, "");
+  code = code.replace(/^\s*type\s+[^=]*=\s*[^;]*;\s*$/gm, "");
+  code = code.replace(/(\w+)<[^<>]*>/g, "$1");
+  code = code.replace(/(\w+)\s+as\s+\w+/g, "$1");
+  return code.replace(/\s+/g, " ").trim();
+}
+
+// src/ssg/fragment.ts
+import { relative as relative3 } from "path";
+var START2 = (i) => `<!--lightspeed-fragment:${i}-->`;
+var END2 = (i) => `<!--/lightspeed-fragment:${i}-->`;
+function createFragmentRenderer(options) {
+  const project = createComponentProject({
+    root: options.root,
+    ...options.componentDirs ? { componentDirs: options.componentDirs } : {},
+    ...options.overrides ? { overrides: options.overrides } : {},
+    ...options.compiler ? { compiler: options.compiler } : {}
+  });
+  async function render(fragments, renderOptions = {}) {
+    await project.rebuild();
+    if (project.conflicts.length) {
+      throw new Error(project.conflicts.map((conflict) => describeConflict(conflict, (file) => relative3(options.root, file))).join(`
+`));
+    }
+    const definitions = await project.definitions();
+    const compiled = fragments.map((fragment) => project.compileMarkup(fragment));
+    const markup = compiled.map((c, i) => `${START2(i)}${c}${END2(i)}`).join("");
+    const expressions = new Map;
+    for (const one of extractExpressions(compiled.join(`
+`))) {
+      expressions.set(expressionKey(one.expr, one.params), one);
+    }
+    const result = await renderPage({
+      html: `<!doctype html><html><head></head><body>${markup}</body></html>`,
+      definitions,
+      css: "external",
+      flattenStatic: renderOptions.flattenStatic !== false,
+      pageExpressions: buildExpressionTable([...expressions.values()])
+    });
+    const body = result.html.slice(result.html.indexOf("<body>") + "<body>".length, result.html.lastIndexOf("</body>"));
+    const html = compiled.map((_, i) => {
+      const start = body.indexOf(START2(i));
+      const end = body.indexOf(END2(i));
+      return start === -1 || end === -1 ? "" : body.slice(start + START2(i).length, end);
+    });
+    const subset = manifestForPage(compiled.join(`
+`), buildManifest(definitions));
+    const metadata = Object.fromEntries(Object.entries(subset.components).map(([id, entry]) => [id, { scope: entry.scope, skeleton: entry.skeleton }]));
+    const pageHead = result.html.slice(result.html.indexOf("<head>") + "<head>".length, result.html.indexOf("</head>"));
+    const head = (Object.keys(metadata).length ? `<script type="application/json" id="lightspeed-manifest">${JSON.stringify(metadata)}</script>` : "") + pageHead.trim();
+    return {
+      html,
+      head,
+      css: result.css,
+      cssDeferred: result.cssDeferred,
+      used: result.used,
+      rendered: result.rendered,
+      flattened: result.flattened,
+      expressions: [...expressions.values()]
+    };
+  }
+  return { render, project };
+}
 // src/ssg/rebuild.ts
-import { readFile, writeFile, mkdir, rm } from "fs/promises";
-import { join, dirname } from "path";
+import { readFile as readFile2, writeFile, mkdir, rm } from "fs/promises";
+import { join as join2, dirname as dirname3 } from "path";
 
 // src/vite/routes.ts
 function rowsFrom(state, from, page) {
@@ -3471,10 +4768,10 @@ function toRoutePage(page, shell, declaration, shellDepth = 0) {
 
 // src/ssg/rebuild.ts
 async function rebuildPages(options) {
-  const manifestPath = options.manifest ?? join(MANIFEST_DIR, MANIFEST_FILE);
+  const manifestPath = options.manifest ?? join2(MANIFEST_DIR, MANIFEST_FILE);
   let manifest;
   try {
-    manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+    manifest = JSON.parse(await readFile2(manifestPath, "utf-8"));
   } catch {
     throw new Error(`No build to rebuild from: ${manifestPath} is missing or unreadable. Run a full build first.`);
   }
@@ -3512,8 +4809,8 @@ async function rebuildPages(options) {
       css: options.css ?? "inline"
     });
     const file = outputFor.get(name) ?? name;
-    await mkdir(dirname(join(options.dist, file)), { recursive: true });
-    await writeFile(join(options.dist, file), result.html);
+    await mkdir(dirname3(join2(options.dist, file)), { recursive: true });
+    await writeFile(join2(options.dist, file), result.html);
     rebuilt.push(file);
     if (result.content.length !== entry.content.length) {
       warn(`${name} read different content this time (${result.content.join(", ") || "none"} vs ${entry.content.join(", ")}). The manifest is stale - a full build will correct it.`);
@@ -3542,8 +4839,8 @@ async function rebuildPages(options) {
         route: { path: route.path, pattern: route.pattern, params: route.params }
       }
     });
-    const file = join(options.dist, outputFileFor(route.path));
-    await mkdir(dirname(file), { recursive: true });
+    const file = join2(options.dist, outputFileFor(route.path));
+    await mkdir(dirname3(file), { recursive: true });
     await writeFile(file, result.html);
     rebuilt.push(route.path);
     if (result.content.length && result.content.join("|") !== route.content.join("|")) {
@@ -3592,8 +4889,8 @@ async function rebuildPages(options) {
           route: { path: one.path, pattern: sample.pattern, params: one.params }
         }
       });
-      const file = join(options.dist, one.file);
-      await mkdir(dirname(file), { recursive: true });
+      const file = join2(options.dist, one.file);
+      await mkdir(dirname3(file), { recursive: true });
       await writeFile(file, result.html);
       rebuilt.push(one.path);
       added.push({ ...sample, path: one.path, params: one.params, content: result.content });
@@ -3601,7 +4898,7 @@ async function rebuildPages(options) {
     for (const path of had) {
       if (now.has(path))
         continue;
-      await rm(join(options.dist, outputFileFor(path)), { force: true });
+      await rm(join2(options.dist, outputFileFor(path)), { force: true });
       removed.push(path);
     }
   }
@@ -3616,5 +4913,6 @@ export {
   rebuildPages,
   parseRoute,
   outputFileFor,
-  matchPath
+  matchPath,
+  createFragmentRenderer
 };