@lightspeed-js/core 0.1.0

package/dist/compile.js

@@ -0,0 +1,1494 @@
+// 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/runtime/diagnostics.ts
+var PREFIX = "[lightspeed]";
+function warn(message, ...detail) {
+  console.warn(`${PREFIX} ${message}`, ...detail);
+}
+function fail(message, ...detail) {
+  console.error(`${PREFIX} ${message}`, ...detail);
+}
+
+// src/marker.ts
+var START = "lsp ";
+var END = "/lsp";
+var MARKER_END = `<!--${END}-->`;
+function serializeMarker(payload) {
+  const json = JSON.stringify(payload).replace(/-(?=-)/g, "\\u002d");
+  return `<!--${START}${json}-->`;
+}
+
+// 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/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/specifiers.ts
+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 setupSource(compiled) {
+  return `export function setup(__ctx) {
+${compiled.body}
+}`;
+}
+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/runtime/bindings/BindingEvaluator.ts
+class BindingScope {
+  instance;
+  locals;
+  cleanup;
+  constructor(instance, locals, cleanup) {
+    this.instance = instance;
+    this.locals = locals;
+    this.cleanup = cleanup;
+  }
+  get id() {
+    return this.instance.id;
+  }
+  get state() {
+    return this.instance.state;
+  }
+  get props() {
+    return this.instance.props;
+  }
+}
+var BOOLEAN_ATTRIBUTES = new Set([
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+var NO_LOCALS = [];
+var SKIP = Symbol("skip");
+var IDENTITY = (raw) => raw;
+var TO_NUMBER = (raw) => raw === "" || raw == null ? undefined : Number(raw);
+function resolveModelTarget(el) {
+  const tag = el.tagName;
+  if (tag === "SELECT")
+    return { prop: "value", event: "change", coerce: IDENTITY };
+  if (tag === "TEXTAREA")
+    return { prop: "value", event: "input", coerce: IDENTITY };
+  if (tag === "INPUT") {
+    const type = el.type;
+    if (type === "checkbox")
+      return { prop: "checked", event: "change", coerce: Boolean };
+    if (type === "radio")
+      return { prop: "value", event: "change", coerce: IDENTITY, radio: true };
+    if (type === "number" || type === "range")
+      return { prop: "value", event: "input", coerce: TO_NUMBER };
+  }
+  return { prop: "value", event: "input", coerce: IDENTITY };
+}
+
+class BindingEvaluator {
+  cells;
+  onPropChanged;
+  compiledCache = new Map;
+  writerCache = new Map;
+  constructor(cells, onPropChanged = () => {
+  }) {
+    this.cells = cells;
+    this.onPropChanged = onPropChanged;
+  }
+  expressions = new Map;
+  writers = new Map;
+  registerExpressions(expressions = {}, writers = {}) {
+    for (const [key, fn] of Object.entries(expressions)) {
+      this.expressions.set(key, fn);
+    }
+    for (const [key, fn] of Object.entries(writers)) {
+      this.writers.set(key, fn);
+    }
+  }
+  compile(expr, params) {
+    const compiled = this.expressions.get(`${params.join(",")}|${expr}`);
+    if (compiled)
+      return compiled;
+    fail(`No compiled expression for ${JSON.stringify(expr)}` + (params.length ? ` in scope [${params.join(", ")}]` : ""));
+    return () => {
+      return;
+    };
+  }
+  compileWriter(expr, params) {
+    const writer = this.writers.get(`${params.join(",")}|${expr}`);
+    if (writer)
+      return writer;
+    warn(`$model needs an assignable expression, got "${expr}" - it will render but not write back.`);
+    return () => {
+      return;
+    };
+  }
+  createBinding(el, kind, expr, attr, params = []) {
+    return { el, kind, attr, expr, compiled: this.compile(expr, params) };
+  }
+  createPropBinding(target, name, expr, params = []) {
+    return {
+      kind: "prop",
+      target,
+      name,
+      expr,
+      compiled: this.compile(expr, params)
+    };
+  }
+  bindCellProp(target, name, key) {
+    const cell = this.cells.get(key);
+    if (!cell.pending)
+      target.props[name] = cell.value;
+    target.runtimeCells.add(key);
+    const unsubscribe = cell.subscribe((value) => {
+      if (Object.is(target.props[name], value))
+        return;
+      target.props[name] = value;
+      this.onPropChanged(target);
+    });
+    target.addLogicCleanup(unsubscribe);
+  }
+  createModelBinding(el, expr, params = []) {
+    return {
+      kind: "model",
+      el,
+      expr,
+      target: resolveModelTarget(el),
+      compiled: this.compile(expr, params),
+      write: this.compileWriter(expr, params)
+    };
+  }
+  createForBinding(block, expr, params = []) {
+    return { kind: "for", block, expr, compiled: this.compile(expr, params) };
+  }
+  readProxy() {
+    return this.cells.createReadProxy();
+  }
+  pendingProbe(onRead) {
+    return (key) => {
+      onRead?.(key);
+      return this.cells.get(key).pending;
+    };
+  }
+  get cellManager() {
+    return this.cells;
+  }
+  compileExpression(expr, params = []) {
+    return this.compile(expr, params);
+  }
+  evaluate(expr, instance, locals = []) {
+    try {
+      return this.compile(expr, [])(instance.state, instance.props, this.cells.createReadProxy(), this.pendingProbe(), ...locals);
+    } catch (error) {
+      warn(`Error evaluating "${expr}" in ${instance.id}:`, error);
+      return;
+    }
+  }
+  applyBinding(binding, scope) {
+    this.apply(binding, scope);
+  }
+  updateInstance(instance) {
+    const scope = new BindingScope(instance, NO_LOCALS, instance);
+    for (const binding of instance.bindings) {
+      this.apply(binding, scope);
+    }
+    for (const block of instance.blocks) {
+      this.updateBlock(block);
+    }
+  }
+  updateRow(instance, row) {
+    const scope = new BindingScope(instance, row.locals, row);
+    for (const binding of row.bindings) {
+      this.apply(binding, scope);
+    }
+    for (const block of row.blocks) {
+      this.updateBlock(block);
+    }
+  }
+  updateBlock(block) {
+    block.rows.forEach((row) => {
+      for (let i = 0;i < block.parentLocals.length; i++) {
+        row.locals[i] = block.parentLocals[i];
+      }
+      this.updateRow(block.owner, row);
+    });
+  }
+  updateTree(instance) {
+    this.updateInstance(instance);
+    for (const child of instance.children) {
+      this.updateTree(child);
+    }
+  }
+  attachModel(binding, scope) {
+    const listener = () => {
+      const next = this.readFromDom(binding);
+      if (next === SKIP)
+        return;
+      try {
+        binding.write(scope.state, scope.props, this.cells.createReadProxy(), this.pendingProbe(), next, ...scope.locals);
+      } catch (error) {
+        warn(`Failed writing $model="${binding.expr}":`, error);
+      }
+    };
+    binding.el.addEventListener(binding.target.event, listener);
+    scope.cleanup.addCleanup(() => binding.el.removeEventListener(binding.target.event, listener));
+  }
+  readFromDom(binding) {
+    const el = binding.el;
+    if (binding.target.radio) {
+      return el.checked ? el.value : SKIP;
+    }
+    return binding.target.coerce(el[binding.target.prop]);
+  }
+  apply(binding, scope) {
+    const reads = new Set;
+    const shared = this.cells.createReadProxy((key) => reads.add(key));
+    const pending = this.pendingProbe((key) => reads.add(key));
+    let value;
+    try {
+      value = binding.compiled(scope.state, scope.props, shared, pending, ...scope.locals);
+      this.syncCellSubscriptions(binding, scope, reads);
+    } catch (error) {
+      warn(`Error evaluating "${binding.expr}" in ${scope.id}:`, error);
+      return;
+    }
+    if (binding.kind === "for") {
+      binding.block.schedule(binding.block.toItems(value));
+      return;
+    }
+    if (binding.kind === "model") {
+      this.applyModel(binding, value);
+      return;
+    }
+    if (binding.kind === "prop") {
+      const target = binding.target;
+      if (Object.is(target.props[binding.name], value))
+        return;
+      target.props[binding.name] = value;
+      this.onPropChanged(target);
+      return;
+    }
+    switch (binding.kind) {
+      case "text":
+        binding.el.textContent = value == null ? "" : String(value);
+        break;
+      case "class":
+        this.updateClasses(binding.el, value);
+        break;
+      case "show":
+        setHidden(binding.el, !value);
+        break;
+      case "html":
+        binding.el.innerHTML = value == null ? "" : String(value);
+        break;
+      case "attr": {
+        const attr = binding.attr;
+        const aria = attr.startsWith("aria-");
+        if (BOOLEAN_ATTRIBUTES.has(attr) && !aria) {
+          if (value)
+            binding.el.setAttribute(attr, "");
+          else
+            binding.el.removeAttribute(attr);
+          break;
+        }
+        if (value == null || value === false && !aria) {
+          binding.el.removeAttribute(attr);
+        } else if (aria) {
+          binding.el.setAttribute(attr, String(value));
+        } else {
+          binding.el.setAttribute(attr, value === true ? "" : String(value));
+        }
+        break;
+      }
+    }
+  }
+  applyModel(binding, value) {
+    const el = binding.el;
+    const { prop, radio, coerce } = binding.target;
+    if (radio) {
+      const shouldCheck = String(value) === el.value;
+      if (el.checked !== shouldCheck)
+        el.checked = shouldCheck;
+      return;
+    }
+    if (Object.is(coerce(el[prop]), value))
+      return;
+    if (prop === "checked") {
+      el.checked = Boolean(value);
+    } else {
+      el.value = value == null ? "" : String(value);
+    }
+  }
+  syncCellSubscriptions(binding, scope, reads) {
+    const previous = binding.cellKeys;
+    if (previous && sameKeys(previous, reads))
+      return;
+    binding.cellUnsubscribes?.forEach((unsubscribe) => unsubscribe());
+    binding.cellKeys = reads;
+    binding.cellUnsubscribes = [...reads].map((key) => this.cells.get(key).subscribe(() => this.apply(binding, scope)));
+    if (!binding.cleanupRegistered) {
+      binding.cleanupRegistered = true;
+      scope.cleanup.addCleanup(() => {
+        binding.cellUnsubscribes?.forEach((unsubscribe) => unsubscribe());
+        binding.cellUnsubscribes = [];
+        binding.cellKeys = undefined;
+      });
+    }
+  }
+  appliedClasses = new WeakMap;
+  updateClasses(element, classObj) {
+    if (typeof classObj === "string") {
+      const previous = this.appliedClasses.get(element) ?? [];
+      const next = classObj.split(/\s+/).filter(Boolean);
+      for (const name of previous) {
+        if (!next.includes(name))
+          element.classList.remove(name);
+      }
+      for (const name of next)
+        element.classList.add(name);
+      this.appliedClasses.set(element, next);
+      return;
+    }
+    if (typeof classObj === "object" && classObj !== null) {
+      Object.entries(classObj).forEach(([className, shouldAdd]) => {
+        if (shouldAdd) {
+          element.classList.add(className);
+        } else {
+          element.classList.remove(className);
+        }
+      });
+    }
+  }
+}
+function sameKeys(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const key of a)
+    if (!b.has(key))
+      return false;
+  return true;
+}
+var HIDDEN_ATTR = "data-lsp-hidden";
+function setHidden(el, hidden) {
+  if (hidden)
+    el.setAttribute(HIDDEN_ATTR, "");
+  else
+    el.removeAttribute(HIDDEN_ATTR);
+}
+// src/runtime/dom/ForBlock.ts
+function toIterable(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return value;
+  if (typeof value === "number") {
+    return Array.from({ length: Math.max(0, Math.floor(value)) }, (_, i) => i);
+  }
+  if (typeof value[Symbol.iterator] === "function")
+    return [...value];
+  if (typeof value === "object")
+    return Object.values(value);
+  return [];
+}
+var nextObjectId = 1;
+var objectIds = new WeakMap;
+function identityOf(value) {
+  if (typeof value === "symbol")
+    return value.toString();
+  if (value !== null && typeof value === "object") {
+    let id = objectIds.get(value);
+    if (id === undefined) {
+      id = nextObjectId++;
+      objectIds.set(value, id);
+    }
+    return `o${id}`;
+  }
+  return `${typeof value}:${String(value)}`;
+}
+
+class ForBlock {
+  owner;
+  anchor;
+  templates;
+  alias;
+  params;
+  parentLocals;
+  keyFor;
+  renderer;
+  conditional;
+  itemsExpr;
+  rows = new Map;
+  order = [];
+  pendingItems = null;
+  running = false;
+  warnedDuplicates = false;
+  constructor(owner, anchor, templates, alias, params, parentLocals, keyFor, renderer, conditional = false, itemsExpr = "") {
+    this.owner = owner;
+    this.anchor = anchor;
+    this.templates = templates;
+    this.alias = alias;
+    this.params = params;
+    this.parentLocals = parentLocals;
+    this.keyFor = keyFor;
+    this.renderer = renderer;
+    this.conditional = conditional;
+    this.itemsExpr = itemsExpr;
+  }
+  toItems(value) {
+    if (this.conditional) {
+      return Number.isInteger(value) && value >= 0 ? [value] : [];
+    }
+    return toIterable(value);
+  }
+  templateFor(item) {
+    return this.conditional ? this.templates[item] : this.templates[0];
+  }
+  schedule(items) {
+    this.pendingItems = items;
+    if (this.running)
+      return;
+    this.running = true;
+    this.drain();
+  }
+  async drain() {
+    try {
+      while (this.pendingItems !== null) {
+        const items = this.pendingItems;
+        this.pendingItems = null;
+        await this.reconcile(items);
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+  keysFor(items) {
+    const occurrences = new Map;
+    return items.map((item) => {
+      const locals = [...this.parentLocals, item];
+      const base = identityOf(this.keyFor ? this.keyFor(locals) : item);
+      const seen = occurrences.get(base) ?? 0;
+      occurrences.set(base, seen + 1);
+      if (seen > 0 && !this.keyFor && !this.warnedDuplicates) {
+        this.warnedDuplicates = true;
+        {
+          warn(`$for over duplicate values in "${this.alias}" - rows are matched by position among equal items. Add $key for exact identity.`);
+        }
+      }
+      return `${base}#${seen}`;
+    });
+  }
+  async reconcile(items) {
+    const keys = this.keysFor(items);
+    const next = new Map;
+    for (let i = 0;i < items.length; i++) {
+      const key = keys[i];
+      const existing = this.rows.get(key);
+      if (existing) {
+        this.rows.delete(key);
+        if (this.alias)
+          existing.item = items[i];
+        this.renderer.refreshRow(this, existing);
+        next.set(key, existing);
+      } else {
+        const row = await this.renderer.createRow(this, items[i]);
+        row.key = key;
+        next.set(key, row);
+      }
+    }
+    this.rows.forEach((row) => this.renderer.destroyRow(this, row));
+    this.rows = next;
+    this.order = keys;
+    this.position();
+  }
+  position() {
+    const parent = this.anchor.parentNode;
+    if (!parent)
+      return;
+    let reference = this.anchor;
+    for (let i = this.order.length - 1;i >= 0; i--) {
+      const row = this.rows.get(this.order[i]);
+      if (!row)
+        continue;
+      for (let j = row.nodes.length - 1;j >= 0; j--) {
+        const node = row.nodes[j];
+        if (node.nextSibling !== reference || node.parentNode !== parent) {
+          parent.insertBefore(node, reference);
+        }
+        reference = node;
+      }
+    }
+    if (parent.isConnected)
+      this.renderer.connected?.();
+  }
+  destroy() {
+    this.pendingItems = null;
+    this.rows.forEach((row) => this.renderer.destroyRow(this, row));
+    this.rows.clear();
+    this.order = [];
+    this.anchor.parentNode?.removeChild(this.anchor);
+  }
+}
+
+// src/runtime/dom/hydration.ts
+var TRIGGERS = new Set([
+  "load",
+  "idle",
+  "visible",
+  "interaction",
+  "never",
+  "always"
+]);
+
+// src/runtime/dom/Mounter.ts
+function composeBranchExpression(branches) {
+  const elseIndex = branches.findIndex((branch) => branch.condition === null);
+  let expression = elseIndex >= 0 ? String(elseIndex) : "-1";
+  for (let i = branches.length - 1;i >= 0; i--) {
+    const { condition } = branches[i];
+    if (condition === null)
+      continue;
+    expression = `((${condition}) ? ${i} : ${expression})`;
+  }
+  return expression;
+}
+
+// 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 parseForExpression(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 = parseForExpression(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/compile/index.ts
+async function compileComponents(sources, transpile = (logic) => logic, load, readStyle) {
+  const parsed = new Map(sources.map(({ id, source }) => {
+    const block = parseLSP(source, id);
+    const shares = block.styleSources.length || block.styleDeferredSources.length;
+    if (shares && !readStyle) {
+      throw new Error(`${id}: <style src="…"> needs a reader - pass one to compileComponents.`);
+    }
+    return [
+      id.toLowerCase(),
+      shares ? inlineStyleSources(block, readStyle) : block
+    ];
+  }));
+  const registry = Object.fromEntries([...parsed].map(([id, block]) => [
+    id,
+    { template: block.view, style: block.style, logic: block.logic }
+  ]));
+  const definitions = {};
+  for (const [id, block] of parsed) {
+    const scopeId = scopeIdFor(id);
+    definitions[id] = {
+      id,
+      template: transformTemplate(block.view, id, registry),
+      skeleton: block.skeleton ? transformTemplate(block.skeleton, id, registry) : "",
+      style: scopeStyles(block.style ?? "", scopeId),
+      styleDeferred: scopeStyles(block.styleDeferred ?? "", scopeId),
+      setup: await buildSetup(block.logic ?? "", { transpile, load }),
+      handlers: handlerParams(block.logic ?? ""),
+      ...buildExpressionTable([
+        ...extractExpressions(transformTemplate(block.view, id, registry), {
+          handlers: handlerParams(block.logic ?? "")
+        }),
+        ...extractExpressions(block.skeleton ? transformTemplate(block.skeleton, id, registry) : "", { handlers: handlerParams(block.logic ?? "") })
+      ]),
+      scopeId
+    };
+  }
+  return definitions;
+}
+export {
+  transformTemplate,
+  setupSource,
+  scopeStyles,
+  scopeIdFor,
+  parseLSP,
+  compileLogic,
+  compileComponents,
+  buildSetup
+};