@csszyx/compiler 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -0,0 +1,2706 @@
+import { init, version, transform_sz } from '@csszyx/core';
+import { t as transform, C as COLOR_PROPERTIES, P as PROPERTY_MAP, g as getCSSVariableName, a as PropertyCategory, K as KNOWN_VARIANTS, b as getVariantPrefix, c as getPropertyCategory, s as stripInvalidColorStrings } from './shared/compiler.BIUVmI0H.mjs';
+export { B as BOOLEAN_SHORTHANDS, d as PROPERTY_CATEGORY_MAP, S as SUGGESTION_MAP, i as isValidSzProp, n as normalizeClassName } from './shared/compiler.BIUVmI0H.mjs';
+import * as t from '@babel/types';
+import { createHash } from 'node:crypto';
+import * as babel from '@babel/core';
+import MagicString from 'magic-string';
+import { parseSync } from 'oxc-parser';
+
+const AST_BUDGET = 5e4;
+class ASTBudgetExceededError extends Error {
+  /**
+   * Source filename if known (set by callers via the `filename` argument
+   * to {@link transformSourceCode}). May be `undefined` when invoked
+   * with raw source strings outside a build context (e.g. tests).
+   */
+  filename;
+  /**
+   * Node count at the point traversal was aborted. Always strictly
+   * greater than {@link budget}.
+   */
+  nodeCount;
+  /**
+   * Effective budget that was exceeded. Equals the third constructor
+   * argument, the caller's `options.astBudget`, or {@link AST_BUDGET}
+   * when no override was supplied.
+   */
+  budget;
+  /**
+   *
+   * @param filename Source filename if known, otherwise `undefined`.
+   * @param nodeCount Node count at the point traversal was aborted.
+   * @param budget Effective budget that was exceeded. Defaults to
+   *   {@link AST_BUDGET} for backwards compatibility with callers that
+   *   don't pass an override.
+   */
+  constructor(filename, nodeCount, budget = AST_BUDGET) {
+    const where = filename ?? "<anonymous>";
+    super(
+      `[csszyx] AST budget exceeded: ${where} has more than ${budget} nodes (traversal aborted at ${nodeCount}). Files this large are almost always machine-generated and should be excluded from sz transformation. Either exclude the file from the plugin (Vite: \`csszyx({ exclude: [/large-data\\.ts$/] })\`), or raise the limit globally with \`csszyx({ build: { astBudgetLimit: 100_000 } })\`.`
+    );
+    this.name = "ASTBudgetExceededError";
+    this.filename = filename;
+    this.nodeCount = nodeCount;
+    this.budget = budget;
+  }
+}
+
+function generateInlineRecoveryToken(filename, line, column, elementType) {
+  const input = `${filename}:${line}:${column}:${elementType}`;
+  return createHash("sha256").update(input).digest("hex").substring(0, 12);
+}
+function isValidInlineRecoveryMode(value) {
+  return value === "csr" || value === "dev-only";
+}
+
+function transformSourceCode(source, filename, options) {
+  const astBudget = options?.astBudget ?? AST_BUDGET;
+  let usesRuntime = false;
+  let usesMerge = false;
+  let usesColorVar = false;
+  let transformed = false;
+  const collectedClasses = /* @__PURE__ */ new Set();
+  const rawClassNames = /* @__PURE__ */ new Set();
+  const diagnostics = [];
+  const recoveryTokens = /* @__PURE__ */ new Map();
+  if (!source.includes("sz")) {
+    return {
+      code: source,
+      transformed: false,
+      usesRuntime: false,
+      usesMerge: false,
+      usesColorVar: false,
+      classes: collectedClasses,
+      rawClassNames,
+      diagnostics,
+      recoveryTokens
+    };
+  }
+  try {
+    const result = babel.transformSync(source, {
+      filename: filename ?? "file.tsx",
+      // Enable TS/JSX parsing
+      ast: true,
+      code: true,
+      configFile: false,
+      babelrc: false,
+      parserOpts: {
+        plugins: ["typescript", "jsx"]
+      },
+      plugins: [
+        () => ({
+          // Budget guard runs in `pre` (before the visitor pass)
+          // so it short-circuits pathologically large files
+          // before any sz transform work begins, and doesn't
+          // interfere with the JSXAttribute handler below.
+          pre(file) {
+            let nodeCount = 0;
+            babel.traverse(file.ast, {
+              enter() {
+                nodeCount++;
+                if (nodeCount > astBudget) {
+                  throw new ASTBudgetExceededError(
+                    filename,
+                    nodeCount,
+                    astBudget
+                  );
+                }
+              }
+            });
+          },
+          visitor: {
+            JSXAttribute(path) {
+              const attrName = t.isJSXIdentifier(path.node.name) ? path.node.name.name : "";
+              if (attrName === "className" || attrName === "class") {
+                const val = path.node.value;
+                if (t.isStringLiteral(val)) {
+                  for (const c of val.value.split(/\s+/)) {
+                    if (c) {
+                      rawClassNames.add(c);
+                    }
+                  }
+                }
+                return;
+              }
+              if (attrName === "szRecover") {
+                const recoverValue = path.node.value;
+                if (!t.isStringLiteral(recoverValue)) {
+                  diagnostics.push(
+                    `[csszyx] szRecover at ${filename ?? "<anonymous>"}: only string-literal values ("csr" | "dev-only") are supported. Dynamic values disable token emission for this element.`
+                  );
+                  return;
+                }
+                if (!isValidInlineRecoveryMode(recoverValue.value)) {
+                  diagnostics.push(
+                    `[csszyx] szRecover at ${filename ?? "<anonymous>"}: unknown mode "${recoverValue.value}" \u2014 expected "csr" or "dev-only". Token emission skipped.`
+                  );
+                  return;
+                }
+                const opening = path.parentPath;
+                if (!opening?.isJSXOpeningElement()) {
+                  return;
+                }
+                const alreadyTagged = opening.node.attributes.some(
+                  (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "data-sz-recovery-token"
+                );
+                if (alreadyTagged) {
+                  return;
+                }
+                const loc = path.node.loc;
+                const elementType = t.isJSXIdentifier(opening.node.name) ? opening.node.name.name : t.isJSXMemberExpression(opening.node.name) ? "<member>" : "<unknown>";
+                const line = loc?.start.line ?? 0;
+                const column = loc?.start.column ?? 0;
+                const file = filename ?? "file.tsx";
+                const token = generateInlineRecoveryToken(
+                  file,
+                  line,
+                  column,
+                  elementType
+                );
+                opening.node.attributes.push(
+                  t.jsxAttribute(
+                    t.jsxIdentifier("data-sz-recovery-token"),
+                    t.stringLiteral(token)
+                  )
+                );
+                recoveryTokens.set(token, {
+                  mode: recoverValue.value,
+                  component: elementType,
+                  path: `${file}:${line}:${column}`
+                });
+                transformed = true;
+                return;
+              }
+              if (attrName !== "sz") {
+                return;
+              }
+              const value = path.node.value;
+              let existingClassNameNode = null;
+              let existingClassExpr = null;
+              let existingStyleNode = null;
+              let existingStyleExpr = null;
+              if (path.parentPath?.isJSXOpeningElement()) {
+                for (const attr of path.parentPath.node.attributes) {
+                  if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+                    const aName = attr.name;
+                    if (aName.name === "className" || aName.name === "class") {
+                      existingClassNameNode = attr;
+                      const aVal = attr.value;
+                      if (t.isStringLiteral(aVal)) {
+                        existingClassExpr = aVal;
+                      } else if (t.isJSXExpressionContainer(aVal)) {
+                        if (t.isExpression(aVal.expression)) {
+                          existingClassExpr = aVal.expression;
+                        }
+                      }
+                    } else if (aName.name === "style") {
+                      existingStyleNode = attr;
+                      const aVal = attr.value;
+                      if (t.isJSXExpressionContainer(aVal)) {
+                        if (t.isExpression(aVal.expression)) {
+                          existingStyleExpr = aVal.expression;
+                        }
+                      } else if (t.isStringLiteral(aVal)) {
+                        existingStyleExpr = aVal;
+                      }
+                    }
+                  }
+                }
+              }
+              const createMergedClassNameValue = (szExpr) => {
+                if (!existingClassExpr) {
+                  return t.isStringLiteral(szExpr) ? szExpr : t.jsxExpressionContainer(szExpr);
+                }
+                if (existingClassNameNode && path.parentPath?.isJSXOpeningElement()) {
+                  path.parentPath.node.attributes = path.parentPath.node.attributes.filter(
+                    (a) => a !== existingClassNameNode
+                  );
+                  existingClassNameNode = null;
+                }
+                if (t.isStringLiteral(existingClassExpr) && t.isStringLiteral(szExpr)) {
+                  const merged = `${existingClassExpr.value} ${szExpr.value}`.trim();
+                  return t.stringLiteral(merged);
+                }
+                usesRuntime = true;
+                usesMerge = true;
+                return t.jsxExpressionContainer(
+                  t.callExpression(t.identifier("_szMerge"), [
+                    existingClassExpr,
+                    szExpr
+                  ])
+                );
+              };
+              const mergeAndInjectStyle = (newStyleProps) => {
+                if (newStyleProps.length === 0) {
+                  return;
+                }
+                if (!path.parentPath?.isJSXOpeningElement()) {
+                  return;
+                }
+                if (existingStyleNode && existingStyleExpr) {
+                  path.parentPath.node.attributes = path.parentPath.node.attributes.filter(
+                    (a) => a !== existingStyleNode
+                  );
+                  existingStyleNode = null;
+                  if (t.isObjectExpression(existingStyleExpr)) {
+                    existingStyleExpr.properties.push(...newStyleProps);
+                    path.parentPath.node.attributes.push(
+                      t.jsxAttribute(
+                        t.jsxIdentifier("style"),
+                        t.jsxExpressionContainer(existingStyleExpr)
+                      )
+                    );
+                  } else if (t.isStringLiteral(existingStyleExpr)) {
+                    const parsedOldProps = parseStyleStringToObjectExpr(
+                      existingStyleExpr.value
+                    ).properties;
+                    path.parentPath.node.attributes.push(
+                      t.jsxAttribute(
+                        t.jsxIdentifier("style"),
+                        t.jsxExpressionContainer(
+                          t.objectExpression([
+                            ...parsedOldProps,
+                            ...newStyleProps
+                          ])
+                        )
+                      )
+                    );
+                  } else {
+                    const mergedStyle = t.objectExpression([
+                      t.spreadElement(existingStyleExpr),
+                      ...newStyleProps
+                    ]);
+                    path.parentPath.node.attributes.push(
+                      t.jsxAttribute(
+                        t.jsxIdentifier("style"),
+                        t.jsxExpressionContainer(mergedStyle)
+                      )
+                    );
+                  }
+                } else {
+                  path.parentPath.node.attributes.push(
+                    t.jsxAttribute(
+                      t.jsxIdentifier("style"),
+                      t.jsxExpressionContainer(
+                        t.objectExpression(newStyleProps)
+                      )
+                    )
+                  );
+                  existingStyleExpr = t.objectExpression(newStyleProps);
+                  existingStyleNode = path.parentPath.node.attributes[path.parentPath.node.attributes.length - 1];
+                }
+              };
+              if (t.isStringLiteral(value)) {
+                path.node.name.name = "className";
+                for (const c of value.value.split(/\s+/)) {
+                  if (c) {
+                    collectedClasses.add(c);
+                  }
+                }
+                path.node.value = createMergedClassNameValue(value);
+                transformed = true;
+                return;
+              }
+              if (t.isJSXExpressionContainer(value)) {
+                const expression = value.expression;
+                if (t.isObjectExpression(expression)) {
+                  const getBinding = (name) => path.scope.getBinding(name);
+                  const flatExpression = resolveObjectSpreads(expression, getBinding) ?? expression;
+                  const staticObject = evaluateStaticObject(flatExpression);
+                  if (staticObject !== null) {
+                    const { className, attributes } = transform(staticObject);
+                    for (const c of className.split(/\s+/)) {
+                      if (c) {
+                        collectedClasses.add(c);
+                      }
+                    }
+                    path.node.name.name = "className";
+                    path.node.value = createMergedClassNameValue(
+                      t.stringLiteral(className)
+                    );
+                    Object.entries(attributes).forEach(([key, val]) => {
+                      if (path.parentPath?.isJSXOpeningElement()) {
+                        if (key === "style") {
+                          const newProps = parseStyleStringToObjectExpr(
+                            val
+                          ).properties;
+                          mergeAndInjectStyle(
+                            newProps
+                          );
+                        } else {
+                          path.parentPath.node.attributes.push(
+                            t.jsxAttribute(
+                              t.jsxIdentifier(key),
+                              t.stringLiteral(val)
+                            )
+                          );
+                        }
+                      }
+                    });
+                    transformed = true;
+                    return;
+                  }
+                  const hoisted = tryHoistConditionalSpread(
+                    expression,
+                    getBinding
+                  );
+                  if (hoisted !== null) {
+                    path.node.name.name = "className";
+                    path.node.value = createMergedClassNameValue(hoisted);
+                    collectFromExpr(hoisted, collectedClasses);
+                    transformed = true;
+                    return;
+                  }
+                  const partial = evaluatePartialObject$1(flatExpression);
+                  if (partial !== null && !partial.hasSpread && (partial.dynamicProps.size > 0 || partial.conditionalClasses.length > 0)) {
+                    const staticClasses = [];
+                    if (Object.keys(partial.staticProps).length > 0) {
+                      const { className: sc } = transform(
+                        partial.staticProps
+                      );
+                      if (sc) {
+                        staticClasses.push(sc);
+                      }
+                    }
+                    const cssVarClasses = [];
+                    const styleProps = [];
+                    for (const [, info] of partial.dynamicProps) {
+                      if (!info.skipClass) {
+                        cssVarClasses.push(buildCSSVarClassName$1(info));
+                      }
+                      styleProps.push(
+                        t.objectProperty(
+                          t.stringLiteral(info.varName),
+                          generateStyleValueExpression(info)
+                        )
+                      );
+                    }
+                    const baseClasses = [
+                      ...staticClasses,
+                      ...partial.rawClasses,
+                      ...cssVarClasses
+                    ].join(" ");
+                    for (const c of baseClasses.split(/\s+/)) {
+                      if (c) {
+                        collectedClasses.add(c);
+                      }
+                    }
+                    for (const cc of partial.conditionalClasses) {
+                      for (const c of cc.consequent.split(/\s+/)) {
+                        if (c) {
+                          collectedClasses.add(c);
+                        }
+                      }
+                      for (const c of cc.alternate.split(/\s+/)) {
+                        if (c) {
+                          collectedClasses.add(c);
+                        }
+                      }
+                    }
+                    const classExpr = partial.conditionalClasses.length > 0 ? buildConditionalClassExpr(
+                      baseClasses,
+                      partial.conditionalClasses
+                    ) : t.stringLiteral(baseClasses);
+                    path.node.name.name = "className";
+                    path.node.value = createMergedClassNameValue(classExpr);
+                    mergeAndInjectStyle(styleProps);
+                    if (partial.usesColorVar) {
+                      usesColorVar = true;
+                    }
+                    transformed = true;
+                    return;
+                  }
+                }
+                if (t.isIdentifier(expression) && !t.isJSXEmptyExpression(expression)) {
+                  const binding = path.scope.getBinding(expression.name);
+                  if (binding?.path.isVariableDeclarator()) {
+                    const init = binding.path.node.init;
+                    if (init) {
+                      const gbIdent = (name) => path.scope.getBinding(name);
+                      const resolved = tryStaticTransformNode(init, gbIdent);
+                      if (resolved !== null) {
+                        path.node.name.name = "className";
+                        if (t.isStringLiteral(resolved)) {
+                          path.node.value = createMergedClassNameValue(resolved);
+                          for (const c of resolved.value.split(/\s+/)) {
+                            if (c) {
+                              collectedClasses.add(c);
+                            }
+                          }
+                        } else {
+                          path.node.value = createMergedClassNameValue(resolved);
+                          collectFromExpr(resolved, collectedClasses);
+                        }
+                        transformed = true;
+                        return;
+                      }
+                    }
+                  }
+                }
+                if (t.isConditionalExpression(expression)) {
+                  const gbCond = (name) => path.scope.getBinding(name);
+                  const resolved = tryStaticTransformNode(expression, gbCond);
+                  if (resolved !== null) {
+                    path.node.name.name = "className";
+                    if (t.isStringLiteral(resolved)) {
+                      path.node.value = createMergedClassNameValue(resolved);
+                      for (const c of resolved.value.split(/\s+/)) {
+                        if (c) {
+                          collectedClasses.add(c);
+                        }
+                      }
+                    } else {
+                      path.node.value = createMergedClassNameValue(resolved);
+                      collectFromExpr(resolved, collectedClasses);
+                    }
+                    transformed = true;
+                    return;
+                  }
+                }
+                if (t.isArrayExpression(expression)) {
+                  const parts = [];
+                  let hasRuntime = false;
+                  const getBindingForArray = (name) => path.scope.getBinding(name);
+                  for (const element of expression.elements) {
+                    if (element === null) {
+                      continue;
+                    }
+                    if (t.isBooleanLiteral(element) && !element.value) {
+                      continue;
+                    }
+                    if (t.isNullLiteral(element)) {
+                      continue;
+                    }
+                    if (t.isIdentifier(element) && element.name === "undefined") {
+                      continue;
+                    }
+                    if (t.isLogicalExpression(element) && element.operator === "&&") {
+                      const resolved2 = tryStaticTransformNode(
+                        element.right,
+                        getBindingForArray
+                      );
+                      if (resolved2 !== null && t.isStringLiteral(resolved2)) {
+                        if (resolved2.value) {
+                          parts.push(
+                            t.logicalExpression(
+                              "&&",
+                              element.left,
+                              resolved2
+                            )
+                          );
+                          for (const c of resolved2.value.split(/\s+/)) {
+                            if (c) {
+                              collectedClasses.add(c);
+                            }
+                          }
+                          hasRuntime = true;
+                        }
+                        continue;
+                      }
+                      parts.push(element);
+                      hasRuntime = true;
+                      continue;
+                    }
+                    const resolved = tryStaticTransformNode(
+                      element,
+                      getBindingForArray
+                    );
+                    if (resolved !== null) {
+                      if (t.isStringLiteral(resolved)) {
+                        if (resolved.value) {
+                          parts.push(resolved);
+                          for (const c of resolved.value.split(/\s+/)) {
+                            if (c) {
+                              collectedClasses.add(c);
+                            }
+                          }
+                        }
+                      } else {
+                        parts.push(resolved);
+                        collectFromExpr(resolved, collectedClasses);
+                        hasRuntime = true;
+                      }
+                    } else {
+                      parts.push(element);
+                      hasRuntime = true;
+                    }
+                  }
+                  path.node.name.name = "className";
+                  if (parts.length === 0) {
+                    path.node.value = createMergedClassNameValue(
+                      t.stringLiteral("")
+                    );
+                  } else if (!hasRuntime) {
+                    const merged = parts.map((p) => p.value).filter(Boolean).join(" ");
+                    path.node.value = createMergedClassNameValue(
+                      t.stringLiteral(merged)
+                    );
+                  } else {
+                    if (existingClassExpr) {
+                      parts.unshift(existingClassExpr);
+                      if (existingClassNameNode && path.parentPath?.isJSXOpeningElement()) {
+                        path.parentPath.node.attributes = path.parentPath.node.attributes.filter(
+                          (a) => a !== existingClassNameNode
+                        );
+                        existingClassNameNode = null;
+                      }
+                    }
+                    const szCall2 = t.callExpression(
+                      t.identifier("_szMerge"),
+                      parts
+                    );
+                    path.node.value = t.jsxExpressionContainer(szCall2);
+                    usesMerge = true;
+                    usesRuntime = true;
+                  }
+                  transformed = true;
+                  return;
+                }
+                const loc = expression.loc;
+                const lineCol = loc ? `${loc.start.line}:${loc.start.column + 1}` : "?";
+                let reason, suggestion;
+                if (t.isCallExpression(expression)) {
+                  const callee = expression.callee;
+                  const name = t.isIdentifier(callee) ? callee.name : t.isMemberExpression(callee) && t.isIdentifier(callee.property) ? callee.property.name : "?";
+                  reason = `function call \`${name}()\` result is unknown at build time`;
+                  suggestion = "If it returns static variants \u2192 convert to szv(). If it depends on runtime data \u2192 use dynamic().";
+                } else if (t.isIdentifier(expression)) {
+                  reason = `identifier \`${expression.name}\` could not be resolved to a static value`;
+                  suggestion = "Make sure it's a module-level or function-body const with a literal object value. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+                } else if (t.isMemberExpression(expression)) {
+                  reason = "member expression is not statically resolvable";
+                  suggestion = "Extract the value to a module-level const. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+                } else {
+                  reason = `expression of type \`${expression.type}\` is not statically analyzable`;
+                  suggestion = "Use a literal sz object or a module-level const. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+                }
+                diagnostics.push(
+                  `sz fallback at ${lineCol}: ${reason}.
+  Suggestion: ${suggestion}`
+                );
+                path.node.name.name = "className";
+                const szCall = t.callExpression(t.identifier("_sz"), [
+                  expression
+                ]);
+                path.node.value = createMergedClassNameValue(szCall);
+                usesRuntime = true;
+                transformed = true;
+              }
+            },
+            // ── szv catalog extraction ────────────────────────────────────────
+            // When the compiler sees `const X = szv({...})` with a static config,
+            // it emits a no-op catalog array so Tailwind JIT can scan all variant
+            // class strings — even when szv is called at runtime with dynamic args.
+            VariableDeclarator(path) {
+              const init = path.node.init;
+              if (!t.isCallExpression(init)) {
+                return;
+              }
+              if (!t.isIdentifier(init.callee) || init.callee.name !== "szv") {
+                return;
+              }
+              if (init.arguments.length === 0) {
+                return;
+              }
+              if (!t.isIdentifier(path.node.id)) {
+                return;
+              }
+              const configArg = init.arguments[0];
+              if (!t.isObjectExpression(configArg)) {
+                return;
+              }
+              const config = evaluateStaticObject(configArg);
+              if (!config) {
+                return;
+              }
+              const base = config.base ?? {};
+              const variants = config.variants ?? {};
+              const classStrings = [];
+              const baseResult = transform(base);
+              const baseCls = typeof baseResult === "string" ? baseResult : baseResult.className;
+              if (baseCls) {
+                classStrings.push(baseCls);
+              }
+              for (const variantValues of Object.values(variants)) {
+                for (const variantObj of Object.values(variantValues)) {
+                  if (!variantObj || typeof variantObj !== "object") {
+                    continue;
+                  }
+                  const merged = {
+                    ...base,
+                    ...variantObj
+                  };
+                  const result2 = transform(merged);
+                  const cls = typeof result2 === "string" ? result2 : result2.className;
+                  if (cls) {
+                    classStrings.push(cls);
+                  }
+                }
+              }
+              if (classStrings.length === 0) {
+                return;
+              }
+              for (const combined of classStrings) {
+                for (const c of combined.split(/\s+/)) {
+                  if (c) {
+                    collectedClasses.add(c);
+                  }
+                }
+              }
+              const catalogDecl = t.variableDeclaration("const", [
+                t.variableDeclarator(
+                  t.identifier(`_szv_catalog_${path.node.id.name}`),
+                  t.arrayExpression(classStrings.map((s) => t.stringLiteral(s)))
+                )
+              ]);
+              const parentPath = path.parentPath;
+              if (parentPath && t.isVariableDeclaration(parentPath.node)) {
+                parentPath.insertAfter(
+                  catalogDecl
+                );
+                transformed = true;
+              }
+            },
+            // ── dynamic() literal extraction ──────────────────────────────────
+            // Detects `dynamic({...})` and `dynamic(CONST_IDENTIFIER)` calls
+            // with statically-analyzable arguments and adds the resulting
+            // class tokens to collectedClasses so prescanAndWriteClasses()
+            // includes them in csszyx-classes.html for Tailwind to scan.
+            // This means dynamic() with static/const args works in Astro SSR
+            // without needing client:* directives.
+            CallExpression(path) {
+              const callee = path.node.callee;
+              if (!t.isIdentifier(callee) || callee.name !== "dynamic") {
+                return;
+              }
+              if (path.node.arguments.length === 0) {
+                return;
+              }
+              const arg = path.node.arguments[0];
+              if (t.isObjectExpression(arg)) {
+                const staticObj = evaluateStaticObject(arg);
+                if (!staticObj) {
+                  return;
+                }
+                const { className } = transform(staticObj);
+                for (const c of className.split(/\s+/)) {
+                  if (c) {
+                    collectedClasses.add(c);
+                  }
+                }
+                return;
+              }
+              let argExpr = arg;
+              while (t.isTSAsExpression(argExpr) || t.isTSSatisfiesExpression(argExpr)) {
+                argExpr = argExpr.expression;
+              }
+              if (t.isIdentifier(argExpr)) {
+                const binding = path.scope.getBinding(argExpr.name);
+                if (!binding) {
+                  return;
+                }
+                const declarator = binding.path.node;
+                if (!t.isVariableDeclarator(declarator) || !declarator.init) {
+                  return;
+                }
+                let initExpr = declarator.init;
+                while (t.isTSAsExpression(initExpr) || t.isTSSatisfiesExpression(initExpr)) {
+                  initExpr = initExpr.expression;
+                }
+                if (!t.isObjectExpression(initExpr)) {
+                  return;
+                }
+                const staticObj = evaluateStaticObject(initExpr);
+                if (!staticObj) {
+                  return;
+                }
+                const { className } = transform(staticObj);
+                for (const c of className.split(/\s+/)) {
+                  if (c) {
+                    collectedClasses.add(c);
+                  }
+                }
+              }
+            }
+          }
+        })
+      ]
+    });
+    return {
+      code: result?.code || source,
+      transformed,
+      usesRuntime,
+      usesMerge,
+      usesColorVar,
+      classes: collectedClasses,
+      rawClassNames,
+      diagnostics,
+      recoveryTokens
+    };
+  } catch (e) {
+    if (e instanceof ASTBudgetExceededError) {
+      throw e;
+    }
+    console.warn("[csszyx] AST transform failed, falling back to original code:", e);
+    return {
+      code: source,
+      transformed: false,
+      usesRuntime: false,
+      usesMerge: false,
+      usesColorVar: false,
+      classes: collectedClasses,
+      rawClassNames,
+      diagnostics,
+      recoveryTokens
+    };
+  }
+}
+function parseStyleStringToObjectExpr(styleStr) {
+  const props = styleStr.split(";").map((s) => s.trim()).filter(Boolean);
+  const objProps = [];
+  for (const prop of props) {
+    const idx = prop.indexOf(":");
+    if (idx > -1) {
+      const k = prop.slice(0, idx).trim();
+      const v = prop.slice(idx + 1).trim();
+      let keyNode;
+      if (k.startsWith("--")) {
+        keyNode = t.stringLiteral(k);
+      } else {
+        const camel = k.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        keyNode = t.identifier(camel);
+      }
+      objProps.push(t.objectProperty(keyNode, t.stringLiteral(v)));
+    }
+  }
+  return t.objectExpression(objProps);
+}
+function tryStaticTransformNode(node, getBinding) {
+  if (t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node)) {
+    return tryStaticTransformNode(node.expression, getBinding);
+  }
+  if (t.isObjectExpression(node)) {
+    const resolved = getBinding ? resolveObjectSpreads(node, getBinding) ?? node : node;
+    const staticObj = evaluateStaticObject(resolved);
+    if (staticObj !== null) {
+      const { className } = transform(staticObj);
+      return t.stringLiteral(className);
+    }
+    if (getBinding) {
+      const hoisted = tryHoistConditionalSpread(node, getBinding);
+      if (hoisted !== null) {
+        return hoisted;
+      }
+    }
+    return null;
+  }
+  if (t.isStringLiteral(node)) {
+    return node;
+  }
+  if (t.isIdentifier(node) && getBinding) {
+    const binding = getBinding(node.name);
+    if (binding?.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (init) {
+        return tryStaticTransformNode(init, getBinding);
+      }
+    }
+    return null;
+  }
+  if (t.isConditionalExpression(node)) {
+    const consequent = tryStaticTransformNode(node.consequent, getBinding);
+    const alternate = tryStaticTransformNode(node.alternate, getBinding);
+    if (consequent !== null && alternate !== null) {
+      return t.conditionalExpression(node.test, consequent, alternate);
+    }
+    return null;
+  }
+  return null;
+}
+function tryHoistConditionalSpread(node, getBinding) {
+  let conditionalSpreadIdx = -1;
+  let conditionalExpr = null;
+  for (let i = 0; i < node.properties.length; i++) {
+    const prop = node.properties[i];
+    if (!t.isSpreadElement(prop)) {
+      continue;
+    }
+    if (t.isConditionalExpression(prop.argument)) {
+      if (conditionalSpreadIdx !== -1) {
+        return null;
+      }
+      conditionalSpreadIdx = i;
+      conditionalExpr = prop.argument;
+    } else {
+      return null;
+    }
+  }
+  if (conditionalSpreadIdx === -1 || conditionalExpr === null) {
+    return null;
+  }
+  const otherProps = node.properties.filter((_, i) => i !== conditionalSpreadIdx);
+  const mkObj = (branch) => t.objectExpression([t.spreadElement(branch), ...otherProps]);
+  const resolvedA = tryStaticTransformNode(mkObj(conditionalExpr.consequent), getBinding);
+  const resolvedB = tryStaticTransformNode(mkObj(conditionalExpr.alternate), getBinding);
+  if (!resolvedA || !resolvedB) {
+    return null;
+  }
+  if (!t.isStringLiteral(resolvedA) || !t.isStringLiteral(resolvedB)) {
+    return null;
+  }
+  return t.conditionalExpression(conditionalExpr.test, resolvedA, resolvedB);
+}
+function evaluateStaticObject(node) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (!t.isObjectProperty(prop)) {
+      return null;
+    }
+    if (prop.computed) {
+      return null;
+    }
+    let key;
+    if (t.isIdentifier(prop.key)) {
+      key = prop.key.name;
+    } else if (t.isStringLiteral(prop.key)) {
+      key = prop.key.value;
+    } else if (t.isNumericLiteral(prop.key)) {
+      key = String(prop.key.value);
+    } else {
+      return null;
+    }
+    const value = prop.value;
+    if (t.isStringLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isNumericLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isBooleanLiteral(value)) {
+      result[key] = value.value;
+    } else if (t.isUnaryExpression(value) && value.operator === "-" && t.isNumericLiteral(value.argument)) {
+      result[key] = -value.argument.value;
+    } else if (t.isObjectExpression(value)) {
+      const nested = evaluateStaticObject(value);
+      if (nested === null) {
+        return null;
+      }
+      result[key] = nested;
+    } else {
+      return null;
+    }
+  }
+  return result;
+}
+function resolveObjectSpreads(node, getBinding) {
+  const newProps = [];
+  for (const prop of node.properties) {
+    if (!t.isSpreadElement(prop)) {
+      if (t.isObjectProperty(prop) && t.isObjectExpression(prop.value)) {
+        const resolvedValue = resolveObjectSpreads(prop.value, getBinding);
+        if (resolvedValue === null) {
+          return null;
+        }
+        newProps.push(
+          t.objectProperty(prop.key, resolvedValue, prop.computed, prop.shorthand)
+        );
+      } else {
+        newProps.push(prop);
+      }
+      continue;
+    }
+    const arg = prop.argument;
+    if (!t.isIdentifier(arg)) {
+      return null;
+    }
+    const binding = getBinding(arg.name);
+    if (!binding?.path.isVariableDeclarator()) {
+      return null;
+    }
+    let init = binding.path.node.init;
+    if (t.isTSAsExpression(init) || t.isTSSatisfiesExpression(init)) {
+      init = init.expression;
+    }
+    if (!t.isObjectExpression(init)) {
+      return null;
+    }
+    const inner = resolveObjectSpreads(init, getBinding);
+    if (inner === null) {
+      return null;
+    }
+    newProps.push(...inner.properties);
+  }
+  return t.objectExpression(newProps);
+}
+function extractStaticLiteralValue$1(node) {
+  if (t.isStringLiteral(node)) {
+    return node.value;
+  }
+  if (t.isNumericLiteral(node)) {
+    return node.value;
+  }
+  if (t.isBooleanLiteral(node)) {
+    return node.value;
+  }
+  if (t.isUnaryExpression(node) && node.operator === "-" && t.isNumericLiteral(node.argument)) {
+    return -node.argument.value;
+  }
+  return null;
+}
+function buildConditionalClassExpr(baseClasses, conditionalClasses) {
+  if (conditionalClasses.length === 0) {
+    return t.stringLiteral(baseClasses);
+  }
+  const makeCondExpr = (cc) => t.conditionalExpression(
+    cc.test,
+    t.stringLiteral(cc.consequent),
+    t.stringLiteral(cc.alternate)
+  );
+  if (conditionalClasses.length === 1 && !baseClasses) {
+    return makeCondExpr(conditionalClasses[0]);
+  }
+  const quasis = [];
+  const exprs = [];
+  for (let i = 0; i < conditionalClasses.length; i++) {
+    const prefix = i === 0 ? baseClasses ? `${baseClasses} ` : "" : " ";
+    quasis.push(t.templateElement({ raw: prefix, cooked: prefix }, false));
+    exprs.push(makeCondExpr(conditionalClasses[i]));
+  }
+  quasis.push(t.templateElement({ raw: "", cooked: "" }, true));
+  return t.templateLiteral(quasis, exprs);
+}
+function evaluatePartialObject$1(node, variantChain = "") {
+  const staticProps = {};
+  const dynamicProps = /* @__PURE__ */ new Map();
+  const rawClasses = [];
+  const conditionalClasses = [];
+  let usesColorVar = false;
+  for (const prop of node.properties) {
+    if (t.isSpreadElement(prop)) {
+      return null;
+    }
+    if (!t.isObjectProperty(prop)) {
+      return null;
+    }
+    if (prop.computed) {
+      return null;
+    }
+    let key;
+    if (t.isIdentifier(prop.key)) {
+      key = prop.key.name;
+    } else if (t.isStringLiteral(prop.key)) {
+      key = prop.key.value;
+    } else if (t.isNumericLiteral(prop.key)) {
+      key = String(prop.key.value);
+    } else {
+      return null;
+    }
+    const value = prop.value;
+    if (t.isStringLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isNumericLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isBooleanLiteral(value)) {
+      staticProps[key] = value.value;
+    } else if (t.isUnaryExpression(value) && value.operator === "-" && t.isNumericLiteral(value.argument)) {
+      staticProps[key] = -value.argument.value;
+    } else if (t.isObjectExpression(value)) {
+      const nested = evaluateStaticObject(value);
+      if (nested !== null) {
+        staticProps[key] = nested;
+      } else {
+        const colorObjProps = /* @__PURE__ */ new Map();
+        for (const p of value.properties) {
+          if (t.isObjectProperty(p) && !p.computed && t.isIdentifier(p.key)) {
+            colorObjProps.set(p.key.name, p);
+          }
+        }
+        if (colorObjProps.has("color") && COLOR_PROPERTIES.has(key)) {
+          const colorProp = colorObjProps.get("color");
+          if (!colorProp) {
+            continue;
+          }
+          const opProp = colorObjProps.get("op");
+          const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+          let colorStr = null;
+          if (t.isStringLiteral(colorProp.value)) {
+            colorStr = colorProp.value.value;
+          }
+          if (colorStr && opProp) {
+            const opVarName = getCSSVariableName(
+              `${key}-op`,
+              variantChain || void 0
+            );
+            const uniqueKey = variantChain ? `${variantChain}-${key}-op` : `${key}-op`;
+            if (t.isStringLiteral(opProp.value) || t.isNumericLiteral(opProp.value)) {
+              const opVal = t.isStringLiteral(opProp.value) ? opProp.value.value : opProp.value.value;
+              staticProps[key] = { color: colorStr, op: opVal };
+            } else if (t.isExpression(opProp.value)) {
+              const variantPfx = variantChain ? `${variantChain}:` : "";
+              rawClasses.push(`${variantPfx}${twPrefix}-${colorStr}/(${opVarName})`);
+              dynamicProps.set(uniqueKey, {
+                expression: opProp.value,
+                category: PropertyCategory.UNITLESS,
+                varName: opVarName,
+                twPrefix: `${twPrefix}-op`,
+                variantChain: variantChain || "",
+                skipClass: true
+              });
+            }
+          } else if (!colorStr && opProp) {
+            const varName = getCSSVariableName(key, variantChain || void 0);
+            const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+            usesColorVar = true;
+            dynamicProps.set(uniqueKey, {
+              expression: t.isExpression(colorProp.value) ? colorProp.value : t.stringLiteral(""),
+              category: PropertyCategory.COLOR,
+              varName,
+              twPrefix,
+              variantChain: variantChain || ""
+            });
+          } else if (colorStr && !opProp) {
+            staticProps[key] = colorStr;
+          }
+        } else {
+          const isVariant = KNOWN_VARIANTS.has(key) || KNOWN_VARIANTS.has(getVariantPrefix(key));
+          if (isVariant) {
+            const variantKey = variantChain ? `${variantChain}-${key}` : key;
+            const nestedResult = evaluatePartialObject$1(value, variantKey);
+            if (nestedResult === null) {
+              return null;
+            }
+            if (Object.keys(nestedResult.staticProps).length > 0) {
+              staticProps[key] = nestedResult.staticProps;
+            }
+            for (const [k, v] of nestedResult.dynamicProps) {
+              dynamicProps.set(k, v);
+            }
+            rawClasses.push(...nestedResult.rawClasses);
+            conditionalClasses.push(...nestedResult.conditionalClasses);
+            if (nestedResult.usesColorVar) {
+              usesColorVar = true;
+            }
+          } else {
+            return null;
+          }
+        }
+      }
+    } else if (t.isConditionalExpression(value)) {
+      const consVal = extractStaticLiteralValue$1(value.consequent);
+      const altVal = extractStaticLiteralValue$1(value.alternate);
+      if (consVal !== null && altVal !== null) {
+        const { className: classA } = transform({ [key]: consVal });
+        const { className: classB } = transform({ [key]: altVal });
+        const vPfx = variantChain ? `${getVariantPrefix(variantChain)}:` : "";
+        const prefixed = (cls) => vPfx ? cls.split(/\s+/).filter(Boolean).map((c) => vPfx + c).join(" ") : cls;
+        conditionalClasses.push({
+          test: value.test,
+          consequent: prefixed(classA),
+          alternate: prefixed(classB)
+        });
+      } else {
+        const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+        const category = getPropertyCategory(key);
+        const varName = getCSSVariableName(key, variantChain || void 0);
+        const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+        if (COLOR_PROPERTIES.has(key)) {
+          usesColorVar = true;
+        }
+        dynamicProps.set(uniqueKey, {
+          expression: value,
+          category,
+          varName,
+          twPrefix,
+          variantChain: variantChain || ""
+        });
+      }
+    } else if (t.isExpression(value)) {
+      const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      const category = getPropertyCategory(key);
+      const varName = getCSSVariableName(key, variantChain || void 0);
+      const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+      if (COLOR_PROPERTIES.has(key)) {
+        usesColorVar = true;
+      }
+      dynamicProps.set(uniqueKey, {
+        expression: value,
+        category,
+        varName,
+        twPrefix,
+        variantChain: variantChain || ""
+      });
+    } else {
+      return null;
+    }
+  }
+  return {
+    staticProps,
+    dynamicProps,
+    rawClasses,
+    conditionalClasses,
+    hasSpread: false,
+    usesColorVar
+  };
+}
+function generateStyleValueExpression(info) {
+  const { expression, category } = info;
+  switch (category) {
+    case PropertyCategory.SPACING:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "calc(", cooked: "calc(" }, false),
+          t.templateElement(
+            { raw: " * var(--spacing))", cooked: " * var(--spacing))" },
+            true
+          )
+        ],
+        [expression]
+      );
+    case PropertyCategory.COLOR:
+      return t.callExpression(t.identifier("__szColorVar"), [expression]);
+    case PropertyCategory.ANGLE:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "deg", cooked: "deg" }, true)
+        ],
+        [expression]
+      );
+    case PropertyCategory.DURATION:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "ms", cooked: "ms" }, true)
+        ],
+        [expression]
+      );
+    default:
+      return t.templateLiteral(
+        [
+          t.templateElement({ raw: "", cooked: "" }, false),
+          t.templateElement({ raw: "", cooked: "" }, true)
+        ],
+        [expression]
+      );
+  }
+}
+function collectFromExpr(node, classes) {
+  if (t.isStringLiteral(node)) {
+    for (const c of node.value.split(/\s+/)) {
+      if (c) {
+        classes.add(c);
+      }
+    }
+  } else if (t.isConditionalExpression(node)) {
+    collectFromExpr(node.consequent, classes);
+    collectFromExpr(node.alternate, classes);
+  }
+}
+function buildCSSVarClassName$1(info) {
+  const { twPrefix, varName, variantChain } = info;
+  const variantPrefix = variantChain ? `${getVariantPrefix(variantChain)}:` : "";
+  return `${variantPrefix}${twPrefix}-(${varName})`;
+}
+
+class CsszyxCompiler {
+  static instance;
+  wasmLoaded = false;
+  /**
+   * Private constructor to enforce singleton pattern.
+   */
+  constructor() {
+  }
+  /**
+   * Gets the singleton instance of the compiler.
+   *
+   * @returns {CsszyxCompiler} The compiler instance.
+   */
+  static getInstance() {
+    if (!CsszyxCompiler.instance) {
+      CsszyxCompiler.instance = new CsszyxCompiler();
+    }
+    return CsszyxCompiler.instance;
+  }
+  /**
+   * Initializes the WASM core.
+   *
+   * @returns {Promise<void>} Resolves when WASM is ready.
+   */
+  async init() {
+    if (this.wasmLoaded) {
+      return;
+    }
+    try {
+      init();
+      this.wasmLoaded = true;
+      console.info(`[csszyx] WASM Core initialized (v${version()})`);
+    } catch (error) {
+      console.warn(
+        "[csszyx] Failed to initialize WASM core, falling back to JavaScript transformer",
+        error
+      );
+      this.wasmLoaded = false;
+    }
+  }
+  /**
+   * Transforms an sz object into Tailwind classes.
+   *
+   * @param {SzObject} sz - The object to transform.
+   * @returns {string} The transformed class string.
+   */
+  transform(sz) {
+    if (this.wasmLoaded) {
+      const cleaned = stripInvalidColorStrings(sz);
+      try {
+        return transform_sz(cleaned);
+      } catch (error) {
+        console.warn("[csszyx] WASM transformation failed, using JS fallback", error);
+        return transform(sz).className;
+      }
+    }
+    return transform(sz).className;
+  }
+  /**
+   * Checks if the WASM core is currently active.
+   *
+   * @returns {boolean} True if WASM is loaded.
+   */
+  isWasmActive() {
+    return this.wasmLoaded;
+  }
+  /**
+   * Generates a recovery token using WASM or JS fallback.
+   *
+   * @param {object} metadata - Token metadata
+   * @param metadata.component - Component name
+   * @param metadata.filePath - File path source
+   * @param metadata.line - Line number
+   * @param metadata.column - Column number
+   * @param metadata.mode - Build mode (dev/prod)
+   * @param metadata.buildId - Unique build identifier
+   * @returns {string} The generated token
+   */
+  generateRecoveryToken(metadata) {
+    if (this.wasmLoaded) {
+      try {
+        const { generate_token } = require("@csszyx/core");
+        return generate_token(
+          metadata.component,
+          metadata.filePath,
+          metadata.line,
+          metadata.column,
+          metadata.mode,
+          metadata.buildId
+        );
+      } catch (error) {
+        console.warn("[csszyx] WASM token generation failed", error);
+      }
+    }
+    const str = `${metadata.component}:${metadata.filePath}:${metadata.line}:${metadata.column}:${metadata.mode}:${metadata.buildId}`;
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+    }
+    return Math.abs(hash).toString(16).padStart(12, "0").slice(0, 12);
+  }
+}
+
+function findLCA(nodeA, nodeB, parentMap) {
+  const ancestorsA = /* @__PURE__ */ new Set();
+  let current = nodeA;
+  while (current) {
+    ancestorsA.add(current);
+    current = parentMap.get(current);
+  }
+  current = nodeB;
+  while (current) {
+    if (ancestorsA.has(current) && t.isJSXOpeningElement(current) && current !== nodeA && current !== nodeB) {
+      return current;
+    }
+    current = parentMap.get(current);
+  }
+  return null;
+}
+function isFragment(node) {
+  if (t.isJSXIdentifier(node.name)) {
+    return node.name.name === "Fragment";
+  }
+  if (t.isJSXMemberExpression(node.name)) {
+    return t.isJSXIdentifier(node.name.property) && node.name.property.name === "Fragment";
+  }
+  return false;
+}
+function removeStyleVar(element, varName) {
+  for (const attr of element.attributes) {
+    if (!t.isJSXAttribute(attr)) {
+      continue;
+    }
+    if (!t.isJSXIdentifier(attr.name) || attr.name.name !== "style") {
+      continue;
+    }
+    if (!t.isJSXExpressionContainer(attr.value)) {
+      continue;
+    }
+    const styleObj = attr.value.expression;
+    if (!t.isObjectExpression(styleObj)) {
+      continue;
+    }
+    styleObj.properties = styleObj.properties.filter((prop) => {
+      if (!t.isObjectProperty(prop)) {
+        return true;
+      }
+      if (t.isStringLiteral(prop.key)) {
+        return prop.key.value !== varName;
+      }
+      return true;
+    });
+    if (styleObj.properties.length === 0) {
+      const idx = element.attributes.indexOf(attr);
+      if (idx !== -1) {
+        element.attributes.splice(idx, 1);
+      }
+    }
+    break;
+  }
+}
+function addStyleVar(element, varName, valueExpr) {
+  for (const attr of element.attributes) {
+    if (!t.isJSXAttribute(attr)) {
+      continue;
+    }
+    if (!t.isJSXIdentifier(attr.name) || attr.name.name !== "style") {
+      continue;
+    }
+    if (!t.isJSXExpressionContainer(attr.value)) {
+      continue;
+    }
+    const styleObj = attr.value.expression;
+    if (!t.isObjectExpression(styleObj)) {
+      continue;
+    }
+    const existing = styleObj.properties.find(
+      (prop) => t.isObjectProperty(prop) && t.isStringLiteral(prop.key) && prop.key.value === varName
+    );
+    if (!existing) {
+      styleObj.properties.push(t.objectProperty(t.stringLiteral(varName), valueExpr));
+    }
+    return;
+  }
+  element.attributes.push(
+    t.jsxAttribute(
+      t.jsxIdentifier("style"),
+      t.jsxExpressionContainer(
+        t.objectExpression([t.objectProperty(t.stringLiteral(varName), valueExpr)])
+      )
+    )
+  );
+}
+function hoistCSSVariables(usages, parentMap) {
+  if (usages.length < 2) {
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    if (usage.serializedValue === null) {
+      continue;
+    }
+    const groupKey = `${usage.varName}::${usage.serializedValue}`;
+    const group = groups.get(groupKey) || [];
+    group.push(usage);
+    groups.set(groupKey, group);
+  }
+  for (const [, group] of groups) {
+    if (group.length < 2) {
+      continue;
+    }
+    let lca = group[0].element;
+    for (let i = 1; i < group.length; i++) {
+      const newLca = findLCA(lca, group[i].element, parentMap);
+      if (newLca === null || isFragment(newLca)) {
+        lca = null;
+        break;
+      }
+      lca = newLca;
+    }
+    if (!lca) {
+      continue;
+    }
+    addStyleVar(lca, group[0].varName, group[0].valueExpr);
+    for (const usage of group) {
+      removeStyleVar(usage.element, usage.varName);
+    }
+  }
+}
+function buildParentMap(ast) {
+  const map = /* @__PURE__ */ new Map();
+  function traverse(node, parent) {
+    if (parent) {
+      map.set(node, parent);
+    }
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (value && typeof value === "object") {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (item && typeof item === "object" && "type" in item) {
+              traverse(item, node);
+            }
+          }
+        } else if ("type" in value) {
+          traverse(value, node);
+        }
+      }
+    }
+  }
+  traverse(ast);
+  return map;
+}
+
+class ManifestBuilder {
+  tokens = /* @__PURE__ */ new Map();
+  buildId;
+  /**
+   * Creates a new manifest builder.
+   *
+   * @param {string} buildId - Build ID (git hash or timestamp)
+   *
+   * @example
+   * ```typescript
+   * const builder = new ManifestBuilder('abc123');
+   * ```
+   */
+  constructor(buildId) {
+    this.buildId = buildId;
+  }
+  /**
+   * Adds a token to the manifest.
+   *
+   * @param {string} token - The recovery token
+   * @param {TokenMetadata} metadata - Token metadata
+   *
+   * @example
+   * ```typescript
+   * builder.addToken('a94f1c2e8b3d', {
+   *     mode: 'csr',
+   *     component: 'Button',
+   *     filePath: '/app/Button.tsx',
+   *     line: 10,
+   *     column: 5,
+   *     buildId: 'abc123'
+   * });
+   * ```
+   */
+  addToken(token, metadata) {
+    const relativePath = this.toRelativePath(metadata.filePath);
+    this.tokens.set(token, {
+      mode: metadata.mode,
+      component: metadata.component,
+      path: relativePath
+    });
+  }
+  /**
+   * Converts absolute path to relative path.
+   *
+   * @param {string} absolutePath - Absolute file path
+   * @returns {string} Relative path
+   */
+  toRelativePath(absolutePath) {
+    if (absolutePath.startsWith("/")) {
+      const parts = absolutePath.split("/");
+      const rootIndex = parts.findIndex(
+        (p) => p === "src" || p === "app" || p === "components"
+      );
+      if (rootIndex > 0) {
+        return parts.slice(rootIndex).join("/");
+      }
+    }
+    return absolutePath;
+  }
+  /**
+   * Computes checksum of the tokens object.
+   *
+   * @param {Record<string, TokenData>} tokens - Tokens object
+   * @returns {string} SHA-256 checksum
+   */
+  computeChecksum(tokens) {
+    const sortedKeys = Object.keys(tokens).sort();
+    const sortedTokens = {};
+    for (const key of sortedKeys) {
+      sortedTokens[key] = tokens[key];
+    }
+    const content = JSON.stringify(sortedTokens);
+    return createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Builds the final recovery manifest.
+   *
+   * @returns {RecoveryManifest} The complete recovery manifest
+   *
+   * @example
+   * ```typescript
+   * const manifest = builder.build();
+   * // Returns: { buildId: 'abc123', checksum: '...', tokens: {...} }
+   * ```
+   */
+  build() {
+    const tokensObject = {};
+    for (const [token, data] of this.tokens.entries()) {
+      tokensObject[token] = data;
+    }
+    const checksum = this.computeChecksum(tokensObject);
+    return {
+      buildId: this.buildId,
+      checksum,
+      tokens: tokensObject
+    };
+  }
+  /**
+   * Gets the number of tokens in the manifest.
+   *
+   * @returns {number} Token count
+   */
+  size() {
+    return this.tokens.size;
+  }
+  /**
+   * Checks if a token exists in the manifest.
+   *
+   * @param {string} token - Token to check
+   * @returns {boolean} True if token exists
+   */
+  hasToken(token) {
+    return this.tokens.has(token);
+  }
+  /**
+   * Clears all tokens from the manifest.
+   */
+  clear() {
+    this.tokens.clear();
+  }
+}
+function serializeManifest(manifest, pretty = false) {
+  return JSON.stringify(manifest, null, pretty ? 2 : 0);
+}
+function parseManifest(json) {
+  const parsed = JSON.parse(json);
+  if (!parsed.buildId || !parsed.checksum || !parsed.tokens) {
+    throw new Error("Invalid recovery manifest format");
+  }
+  return parsed;
+}
+function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, error: "Manifest must be an object" };
+  }
+  const m = manifest;
+  if (typeof m.buildId !== "string") {
+    return { valid: false, error: "buildId must be a string" };
+  }
+  if (typeof m.checksum !== "string") {
+    return { valid: false, error: "checksum must be a string" };
+  }
+  if (!m.tokens || typeof m.tokens !== "object") {
+    return { valid: false, error: "tokens must be an object" };
+  }
+  return { valid: true };
+}
+
+function isValidRecoveryMode(value) {
+  return value === "csr" || value === "dev-only";
+}
+function generateRecoveryToken(metadata) {
+  return CsszyxCompiler.getInstance().generateRecoveryToken(metadata);
+}
+function createRecoveryToken(metadata, buildId) {
+  const fullMetadata = {
+    ...metadata,
+    buildId
+  };
+  const token = generateRecoveryToken(fullMetadata);
+  return {
+    token,
+    metadata: fullMetadata
+  };
+}
+function validateSzRecover(value, componentName) {
+  if (!isValidRecoveryMode(value)) {
+    return {
+      valid: false,
+      error: `szRecover in ${componentName} must be static literal "csr" or "dev-only", got: ${JSON.stringify(value)}`
+    };
+  }
+  return { valid: true };
+}
+function injectRecoveryToken(attributes, token) {
+  return {
+    ...attributes,
+    "data-sz-recovery-token": token
+  };
+}
+
+class OxcNotImplementedError extends Error {
+  /**
+   * @param slice The Phase D slice expected to implement this path.
+   * @param detail What the caller asked for that is not yet wired.
+   */
+  constructor(slice, detail) {
+    super(`transformOxc: ${slice} not implemented yet \u2014 ${detail}`);
+    this.name = "OxcNotImplementedError";
+  }
+}
+function transformOxc(source, filename, options) {
+  const classes = /* @__PURE__ */ new Set();
+  const rawClassNames = /* @__PURE__ */ new Set();
+  const diagnostics = [];
+  const recoveryTokens = /* @__PURE__ */ new Map();
+  if (!source.includes("sz")) {
+    return {
+      code: source,
+      transformed: false,
+      usesRuntime: false,
+      usesMerge: false,
+      usesColorVar: false,
+      classes,
+      rawClassNames,
+      diagnostics,
+      recoveryTokens
+    };
+  }
+  const effectiveFilename = filename ?? "file.tsx";
+  const astBudget = options?.astBudget ?? AST_BUDGET;
+  const parsed = parseSync(effectiveFilename, source);
+  if (parsed.errors.length > 0) {
+    throw new Error(
+      `oxc-parser errors in ${effectiveFilename}: ` + parsed.errors.map((e) => e.message).join("; ")
+    );
+  }
+  assertAstBudget(parsed.program, effectiveFilename, astBudget);
+  const edits = new MagicString(source);
+  const objectBindings = collectObjectBindings(parsed.program);
+  const conditionalBindings = collectConditionalBindings(parsed.program);
+  let transformed = false;
+  let usesRuntime = false;
+  let usesMerge = false;
+  let usesColorVar = false;
+  walk(parsed.program, (node) => {
+    if (node.type === "CallExpression") {
+      collectDynamicCallClasses(
+        node,
+        effectiveFilename,
+        objectBindings,
+        classes
+      );
+      return;
+    }
+    if (node.type !== "JSXOpeningElement") {
+      return;
+    }
+    const openingNode = node;
+    const attrs = openingNode.attributes ?? [];
+    const szAttrs = [];
+    let classNameAttr = null;
+    let styleAttr = null;
+    let szRecoverAttr = null;
+    let alreadyTagged = false;
+    let lastAttr = null;
+    for (const attrRaw of attrs) {
+      if (attrRaw.type !== "JSXAttribute") {
+        continue;
+      }
+      const attr = attrRaw;
+      lastAttr = attr;
+      const name = attr.name?.name;
+      if (name === "sz") {
+        szAttrs.push(attr);
+      } else if (name === "className" || name === "class") {
+        classNameAttr = attr;
+      } else if (name === "style") {
+        styleAttr = attr;
+      } else if (name === "szRecover") {
+        szRecoverAttr = attr;
+      } else if (name === "data-sz-recovery-token") {
+        alreadyTagged = true;
+      }
+    }
+    if (szRecoverAttr && !alreadyTagged) {
+      const recoverValue = stringLiteralValue(szRecoverAttr.value);
+      if (recoverValue === null) {
+        diagnostics.push(
+          `[csszyx] szRecover at ${effectiveFilename}: only string-literal values ("csr" | "dev-only") are supported. Dynamic values disable token emission for this element.`
+        );
+      } else if (!isValidInlineRecoveryMode(recoverValue)) {
+        diagnostics.push(
+          `[csszyx] szRecover at ${effectiveFilename}: unknown mode "${recoverValue}" \u2014 expected "csr" or "dev-only". Token emission skipped.`
+        );
+      } else {
+        const elementType = extractElementName(openingNode.name);
+        const { line, column } = offsetToLineColumn(source, szRecoverAttr.start);
+        const token = generateInlineRecoveryToken(
+          effectiveFilename,
+          line,
+          column,
+          elementType
+        );
+        if (lastAttr) {
+          edits.appendRight(lastAttr.end, ` data-sz-recovery-token="${token}"`);
+        }
+        recoveryTokens.set(token, {
+          mode: recoverValue,
+          component: elementType,
+          path: `${effectiveFilename}:${line}:${column}`
+        });
+        transformed = true;
+      }
+    }
+    if (classNameAttr) {
+      const rawValue = stringLiteralValue(classNameAttr.value);
+      if (rawValue !== null) {
+        for (const c of rawValue.split(/\s+/)) {
+          if (c) {
+            rawClassNames.add(c);
+          }
+        }
+      }
+    }
+    if (szAttrs.length === 0) {
+      return;
+    }
+    const szDerived = [];
+    let runtimeFallbackExpr = null;
+    let runtimeFallbackAttr = null;
+    for (const szAttr of szAttrs) {
+      const value = szAttr.value;
+      if (!value) {
+        throw new OxcNotImplementedError(
+          "D3",
+          `sz attribute without value at ${effectiveFilename}:${szAttr.start}`
+        );
+      }
+      const stringValue = stringLiteralValue(value);
+      if (stringValue !== null) {
+        for (const c of stringValue.split(/\s+/)) {
+          if (c) {
+            szDerived.push(c);
+            classes.add(c);
+          }
+        }
+        continue;
+      }
+      if (value.type !== "JSXExpressionContainer") {
+        throw new OxcNotImplementedError(
+          "D3",
+          `unsupported sz attribute value ${value.type} at ${effectiveFilename}:${szAttr.start}`
+        );
+      }
+      const expression = value.expression;
+      if (expression.type === "ConditionalExpression") {
+        const conditionalClassExpr = buildStaticConditionalClassExpression(
+          expression,
+          effectiveFilename,
+          objectBindings,
+          source,
+          classes
+        );
+        if (conditionalClassExpr) {
+          if (classNameAttr || szAttrs.length > 1) {
+            runtimeFallbackExpr = expression;
+            runtimeFallbackAttr = szAttr;
+            break;
+          }
+          edits.overwrite(
+            szAttr.start,
+            szAttr.end,
+            `className={${conditionalClassExpr}}`
+          );
+          transformed = true;
+          return;
+        }
+      }
+      if (expression.type === "Identifier") {
+        const identifierName = String(expression.name);
+        const bound = objectBindings.get(identifierName);
+        if (bound) {
+          const result2 = transform(
+            astObjectToSzObject(bound, effectiveFilename, objectBindings)
+          );
+          for (const c of result2.className.split(/\s+/)) {
+            if (c) {
+              szDerived.push(c);
+              classes.add(c);
+            }
+          }
+          continue;
+        }
+        const conditional = conditionalBindings.get(identifierName);
+        if (conditional) {
+          const conditionalClassExpr = buildStaticConditionalClassExpression(
+            conditional,
+            effectiveFilename,
+            objectBindings,
+            source,
+            classes
+          );
+          if (conditionalClassExpr) {
+            if (classNameAttr || szAttrs.length > 1) {
+              runtimeFallbackExpr = expression;
+              runtimeFallbackAttr = szAttr;
+              break;
+            }
+            edits.overwrite(
+              szAttr.start,
+              szAttr.end,
+              `className={${conditionalClassExpr}}`
+            );
+            transformed = true;
+            return;
+          }
+        }
+      }
+      if (expression.type === "ArrayExpression") {
+        const arrayClasses = astArrayToStaticClasses(
+          expression,
+          effectiveFilename,
+          objectBindings
+        );
+        if (arrayClasses === null) {
+          collectArrayCandidateClasses(
+            expression,
+            effectiveFilename,
+            objectBindings,
+            classes
+          );
+          runtimeFallbackExpr = expression;
+          runtimeFallbackAttr = szAttr;
+          break;
+        }
+        for (const c of arrayClasses) {
+          szDerived.push(c);
+          classes.add(c);
+        }
+        continue;
+      }
+      if (expression.type !== "ObjectExpression") {
+        runtimeFallbackExpr = expression;
+        runtimeFallbackAttr = szAttr;
+        break;
+      }
+      let szObj;
+      try {
+        szObj = astObjectToSzObject(
+          expression,
+          effectiveFilename,
+          objectBindings
+        );
+      } catch (err) {
+        if (err instanceof OxcNotImplementedError) {
+          const conditionalSpreadClassExpr = buildConditionalSpreadClassExpression(
+            expression,
+            effectiveFilename,
+            objectBindings,
+            source,
+            classes
+          );
+          if (conditionalSpreadClassExpr) {
+            if (classNameAttr || szAttrs.length > 1) {
+              runtimeFallbackExpr = expression;
+              runtimeFallbackAttr = szAttr;
+              break;
+            }
+            edits.overwrite(
+              szAttr.start,
+              szAttr.end,
+              `className={${conditionalSpreadClassExpr}}`
+            );
+            transformed = true;
+            return;
+          }
+          const partial = buildPartialObjectTransform(
+            expression,
+            effectiveFilename,
+            objectBindings,
+            source
+          );
+          if (partial && szAttrs.length === 1) {
+            if (classNameAttr?.value?.type === "JSXExpressionContainer") {
+              const classExpression = classNameAttr.value.expression;
+              const classExpressionSource = source.slice(
+                classExpression.start,
+                classExpression.end
+              );
+              edits.overwrite(
+                classNameAttr.start,
+                classNameAttr.end,
+                `className={_szMerge(${classExpressionSource}, ${JSON.stringify(partial.className)})}`
+              );
+              edits.remove(whitespaceStart(source, szAttr.start), szAttr.end);
+              applyStyleProps(edits, source, styleAttr, lastAttr, partial.styleProps);
+              for (const c of partial.className.split(/\s+/)) {
+                if (c) {
+                  classes.add(c);
+                }
+              }
+              usesRuntime = true;
+              usesMerge = true;
+              usesColorVar ||= partial.usesColorVar;
+              transformed = true;
+              return;
+            }
+            if (classNameAttr && stringLiteralValue(classNameAttr.value) !== null) {
+              const existing = stringLiteralValue(classNameAttr.value);
+              const merged = [existing, partial.className].filter(Boolean).join(" ");
+              edits.overwrite(
+                classNameAttr.start,
+                classNameAttr.end,
+                `className="${merged}"`
+              );
+              edits.remove(whitespaceStart(source, szAttr.start), szAttr.end);
+            } else {
+              edits.overwrite(szAttr.start, szAttr.end, partial.classNameAttr);
+            }
+            applyStyleProps(edits, source, styleAttr, lastAttr, partial.styleProps);
+            for (const c of partial.className.split(/\s+/)) {
+              if (c) {
+                classes.add(c);
+              }
+            }
+            usesColorVar ||= partial.usesColorVar;
+            transformed = true;
+            return;
+          }
+          runtimeFallbackExpr = expression;
+          runtimeFallbackAttr = szAttr;
+          break;
+        }
+        throw err;
+      }
+      const result = transform(szObj);
+      for (const c of result.className.split(/\s+/)) {
+        if (c) {
+          szDerived.push(c);
+          classes.add(c);
+        }
+      }
+    }
+    if (runtimeFallbackExpr && runtimeFallbackAttr) {
+      if (classNameAttr) {
+        throw new OxcNotImplementedError(
+          "D2.5+",
+          `runtime sz fallback combined with existing className at ${effectiveFilename}:${runtimeFallbackAttr.start}`
+        );
+      }
+      const exprSource = source.slice(runtimeFallbackExpr.start, runtimeFallbackExpr.end);
+      if (runtimeFallbackExpr.type !== "ArrayExpression") {
+        diagnostics.push(buildRuntimeFallbackDiagnostic(runtimeFallbackExpr, source));
+      }
+      edits.overwrite(
+        runtimeFallbackAttr.start,
+        runtimeFallbackAttr.end,
+        `className={_sz(${exprSource})}`
+      );
+      for (const szAttr of szAttrs) {
+        if (szAttr === runtimeFallbackAttr) continue;
+        const deleteStart = whitespaceStart(source, szAttr.start);
+        edits.remove(deleteStart, szAttr.end);
+      }
+      usesRuntime = true;
+      transformed = true;
+      return;
+    }
+    const existingRaw = classNameAttr ? stringLiteralValue(classNameAttr.value) : null;
+    const mergedClasses = [
+      ...existingRaw ? existingRaw.split(/\s+/).filter(Boolean) : [],
+      ...szDerived
+    ];
+    const mergedAttr = `className="${mergedClasses.join(" ")}"`;
+    if (classNameAttr) {
+      edits.overwrite(classNameAttr.start, classNameAttr.end, mergedAttr);
+      for (const szAttr of szAttrs) {
+        const deleteStart = whitespaceStart(source, szAttr.start);
+        edits.remove(deleteStart, szAttr.end);
+      }
+    } else {
+      const [firstSz, ...rest] = szAttrs;
+      if (!firstSz) {
+        return;
+      }
+      edits.overwrite(firstSz.start, firstSz.end, mergedAttr);
+      for (const szAttr of rest) {
+        const deleteStart = whitespaceStart(source, szAttr.start);
+        edits.remove(deleteStart, szAttr.end);
+      }
+    }
+    transformed = true;
+  });
+  return {
+    code: transformed ? edits.toString() : source,
+    transformed,
+    usesRuntime,
+    usesMerge,
+    usesColorVar,
+    classes,
+    rawClassNames,
+    diagnostics,
+    recoveryTokens
+  };
+}
+function stringLiteralValue(value) {
+  if (!value) {
+    return null;
+  }
+  if (value.type === "Literal") {
+    const v = value.value;
+    return typeof v === "string" ? v : null;
+  }
+  return null;
+}
+function whitespaceStart(source, attrStart) {
+  let idx = attrStart;
+  while (idx > 0 && /\s/.test(source.charAt(idx - 1))) {
+    idx--;
+  }
+  return idx;
+}
+function offsetToLineColumn(source, offset) {
+  let line = 1;
+  let column = 0;
+  const limit = Math.min(offset, source.length);
+  for (let i = 0; i < limit; i++) {
+    if (source.charCodeAt(i) === 10) {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+function buildRuntimeFallbackDiagnostic(expression, source) {
+  const { line, column } = offsetToLineColumn(source, expression.start);
+  const lineCol = `${line}:${column + 1}`;
+  let reason;
+  let suggestion;
+  if (expression.type === "CallExpression") {
+    const callee = expression.callee;
+    const name = callee.type === "Identifier" ? callee.name : callee.type === "MemberExpression" && (callee.property?.type ?? "") === "Identifier" ? String(
+      callee.property.name
+    ) : "?";
+    reason = `function call \`${name}()\` result is unknown at build time`;
+    suggestion = "If it returns static variants \u2192 convert to szv(). If it depends on runtime data \u2192 use dynamic().";
+  } else if (expression.type === "Identifier") {
+    reason = `identifier \`${expression.name}\` could not be resolved to a static value`;
+    suggestion = "Make sure it's a module-level or function-body const with a literal object value. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+  } else if (expression.type === "MemberExpression") {
+    reason = "member expression is not statically resolvable";
+    suggestion = "Extract the value to a module-level const. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+  } else {
+    reason = `expression of type \`${expression.type}\` is not statically analyzable`;
+    suggestion = "Use a literal sz object or a module-level const. For variant-based styling \u2192 szv(). For true runtime values \u2192 dynamic().";
+  }
+  return `sz fallback at ${lineCol}: ${reason}.
+  Suggestion: ${suggestion}`;
+}
+function extractElementName(nameNode) {
+  if (nameNode.type === "JSXIdentifier") {
+    return String(nameNode.name);
+  }
+  if (nameNode.type === "JSXMemberExpression") {
+    return "<member>";
+  }
+  return "<unknown>";
+}
+function astObjectToSzObject(node, filename, bindings) {
+  const result = {};
+  for (const propRaw of node.properties) {
+    if (propRaw.type === "SpreadElement") {
+      const spread = propRaw;
+      if (spread.argument.type === "Identifier") {
+        const bound = bindings.get(String(spread.argument.name));
+        if (bound) {
+          Object.assign(result, astObjectToSzObject(bound, filename, bindings));
+          continue;
+        }
+      }
+      throw new OxcNotImplementedError(
+        "D5",
+        `unsupported object spread in sz object at ${filename}:${propRaw.start}`
+      );
+    }
+    if (propRaw.type !== "Property") {
+      throw new OxcNotImplementedError(
+        "D5",
+        `non-Property in sz object (e.g. SpreadElement) at ${filename}:${propRaw.start}`
+      );
+    }
+    const prop = propRaw;
+    if (prop.computed) {
+      throw new OxcNotImplementedError(
+        "D2.1",
+        `computed key in sz object at ${filename}:${prop.key.start}`
+      );
+    }
+    const key = extractKeyName(prop.key);
+    if (key === null) {
+      throw new OxcNotImplementedError(
+        "D2.1",
+        `unsupported key shape ${prop.key.type} at ${filename}:${prop.key.start}`
+      );
+    }
+    result[key] = astValueToSzValue(prop.value, filename, bindings);
+  }
+  return result;
+}
+function astArrayToStaticClasses(node, filename, bindings) {
+  const out = [];
+  for (const element of node.elements) {
+    if (!element || isFalsyLiteral(element)) {
+      continue;
+    }
+    let objectNode = null;
+    if (element.type === "ObjectExpression") {
+      objectNode = element;
+    } else if (element.type === "Identifier") {
+      objectNode = bindings.get(String(element.name)) ?? null;
+    }
+    if (!objectNode) {
+      return null;
+    }
+    let result;
+    try {
+      result = transform(astObjectToSzObject(objectNode, filename, bindings));
+    } catch (err) {
+      if (err instanceof OxcNotImplementedError) {
+        return null;
+      }
+      throw err;
+    }
+    for (const c of result.className.split(/\s+/)) {
+      if (c) {
+        out.push(c);
+      }
+    }
+  }
+  return out;
+}
+function collectArrayCandidateClasses(node, filename, bindings, classes) {
+  for (const element of node.elements) {
+    if (!element || isFalsyLiteral(element)) {
+      continue;
+    }
+    const candidate = element.type === "LogicalExpression" && element.operator === "&&" ? element.right : element;
+    collectStaticObjectCandidateClasses(candidate, filename, bindings, classes);
+  }
+}
+function collectStaticObjectCandidateClasses(node, filename, bindings, classes) {
+  const objectNode = resolveObjectExpression(node, bindings);
+  if (!objectNode) {
+    return;
+  }
+  let result;
+  try {
+    result = transform(astObjectToSzObject(objectNode, filename, bindings));
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return;
+    }
+    throw err;
+  }
+  for (const cls of result.className.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+}
+function isFalsyLiteral(node) {
+  if (node.type !== "Literal") {
+    return false;
+  }
+  const value = node.value;
+  return value === false || value === null;
+}
+function assertAstBudget(root, filename, astBudget) {
+  let nodeCount = 0;
+  walk(root, () => {
+    nodeCount++;
+    if (nodeCount > astBudget) {
+      throw new ASTBudgetExceededError(filename, nodeCount, astBudget);
+    }
+  });
+}
+function collectDynamicCallClasses(node, filename, bindings, classes) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "dynamic") {
+    return;
+  }
+  const [firstArg] = node.arguments;
+  if (!firstArg) {
+    return;
+  }
+  const objectNode = resolveObjectExpression(firstArg, bindings);
+  if (!objectNode) {
+    return;
+  }
+  let result;
+  try {
+    result = transform(astObjectToSzObject(objectNode, filename, bindings));
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return;
+    }
+    throw err;
+  }
+  for (const cls of result.className.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+}
+function resolveObjectExpression(node, bindings) {
+  const unwrapped = unwrapExpression(node);
+  if (unwrapped.type === "ObjectExpression") {
+    return unwrapped;
+  }
+  if (unwrapped.type === "Identifier") {
+    return bindings.get(String(unwrapped.name)) ?? null;
+  }
+  return null;
+}
+function buildConditionalSpreadClassExpression(node, filename, bindings, source, classes) {
+  let conditionalSpread = null;
+  const otherProps = [];
+  for (const prop of node.properties) {
+    if (prop.type !== "SpreadElement") {
+      otherProps.push(prop);
+      continue;
+    }
+    const spread = prop;
+    const spreadArgument = unwrapExpression(spread.argument);
+    if (spreadArgument.type !== "ConditionalExpression" || conditionalSpread) {
+      return null;
+    }
+    conditionalSpread = spreadArgument;
+  }
+  if (!conditionalSpread) {
+    return null;
+  }
+  const consequent = compileConditionalSpreadBranch(
+    conditionalSpread.consequent,
+    otherProps,
+    node,
+    filename,
+    bindings
+  );
+  const alternate = compileConditionalSpreadBranch(
+    conditionalSpread.alternate,
+    otherProps,
+    node,
+    filename,
+    bindings
+  );
+  if (consequent === null || alternate === null) {
+    return null;
+  }
+  for (const cls of `${consequent} ${alternate}`.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+  const testSource = source.slice(conditionalSpread.test.start, conditionalSpread.test.end);
+  return `${testSource} ? ${JSON.stringify(consequent)} : ${JSON.stringify(alternate)}`;
+}
+function compileConditionalSpreadBranch(branch, otherProps, sourceNode, filename, bindings) {
+  const branchObject = resolveObjectExpression(branch, bindings);
+  if (!branchObject) {
+    return null;
+  }
+  try {
+    const branchValue = astObjectToSzObject(branchObject, filename, bindings);
+    const overrides = astObjectToSzObject(
+      { ...sourceNode, properties: otherProps },
+      filename,
+      bindings
+    );
+    return transform({ ...branchValue, ...overrides }).className;
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return null;
+    }
+    throw err;
+  }
+}
+function buildPartialObjectTransform(node, filename, bindings, source) {
+  const partial = evaluatePartialObject(node, filename, bindings, source);
+  if (!partial || partial.dynamicProps.size === 0 && partial.conditionalClasses.length === 0) {
+    return null;
+  }
+  if (partial.conditionalClasses.length > 0 && (partial.conditionalClasses.length !== 1 || partial.dynamicProps.size > 0 || Object.keys(partial.staticProps).length > 0)) {
+    return null;
+  }
+  const classParts = [];
+  if (Object.keys(partial.staticProps).length > 0) {
+    const { className: className2 } = transform(partial.staticProps);
+    if (className2) {
+      classParts.push(className2);
+    }
+  }
+  for (const [, info] of partial.dynamicProps) {
+    classParts.push(buildCSSVarClassName(info));
+  }
+  for (const entry of partial.conditionalClasses) {
+    classParts.push(entry.consequent, entry.alternate);
+  }
+  const className = classParts.filter(Boolean).join(" ");
+  const classNameAttr = partial.conditionalClasses.length > 0 ? `className={${buildConditionalClassSource(classParts, partial.conditionalClasses, source)}}` : `className="${className}"`;
+  const styleProps = [...partial.dynamicProps.values()].map(
+    (info) => `${JSON.stringify(info.varName)}: ${generateStyleValueSource(info, source)}`
+  );
+  return { className, classNameAttr, styleProps, usesColorVar: partial.usesColorVar };
+}
+function evaluatePartialObject(node, filename, bindings, source, variantChain = "") {
+  const staticProps = {};
+  const dynamicProps = /* @__PURE__ */ new Map();
+  const conditionalClasses = [];
+  let usesColorVar = false;
+  for (const propRaw of node.properties) {
+    if (propRaw.type === "SpreadElement") {
+      const spread = propRaw;
+      const objectNode = resolveObjectExpression(spread.argument, bindings);
+      if (!objectNode) {
+        return null;
+      }
+      try {
+        Object.assign(staticProps, astObjectToSzObject(objectNode, filename, bindings));
+        continue;
+      } catch (err) {
+        if (err instanceof OxcNotImplementedError) {
+          return null;
+        }
+        throw err;
+      }
+    }
+    if (propRaw.type !== "Property") {
+      return null;
+    }
+    const prop = propRaw;
+    if (prop.computed) {
+      return null;
+    }
+    const key = extractKeyName(prop.key);
+    if (key === null) {
+      return null;
+    }
+    const value = unwrapExpression(prop.value);
+    try {
+      if (value.type === "ObjectExpression") {
+        staticProps[key] = astObjectToSzObject(
+          value,
+          filename,
+          bindings
+        );
+        continue;
+      }
+      staticProps[key] = astValueToSzValue(value, filename, bindings);
+      continue;
+    } catch (err) {
+      if (!(err instanceof OxcNotImplementedError)) {
+        throw err;
+      }
+    }
+    if (value.type === "ObjectExpression" && isKnownVariant(key)) {
+      const nestedVariant = variantChain ? `${variantChain}-${key}` : key;
+      const nested = evaluatePartialObject(
+        value,
+        filename,
+        bindings,
+        source,
+        nestedVariant
+      );
+      if (!nested) {
+        return null;
+      }
+      if (Object.keys(nested.staticProps).length > 0) {
+        staticProps[key] = nested.staticProps;
+      }
+      for (const [nestedKey, nestedInfo] of nested.dynamicProps) {
+        dynamicProps.set(nestedKey, nestedInfo);
+      }
+      conditionalClasses.push(...nested.conditionalClasses);
+      usesColorVar ||= nested.usesColorVar;
+      continue;
+    }
+    if (value.type === "ConditionalExpression") {
+      const conditional = value;
+      const consequent = extractStaticLiteralValue(conditional.consequent);
+      const alternate = extractStaticLiteralValue(conditional.alternate);
+      if (consequent !== null && alternate !== null) {
+        const { className: consequentClasses } = transform({ [key]: consequent });
+        const { className: alternateClasses } = transform({ [key]: alternate });
+        conditionalClasses.push({
+          test: conditional.test,
+          consequent: prefixVariantClasses(consequentClasses, variantChain),
+          alternate: prefixVariantClasses(alternateClasses, variantChain)
+        });
+        continue;
+      }
+    }
+    if (!isRuntimeExpression(value)) {
+      return null;
+    }
+    const twPrefix = PROPERTY_MAP[key] || key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    const category = getPropertyCategory(key);
+    const varName = getCSSVariableName(key, variantChain || void 0);
+    const uniqueKey = variantChain ? `${variantChain}-${key}` : key;
+    if (COLOR_PROPERTIES.has(key)) {
+      usesColorVar = true;
+    }
+    dynamicProps.set(uniqueKey, {
+      expression: value,
+      category,
+      varName,
+      twPrefix,
+      variantChain
+    });
+  }
+  return { staticProps, dynamicProps, conditionalClasses, usesColorVar };
+}
+function applyStyleProps(edits, source, styleAttr, lastAttr, styleProps) {
+  if (styleProps.length === 0) {
+    return;
+  }
+  const propsSource = styleProps.join(", ");
+  if (!styleAttr) {
+    if (lastAttr) {
+      edits.appendRight(lastAttr.end, ` style={{${propsSource}}}`);
+    }
+    return;
+  }
+  if (styleAttr.value?.type !== "JSXExpressionContainer") {
+    return;
+  }
+  const expression = styleAttr.value.expression;
+  const styleSource = source.slice(expression.start, expression.end);
+  edits.overwrite(styleAttr.start, styleAttr.end, `style={{...${styleSource}, ${propsSource}}}`);
+}
+function generateStyleValueSource(info, source) {
+  const expressionSource = source.slice(info.expression.start, info.expression.end);
+  switch (info.category) {
+    case PropertyCategory.SPACING:
+      return `\`calc(\${${expressionSource}} * var(--spacing))\``;
+    case PropertyCategory.COLOR:
+      return `__szColorVar(${expressionSource})`;
+    case PropertyCategory.ANGLE:
+      return `\`\${${expressionSource}}deg\``;
+    case PropertyCategory.DURATION:
+      return `\`\${${expressionSource}}ms\``;
+    default:
+      return `\`\${${expressionSource}}\``;
+  }
+}
+function buildCSSVarClassName(info) {
+  const variantPrefix = info.variantChain ? `${getVariantPrefix(info.variantChain)}:` : "";
+  return `${variantPrefix}${info.twPrefix}-(${info.varName})`;
+}
+function buildConditionalClassSource(classParts, conditionals, source) {
+  if (conditionals.length === 1 && classParts.length === 2) {
+    const [entry] = conditionals;
+    return `${source.slice(entry.test.start, entry.test.end)} ? ${JSON.stringify(entry.consequent)} : ${JSON.stringify(entry.alternate)}`;
+  }
+  return JSON.stringify(classParts.filter(Boolean).join(" "));
+}
+function extractStaticLiteralValue(node) {
+  const unwrapped = unwrapExpression(node);
+  if (unwrapped.type !== "Literal") {
+    return null;
+  }
+  const value = unwrapped.value;
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : null;
+}
+function isKnownVariant(key) {
+  return KNOWN_VARIANTS.has(key) || KNOWN_VARIANTS.has(getVariantPrefix(key));
+}
+function prefixVariantClasses(className, variantChain) {
+  if (!variantChain) {
+    return className;
+  }
+  const prefix = `${getVariantPrefix(variantChain)}:`;
+  return className.split(/\s+/).filter(Boolean).map((cls) => `${prefix}${cls}`).join(" ");
+}
+function isRuntimeExpression(node) {
+  return node.type === "Identifier" || node.type === "MemberExpression" || node.type === "CallExpression" || node.type === "ConditionalExpression" || node.type === "TemplateLiteral" || node.type === "BinaryExpression" || node.type === "LogicalExpression";
+}
+function buildStaticConditionalClassExpression(node, filename, bindings, source, classes) {
+  const consequent = resolveStaticClassString(node.consequent, filename, bindings);
+  const alternate = resolveStaticClassString(node.alternate, filename, bindings);
+  if (consequent === null || alternate === null) {
+    return null;
+  }
+  for (const cls of `${consequent} ${alternate}`.split(/\s+/)) {
+    if (cls) {
+      classes.add(cls);
+    }
+  }
+  const testSource = source.slice(node.test.start, node.test.end);
+  return `${testSource} ? ${JSON.stringify(consequent)} : ${JSON.stringify(alternate)}`;
+}
+function resolveStaticClassString(node, filename, bindings) {
+  const unwrapped = unwrapExpression(node);
+  let objectNode = null;
+  if (unwrapped.type === "ObjectExpression") {
+    objectNode = unwrapped;
+  } else if (unwrapped.type === "Identifier") {
+    objectNode = bindings.get(String(unwrapped.name)) ?? null;
+  }
+  if (!objectNode) {
+    return null;
+  }
+  try {
+    return transform(astObjectToSzObject(objectNode, filename, bindings)).className;
+  } catch (err) {
+    if (err instanceof OxcNotImplementedError) {
+      return null;
+    }
+    throw err;
+  }
+}
+function extractKeyName(key) {
+  if (key.type === "Identifier") {
+    return String(key.name);
+  }
+  if (key.type === "Literal") {
+    const value = key.value;
+    if (typeof value === "string" || typeof value === "number") {
+      return String(value);
+    }
+  }
+  return null;
+}
+function astValueToSzValue(node, filename, bindings) {
+  if (node.type === "Literal") {
+    const value = node.value;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return value;
+    }
+    throw new OxcNotImplementedError(
+      "D2.1",
+      `unsupported literal value type at ${filename}:${node.start}`
+    );
+  }
+  if (node.type === "UnaryExpression") {
+    const operator = node.operator;
+    const argument = node.argument;
+    if (operator === "-" && argument.type === "Literal") {
+      const argValue = argument.value;
+      if (typeof argValue === "number") {
+        return -argValue;
+      }
+    }
+    throw new OxcNotImplementedError(
+      "D2.1",
+      `unsupported unary expression at ${filename}:${node.start}`
+    );
+  }
+  if (node.type === "ObjectExpression") {
+    return astObjectToSzObject(node, filename, bindings);
+  }
+  if (node.type === "Identifier" || node.type === "MemberExpression") {
+    throw new OxcNotImplementedError(
+      "D2.1",
+      `identifier reference in sz object \u2014 scope resolution lands in a later slice (${filename}:${node.start})`
+    );
+  }
+  if (node.type === "ConditionalExpression" || node.type === "LogicalExpression") {
+    throw new OxcNotImplementedError(
+      "D2.5",
+      `conditional/logical expression in sz object at ${filename}:${node.start}`
+    );
+  }
+  throw new OxcNotImplementedError(
+    "D2.1",
+    `unsupported value node type ${node.type} at ${filename}:${node.start}`
+  );
+}
+function collectObjectBindings(root) {
+  const bindings = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator") {
+      return;
+    }
+    const id = node.id;
+    const init = node.init;
+    if (!id || id.type !== "Identifier" || !init) {
+      return;
+    }
+    const unwrapped = unwrapExpression(init);
+    if (unwrapped.type === "ObjectExpression") {
+      bindings.set(String(id.name), unwrapped);
+    }
+  });
+  return bindings;
+}
+function collectConditionalBindings(root) {
+  const bindings = /* @__PURE__ */ new Map();
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator") {
+      return;
+    }
+    const id = node.id;
+    const init = node.init;
+    if (!id || id.type !== "Identifier" || !init) {
+      return;
+    }
+    const unwrapped = unwrapExpression(init);
+    if (unwrapped.type === "ConditionalExpression") {
+      bindings.set(
+        String(id.name),
+        unwrapped
+      );
+    }
+  });
+  return bindings;
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression") {
+    const next = current.expression;
+    if (!next) {
+      break;
+    }
+    current = next;
+  }
+  return current;
+}
+function walk(node, visit) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const typed = node;
+  if (typeof typed.type !== "string") {
+    return;
+  }
+  visit(typed);
+  for (const key of Object.keys(typed)) {
+    if (key === "loc" || key === "range" || key === "start" || key === "end" || key === "type") {
+      continue;
+    }
+    const child = typed[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        walk(item, visit);
+      }
+    } else if (child && typeof child === "object") {
+      walk(child, visit);
+    }
+  }
+}
+
+const VERSION = "0.0.0";
+const DEFAULT_COMPILER_OPTIONS = {
+  buildId: Date.now().toString(),
+  development: process.env.NODE_ENV !== "production",
+  strictMode: false
+};
+function mergeOptions(options = {}) {
+  return {
+    ...DEFAULT_COMPILER_OPTIONS,
+    ...options
+  };
+}
+
+export { COLOR_PROPERTIES, CsszyxCompiler, DEFAULT_COMPILER_OPTIONS, KNOWN_VARIANTS, ManifestBuilder, OxcNotImplementedError, PROPERTY_MAP, PropertyCategory, VERSION, buildParentMap, createRecoveryToken, generateRecoveryToken, getCSSVariableName, getPropertyCategory, hoistCSSVariables, injectRecoveryToken, isValidRecoveryMode, mergeOptions, parseManifest, serializeManifest, transform, transformOxc, transformSourceCode, validateManifest, validateSzRecover };