@semi-solid/compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,2115 @@
+import {
+  VIRTUAL_LOCALE_MODULE,
+  resolveActiveLocalePath,
+  resolveLocaleFiles,
+  virtualLocaleIds
+} from "./chunk-HSIWLJX2.js";
+
+// src/plugin.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/tap-extract.ts
+import { parseSync } from "oxc-parser";
+import MagicString from "magic-string";
+
+// src/ast-utils.ts
+function isIdentifier(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "Identifier" && typeof n.name === "string";
+}
+function isStringLiteral(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "StringLiteral" && typeof n.value === "string" || n.type === "Literal" && typeof n.value === "string";
+}
+function isCallExpression(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "CallExpression" && Array.isArray(n.arguments);
+}
+function isVariableDeclarator(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "VariableDeclarator";
+}
+function isJSXElement(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXElement";
+}
+function isJSXFragment(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXFragment";
+}
+function isJSXText(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXText";
+}
+function isJSXExpressionContainer(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXExpressionContainer";
+}
+function isJSXAttribute(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXAttribute";
+}
+function isJSXIdentifier(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "JSXIdentifier" && typeof n.name === "string";
+}
+function isJSXMemberExpression(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "JSXMemberExpression";
+}
+function isReturnStatement(node) {
+  if (!node || typeof node !== "object") return false;
+  return node.type === "ReturnStatement";
+}
+function isMemberExpression(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "MemberExpression" && !!n.object && !!n.property && typeof n.computed === "boolean";
+}
+function isUnaryExpression(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return n.type === "UnaryExpression" && typeof n.operator === "string" && !!n.argument;
+}
+function isFunctionLike(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression") && Array.isArray(n.params) && !!n.body;
+}
+function unwrapTypeAssertions(node) {
+  let current = node;
+  while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function isTapCall(node) {
+  if (!isCallExpression(node)) return false;
+  if (!isIdentifier(node.callee) || node.callee.name !== "tap") return false;
+  if (node.arguments.length < 2) return false;
+  if (!isStringLiteral(node.arguments[0])) return false;
+  return true;
+}
+function isTapWhenCall(node) {
+  if (!isCallExpression(node)) return false;
+  if (!isIdentifier(node.callee) || node.callee.name !== "tapWhen") return false;
+  if (node.arguments.length < 3) return false;
+  if (!isStringLiteral(node.arguments[0])) return false;
+  return true;
+}
+function isTapPersonalizedCall(node) {
+  if (!isCallExpression(node)) return false;
+  if (!isIdentifier(node.callee) || node.callee.name !== "tapPersonalized") return false;
+  if (node.arguments.length < 3) return false;
+  if (!isStringLiteral(node.arguments[0])) return false;
+  return true;
+}
+function isTapRemoteCall(node) {
+  if (!isCallExpression(node)) return false;
+  if (!isIdentifier(node.callee) || node.callee.name !== "tapRemote") return false;
+  if (node.arguments.length < 2) return false;
+  if (!isIdentifier(node.arguments[0])) return false;
+  return true;
+}
+function walkAst(root, visitor, parent = null) {
+  if (!root || typeof root !== "object") return false;
+  const node = root;
+  if (typeof node.type !== "string") return false;
+  const result = visitor(node, parent);
+  if (result === "stop") return true;
+  for (const key of Object.keys(node)) {
+    if (key === "span" || key === "type") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && typeof item.type === "string") {
+          const stopped = walkAst(item, visitor, node);
+          if (stopped) return true;
+        }
+      }
+    } else if (child && typeof child === "object" && typeof child.type === "string") {
+      const stopped = walkAst(child, visitor, node);
+      if (stopped) return true;
+    }
+  }
+  return false;
+}
+function getJSXTagName(nameNode) {
+  if (isJSXIdentifier(nameNode)) return nameNode.name;
+  if (isJSXMemberExpression(nameNode)) {
+    const obj = getJSXTagName(nameNode.object);
+    const prop = getJSXTagName(nameNode.property);
+    if (obj && prop) return `${obj}.${prop}`;
+  }
+  return null;
+}
+function isComponentTag(tagName) {
+  return tagName.charAt(0) === tagName.charAt(0).toUpperCase() && tagName.charAt(0) !== tagName.charAt(0).toLowerCase();
+}
+function toKebabCase(name) {
+  return name.replace(
+    /([A-Z])/g,
+    (_, char, offset) => offset > 0 ? `-${char.toLowerCase()}` : char.toLowerCase()
+  ).replace(/[_\s]+/g, "-");
+}
+
+// src/tap-extract.ts
+function hasSpan(node) {
+  return typeof node.start === "number" && typeof node.end === "number";
+}
+function extractTapMappings(source, filename = "component.tsx") {
+  const { program, errors } = parseSync(filename, source);
+  const warnings = [];
+  if (errors.length > 0) {
+    for (const err of errors) {
+      warnings.push(`Parse error in ${filename}: ${err.message}`);
+    }
+  }
+  const mappings = {};
+  const reactiveVars = /* @__PURE__ */ new Set();
+  const remoteComponents = /* @__PURE__ */ new Set();
+  const personalizedCalls = [];
+  const s = new MagicString(source);
+  let inlineCounter = 0;
+  let needsTapRemoteImport = false;
+  let needsPersonalizedImport = false;
+  walkAst(program, (node) => {
+    if (isVariableDeclarator(node)) {
+      const { id, init } = node;
+      if (!init || !isIdentifier(id)) return;
+      const inner = unwrapTypeAssertions(init);
+      const isTap = isTapCall(inner);
+      const isTapWhen = !isTap && isTapWhenCall(inner);
+      const isTapPersonalized = !isTap && !isTapWhen && isTapPersonalizedCall(inner);
+      const isTapRemote = !isTap && !isTapWhen && !isTapPersonalized && isTapRemoteCall(inner);
+      if (!isTap && !isTapWhen && !isTapPersonalized && !isTapRemote) return;
+      if (isTapPersonalized) {
+        const varName2 = id.name;
+        const urlLiteral = inner.arguments[0].value;
+        const paramsNode = inner.arguments[1];
+        const fallbackNode = inner.arguments[2];
+        const params = {};
+        if (paramsNode.type === "ObjectExpression" && Array.isArray(paramsNode.properties)) {
+          for (const prop of paramsNode.properties) {
+            if (prop.type !== "Property") continue;
+            const keyNode = prop.key;
+            const valueNode = prop.value;
+            const keyName = isIdentifier(keyNode) ? keyNode.name : keyNode.value;
+            const valueName = isIdentifier(valueNode) ? valueNode.name : keyName;
+            params[keyName] = valueName;
+          }
+        }
+        personalizedCalls.push({ varName: varName2, url: urlLiteral, params });
+        needsPersonalizedImport = true;
+        if (hasSpan(paramsNode) && hasSpan(fallbackNode) && hasSpan(init)) {
+          const paramsSrc = source.slice(paramsNode.start, paramsNode.end);
+          const fallbackSrc = source.slice(fallbackNode.start, fallbackNode.end);
+          s.overwrite(
+            init.start,
+            init.end,
+            `createPersonalizedSignal(${JSON.stringify(urlLiteral)}, ${paramsSrc}, ${fallbackSrc})`
+          );
+        }
+        return;
+      }
+      if (isTapRemote) {
+        const compName = inner.arguments[0].name;
+        const urlNode = inner.arguments[1];
+        remoteComponents.add(compName);
+        needsTapRemoteImport = true;
+        if (hasSpan(urlNode) && hasSpan(init)) {
+          const kebabName = toKebabCase(compName);
+          const urlSrc = source.slice(urlNode.start, urlNode.end);
+          s.overwrite(
+            init.start,
+            init.end,
+            `__tapRemoteHtml("remote-${kebabName}", ${urlSrc})`
+          );
+        }
+        return;
+      }
+      const varName = id.name;
+      const liquidExpr = inner.arguments[0].value;
+      validateLiquidExpr(liquidExpr, varName, warnings);
+      mappings[varName] = liquidExpr;
+      if (isTap) {
+        const fallbackNode = inner.arguments[1];
+        if (hasSpan(fallbackNode) && hasSpan(init)) {
+          const fallbackSrc = source.slice(fallbackNode.start, fallbackNode.end);
+          s.overwrite(init.start, init.end, fallbackSrc);
+        }
+      } else {
+        reactiveVars.add(varName);
+        const depsNode = inner.arguments[1];
+        const fallbackNode = inner.arguments[2];
+        if (hasSpan(depsNode) && hasSpan(fallbackNode) && hasSpan(init)) {
+          const depsSrc = source.slice(depsNode.start, depsNode.end);
+          const fallbackSrc = source.slice(fallbackNode.start, fallbackNode.end);
+          s.overwrite(
+            init.start,
+            init.end,
+            `createTapSignal(${JSON.stringify(varName)}, ${depsSrc}, ${fallbackSrc})`
+          );
+        }
+      }
+      return;
+    }
+    if (isJSXExpressionContainer(node)) {
+      const expr = node.expression;
+      const inner = unwrapTypeAssertions(expr);
+      if (isTapRemoteCall(inner)) {
+        const compName = inner.arguments[0].name;
+        const urlNode = inner.arguments[1];
+        remoteComponents.add(compName);
+        needsTapRemoteImport = true;
+        if (hasSpan(urlNode) && hasSpan(expr)) {
+          const kebabName = toKebabCase(compName);
+          const urlSrc = source.slice(urlNode.start, urlNode.end);
+          s.overwrite(
+            expr.start,
+            expr.end,
+            `__tapRemoteHtml("remote-${kebabName}", ${urlSrc})`
+          );
+        }
+        return;
+      }
+      if (!isTapCall(inner)) return;
+      const liquidExpr = inner.arguments[0].value;
+      const fallbackNode = inner.arguments[1];
+      const syntheticName = `__tap_inline_${inlineCounter++}__`;
+      validateLiquidExpr(liquidExpr, "inline", warnings);
+      mappings[syntheticName] = liquidExpr;
+      if (hasSpan(fallbackNode) && hasSpan(expr)) {
+        const fallbackSrc = source.slice(fallbackNode.start, fallbackNode.end);
+        s.overwrite(expr.start, expr.end, fallbackSrc);
+      }
+    }
+  });
+  if (reactiveVars.size > 0) {
+    s.prepend(`import { createTapSignal } from '$lib/runtime';
+`);
+  }
+  if (needsPersonalizedImport) {
+    s.prepend(`import { createPersonalizedSignal } from '$lib/runtime';
+`);
+  }
+  if (needsTapRemoteImport) {
+    s.prepend(`import { __tapRemoteHtml } from '$lib/runtime';
+`);
+  }
+  const cleanedSource = s.toString();
+  const sourceMap = s.generateMap({ hires: true }).toString();
+  return { mappings, cleanedSource, sourceMap, warnings, reactiveVars, remoteComponents, personalizedCalls };
+}
+function validateLiquidExpr(expr, context, warnings) {
+  if (expr.includes("`")) {
+    warnings.push(
+      `tap() in "${context}": liquid expression contains a backtick. Use a plain string literal, not a template literal.`
+    );
+  }
+}
+
+// src/liquid-gen.ts
+import { parseSync as parseSync2 } from "oxc-parser";
+
+// src/control-flow.ts
+function resolveShowCondition(whenExpr, mappings, loopVars, warnings) {
+  if (isIdentifier(whenExpr)) {
+    const liquidStr = mappings[whenExpr.name];
+    if (liquidStr) {
+      if (hasLiquidFilters(liquidStr)) {
+        warnings?.push(
+          `<Show when={${whenExpr.name}}>: tap() expression '${liquidStr}' contains Liquid filters which are not valid in {% if %} tag context. Use a separate tap() without filters for conditions (e.g. tap('{{ product.available }}', false)). Falling back to client-side rendering.`
+        );
+        return null;
+      }
+      return { liquidExpr: stripLiquidBraces(liquidStr), negated: false };
+    }
+    if (loopVars.has(whenExpr.name)) {
+      return { liquidExpr: whenExpr.name, negated: false };
+    }
+    return null;
+  }
+  if (isUnaryExpression(whenExpr) && whenExpr.operator === "!") {
+    const inner = resolveShowCondition(whenExpr.argument, mappings, loopVars, warnings);
+    if (inner) return { liquidExpr: inner.liquidExpr, negated: !inner.negated };
+    return null;
+  }
+  const memberPath = resolveMemberPath(whenExpr, mappings, loopVars);
+  if (memberPath && memberPath.includes("|")) {
+    warnings?.push(
+      `<Show when={...}>: resolved expression '${memberPath}' contains Liquid filters which are not valid in {% if %} tag context. Falling back to client-side rendering.`
+    );
+    return null;
+  }
+  if (memberPath) return { liquidExpr: memberPath, negated: false };
+  return null;
+}
+function resolveForIteration(eachExpr, loopVarName, mappings, loopVars = /* @__PURE__ */ new Set(), warnings) {
+  if (isIdentifier(eachExpr)) {
+    const liquidStr = mappings[eachExpr.name];
+    if (!liquidStr) return null;
+    if (hasLiquidFilters(liquidStr)) {
+      warnings?.push(
+        `<For each={${eachExpr.name}}>: tap() expression '${liquidStr}' contains Liquid filters which are not valid in {% for %} tag context. Use a separate tap() without filters for collections. Falling back to client-side rendering.`
+      );
+      return null;
+    }
+    return {
+      collection: stripLiquidBraces(liquidStr),
+      loopVar: loopVarName
+    };
+  }
+  if (isMemberExpression(eachExpr)) {
+    const memberPath = resolveMemberPath(eachExpr, mappings, loopVars);
+    if (memberPath && memberPath.includes("|")) {
+      warnings?.push(
+        `<For each={...}>: resolved expression '${memberPath}' contains Liquid filters which are not valid in {% for %} tag context. Falling back to client-side rendering.`
+      );
+      return null;
+    }
+    if (memberPath) {
+      return { collection: memberPath, loopVar: loopVarName };
+    }
+  }
+  return null;
+}
+function resolveMemberPath(node, mappings, loopVars) {
+  if (isIdentifier(node)) {
+    if (loopVars.has(node.name)) return node.name;
+    if (mappings[node.name]) return stripLiquidBraces(mappings[node.name]);
+    return null;
+  }
+  if (isMemberExpression(node)) {
+    if (node.computed) return null;
+    const objPath = resolveMemberPath(node.object, mappings, loopVars);
+    if (!objPath) return null;
+    if (!isIdentifier(node.property)) return null;
+    return `${objPath}.${node.property.name}`;
+  }
+  return null;
+}
+function stripLiquidBraces(liquidStr) {
+  const trimmed = liquidStr.trim();
+  if (trimmed.startsWith("{{") && trimmed.endsWith("}}")) {
+    return trimmed.slice(2, -2).trim();
+  }
+  return trimmed;
+}
+function hasLiquidFilters(liquidStr) {
+  const bare = stripLiquidBraces(liquidStr);
+  return bare.includes("|");
+}
+
+// src/liquid-gen.ts
+var TRANSPARENT_COMPONENTS = /* @__PURE__ */ new Set([
+  "Transition",
+  "TransitionGroup",
+  "ErrorBoundary",
+  "Suspense"
+]);
+var OPAQUE_COMPONENTS = /* @__PURE__ */ new Set([
+  "Portal",
+  "Dynamic"
+]);
+function generateLiquid(source, mappings, options) {
+  const filename = `${options.componentName}.tsx`;
+  const { program, errors } = parseSync2(filename, source);
+  if (errors.length > 0) {
+    const msgs = errors.map((e) => e.message).join(", ");
+    throw new Error(`Parse errors in ${filename}: ${msgs}`);
+  }
+  let jsxRoot = null;
+  walkAst(program, (node) => {
+    if (jsxRoot) return;
+    if (isReturnStatement(node) && node.argument) {
+      let candidate = node.argument;
+      if (candidate.type === "ParenthesizedExpression" && candidate.expression) {
+        candidate = candidate.expression;
+      }
+      if (isJSXElement(candidate) || isJSXFragment(candidate)) {
+        jsxRoot = candidate;
+      }
+    }
+  });
+  if (!jsxRoot) {
+    throw new Error(
+      `No JSX return statement found in ${filename}. The component must return JSX directly from its function body.`
+    );
+  }
+  const warnings = options.warnings ?? [];
+  const ctx = {
+    mappings,
+    indent: options.indent ?? "  ",
+    source,
+    loopVars: /* @__PURE__ */ new Set(),
+    sectionComponents: options.sectionComponents ?? /* @__PURE__ */ new Set(),
+    hydration: options.dataProps != null ? {
+      componentName: options.componentName,
+      dataProps: options.dataProps,
+      dataSectionId: options.dataSectionId,
+      applied: false
+    } : null,
+    warnings
+  };
+  return renderNode(jsxRoot, ctx, 0).trim() + "\n";
+}
+function ind(ctx, depth) {
+  return ctx.indent.repeat(depth);
+}
+function withLoopVar(ctx, varName) {
+  return { ...ctx, loopVars: /* @__PURE__ */ new Set([...ctx.loopVars, varName]) };
+}
+function renderNode(node, ctx, depth) {
+  if (isJSXElement(node)) return renderElement(node, ctx, depth);
+  if (isJSXFragment(node)) return renderChildren(node.children, ctx, depth);
+  if (isJSXText(node)) return renderJSXText(node.value);
+  if (isJSXExpressionContainer(node)) {
+    return renderExpression(node.expression, ctx, depth);
+  }
+  return "";
+}
+function renderElement(element, ctx, depth) {
+  const opening = element.openingElement;
+  const tagName = getJSXTagName(opening.name);
+  if (!tagName) return `<!-- unknown tag -->`;
+  if (tagName === "Show") return renderShow(element, ctx, depth);
+  if (tagName === "For") return renderFor(element, ctx, depth);
+  if (tagName === "Match") return renderMatch(element, ctx, depth);
+  if (tagName === "Case") return `<!-- <Case> must appear inside <Match> -->`;
+  if (TRANSPARENT_COMPONENTS.has(tagName)) {
+    return renderChildren(element.children, ctx, depth);
+  }
+  if (OPAQUE_COMPONENTS.has(tagName)) {
+    return "";
+  }
+  if (isComponentTag(tagName)) {
+    return renderComponent(element, ctx, depth);
+  }
+  const attrs = renderAttributes(opening.attributes, ctx);
+  let hydrationAttrStr = "";
+  if (ctx.hydration && !ctx.hydration.applied) {
+    ctx.hydration.applied = true;
+    hydrationAttrStr = ` data-component="${ctx.hydration.componentName}" data-props='${ctx.hydration.dataProps}'`;
+    if (ctx.hydration.dataSectionId) {
+      hydrationAttrStr += ` data-section-id="${ctx.hydration.dataSectionId}"`;
+    }
+  }
+  const attrStr = (attrs.length > 0 ? " " + attrs.join(" ") : "") + hydrationAttrStr;
+  const selfClosing = !!opening.selfClosing;
+  if (selfClosing) {
+    return `${ind(ctx, depth)}<${tagName}${attrStr} />`;
+  }
+  const children = element.children;
+  if (children.length === 0) {
+    return `${ind(ctx, depth)}<${tagName}${attrStr}></${tagName}>`;
+  }
+  const renderedChildren = children.map((child) => renderNode(child, ctx, depth + 1)).filter((s) => s.trim().length > 0);
+  if (renderedChildren.length === 1 && !renderedChildren[0].includes("\n")) {
+    const child = renderedChildren[0].trim();
+    return `${ind(ctx, depth)}<${tagName}${attrStr}>${child}</${tagName}>`;
+  }
+  const childLines = renderedChildren.map(
+    (s) => s.startsWith(ind(ctx, depth + 1)) ? s : `${ind(ctx, depth + 1)}${s.trim()}`
+  ).join("\n");
+  return [
+    `${ind(ctx, depth)}<${tagName}${attrStr}>`,
+    childLines,
+    `${ind(ctx, depth)}</${tagName}>`
+  ].join("\n");
+}
+function renderShow(element, ctx, depth) {
+  const attrs = element.openingElement.attributes;
+  const whenAttr = findJSXAttr(attrs, "when");
+  const fallbackAttr = findJSXAttr(attrs, "fallback");
+  if (!whenAttr) {
+    return `<!-- <Show> missing 'when' prop -->`;
+  }
+  const whenExpr = getJSXAttrExpr(whenAttr);
+  if (!whenExpr) {
+    return `<!-- <Show> 'when' prop must be a JSX expression -->`;
+  }
+  const condition = resolveShowCondition(whenExpr, ctx.mappings, ctx.loopVars, ctx.warnings);
+  if (!condition) {
+    return `<!-- <Show> condition is not Liquid-mapped \u2014 rendered client-side -->`;
+  }
+  const tag = condition.negated ? "unless" : "if";
+  const endTag = condition.negated ? "endunless" : "endif";
+  const thenContent = renderShowChildren(element.children, ctx, depth + 1);
+  if (!fallbackAttr) {
+    return [
+      `${ind(ctx, depth)}{% ${tag} ${condition.liquidExpr} %}`,
+      thenContent,
+      `${ind(ctx, depth)}{% ${endTag} %}`
+    ].join("\n");
+  }
+  const fallbackContent = renderShowFallback(fallbackAttr, ctx, depth + 1);
+  return [
+    `${ind(ctx, depth)}{% ${tag} ${condition.liquidExpr} %}`,
+    thenContent,
+    `${ind(ctx, depth)}{% else %}`,
+    fallbackContent,
+    `${ind(ctx, depth)}{% ${endTag} %}`
+  ].join("\n");
+}
+function renderShowChildren(children, ctx, depth) {
+  const parts = [];
+  for (const child of children) {
+    if (isJSXExpressionContainer(child)) {
+      const expr = child.expression;
+      if (isFunctionLike(expr)) {
+        const body = extractFunctionBody(expr);
+        if (body) {
+          parts.push(renderNode(body, ctx, depth));
+          continue;
+        }
+      }
+    }
+    const rendered = renderNode(child, ctx, depth);
+    if (rendered.trim()) parts.push(rendered);
+  }
+  return parts.map((s) => s.startsWith(ind(ctx, depth)) ? s : `${ind(ctx, depth)}${s.trim()}`).join("\n");
+}
+function renderShowFallback(fallbackAttr, ctx, depth) {
+  const value = fallbackAttr.value;
+  if (!value) return "";
+  if (isJSXExpressionContainer(value)) {
+    const expr = value.expression;
+    if (isJSXElement(expr) || isJSXFragment(expr)) {
+      const rendered = renderNode(expr, ctx, depth);
+      return rendered.startsWith(ind(ctx, depth)) ? rendered : `${ind(ctx, depth)}${rendered.trim()}`;
+    }
+  }
+  return "";
+}
+function renderFor(element, ctx, depth) {
+  const attrs = element.openingElement.attributes;
+  const eachAttr = findJSXAttr(attrs, "each");
+  if (!eachAttr) {
+    return `<!-- <For> missing 'each' prop -->`;
+  }
+  const eachExpr = getJSXAttrExpr(eachAttr);
+  if (!eachExpr) {
+    return `<!-- <For> 'each' prop must be a JSX expression -->`;
+  }
+  const children = element.children;
+  const funcContainer = children.find(
+    (c) => isJSXExpressionContainer(c) && isFunctionLike(c.expression)
+  );
+  if (!funcContainer) {
+    return `<!-- <For> children must be a render function: {(item) => <jsx>} -->`;
+  }
+  const renderFn = funcContainer.expression;
+  const params = renderFn.params;
+  if (params.length === 0 || !isIdentifier(params[0])) {
+    return `<!-- <For> render function must have at least one identifier parameter -->`;
+  }
+  const loopVarName = params[0].name;
+  const iteration = resolveForIteration(eachExpr, loopVarName, ctx.mappings, ctx.loopVars, ctx.warnings);
+  if (!iteration) {
+    return `<!-- <For> collection is not Liquid-mapped \u2014 rendered client-side -->`;
+  }
+  const bodyJSX = extractFunctionBody(renderFn);
+  if (!bodyJSX) {
+    return `<!-- <For> could not extract JSX body from render function -->`;
+  }
+  const loopCtx = withLoopVar(ctx, iteration.loopVar);
+  const bodyContent = renderNode(bodyJSX, loopCtx, depth + 1);
+  const indentedBody = bodyContent.startsWith(ind(ctx, depth + 1)) ? bodyContent : `${ind(ctx, depth + 1)}${bodyContent.trim()}`;
+  return [
+    `${ind(ctx, depth)}{% for ${iteration.loopVar} in ${iteration.collection} %}`,
+    indentedBody,
+    `${ind(ctx, depth)}{% endfor %}`
+  ].join("\n");
+}
+function renderMatch(element, ctx, depth) {
+  const attrs = element.openingElement.attributes;
+  const onAttr = findJSXAttr(attrs, "on");
+  if (!onAttr) {
+    return `<!-- <Match> missing 'on' prop -->`;
+  }
+  const onExpr = getJSXAttrExpr(onAttr);
+  if (!onExpr) {
+    return `<!-- <Match> 'on' prop must be a JSX expression -->`;
+  }
+  let liquidPath = null;
+  const memberPath = resolveMemberPath(onExpr, ctx.mappings, ctx.loopVars);
+  if (memberPath) {
+    liquidPath = memberPath;
+  } else if (isIdentifier(onExpr)) {
+    const varName = onExpr.name;
+    if (ctx.mappings[varName]) {
+      liquidPath = stripLiquidBraces(ctx.mappings[varName]);
+    } else if (ctx.loopVars.has(varName)) {
+      liquidPath = varName;
+    }
+  }
+  if (liquidPath && liquidPath.includes("|")) {
+    ctx.warnings.push(
+      `<Match on={...}>: resolved expression '${liquidPath}' contains Liquid filters which are not valid in {% case %} tag context. Falling back to client-side rendering.`
+    );
+    liquidPath = null;
+  }
+  if (!liquidPath) {
+    return `<!-- <Match> expression is not Liquid-mapped \u2014 rendered client-side -->`;
+  }
+  const children = element.children;
+  const caseParts = [];
+  for (const child of children) {
+    if (!isJSXElement(child)) continue;
+    const caseTag = getJSXTagName(child.openingElement.name);
+    if (caseTag !== "Case") continue;
+    const caseAttrs = child.openingElement.attributes;
+    const valueAttr = findJSXAttr(caseAttrs, "value");
+    if (!valueAttr) {
+      caseParts.push(`${ind(ctx, depth + 1)}<!-- <Case> missing 'value' prop -->`);
+      continue;
+    }
+    let caseValue = null;
+    const rawValue = valueAttr.value;
+    if (rawValue) {
+      if (isStringLiteral(rawValue)) {
+        caseValue = rawValue.value;
+      } else if (isJSXExpressionContainer(rawValue)) {
+        const inner = rawValue.expression;
+        if (isStringLiteral(inner)) {
+          caseValue = inner.value;
+        }
+      }
+    }
+    if (caseValue === null) {
+      caseParts.push(`${ind(ctx, depth + 1)}<!-- <Case> 'value' must be a string literal -->`);
+      continue;
+    }
+    const caseChildren = child.children;
+    const renderedBody = caseChildren.map((c) => renderNode(c, ctx, depth + 2)).filter((s) => s.trim().length > 0);
+    const bodyLines = renderedBody.map(
+      (s) => s.startsWith(ind(ctx, depth + 2)) ? s : `${ind(ctx, depth + 2)}${s.trim()}`
+    ).join("\n");
+    caseParts.push(
+      `${ind(ctx, depth + 1)}{% when '${caseValue}' %}` + (bodyLines ? `
+${bodyLines}` : "")
+    );
+  }
+  if (caseParts.length === 0) {
+    return `${ind(ctx, depth)}{% case ${liquidPath} %}
+${ind(ctx, depth)}{% endcase %}`;
+  }
+  return [
+    `${ind(ctx, depth)}{% case ${liquidPath} %}`,
+    ...caseParts,
+    `${ind(ctx, depth)}{% endcase %}`
+  ].join("\n");
+}
+function renderComponent(element, ctx, depth) {
+  const opening = element.openingElement;
+  const tagName = getJSXTagName(opening.name);
+  const snippetName = toKebabCase(tagName);
+  const attrs = opening.attributes;
+  if (ctx.sectionComponents.has(tagName)) {
+    return `${ind(ctx, depth)}{% section '${snippetName}' %}`;
+  }
+  const params = [];
+  for (const attr of attrs) {
+    if (!isJSXAttribute(attr)) continue;
+    const nameNode = attr.name;
+    if (!isJSXIdentifier(nameNode)) continue;
+    const propName = nameNode.name;
+    if (propName.startsWith("on") || propName === "ref" || propName === "key") continue;
+    const value = attr.value;
+    if (!value) continue;
+    if (isJSXExpressionContainer(value)) {
+      const expr = value.expression;
+      const liquidExpr = exprToLiquid(expr, ctx);
+      if (liquidExpr) {
+        params.push(`${propName}: ${stripLiquidBraces(liquidExpr)}`);
+      }
+    }
+  }
+  const explicitPropNames = new Set(params.map((p) => p.split(":")[0].trim()));
+  const contextObjects = /* @__PURE__ */ new Set();
+  for (const liquidExpr of Object.values(ctx.mappings)) {
+    const m = liquidExpr.match(/\{\{\s*([a-z_]\w+)\./);
+    if (m) contextObjects.add(m[1]);
+  }
+  for (const obj of contextObjects) {
+    if (!explicitPropNames.has(obj)) {
+      params.push(`${obj}: ${obj}`);
+    }
+  }
+  if (params.length === 0) {
+    return `${ind(ctx, depth)}{% render '${snippetName}' %}`;
+  }
+  return `${ind(ctx, depth)}{% render '${snippetName}', ${params.join(", ")} %}`;
+}
+function renderAttributes(attrs, ctx) {
+  const result = [];
+  for (const attr of attrs) {
+    if (attr.type === "JSXSpreadAttribute") {
+      const arg = attr.argument;
+      if (arg && isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "blockAttrs") {
+        result.push("{{ block.shopify_attributes }}");
+      }
+      continue;
+    }
+    if (!isJSXAttribute(attr)) continue;
+    const nameNode = attr.name;
+    if (!isJSXIdentifier(nameNode)) continue;
+    const attrName = nameNode.name;
+    if (attrName.startsWith("on") || attrName === "ref" || attrName === "key" || attrName === "classList") continue;
+    const value = attr.value;
+    if (!value) {
+      result.push(attrName);
+      continue;
+    }
+    if (isStringLiteral(value)) {
+      result.push(`${attrName}="${escapeAttr(value.value)}"`);
+      continue;
+    }
+    if (isJSXExpressionContainer(value)) {
+      const expr = value.expression;
+      if (attrName === "class" && expr.type === "TemplateLiteral") {
+        const quasis = expr.quasis;
+        const staticParts = quasis.map((q) => {
+          const val = q.value;
+          return (val?.raw ?? "").trim();
+        }).filter((s) => s.length > 0).join(" ");
+        if (staticParts) {
+          result.push(`${attrName}="${escapeAttr(staticParts)}"`);
+        }
+        continue;
+      }
+      const liquidExpr = exprToLiquid(expr, ctx);
+      if (liquidExpr) {
+        result.push(`${attrName}="${sanitiseLiquidForAttr(liquidExpr)}"`);
+      }
+    }
+  }
+  return result;
+}
+function renderExpression(expr, ctx, depth) {
+  if (isFunctionLike(expr)) {
+    const body = extractFunctionBody(expr);
+    if (body) return renderNode(body, ctx, depth);
+    return "";
+  }
+  const liquid = exprToLiquid(expr, ctx);
+  return liquid ?? "";
+}
+function exprToLiquid(expr, ctx) {
+  if (isTapCall(expr)) {
+    const liquidStr = expr.arguments[0].value;
+    return ensureLiquidOutput(liquidStr);
+  }
+  if (isIdentifier(expr) && ctx.loopVars.has(expr.name)) {
+    return `{{ ${expr.name} }}`;
+  }
+  if (isIdentifier(expr) && ctx.mappings[expr.name]) {
+    return ensureLiquidOutput(ctx.mappings[expr.name]);
+  }
+  if (isMemberExpression(expr) && isIdentifier(expr.object) && expr.object.name === "props" && !expr.computed && isIdentifier(expr.property) && expr.property.name === "children") {
+    return "{{ content_for_layout }}";
+  }
+  const memberPath = resolveMemberPath(expr, ctx.mappings, ctx.loopVars);
+  if (memberPath) return `{{ ${memberPath} }}`;
+  if (isCallExpression(expr) && isIdentifier(expr.callee) && expr.callee.name === "liquidRaw" && expr.arguments.length >= 1) {
+    const arg = expr.arguments[0];
+    if (isStringLiteral(arg)) {
+      return arg.value;
+    }
+  }
+  if (isCallExpression(expr) && isIdentifier(expr.callee) && expr.callee.name === "t" && expr.arguments.length >= 1) {
+    const keyArg = expr.arguments[0];
+    if (isStringLiteral(keyArg)) {
+      return `{{ '${keyArg.value}' | t }}`;
+    }
+  }
+  if (isCallExpression(expr) && isIdentifier(expr.callee) && expr.callee.name === "filter" && expr.arguments.length >= 2) {
+    const innerExpr = expr.arguments[0];
+    const filterNameArg = expr.arguments[1];
+    if (isStringLiteral(filterNameArg)) {
+      const innerLiquid = exprToLiquid(innerExpr, ctx);
+      if (innerLiquid) {
+        const barePath = stripLiquidBraces(innerLiquid);
+        const filterName = filterNameArg.value;
+        let argStr = "";
+        if (expr.arguments.length >= 3) {
+          const argsObj = expr.arguments[2];
+          if (argsObj.type === "ObjectExpression" && Array.isArray(argsObj.properties)) {
+            const pairs = argsObj.properties.filter((p) => p.type === "ObjectProperty" || p.type === "Property").map((p) => {
+              const key = isIdentifier(p.key) ? p.key.name : isStringLiteral(p.key) ? p.key.value : null;
+              if (!key) return null;
+              const val = p.value;
+              if (val.type === "Literal" && typeof val.value === "number") {
+                return `${key}: ${val.value}`;
+              }
+              if (isStringLiteral(val)) {
+                return `${key}: '${val.value}'`;
+              }
+              return null;
+            }).filter(Boolean);
+            if (pairs.length > 0) {
+              argStr = ": " + pairs.join(", ");
+            }
+          }
+        }
+        return `{{ ${barePath} | ${filterName}${argStr} }}`;
+      }
+    }
+  }
+  return null;
+}
+function extractFunctionBody(fnNode) {
+  const body = fnNode.body;
+  if (!body) return null;
+  if (isJSXElement(body) || isJSXFragment(body)) return body;
+  if (body.type === "ParenthesizedExpression" && body.expression) {
+    const inner = body.expression;
+    if (isJSXElement(inner) || isJSXFragment(inner)) return inner;
+  }
+  if (body.type === "BlockStatement" && Array.isArray(body.body)) {
+    for (const stmt of body.body) {
+      if (isReturnStatement(stmt) && stmt.argument) {
+        let arg = stmt.argument;
+        if (arg.type === "ParenthesizedExpression" && arg.expression) {
+          arg = arg.expression;
+        }
+        if (isJSXElement(arg) || isJSXFragment(arg)) return arg;
+      }
+    }
+  }
+  return null;
+}
+function findJSXAttr(attrs, name) {
+  return attrs.find(
+    (a) => isJSXAttribute(a) && isJSXIdentifier(a.name) && a.name.name === name
+  );
+}
+function getJSXAttrExpr(attr) {
+  const value = attr.value;
+  if (!value) return null;
+  if (isJSXExpressionContainer(value)) return value.expression;
+  return null;
+}
+function ensureLiquidOutput(liquidStr) {
+  const trimmed = liquidStr.trim();
+  if (trimmed.startsWith("{{") || trimmed.startsWith("{%")) return trimmed;
+  return `{{ ${trimmed} }}`;
+}
+function sanitiseLiquidForAttr(liquidExpr) {
+  return liquidExpr.replace(/\{\{([^}]*)\}\}/g, (_, inner) => {
+    return `{{ ${inner.trim().replace(/"/g, "'")} }}`;
+  });
+}
+function renderChildren(children, ctx, depth) {
+  return children.map((child) => renderNode(child, ctx, depth)).filter((s) => s.trim().length > 0).join("\n");
+}
+function renderJSXText(raw) {
+  return raw.replace(/\s+/g, " ").trim();
+}
+function escapeAttr(value) {
+  return value.replace(/"/g, "&quot;");
+}
+
+// src/route-map.ts
+import path from "path";
+function resolveRoute(filePath, routesDir) {
+  const rel = path.relative(routesDir, filePath).replace(/\.(tsx|jsx|ts|js)$/, "");
+  const normalized = rel.replace(/\\/g, "/");
+  if (/^\+layout$/.test(normalized)) {
+    return {
+      template: "_layout",
+      outputPath: "layout/theme.liquid",
+      context: ["shop", "cart", "request"],
+      isLayout: true
+    };
+  }
+  return null;
+}
+function isRouteFile(filePath, projectRoot) {
+  const routesDir = getRoutesDir(projectRoot);
+  const normalized = filePath.replace(/\\/g, "/");
+  const normalizedRoutesDir = routesDir.replace(/\\/g, "/");
+  return normalized.startsWith(normalizedRoutesDir + "/");
+}
+function getRoutesDir(projectRoot) {
+  return path.join(projectRoot, "src", "routes");
+}
+
+// src/section-schema.ts
+import { parseSync as parseSync3 } from "oxc-parser";
+function extractSectionSchema(source) {
+  const { program, errors } = parseSync3("__schema__.tsx", source);
+  if (errors.length > 0) {
+    const msgs = errors.map((e) => e.message).join(", ");
+    throw new Error(`Parse errors while extracting schema: ${msgs}`);
+  }
+  let schemaValue = null;
+  walkAst(program, (node) => {
+    if (schemaValue) return;
+    if (node.type !== "ExportNamedDeclaration") return;
+    const decl = node.declaration;
+    if (!decl || decl.type !== "VariableDeclaration") return;
+    const declarations = decl.declarations;
+    for (const declarator of declarations) {
+      if (declarator.type !== "VariableDeclarator") continue;
+      const id = declarator.id;
+      if (id.type !== "Identifier" || id.name !== "schema") continue;
+      const init = declarator.init;
+      if (!init) continue;
+      const unwrapped = unwrapTypeAssertions(init);
+      if (unwrapped.type !== "ObjectExpression") continue;
+      schemaValue = unwrapped;
+      break;
+    }
+  });
+  if (!schemaValue) return null;
+  return evaluateAstValue(schemaValue);
+}
+function formatSchemaTag(schemaObj) {
+  return `{% schema %}
+${JSON.stringify(schemaObj, null, 2)}
+{% endschema %}
+`;
+}
+function evaluateAstValue(node) {
+  switch (node.type) {
+    // Literals (oxc native + ESTree compat)
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral": {
+      return node.value;
+    }
+    case "NullLiteral": {
+      return null;
+    }
+    case "ObjectExpression": {
+      const result = {};
+      for (const prop of node.properties) {
+        if (prop.type !== "Property" && prop.type !== "ObjectProperty") {
+          throw new Error(
+            `Unsupported property type in schema object: ${prop.type}. Only plain properties are allowed.`
+          );
+        }
+        const key = resolvePropertyKey(prop.key);
+        result[key] = evaluateAstValue(prop.value);
+      }
+      return result;
+    }
+    case "ArrayExpression": {
+      const elements = node.elements;
+      return elements.map((el) => {
+        if (!el) return null;
+        return evaluateAstValue(el);
+      });
+    }
+    case "UnaryExpression": {
+      if (node.operator === "-") {
+        const inner = evaluateAstValue(node.argument);
+        if (typeof inner !== "number") {
+          throw new Error(
+            `UnaryExpression '-' applied to non-numeric value in schema.`
+          );
+        }
+        return -inner;
+      }
+      throw new Error(
+        `Unsupported UnaryExpression operator '${node.operator}' in schema. Only '-' (negation) is supported.`
+      );
+    }
+    case "TemplateLiteral": {
+      const quasis = node.quasis;
+      const exprs = node.expressions;
+      if (exprs.length > 0) {
+        throw new Error(
+          `TemplateLiteral with expressions is not supported in schema values. Use plain string literals instead.`
+        );
+      }
+      return quasis.map((q) => q.value?.cooked ?? "").join("");
+    }
+    // TSAsExpression / TSSatisfiesExpression / TSNonNullExpression can appear
+    // when the initialiser is `{ ... } as const satisfies SomeType`. Strip them.
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression": {
+      return evaluateAstValue(unwrapTypeAssertions(node));
+    }
+    default: {
+      throw new Error(
+        `Unsupported AST node type '${node.type}' in schema value. Schema must contain only literals, objects, and arrays.`
+      );
+    }
+  }
+}
+function resolvePropertyKey(keyNode) {
+  if (keyNode.type === "Identifier") {
+    return keyNode.name;
+  }
+  if (keyNode.type === "Literal" || keyNode.type === "StringLiteral" || keyNode.type === "NumericLiteral") {
+    return String(keyNode.value);
+  }
+  throw new Error(
+    `Unsupported property key type '${keyNode.type}' in schema object.`
+  );
+}
+
+// src/hydration.ts
+import { parseSync as parseSync4 } from "oxc-parser";
+function isInteractiveComponent(source) {
+  if (/\bcreateSignal\b|\bcreateEffect\b/.test(source)) return true;
+  if (/\bon[A-Z][a-zA-Z]*\s*=\s*\{/.test(source)) return true;
+  if (/\btapWhen\b/.test(source)) return true;
+  if (/\btapRemote\b/.test(source)) return true;
+  if (/\btapPersonalized\b/.test(source)) return true;
+  return false;
+}
+function detectPropVars(source, mappings) {
+  const { program, errors } = parseSync4("component.tsx", source);
+  if (errors.length > 0) return [];
+  const handlerExprs = [];
+  walkAst(program, (node) => {
+    if (!isJSXAttribute(node)) return;
+    const nameNode = node.name;
+    if (!isJSXIdentifier(nameNode)) return;
+    const attrName = nameNode.name;
+    if (attrName.length < 3) return;
+    if (!attrName.startsWith("on")) return;
+    if (attrName[2] !== attrName[2].toUpperCase()) return;
+    const value = node.value;
+    if (value && isJSXExpressionContainer(value)) {
+      handlerExprs.push(value.expression);
+    }
+  });
+  if (handlerExprs.length === 0) return [];
+  const namedFuncNodes = /* @__PURE__ */ new Map();
+  walkAst(program, (node) => {
+    if (node.type === "FunctionDeclaration" && node.id) {
+      const name = node.id.name;
+      namedFuncNodes.set(name, node);
+      return;
+    }
+    if (node.type === "VariableDeclarator" && node.id && isIdentifier(node.id) && node.init && isFunctionLike(node.init)) {
+      const name = node.id.name;
+      namedFuncNodes.set(name, node.init);
+    }
+  });
+  const nodesToSearch = [];
+  for (const expr of handlerExprs) {
+    if (isIdentifier(expr)) {
+      const funcNode = namedFuncNodes.get(expr.name);
+      if (funcNode) nodesToSearch.push(funcNode);
+    } else if (isFunctionLike(expr)) {
+      nodesToSearch.push(expr);
+    }
+  }
+  const result = /* @__PURE__ */ new Set();
+  for (const node of nodesToSearch) {
+    walkAst(node, (n) => {
+      if (isIdentifier(n)) {
+        const name = n.name;
+        if (mappings[name]) result.add(name);
+      }
+    });
+  }
+  return [...result];
+}
+function generateDataProps(propVars, mappings) {
+  if (propVars.length === 0) return "{}";
+  const entries = propVars.map((varName) => {
+    const liquidExpr = mappings[varName];
+    const bare = stripLiquidBraces(liquidExpr);
+    return `"${varName}": ${serializeLiquidValue(bare)}`;
+  });
+  return `{ ${entries.join(", ")} }`;
+}
+function serializeLiquidValue(bare) {
+  if (/^linklists\.\S+\.links$/.test(bare)) {
+    return [
+      `[{% for _l in ${bare} %}`,
+      `{% unless forloop.first %},{% endunless %}`,
+      `{"title":{{ _l.title | json }},`,
+      `"url":{{ _l.url | json }},`,
+      `"links":[{% for _c in _l.links %}`,
+      `{% unless forloop.first %},{% endunless %}`,
+      `{"title":{{ _c.title | json }},"url":{{ _c.url | json }}}`,
+      `{% endfor %}]}`,
+      `{% endfor %}]`
+    ].join("");
+  }
+  return `{{ ${bare} | json }}`;
+}
+function generateDataSection(propVars, mappings) {
+  const entries = propVars.map((varName) => {
+    const liquidExpr = mappings[varName];
+    const bare = stripLiquidBraces(liquidExpr);
+    return `  "${varName}": ${serializeLiquidValue(bare)}`;
+  });
+  return [
+    '<script type="application/json">',
+    "{",
+    entries.join(",\n"),
+    "}",
+    "</script>",
+    ""
+  ].join("\n");
+}
+function generateHydrationEntry(components) {
+  if (components.length === 0) {
+    return "// No interactive components.\n";
+  }
+  const registryEntries = components.map((c) => `  '${c.name}': () => import('${c.importPath}'),`).join("\n");
+  return [
+    `// Generated by Semi-Solid \u2014 do not edit.`,
+    `import { render } from 'solid-js/web';`,
+    ``,
+    `const registry = {`,
+    registryEntries,
+    `};`,
+    ``,
+    `document.querySelectorAll('[data-component]').forEach(async (el) => {`,
+    `  const name = el.getAttribute('data-component');`,
+    `  if (!registry[name]) return;`,
+    `  const props = JSON.parse(el.getAttribute('data-props') || '{}');`,
+    `  const { default: Component } = await registry[name]();`,
+    `  render(() => Component(props), el);`,
+    `});`,
+    ``
+  ].join("\n");
+}
+
+// src/validation.ts
+var GLOBAL_LIQUID_OBJECTS = /* @__PURE__ */ new Set([
+  "shop",
+  "settings",
+  "request",
+  "routes",
+  "linklists",
+  "content_for_header",
+  "content_for_layout",
+  "content_for_index",
+  "pages",
+  "blogs",
+  "collections",
+  "all_products",
+  "customer",
+  "localization",
+  "predictive_search",
+  "recommendations",
+  "powered_by_link",
+  "canonical_url",
+  "section",
+  // available in section files (section.settings.*, section.blocks)
+  "block"
+  // available inside {% for block in section.blocks %}
+]);
+function extractLiquidObjects(liquidExpr) {
+  const stripped = stripLiquidBraces2(liquidExpr);
+  if (!stripped) return [];
+  const baseExpr = stripped.split("|")[0].trim();
+  if (baseExpr.startsWith("'") || baseExpr.startsWith('"')) return [];
+  const match = baseExpr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+  if (!match) return [];
+  return [match[1]];
+}
+function validateTapMappings(mappings, routeContext) {
+  const available = /* @__PURE__ */ new Set([...routeContext, ...GLOBAL_LIQUID_OBJECTS]);
+  const warnings = [];
+  for (const [variable, liquidExpr] of Object.entries(mappings)) {
+    const objects = extractLiquidObjects(liquidExpr);
+    for (const obj of objects) {
+      if (!available.has(obj)) {
+        const contextList = routeContext.length > 0 ? routeContext.join(", ") : "(none)";
+        warnings.push({
+          type: "context_mismatch",
+          message: `Variable '${variable}' uses '{{ ${obj}.* }}' which is not available in this route's Liquid context. Route context: [${contextList}]. Check that the tap() expression matches the Liquid objects for this template.`,
+          variable,
+          liquidExpr
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function validateUnusedMappings(mappings, liquidOutput) {
+  const warnings = [];
+  for (const [variable, liquidExpr] of Object.entries(mappings)) {
+    if (variable.startsWith("__tap_inline_")) continue;
+    const stripped = stripLiquidBraces2(liquidExpr);
+    const baseExpr = stripped.split("|")[0].trim();
+    if (baseExpr.startsWith("'") || baseExpr.startsWith('"')) continue;
+    if (baseExpr && !liquidOutput.includes(baseExpr)) {
+      warnings.push({
+        type: "unused_mapping",
+        message: `Variable '${variable}' was extracted from tap() but '${baseExpr}' does not appear in the generated Liquid output. It may be used only client-side (event handlers, reactive computations), which is fine \u2014 this is informational.`,
+        variable,
+        liquidExpr
+      });
+    }
+  }
+  return warnings;
+}
+function generateManifest(brand, locale, files) {
+  return {
+    brand,
+    locale,
+    templates: [...files.templates].sort(),
+    snippets: [...files.snippets].sort(),
+    sections: [...files.sections ?? []].sort(),
+    assets: [...files.assets].sort(),
+    locales: [...files.locales].sort()
+  };
+}
+function stripLiquidBraces2(s) {
+  const trimmed = s.trim();
+  if (trimmed.startsWith("{{") && trimmed.endsWith("}}")) {
+    return trimmed.slice(2, -2).trim();
+  }
+  return trimmed;
+}
+
+// src/css.ts
+import fs from "fs";
+import path2 from "path";
+function resolveCSSFiles(brand, projectRoot, existsSync = fs.existsSync) {
+  const candidates = [
+    {
+      rel: path2.join("src", "brands", brand, "theme.css"),
+      assetName: "theme.css"
+    },
+    {
+      rel: path2.join("src", "styles", "global.css"),
+      assetName: "global.css"
+    },
+    {
+      rel: path2.join("src", "index.css"),
+      assetName: "index.css"
+    }
+  ];
+  return candidates.map(({ rel, assetName }) => ({
+    src: path2.join(projectRoot, rel),
+    assetName
+  })).filter(({ src }) => existsSync(src));
+}
+function generateStylesheetTag(assetName) {
+  return `<link rel="stylesheet" href="{{ '${assetName}' | asset_url }}" media="all">`;
+}
+function generateScriptTag(assetName) {
+  return `<script src="{{ '${assetName}' | asset_url }}" type="module"></script>`;
+}
+function generatePreconnectTag(baseUrl) {
+  try {
+    const origin = new URL(baseUrl).origin;
+    return `<link rel="preconnect" href="${origin}" crossorigin>`;
+  } catch {
+    return `<link rel="preconnect" href="${baseUrl}" crossorigin>`;
+  }
+}
+function generatePrefetchScript(calls, baseUrl) {
+  if (calls.length === 0) return "";
+  const iifes = [];
+  for (const call of calls) {
+    let fullUrl;
+    if (/^https?:\/\//.test(call.url)) {
+      fullUrl = call.url;
+    } else {
+      fullUrl = baseUrl.replace(/\/$/, "") + "/" + call.url.replace(/^\//, "");
+    }
+    const sortedKeys = Object.keys(call.params).sort();
+    if (sortedKeys.length > 0) {
+      const qs = sortedKeys.map((key) => {
+        const tapVarName = call.params[key];
+        const liquidExpr = call.componentMappings[tapVarName];
+        if (!liquidExpr) {
+          return `${encodeURIComponent(key)}=`;
+        }
+        const bare = liquidExpr.replace(/^\{\{\s*/, "").replace(/\s*\}\}$/, "");
+        return `${encodeURIComponent(key)}={{ ${bare} | url_encode }}`;
+      }).join("&");
+      fullUrl += `?${qs}`;
+    }
+    iifes.push([
+      `(function() {`,
+      `  var u = "${fullUrl}";`,
+      `  window.__p[u] = fetch(u).then(function(r) { return r.json(); });`,
+      `})();`
+    ].join("\n"));
+  }
+  return [
+    "<script>",
+    "window.__p = window.__p || {};",
+    ...iifes,
+    "</script>"
+  ].join("\n");
+}
+function generateAssetIncludes(cssAssets, jsAssets, personalization) {
+  const lines = [];
+  if (personalization?.preconnect && personalization.baseUrl) {
+    lines.push(generatePreconnectTag(personalization.baseUrl));
+  }
+  lines.push(...cssAssets.map(generateStylesheetTag));
+  lines.push(...jsAssets.map(generateScriptTag));
+  if (personalization?.prefetch && personalization.calls.length > 0) {
+    lines.push(generatePrefetchScript(personalization.calls, personalization.baseUrl));
+  }
+  return lines.join("\n");
+}
+
+// src/plugin.ts
+var REQUIRED_THEME_FILES = {
+  // layout/theme.liquid is generated from src/routes/+layout.tsx.
+  // This minimal fallback ensures Shopify CLI never tries to delete the protected
+  // remote file when a build error prevents generation of the real layout.
+  "layout/theme.liquid": [
+    `<!DOCTYPE html>`,
+    `<html lang="{{ request.locale.iso_code }}">`,
+    `<head>`,
+    `  <meta charset="utf-8">`,
+    `  {{ content_for_header }}`,
+    `</head>`,
+    `<body>`,
+    `  {{ content_for_layout }}`,
+    `</body>`,
+    `</html>`,
+    ``
+  ].join("\n"),
+  // Every Shopify theme must have a gift card template.
+  "templates/gift_card.liquid": [
+    `<!DOCTYPE html>`,
+    `<html lang="{{ request.locale.iso_code }}">`,
+    `<head>`,
+    `  <meta charset="utf-8">`,
+    `  <meta name="viewport" content="width=device-width, initial-scale=1">`,
+    `  <title>{{ 'gift_cards.issued.title' | t }} \u2014 {{ shop.name }}</title>`,
+    `  {{ content_for_header }}`,
+    `  {% render 'theme-assets' %}`,
+    `</head>`,
+    `<body class="gift-card-page">`,
+    `  <header class="text-center py-8">`,
+    `    <a href="{{ shop.url }}">`,
+    `      <h1>{{ shop.name }}</h1>`,
+    `    </a>`,
+    `  </header>`,
+    `  <main class="gift-card max-w-md mx-auto px-4 text-center">`,
+    `    <h2>{{ 'gift_cards.issued.subtext' | t }}</h2>`,
+    `    {% if gift_card.enabled %}`,
+    `      <p class="gift-card__amount text-4xl font-bold my-4">{{ gift_card.initial_value | money }}</p>`,
+    `      {% if gift_card.balance != gift_card.initial_value %}`,
+    `        <p>{{ 'gift_cards.issued.remaining_html' | t: balance: gift_card.balance | money }}</p>`,
+    `      {% endif %}`,
+    `      <div class="gift-card__code my-6">`,
+    `        <input type="text" value="{{ gift_card.code | format_code }}" class="text-center border rounded px-4 py-3 w-full text-lg tracking-widest" readonly onfocus="this.select();">`,
+    `      </div>`,
+    `      {% if gift_card.pass_url %}`,
+    `        <a href="{{ gift_card.pass_url }}" class="inline-block mb-4">`,
+    `          <img src="{{ 'gift-card/add-to-apple-wallet.svg' | shopify_asset_url }}" alt="{{ 'gift_cards.issued.add_to_apple_wallet' | t }}" width="120">`,
+    `        </a>`,
+    `      {% endif %}`,
+    `      <p class="text-sm text-gray-500">{{ 'gift_cards.issued.expiry_html' | t: expires: gift_card.expires_on | date: "%B %d, %Y" }}</p>`,
+    `    {% else %}`,
+    `      <p>{{ 'gift_cards.issued.disabled' | t }}</p>`,
+    `    {% endif %}`,
+    `    <a href="{{ shop.url }}" class="inline-block mt-8 bg-primary text-white px-8 py-3 rounded">{{ 'gift_cards.issued.shop_link' | t }}</a>`,
+    `  </main>`,
+    `</body>`,
+    `</html>`,
+    ``
+  ].join("\n"),
+  // Theme settings schema — typography, layout, and colors.
+  "config/settings_schema.json": JSON.stringify(
+    [
+      {
+        name: "theme_info",
+        theme_name: "Semi-Solid",
+        theme_version: "1.0.0",
+        theme_author: "Semi-Solid",
+        theme_documentation_url: "https://github.com/CarlR100/semi-solid",
+        theme_support_url: "https://github.com/CarlR100/semi-solid"
+      },
+      {
+        name: "Colors",
+        settings: [
+          { type: "color", id: "color_primary", label: "Primary", default: "#111827" },
+          { type: "color", id: "color_secondary", label: "Secondary", default: "#6b7280" },
+          { type: "color", id: "color_background", label: "Background", default: "#ffffff" },
+          { type: "color", id: "color_text", label: "Text", default: "#111827" }
+        ]
+      },
+      {
+        name: "Typography",
+        settings: [
+          { type: "font_picker", id: "heading_font", label: "Heading font", default: "assistant_n4" },
+          { type: "font_picker", id: "body_font", label: "Body font", default: "assistant_n4" }
+        ]
+      },
+      {
+        name: "Layout",
+        settings: [
+          { type: "range", id: "page_width", label: "Page width", default: 1200, min: 1e3, max: 1600, step: 100, unit: "px" }
+        ]
+      }
+    ],
+    null,
+    2
+  ) + "\n",
+  // Theme settings data (JSONC comment header for clarity).
+  "config/settings_data.json": [
+    "// This file is auto-generated. Edit config/settings_schema.json for schema.",
+    '{ "current": {} }',
+    ""
+  ].join("\n")
+};
+function writeIfChanged(filePath, content) {
+  try {
+    if (fs2.readFileSync(filePath, "utf-8") === content) return false;
+  } catch {
+  }
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+function semiSolidPlugin(options) {
+  const { brand, locale } = options;
+  const outDir = options.outDir ?? `dist/${brand}/${locale}`;
+  let resolvedOutDir = outDir;
+  let projectRoot = process.cwd();
+  const interactiveComponents = [];
+  const interactiveComponentPaths = /* @__PURE__ */ new Map();
+  const componentCategories = /* @__PURE__ */ new Map();
+  const generatedTemplates = [];
+  const generatedSnippets = [];
+  const generatedSections = [];
+  const generatedAssets = [];
+  const sectionComponentNames = /* @__PURE__ */ new Set();
+  const remoteWrapperSections = /* @__PURE__ */ new Set();
+  const personalizedCallsCollected = [];
+  let emittedCSSAssets = [];
+  return {
+    name: "semi-solid",
+    // Run before vite-plugin-solid so we see the original JSX source, not
+    // the already-compiled Solid runtime output.
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+      resolvedOutDir = path3.isAbsolute(outDir) ? outDir : path3.resolve(projectRoot, outDir);
+    },
+    // -------------------------------------------------------------------------
+    // Pre-scan component directories so the virtual hydration-entry load() hook
+    // has the full interactive component list before any module is processed.
+    // Must run in buildStart (not configResolved) because projectRoot is set in
+    // configResolved and we need it resolved first.
+    // -------------------------------------------------------------------------
+    buildStart() {
+      interactiveComponentPaths.clear();
+      sectionComponentNames.clear();
+      remoteWrapperSections.clear();
+      generatedTemplates.length = 0;
+      generatedSnippets.length = 0;
+      generatedSections.length = 0;
+      generatedAssets.length = 0;
+      interactiveComponents.length = 0;
+      personalizedCallsCollected.length = 0;
+      componentCategories.clear();
+      const categories = ["snippets", "sections", "blocks"];
+      for (const category of categories) {
+        const scanDirs = [
+          path3.join(projectRoot, "src", category),
+          path3.join(projectRoot, "src", "brands", brand, category)
+        ];
+        for (const dir of scanDirs) {
+          if (!fs2.existsSync(dir)) continue;
+          for (const file of fs2.readdirSync(dir)) {
+            if (!/\.(tsx|jsx)$/.test(file)) continue;
+            const filePath = path3.join(dir, file);
+            try {
+              const source = fs2.readFileSync(filePath, "utf-8");
+              const name = path3.basename(file).replace(/\.(tsx|jsx)$/, "");
+              componentCategories.set(name, category);
+              if (isInteractiveComponent(source)) {
+                interactiveComponentPaths.set(name, filePath);
+              }
+              try {
+                const schema = extractSectionSchema(source);
+                if (schema !== null) {
+                  sectionComponentNames.add(name);
+                }
+              } catch {
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    },
+    // -------------------------------------------------------------------------
+    // Phase 5: virtual:semi-solid/locale — inlines the active locale JSON
+    // into the JS bundle so the runtime t() function can call setTranslations.
+    //
+    // Usage in entry modules:
+    //   import translations from 'virtual:semi-solid/locale';
+    //   import { setTranslations } from '@semi-solid/runtime';
+    //   setTranslations(translations);
+    // -------------------------------------------------------------------------
+    resolveId(id) {
+      if (id === "virtual:semi-solid/hydration-entry") return "\0virtual:semi-solid/hydration-entry";
+      if (id === virtualLocaleIds.external) return virtualLocaleIds.internal;
+      return null;
+    },
+    load(id) {
+      if (id === "\0virtual:semi-solid/hydration-entry") {
+        const componentNames = [...interactiveComponentPaths.keys()];
+        if (componentNames.length === 0) {
+          return "// No interactive components\n";
+        }
+        const personalizationLines = [];
+        if (options.personalization?.baseUrl) {
+          personalizationLines.push(
+            "import { __setPersonalizationBaseUrl } from '$lib/tapPersonalized';"
+          );
+        }
+        const lines = [
+          "import { render } from 'solid-js/web';",
+          "import { __setSectionId } from '$lib/tapWhen';",
+          "import { setTranslations } from '$lib/i18n';",
+          "import __translations from 'virtual:semi-solid/locale';",
+          ...personalizationLines,
+          ...componentNames.map((n) => {
+            const category = componentCategories.get(n) ?? "snippets";
+            return `import ${n} from '$${category}/${n}';`;
+          }),
+          "",
+          // Initialize translations before any component mounts so t() calls
+          // resolve to actual translated strings instead of raw key names.
+          "setTranslations(__translations);",
+          "",
+          // Set personalization base URL before any component mounts
+          ...options.personalization?.baseUrl ? [`__setPersonalizationBaseUrl(${JSON.stringify(options.personalization.baseUrl)});`, ""] : [],
+          "const registry = {",
+          ...componentNames.map((n) => `  '${n}': ${n},`),
+          "};",
+          "",
+          "document.querySelectorAll('[data-component]').forEach((el) => {",
+          "  const name = el.getAttribute('data-component');",
+          "  const Component = registry[name];",
+          "  if (!Component) return;",
+          "  const props = JSON.parse(el.getAttribute('data-props') || '{}');",
+          "  // Clear Liquid SSR content before mounting \u2014 SolidJS render() appends",
+          "  // rather than replaces, so without this the SSR HTML stays alongside",
+          "  // the newly mounted component, producing duplicate content.",
+          "  el.textContent = '';",
+          "  // Set the active section ID before render() so createTapSignal() can",
+          "  // capture it synchronously at component initialisation time.",
+          "  __setSectionId(el.getAttribute('data-section-id'));",
+          "  render(() => Component(props), el);",
+          "  __setSectionId(undefined);",
+          "});"
+        ];
+        return lines.join("\n") + "\n";
+      }
+      if (id !== virtualLocaleIds.internal) return null;
+      const localePath = resolveActiveLocalePath(brand, locale, projectRoot);
+      if (localePath) {
+        const json = fs2.readFileSync(localePath, "utf-8");
+        return `export default ${json};`;
+      }
+      return "export default {};";
+    },
+    // -------------------------------------------------------------------------
+    // Capture CSS assets emitted by Vite/Tailwind so buildEnd can reference
+    // the correct hashed filenames in snippets/theme-assets.liquid.
+    // -------------------------------------------------------------------------
+    generateBundle(_outputOptions, bundle) {
+      emittedCSSAssets = [];
+      for (const [fileName, asset] of Object.entries(bundle)) {
+        if (asset.type === "asset" && fileName.endsWith(".css")) {
+          emittedCSSAssets.push(fileName);
+        }
+      }
+    },
+    // -------------------------------------------------------------------------
+    // Phase 5: copy locale JSON files to dist/{brand}/{locale}/locales/
+    // Phase 6: write assets/theme.entry.js for interactive components
+    //
+    // NOTE: Must use closeBundle (not buildEnd) because CSS assets are emitted
+    // during the output generation phase (generateBundle), which runs AFTER
+    // buildEnd. closeBundle fires after all output has been written, so
+    // emittedCSSAssets is fully populated when we need it here.
+    // -------------------------------------------------------------------------
+    closeBundle() {
+      const pairs = resolveLocaleFiles(brand, locale, projectRoot, resolvedOutDir);
+      for (const { src, dest } of pairs) {
+        try {
+          fs2.mkdirSync(path3.dirname(dest), { recursive: true });
+          const localeContent = fs2.readFileSync(src, "utf-8");
+          if (writeIfChanged(dest, localeContent)) {
+            this.info(
+              `semi-solid: copied locale ${path3.basename(src)} \u2192 ${path3.relative(projectRoot, dest)}`
+            );
+          }
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to copy locale file ${src}: ${err.message}`
+          );
+        }
+      }
+      const cssAssetNames = [];
+      for (const cssPath of emittedCSSAssets) {
+        const baseName = path3.basename(cssPath);
+        cssAssetNames.push(baseName);
+        generatedAssets.push(cssPath);
+        this.info(`semi-solid: CSS asset from Vite \u2192 ${cssPath}`);
+      }
+      if (interactiveComponentPaths.size > 0) {
+        generatedAssets.push("assets/theme.entry.js");
+        this.info(
+          `semi-solid: theme.entry.js bundled by Vite (${interactiveComponentPaths.size} interactive component${interactiveComponentPaths.size === 1 ? "" : "s"})`
+        );
+      }
+      for (const sectionName of sectionComponentNames) {
+        const kebab = toKebabCase(sectionName);
+        const expectedFile = `sections/${kebab}.liquid`;
+        if (generatedSections.includes(expectedFile)) continue;
+        const brandPath = path3.join(projectRoot, "src", "brands", brand, "sections", `${sectionName}.tsx`);
+        const basePath = path3.join(projectRoot, "src", "sections", `${sectionName}.tsx`);
+        const srcPath = fs2.existsSync(brandPath) ? brandPath : basePath;
+        if (!fs2.existsSync(srcPath)) {
+          this.warn(`semi-solid: section source not found for ${sectionName}`);
+          continue;
+        }
+        try {
+          const source = fs2.readFileSync(srcPath, "utf-8");
+          const { mappings } = extractTapMappings(source, srcPath);
+          const liquidWarnings = [];
+          let liquidContent = generateLiquid(source, mappings, {
+            componentName: sectionName,
+            sectionComponents: sectionComponentNames,
+            warnings: liquidWarnings
+          });
+          for (const w of liquidWarnings) {
+            this.warn(`semi-solid: ${sectionName}: ${w}`);
+          }
+          const schema = extractSectionSchema(source);
+          if (schema !== null) {
+            liquidContent += "\n" + formatSchemaTag(schema);
+          }
+          const sectionsDir = path3.join(resolvedOutDir, "sections");
+          fs2.mkdirSync(sectionsDir, { recursive: true });
+          writeIfChanged(path3.join(sectionsDir, `${kebab}.liquid`), liquidContent);
+          generatedSections.push(expectedFile);
+          this.info(`semi-solid: wrote ${expectedFile} (section, closeBundle fallback)`);
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to compile section ${sectionName}: ${err.message}`
+          );
+        }
+      }
+      for (const [relPath, content] of Object.entries(REQUIRED_THEME_FILES)) {
+        const fullPath = path3.join(resolvedOutDir, relPath);
+        const isFallback = relPath.startsWith("layout/") || relPath.startsWith("templates/");
+        if (isFallback && fs2.existsSync(fullPath)) continue;
+        try {
+          fs2.mkdirSync(path3.dirname(fullPath), { recursive: true });
+          if (writeIfChanged(fullPath, content)) {
+            this.info(`semi-solid: wrote required file ${relPath}`);
+          }
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to write ${relPath}: ${err.message}`
+          );
+        }
+      }
+      const jsAssetNames = interactiveComponentPaths.size > 0 ? ["theme.entry.js"] : [];
+      let personalizationAssets;
+      if (options.personalization?.baseUrl && personalizedCallsCollected.length > 0) {
+        personalizationAssets = {
+          baseUrl: options.personalization.baseUrl,
+          preconnect: options.personalization.preconnect ?? true,
+          prefetch: options.personalization.prefetch ?? true,
+          calls: personalizedCallsCollected
+        };
+      }
+      const hasPersonalization = !!personalizationAssets;
+      if (cssAssetNames.length > 0 || jsAssetNames.length > 0 || hasPersonalization) {
+        const assetSnippet = generateAssetIncludes(cssAssetNames, jsAssetNames, personalizationAssets) + "\n";
+        const snippetsDir = path3.join(resolvedOutDir, "snippets");
+        try {
+          fs2.mkdirSync(snippetsDir, { recursive: true });
+          const snippetPath = path3.join(snippetsDir, "theme-assets.liquid");
+          writeIfChanged(snippetPath, assetSnippet);
+          generatedSnippets.push("snippets/theme-assets.liquid");
+          this.info(`semi-solid: wrote snippets/theme-assets.liquid`);
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to write theme-assets.liquid: ${err.message}`
+          );
+        }
+      }
+      const baseTemplatesDir = path3.join(projectRoot, "src", "templates");
+      const brandTemplatesDir = path3.join(projectRoot, "src", "brands", brand, "templates");
+      const templateFileMap = /* @__PURE__ */ new Map();
+      for (const dir of [baseTemplatesDir, brandTemplatesDir]) {
+        if (!fs2.existsSync(dir)) continue;
+        for (const file of fs2.readdirSync(dir)) {
+          if (!file.endsWith(".json")) continue;
+          templateFileMap.set(file, path3.join(dir, file));
+        }
+      }
+      if (templateFileMap.size > 0) {
+        const destDir = path3.join(resolvedOutDir, "templates");
+        fs2.mkdirSync(destDir, { recursive: true });
+        for (const [file, srcPath] of templateFileMap) {
+          const content = fs2.readFileSync(srcPath, "utf-8");
+          writeIfChanged(path3.join(destDir, file), content);
+          generatedTemplates.push(`templates/${file}`);
+          const isBrandOverride = srcPath.startsWith(brandTemplatesDir);
+          this.info(`semi-solid: copied templates/${file}${isBrandOverride ? ` (brand: ${brand})` : ""}`);
+        }
+      }
+      const baseThemeDir = path3.join(projectRoot, "src", "theme");
+      const brandThemeDir = path3.join(projectRoot, "src", "brands", brand, "theme");
+      for (const themeDir of [baseThemeDir, brandThemeDir]) {
+        if (!fs2.existsSync(themeDir)) continue;
+        const copyThemeFiles = (dir, relBase) => {
+          for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+            const srcPath = path3.join(dir, entry.name);
+            const relPath = path3.join(relBase, entry.name);
+            if (entry.isDirectory()) {
+              copyThemeFiles(srcPath, relPath);
+            } else {
+              const destPath = path3.join(resolvedOutDir, relPath);
+              if (fs2.existsSync(destPath)) continue;
+              try {
+                fs2.mkdirSync(path3.dirname(destPath), { recursive: true });
+                const content = fs2.readFileSync(srcPath, "utf-8");
+                writeIfChanged(destPath, content);
+                if (relPath.startsWith("sections")) generatedSections.push(relPath);
+                else if (relPath.startsWith("snippets")) generatedSnippets.push(relPath);
+                else if (relPath.startsWith("templates")) generatedTemplates.push(relPath);
+                this.info(`semi-solid: copied theme file ${relPath}${themeDir === brandThemeDir ? ` (brand: ${brand})` : ""}`);
+              } catch (err) {
+                this.warn(`semi-solid: failed to copy theme file ${relPath}: ${err.message}`);
+              }
+            }
+          }
+        };
+        copyThemeFiles(themeDir, "");
+      }
+      try {
+        const localeFiles = resolveLocaleFiles(brand, locale, projectRoot, resolvedOutDir).map(({ dest }) => path3.relative(resolvedOutDir, dest));
+        const manifest = generateManifest(brand, locale, {
+          templates: generatedTemplates,
+          snippets: generatedSnippets,
+          sections: generatedSections,
+          assets: generatedAssets,
+          locales: localeFiles
+        });
+        fs2.mkdirSync(resolvedOutDir, { recursive: true });
+        writeIfChanged(
+          path3.join(resolvedOutDir, "manifest.json"),
+          JSON.stringify(manifest, null, 2) + "\n"
+        );
+        this.info(`semi-solid: wrote manifest.json`);
+      } catch (err) {
+        this.warn(`semi-solid: failed to write manifest.json: ${err.message}`);
+      }
+    },
+    transform(code, id) {
+      if (!id.includes(`${path3.sep}src${path3.sep}`) && !id.includes("/src/")) {
+        return null;
+      }
+      if (!id.endsWith(".tsx") && !id.endsWith(".jsx")) {
+        return null;
+      }
+      const componentName = path3.basename(id).replace(/\.(tsx|jsx|ts|js)$/, "");
+      if (id.includes(`${path3.sep}routes${path3.sep}`) || id.includes("/routes/")) {
+        const basename = path3.basename(id).replace(/\.(tsx|jsx|ts|js)$/, "");
+        if (basename !== "+layout") return null;
+        const routesDir = getRoutesDir(projectRoot);
+        const routeInfo = resolveRoute(id, routesDir);
+        if (!routeInfo) {
+          this.warn(`semi-solid: unrecognized route file: ${id}`);
+          return null;
+        }
+        const { mappings: mappings2, cleanedSource: cleanedSource2, sourceMap: sourceMap2, warnings: warnings2 } = extractTapMappings(code, id);
+        for (const warning of warnings2) {
+          this.warn(warning);
+        }
+        for (const warn of validateTapMappings(mappings2, routeInfo.context)) {
+          this.warn(`semi-solid: ${warn.message}`);
+        }
+        const liquidWarnings = [];
+        let liquidContent2;
+        try {
+          liquidContent2 = generateLiquid(code, mappings2, {
+            componentName,
+            sectionComponents: sectionComponentNames,
+            warnings: liquidWarnings
+          });
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to generate liquid for ${id}: ${err.message}`
+          );
+          return { code: cleanedSource2, map: sourceMap2 };
+        }
+        for (const w of liquidWarnings) {
+          this.warn(`semi-solid: ${componentName}: ${w}`);
+        }
+        for (const warn of validateUnusedMappings(mappings2, liquidContent2)) {
+          this.warn(`semi-solid: ${warn.message}`);
+        }
+        const outputPath = path3.join(resolvedOutDir, routeInfo.outputPath);
+        try {
+          fs2.mkdirSync(path3.dirname(outputPath), { recursive: true });
+          writeIfChanged(outputPath, liquidContent2);
+          generatedTemplates.push(routeInfo.outputPath);
+          this.info(`semi-solid: wrote ${path3.relative(projectRoot, outputPath)}`);
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to write liquid for ${id}: ${err.message}`
+          );
+        }
+        return { code: cleanedSource2, map: sourceMap2 };
+      }
+      const { mappings, cleanedSource, sourceMap, warnings, reactiveVars, remoteComponents, personalizedCalls } = extractTapMappings(code, id);
+      for (const warning of warnings) {
+        this.warn(warning);
+      }
+      for (const call of personalizedCalls) {
+        personalizedCallsCollected.push({
+          url: call.url,
+          params: call.params,
+          componentMappings: mappings
+        });
+      }
+      for (const compName of remoteComponents) {
+        const wrapperName = `remote-${toKebabCase(compName)}`;
+        if (!remoteWrapperSections.has(wrapperName)) {
+          remoteWrapperSections.add(wrapperName);
+          const wrapperContent = `{% render '${toKebabCase(compName)}' %}
+`;
+          const sectionsDir = path3.join(resolvedOutDir, "sections");
+          try {
+            fs2.mkdirSync(sectionsDir, { recursive: true });
+            writeIfChanged(path3.join(sectionsDir, `${wrapperName}.liquid`), wrapperContent);
+            generatedSections.push(`sections/${wrapperName}.liquid`);
+            this.info(`semi-solid: wrote sections/${wrapperName}.liquid (remote wrapper)`);
+          } catch (err) {
+            this.warn(
+              `semi-solid: failed to write remote wrapper section ${wrapperName}: ${err.message}`
+            );
+          }
+        }
+      }
+      if (Object.keys(mappings).length === 0) {
+        return null;
+      }
+      const kebabName = toKebabCase(componentName);
+      let dataProps;
+      let dataSectionId;
+      if (isInteractiveComponent(code)) {
+        const propVars = Object.keys(mappings);
+        dataProps = generateDataProps(propVars, mappings);
+        interactiveComponents.push({
+          name: componentName,
+          importPath: `./${kebabName}.js`
+        });
+        if (reactiveVars.size > 0) {
+          dataSectionId = `${kebabName}-data`;
+          const dataSectionContent = generateDataSection(propVars, mappings);
+          const sectionsDir = path3.join(resolvedOutDir, "sections");
+          try {
+            fs2.mkdirSync(sectionsDir, { recursive: true });
+            const dataSectionPath = path3.join(sectionsDir, `${dataSectionId}.liquid`);
+            writeIfChanged(dataSectionPath, dataSectionContent);
+            generatedSnippets.push(`sections/${dataSectionId}.liquid`);
+            this.info(`semi-solid: wrote sections/${dataSectionId}.liquid`);
+          } catch (err) {
+            this.warn(
+              `semi-solid: failed to write data section for ${id}: ${err.message}`
+            );
+          }
+        }
+      }
+      const liquidFileName = kebabName + ".liquid";
+      const liquidWarnings2 = [];
+      let liquidContent;
+      try {
+        liquidContent = generateLiquid(code, mappings, {
+          componentName,
+          dataProps,
+          dataSectionId,
+          sectionComponents: sectionComponentNames,
+          warnings: liquidWarnings2
+        });
+      } catch (err) {
+        this.warn(
+          `semi-solid: failed to generate liquid for ${id}: ${err.message}`
+        );
+        return { code: cleanedSource, map: sourceMap };
+      }
+      for (const w of liquidWarnings2) {
+        this.warn(`semi-solid: ${componentName}: ${w}`);
+      }
+      for (const warn of validateUnusedMappings(mappings, liquidContent)) {
+        this.warn(`semi-solid: ${warn.message}`);
+      }
+      let isSection = false;
+      try {
+        const schema = extractSectionSchema(code);
+        if (schema !== null) {
+          isSection = true;
+          liquidContent += "\n" + formatSchemaTag(schema);
+          sectionComponentNames.add(componentName);
+          const sectionsDir = path3.join(resolvedOutDir, "sections");
+          fs2.mkdirSync(sectionsDir, { recursive: true });
+          const liquidPath = path3.join(sectionsDir, liquidFileName);
+          writeIfChanged(liquidPath, liquidContent);
+          generatedSections.push(`sections/${liquidFileName}`);
+          this.info(`semi-solid: wrote sections/${liquidFileName} (section)`);
+        }
+      } catch (err) {
+        this.warn(
+          `semi-solid: failed to extract/write section schema for ${id}: ${err.message}`
+        );
+      }
+      if (!isSection) {
+        const snippetsDir = path3.join(resolvedOutDir, "snippets");
+        try {
+          fs2.mkdirSync(snippetsDir, { recursive: true });
+          const liquidPath = path3.join(snippetsDir, liquidFileName);
+          writeIfChanged(liquidPath, liquidContent);
+          generatedSnippets.push(`snippets/${liquidFileName}`);
+          this.info(`semi-solid: wrote ${path3.relative(projectRoot, liquidPath)}`);
+        } catch (err) {
+          this.warn(
+            `semi-solid: failed to write liquid for ${id}: ${err.message}`
+          );
+        }
+      }
+      return {
+        code: cleanedSource,
+        map: sourceMap
+      };
+    }
+  };
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex").slice(0, 8);
+}
+function versionedName(basename, hash) {
+  const lastDot = basename.lastIndexOf(".");
+  if (lastDot === -1) return `${basename}-${hash}`;
+  return `${basename.slice(0, lastDot)}-${hash}${basename.slice(lastDot)}`;
+}
+function parseVersionedName(filename) {
+  const match = filename.match(/^(.+)-([0-9a-f]{8})(\.[^.]+)$/);
+  if (!match) return null;
+  return { name: match[1] + match[3], hash: match[2] };
+}
+
+// src/brand-resolve.ts
+import fs3 from "fs";
+import path4 from "path";
+var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var CATEGORY_PREFIXES = {
+  "$snippets/": "snippets",
+  "$sections/": "sections",
+  "$blocks/": "blocks"
+};
+function resolveCategoryBrandPath(componentPath, category, brand, projectRoot, existsSync = fs3.existsSync) {
+  const nameNoExt = componentPath.replace(/\.(tsx|jsx|ts|js)$/, "");
+  const overrideBase = path4.join(
+    projectRoot,
+    "src",
+    "brands",
+    brand,
+    category,
+    nameNoExt
+  );
+  for (const ext of EXTENSIONS) {
+    const candidate = overrideBase + ext;
+    if (existsSync(candidate)) return candidate;
+  }
+  const baseComponentBase = path4.join(
+    projectRoot,
+    "src",
+    category,
+    nameNoExt
+  );
+  for (const ext of EXTENSIONS) {
+    const candidate = baseComponentBase + ext;
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveBrandPath(componentPath, brand, projectRoot, existsSync = fs3.existsSync) {
+  for (const category of ["snippets", "sections", "blocks"]) {
+    const result = resolveCategoryBrandPath(componentPath, category, brand, projectRoot, existsSync);
+    if (result) return result;
+  }
+  return null;
+}
+function createBrandResolver(brand, projectRoot) {
+  let resolvedRoot = projectRoot ?? process.cwd();
+  return {
+    name: "semi-solid-brand-resolve",
+    configResolved(config) {
+      if (!projectRoot) {
+        resolvedRoot = config.root;
+      }
+    },
+    resolveId(source) {
+      for (const [prefix, category] of Object.entries(CATEGORY_PREFIXES)) {
+        if (source.startsWith(prefix)) {
+          const componentPath = source.slice(prefix.length);
+          return resolveCategoryBrandPath(componentPath, category, brand, resolvedRoot);
+        }
+      }
+      return null;
+    }
+  };
+}
+export {
+  GLOBAL_LIQUID_OBJECTS,
+  VIRTUAL_LOCALE_MODULE,
+  createBrandResolver,
+  detectPropVars,
+  extractLiquidObjects,
+  extractTapMappings,
+  generateAssetIncludes,
+  generateDataProps,
+  generateHydrationEntry,
+  generateLiquid,
+  generateManifest,
+  generatePreconnectTag,
+  generatePrefetchScript,
+  generateScriptTag,
+  generateStylesheetTag,
+  getRoutesDir,
+  hashContent,
+  isInteractiveComponent,
+  isRouteFile,
+  parseVersionedName,
+  resolveActiveLocalePath,
+  resolveBrandPath,
+  resolveCSSFiles,
+  resolveForIteration,
+  resolveLocaleFiles,
+  resolveMemberPath,
+  resolveRoute,
+  resolveShowCondition,
+  semiSolidPlugin,
+  stripLiquidBraces,
+  toKebabCase,
+  validateTapMappings,
+  validateUnusedMappings,
+  versionedName,
+  virtualLocaleIds
+};