@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/utils.js

@@ -0,0 +1,1170 @@
+import fs from "node:fs";
+import path from "node:path";
+import { extractAndStripCssImports, extractBridgeData, injectBrowserCoreAutoImports, processClientScript, renderVendorStyleTags } from "./client-script.js";
+import {
+  COMPONENT_CLIENT_FACTORIES_CONTEXT_KEY,
+  componentClientFactoriesRegisteredSince,
+  registerComponentClientFactory,
+  replayComponentClientFactories,
+  snapshotComponentClientFactoryCounts
+} from "./component-client-factories.js";
+import { interpolateScriptExpressions, processExpressions, usesSignalsInScript } from "./expressions.js";
+import { COMPONENT_SCOPE_LOCAL_GLOBALS, buildRuntimeGlobalsDestructure } from "./runtime-globals.js";
+import { contentKey, depsUnchanged, renderMemo, snapshotDeps } from "./render-memo.js";
+import { transformStoreImports } from "./store-imports.js";
+import { LRUCache } from "./performance-utils.js";
+import { processDirectives } from "./process.js";
+import { getPublicEnvDefine } from "./public-env.js";
+import { isUsableParamName } from "./safe-evaluator.js";
+import { processScopedStyles } from "./style-scoping.js";
+import { findSfcTemplateBlock } from "./sfc-template.js";
+import { importOnce } from "./lazy-module.js";
+import { stashScriptElements } from "./html-masking.js";
+export {
+  extractDirectiveNames,
+  getPositionInfo,
+  hasDirectives,
+  validateDirective,
+  validateTemplate
+} from "./validator.js";
+export {
+  convertToCommonJS,
+  extractScriptFromTemplate,
+  extractVariables,
+  hasVariables
+} from "./variable-extractor.js";
+const componentsCache = new LRUCache(500), componentResolutionCache = new LRUCache(1000), COMPONENT_RENDER_CACHE_BYTES = 33554432;
+let appliedComponentRenderCacheBytes = COMPONENT_RENDER_CACHE_BYTES;
+function applyComponentRenderCacheBudget(options) {
+  const configured = options.componentRenderCacheBytes;
+  if (typeof configured !== "number" || configured < 0 || configured === appliedComponentRenderCacheBytes)
+    return;
+  appliedComponentRenderCacheBytes = configured;
+  componentRenderCache.setMaxBytes(configured);
+}
+const componentRenderCache = new LRUCache(2000, {
+  maxBytes: COMPONENT_RENDER_CACHE_BYTES,
+  sizeOf: (entry) => entry.output.length
+});
+let scopeIdCounter = 0;
+function serializeComponentRenderInput(value) {
+  const seen = new WeakSet;
+  try {
+    const normalize = (input) => {
+      if (input === void 0)
+        return { __stxType: "undefined" };
+      if (typeof input === "bigint")
+        return { __stxType: "bigint", value: input.toString() };
+      if (typeof input === "function" || typeof input === "symbol")
+        throw TypeError("Non-serializable component input");
+      if (input === null || typeof input !== "object")
+        return input;
+      if (seen.has(input))
+        throw TypeError("Circular component input");
+      seen.add(input);
+      if (input instanceof Date)
+        return { __stxType: "date", value: input.toISOString() };
+      if (Array.isArray(input))
+        return input.map(normalize);
+      const normalized = {};
+      for (const key of Object.keys(input).sort())
+        normalized[key] = normalize(input[key]);
+      return normalized;
+    };
+    return JSON.stringify(normalize(value));
+  } catch {
+    return null;
+  }
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function isJavaScriptScript(attrs) {
+  return /\bjs\b/.test(attrs) || /\blang\s*=\s*["']?(js|javascript)["']?/i.test(attrs);
+}
+export function shouldTranspileTypeScript(attrs) {
+  return !isJavaScriptScript(attrs);
+}
+const transpilerPool = new Map;
+export function getSharedTranspiler(options) {
+  let key;
+  try {
+    key = JSON.stringify(options);
+  } catch {
+    return new Bun.Transpiler(options);
+  }
+  const pooled = transpilerPool.get(key);
+  if (pooled)
+    return pooled;
+  if (transpilerPool.size >= 16)
+    transpilerPool.clear();
+  const transpiler = new Bun.Transpiler(options);
+  transpilerPool.set(key, transpiler);
+  return transpiler;
+}
+const transpileResults = new WeakMap, TRANSPILE_RESULTS_MAX_ENTRIES = 256;
+export function transpileTypeScript(code) {
+  try {
+    const transpiler = getSharedTranspiler({
+      loader: "ts",
+      target: "browser",
+      define: getPublicEnvDefine()
+    });
+    let results = transpileResults.get(transpiler);
+    if (!results) {
+      results = new Map;
+      transpileResults.set(transpiler, results);
+    }
+    const cached = results.get(code);
+    if (cached !== void 0)
+      return cached;
+    let processedCode = code.replace(/^\s*import\s+\w+\s+from\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    processedCode = processedCode.replace(/^\s*import\s+['"][^'"]*\.stx['"]\s*;?\s*$/gm, "");
+    const placeholders = [];
+    processedCode = processedCode.replace(/\{!![\s\S]*?!!\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    processedCode = processedCode.replace(/\{\{\{[\s\S]*?\}\}\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    processedCode = processedCode.replace(/\{\{[\s\S]*?\}\}/g, (match) => {
+      const idx = placeholders.length;
+      placeholders.push(match);
+      return `"__STX_EXPR_${idx}__"`;
+    });
+    let result = transpiler.transformSync(processedCode);
+    for (let i = 0;i < placeholders.length; i++) {
+      result = result.replace(`"__STX_EXPR_${i}__"`, placeholders[i]);
+      result = result.replace(`'__STX_EXPR_${i}__'`, placeholders[i]);
+    }
+    if (results.size >= TRANSPILE_RESULTS_MAX_ENTRIES) {
+      const oldest = results.keys().next();
+      if (!oldest.done)
+        results.delete(oldest.value);
+    }
+    results.set(code, result);
+    return result;
+  } catch (e) {
+    if (process.env.STX_DEBUG_TS)
+      console.warn("[STX] TypeScript transpilation error:", e);
+    return code;
+  }
+}
+function extractVariableNames(code) {
+  const names = [], seen = new Set;
+  let depth = 0, i = 0;
+  const len = code.length, skipString = (quote) => {
+    i++;
+    while (i < len) {
+      if (code[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (code[i] === quote) {
+        i++;
+        return;
+      }
+      i++;
+    }
+  }, skipTemplateLiteral = () => {
+    i++;
+    while (i < len) {
+      if (code[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (code[i] === "`") {
+        i++;
+        return;
+      }
+      if (code[i] === "$" && code[i + 1] === "{") {
+        i += 2;
+        let templateDepth = 1;
+        while (i < len && templateDepth > 0)
+          if (code[i] === "{") {
+            templateDepth++;
+            i++;
+          } else if (code[i] === "}") {
+            templateDepth--;
+            i++;
+          } else if (code[i] === "'" || code[i] === '"')
+            skipString(code[i]);
+          else if (code[i] === "`")
+            skipTemplateLiteral();
+          else
+            i++;
+        continue;
+      }
+      i++;
+    }
+  }, skipComment = () => {
+    if (code[i] === "/" && code[i + 1] === "/") {
+      while (i < len && code[i] !== `
+`)
+        i++;
+      return !0;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      i += 2;
+      while (i < len - 1 && !(code[i] === "*" && code[i + 1] === "/"))
+        i++;
+      i += 2;
+      return !0;
+    }
+    return !1;
+  }, checkDeclaration = () => {
+    if (depth !== 0)
+      return;
+    const destructMatch = code.slice(i).match(/^(const|let|var)\s*\{([^}]+)\}\s*=/);
+    if (destructMatch) {
+      const vars = destructMatch[2].split(",").map((v) => {
+        const parts = v.trim().split(":");
+        return parts[parts.length - 1].trim();
+      });
+      for (const varName of vars)
+        if (varName && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(varName) && !seen.has(varName)) {
+          names.push(varName);
+          seen.add(varName);
+        }
+      return;
+    }
+    const declMatch = code.slice(i).match(/^(const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/);
+    if (declMatch) {
+      const varName = declMatch[2];
+      if (!seen.has(varName)) {
+        names.push(varName);
+        seen.add(varName);
+      }
+      return;
+    }
+    const funcMatch = code.slice(i).match(/^function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+    if (funcMatch) {
+      const funcName = funcMatch[1];
+      if (!seen.has(funcName)) {
+        names.push(funcName);
+        seen.add(funcName);
+      }
+      return;
+    }
+    const asyncMatch = code.slice(i).match(/^async\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+    if (asyncMatch) {
+      const funcName = asyncMatch[1];
+      if (!seen.has(funcName)) {
+        names.push(funcName);
+        seen.add(funcName);
+      }
+    }
+  };
+  while (i < len) {
+    if (skipComment())
+      continue;
+    if (code[i] === "'" || code[i] === '"') {
+      skipString(code[i]);
+      continue;
+    }
+    if (code[i] === "`") {
+      skipTemplateLiteral();
+      continue;
+    }
+    if (code[i] === "{") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (code[i] === "}") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0 && /[a-z]/i.test(code[i]) && (i === 0 || /\s|[;{}()]/.test(code[i - 1])))
+      checkDeclaration();
+    i++;
+  }
+  return names;
+}
+function splitTopLevelCommas(body) {
+  const parts = [];
+  let depth = 0, start = 0, quote = null;
+  for (let i = 0;i < body.length; i++) {
+    const c = body[i];
+    if (quote) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === quote)
+        quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth--;
+    else if (c === "," && depth === 0) {
+      parts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (start < body.length)
+    parts.push(body.slice(start));
+  return parts;
+}
+function topLevelDefaultEq(entry) {
+  let depth = 0, quote = null;
+  for (let i = 0;i < entry.length; i++) {
+    const c = entry[i];
+    if (quote) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === quote)
+        quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{")
+      depth++;
+    else if (c === ")" || c === "]" || c === "}")
+      depth--;
+    else if (c === "=" && depth === 0) {
+      const prev = entry[i - 1], next = entry[i + 1];
+      if (prev === "!" || prev === "<" || prev === ">" || prev === "=")
+        continue;
+      if (next === "=" || next === ">")
+        continue;
+      return i;
+    }
+  }
+  return -1;
+}
+function applyDestructuredPropDefaults(componentContent, ctx) {
+  try {
+    const m = /=\s*(?:withDefaults\s*\([\s\S]*?defineProps|defineProps)\b/.exec(componentContent);
+    if (!m)
+      return;
+    let i = m.index - 1;
+    while (i >= 0 && /\s/.test(componentContent[i]))
+      i--;
+    if (componentContent[i] !== "}")
+      return;
+    const end = i;
+    let depth = 0, start = -1;
+    for (;i >= 0; i--) {
+      const c = componentContent[i];
+      if (c === "}")
+        depth++;
+      else if (c === "{") {
+        depth--;
+        if (depth === 0) {
+          start = i;
+          break;
+        }
+      }
+    }
+    if (start === -1)
+      return;
+    const body = componentContent.slice(start + 1, end);
+    for (const rawEntry of splitTopLevelCommas(body)) {
+      const entry = rawEntry.trim();
+      if (!entry || entry.startsWith("..."))
+        continue;
+      const eq = topLevelDefaultEq(entry);
+      if (eq === -1)
+        continue;
+      const name = entry.slice(0, eq).trim();
+      if (!/^[A-Z_$][\w$]*$/i.test(name))
+        continue;
+      if (ctx[name] !== void 0)
+        continue;
+      const expr = entry.slice(eq + 1).trim();
+      if (!expr)
+        continue;
+      try {
+        const keys = Object.keys(ctx).filter(isUsableParamName), fn = Function(...keys, `"use strict"; return (${expr});`);
+        ctx[name] = fn(...keys.map((k) => ctx[k]));
+      } catch {}
+    }
+  } catch {}
+}
+export async function userComponentFileExists(componentPath, componentsDir, parentContext, parentFilePath, options) {
+  const baseName = componentPath.endsWith(".stx") ? componentPath.slice(0, -4) : componentPath, kebabToPascal = (str) => str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(""), pascalToKebab = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), importedComponents = parentContext.__importedComponents;
+  if (importedComponents) {
+    for (const name of [baseName, baseName.toLowerCase(), kebabToPascal(baseName), pascalToKebab(baseName)])
+      if (importedComponents.has(name))
+        return !0;
+  }
+  const variants = [...new Set([`${baseName}.stx`, `${kebabToPascal(baseName)}.stx`, `${pascalToKebab(baseName)}.stx`])], configuredRoot = typeof options.root === "string" ? path.resolve(options.root) : void 0, resolveBase = configuredRoot ?? path.dirname(parentFilePath), searchDirs = [], push = (dir) => {
+    if (dir && !searchDirs.includes(dir))
+      searchDirs.push(dir);
+  }, originalFilePath = parentContext.__originalFilePath;
+  if (originalFilePath)
+    push(path.join(path.dirname(originalFilePath), "components"));
+  push(componentsDir);
+  push(options._rootComponentsDir);
+  push(path.join(path.dirname(parentFilePath), "components"));
+  push(options.componentsDir);
+  if (configuredRoot) {
+    push(path.resolve(configuredRoot, "resources/views/components"));
+    push(path.resolve(configuredRoot, "resources/components"));
+    push(path.resolve(configuredRoot, "src/components"));
+    push(path.resolve(configuredRoot, "components"));
+  }
+  const pluginDirs = options._pluginComponentDirs;
+  if (Array.isArray(pluginDirs))
+    for (const dir of pluginDirs)
+      push(typeof dir === "string" ? dir : null);
+  push(options.fallbackComponentsDir);
+  if (baseName.startsWith("./") || baseName.startsWith("../"))
+    return fileExists(path.resolve(path.dirname(parentFilePath), `${baseName}.stx`));
+  for (const dir of searchDirs) {
+    const resolvedDir = path.isAbsolute(dir) ? dir : path.resolve(resolveBase, dir);
+    for (const variant of variants)
+      if (await fileExists(path.join(resolvedDir, variant)))
+        return !0;
+  }
+  return !1;
+}
+export function isHydrateTrigger(trigger) {
+  return trigger === "visible" || trigger === "idle" || trigger === "interaction" || trigger.startsWith("media:");
+}
+export function slotContentHasExpressions(slotContent) {
+  if (!slotContent)
+    return !1;
+  const withoutScripts = slotContent.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "");
+  return /\{\{[\s\S]*?\}\}|\{!![\s\S]*?!!\}/.test(withoutScripts);
+}
+export function componentClientSignalNames(scripts) {
+  const names = new Set, declaration = /\b(?:const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=\s*(?:state|derived|computed|ref|reactive|signal|useReactiveProp|useLocalStorage|useSessionStorage|useCookie|useDebouncedValue)\s*(?:<[^>]*>)?\s*\(/g;
+  for (const script of scripts) {
+    let match;
+    while ((match = declaration.exec(script)) !== null)
+      names.add(match[1]);
+    declaration.lastIndex = 0;
+  }
+  return [...names];
+}
+export async function renderComponentWithSlot(componentPath, props, slotContent, componentsDir, parentContext, parentFilePath, options, processedComponents = new Set, dependencies) {
+  const { extractVariables } = await importOnce("stx/variable-extractor", () => import("./variable-extractor.js")), components = processedComponents ?? new Set;
+  if (components.has(componentPath))
+    return `[Circular component reference: ${componentPath}]`;
+  const branchComponents = new Set(components);
+  branchComponents.add(componentPath);
+  const clientAttr = typeof props.client === "string" ? props.client.trim() : "";
+  if ("client" in props)
+    delete props.client;
+  const hydrateTrigger = clientAttr && clientAttr !== "load" && isHydrateTrigger(clientAttr) ? clientAttr : "";
+  try {
+    const kebabToPascal = (str) => str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(""), pascalToKebab = (str) => str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), baseName = componentPath.endsWith(".stx") ? componentPath.slice(0, -4) : componentPath;
+    let componentFilePath = null;
+    const importedComponents = parentContext.__importedComponents;
+    if (importedComponents) {
+      const namesToTry = [
+        baseName,
+        baseName.toLowerCase(),
+        kebabToPascal(baseName),
+        pascalToKebab(baseName)
+      ];
+      for (const name of namesToTry)
+        if (importedComponents.has(name)) {
+          componentFilePath = importedComponents.get(name);
+          break;
+        }
+    }
+    const triedPaths = [];
+    if (!componentFilePath) {
+      const fileVariants = [
+        `${baseName}.stx`,
+        `${kebabToPascal(baseName)}.stx`,
+        `${pascalToKebab(baseName)}.stx`
+      ], uniqueVariants = [...new Set(fileVariants)], originalFilePath = parentContext.__originalFilePath, searchDirs = [];
+      if (originalFilePath) {
+        const originalDir = path.join(path.dirname(originalFilePath), "components");
+        searchDirs.push(originalDir);
+      }
+      if (componentsDir)
+        searchDirs.push(componentsDir);
+      const rootComponentsDir = options._rootComponentsDir;
+      if (typeof rootComponentsDir === "string" && !searchDirs.includes(rootComponentsDir))
+        searchDirs.push(rootComponentsDir);
+      const parentRelative = path.join(path.dirname(parentFilePath), "components");
+      if (!searchDirs.includes(parentRelative))
+        searchDirs.push(parentRelative);
+      if (options.componentsDir && options.componentsDir !== componentsDir && !searchDirs.includes(options.componentsDir))
+        searchDirs.push(options.componentsDir);
+      const configuredRoot = typeof options.root === "string" ? path.resolve(options.root) : void 0, resolveBase = configuredRoot ?? path.dirname(parentFilePath), fallbackDirs = [];
+      if (configuredRoot) {
+        fallbackDirs.push(path.resolve(configuredRoot, "resources/views/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "resources/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "src/components"));
+        fallbackDirs.push(path.resolve(configuredRoot, "components"));
+      }
+      fallbackDirs.push(path.resolve(import.meta.dir, "components"));
+      for (const fallback of fallbackDirs)
+        if (!searchDirs.includes(fallback))
+          searchDirs.push(fallback);
+      const pluginDirs = options._pluginComponentDirs;
+      if (Array.isArray(pluginDirs)) {
+        for (const dir of pluginDirs)
+          if (typeof dir === "string" && !searchDirs.includes(dir))
+            searchDirs.push(dir);
+      }
+      if (options.fallbackComponentsDir && !searchDirs.includes(options.fallbackComponentsDir))
+        searchDirs.push(options.fallbackComponentsDir);
+      const normalizedSearchDirs = [...new Set(searchDirs.map((dir) => {
+        if (!dir)
+          return dir;
+        return path.isAbsolute(dir) ? dir : path.resolve(resolveBase, dir);
+      }))];
+      searchDirs.length = 0;
+      searchDirs.push(...normalizedSearchDirs);
+      const resolutionCacheKey = `${baseName}\x00${parentFilePath}\x00${normalizedSearchDirs.join("\x00")}`, cachedResolution = componentResolutionCache.get(resolutionCacheKey);
+      if (cachedResolution)
+        if (await fileExists(cachedResolution))
+          componentFilePath = cachedResolution;
+        else
+          componentResolutionCache.delete(resolutionCacheKey);
+      if (!componentFilePath && (baseName.startsWith("./") || baseName.startsWith("../"))) {
+        componentFilePath = path.resolve(path.dirname(parentFilePath), `${baseName}.stx`);
+        triedPaths.push(componentFilePath);
+      } else if (!componentFilePath)
+        for (const dir of searchDirs) {
+          if (!dir)
+            continue;
+          for (const variant of uniqueVariants) {
+            const tryPath = path.join(dir, variant);
+            triedPaths.push(tryPath);
+            if (await fileExists(tryPath)) {
+              componentFilePath = tryPath;
+              break;
+            }
+          }
+          if (componentFilePath)
+            break;
+          if (!componentFilePath)
+            try {
+              const fs = await import("node:fs");
+              if (!fs.statSync(dir, { throwIfNoEntry: !1 })?.isDirectory())
+                continue;
+              const MAX_DEPTH = 8, stack = [{ path: dir, depth: 0 }];
+              while (stack.length > 0 && !componentFilePath) {
+                const current = stack.pop();
+                if (current.depth >= MAX_DEPTH)
+                  continue;
+                let entries;
+                try {
+                  entries = fs.readdirSync(current.path, { withFileTypes: !0 });
+                } catch {
+                  continue;
+                }
+                for (const entry of entries) {
+                  if (!entry.isDirectory())
+                    continue;
+                  if (entry.name === "node_modules" || entry.name.startsWith("."))
+                    continue;
+                  const subDir = path.join(current.path, entry.name);
+                  for (const variant of uniqueVariants) {
+                    const tryPath = path.join(subDir, variant);
+                    triedPaths.push(tryPath);
+                    if (await fileExists(tryPath)) {
+                      componentFilePath = tryPath;
+                      break;
+                    }
+                  }
+                  if (componentFilePath)
+                    break;
+                  stack.push({ path: subDir, depth: current.depth + 1 });
+                }
+              }
+            } catch {}
+          if (componentFilePath)
+            break;
+        }
+      if (componentFilePath)
+        componentResolutionCache.set(resolutionCacheKey, componentFilePath);
+    }
+    if (!componentFilePath || !await fileExists(componentFilePath)) {
+      const searchInfo = triedPaths.length > 0 ? `
+Searched paths:
+${triedPaths.map((p) => `  - ${p}`).join(`
+`)}` : "";
+      return `[Error loading component: ENOENT: no such file or directory, open '${componentPath}']${searchInfo}`;
+    }
+    dependencies.add(componentFilePath);
+    let componentContent;
+    if (componentsCache.has(componentFilePath))
+      componentContent = componentsCache.get(componentFilePath);
+    else
+      try {
+        componentContent = await Bun.file(componentFilePath).text();
+        componentsCache.set(componentFilePath, componentContent);
+      } catch (error) {
+        return `[Error loading component: ${error instanceof Error ? error.message : String(error)}]`;
+      }
+    const internalKeysToPreserve = new Set([
+      "__originalFilePath",
+      "__importedComponents",
+      COMPONENT_CLIENT_FACTORIES_CONTEXT_KEY,
+      "__stx_client_signal_names",
+      "__stxServeContext",
+      "__stx_scope_seq"
+    ]), filteredParentContext = {};
+    for (const [key, val] of Object.entries(parentContext))
+      if (!key.startsWith("__") || internalKeysToPreserve.has(key))
+        filteredParentContext[key] = val;
+    let callerSlotContent = slotContent;
+    if (slotContent.includes("@include")) {
+      const { processIncludes } = await importOnce("stx/includes", () => import("./includes.js"));
+      callerSlotContent = await processIncludes(slotContent, parentContext, parentFilePath, options, dependencies);
+    }
+    const stashedCallerScripts = stashScriptElements(callerSlotContent), callerClientScripts = [], componentSlotContent = stashedCallerScripts.output.replace(/\x00STX_SCRIPT_(\d+)\x00/g, (_match, index) => {
+      const script = stashedCallerScripts.scripts[Number(index)] || "", attrs = script.match(/^<script\b([^>]*)>/i)?.[1] || "", type = attrs.match(/\btype\s*=\s*["']([^"']+)["']/i)?.[1]?.toLowerCase(), executable = !type || ["module", "text/javascript", "application/javascript"].includes(type);
+      if (!/\bserver\b/i.test(attrs) && executable) {
+        callerClientScripts.push(script);
+        return "";
+      }
+      return script;
+    }), { extractSlotContent } = await importOnce("stx/slots", () => import("./slots.js")), parsedSlotContent = extractSlotContent(componentSlotContent), $slots = {};
+    if (parsedSlotContent.defaultSlot?.trim())
+      $slots.default = parsedSlotContent.defaultSlot;
+    for (const [slotName, slotDef] of parsedSlotContent.namedSlots)
+      $slots[slotName] = slotDef.content;
+    const scopeSeq = parentContext.__stx_scope_seq ??= {
+      n: 0,
+      key: Bun.hash(String(parentContext.__filename ?? parentFilePath)).toString(36).slice(0, 6)
+    }, componentUid = `stx_${baseName.replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeSeq.n}_${scopeSeq.key}`, componentContext = {
+      ...filteredParentContext,
+      $uid: componentUid,
+      ...props,
+      props,
+      slot: componentSlotContent,
+      $slots,
+      __processedComponents: branchComponents,
+      __sections: {},
+      __stx_signals_gate: usesSignalsInScript(componentContent) || slotContentHasExpressions(slotContent)
+    };
+    applyDestructuredPropDefaults(componentContent, componentContext);
+    let workingContent = componentContent;
+    const templateBlock = findSfcTemplateBlock(workingContent);
+    if (templateBlock)
+      workingContent = templateBlock.content.trim();
+    const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, scriptMatches = [...componentContent.matchAll(scriptRegex)], clientScripts = [], cacheableServerComponent = scriptMatches.some((match) => /\bserver\b/.test(match[1] || "") && /\bcache\b/.test(match[1] || ""));
+    let componentRenderCacheKey = null, dependencyBaseline = null, clientFactoryBaseline = null, uidBaseline = 0, preservedExpressionBaseline = null;
+    applyComponentRenderCacheBudget(options);
+    if (cacheableServerComponent && appliedComponentRenderCacheBytes > 0) {
+      const serializedInput = serializeComponentRenderInput({
+        props,
+        slot: slotContent,
+        buildMode: options.buildMode ?? "",
+        skipEventDirectives: options.skipEventDirectives === !0,
+        uid: componentUid
+      });
+      if (serializedInput !== null) {
+        componentRenderCacheKey = `${componentFilePath}\x00${contentKey(componentContent)}\x00${serializedInput}`;
+        const cachedRender = componentRenderCache.get(componentRenderCacheKey);
+        if (cachedRender) {
+          for (const dependency of cachedRender.dependencies)
+            dependencies.add(dependency);
+          replayComponentClientFactories(parentContext, cachedRender.clientFactories);
+          scopeSeq.n += cachedRender.uidsConsumed;
+          if (cachedRender.preservedClientExpressions.length > 0) {
+            const preserved = new Set(Array.isArray(parentContext.__stx_preserved_client_expressions) ? parentContext.__stx_preserved_client_expressions : []);
+            for (const expression of cachedRender.preservedClientExpressions)
+              preserved.add(expression);
+            parentContext.__stx_preserved_client_expressions = [...preserved];
+          }
+          return cachedRender.output;
+        }
+        dependencyBaseline = new Set(dependencies);
+        clientFactoryBaseline = snapshotComponentClientFactoryCounts(parentContext);
+        uidBaseline = scopeSeq.n;
+        preservedExpressionBaseline = new Set(Array.isArray(parentContext.__stx_preserved_client_expressions) ? parentContext.__stx_preserved_client_expressions : []);
+      }
+    }
+    for (const match of scriptMatches) {
+      const attrs = match[1] || "";
+      let content = match[2] || "";
+      const isServerScript = attrs.includes("server");
+      if (shouldTranspileTypeScript(attrs) && content.trim())
+        content = transpileTypeScript(content);
+      if (isServerScript && content)
+        try {
+          await extractVariables(content, componentContext, componentFilePath);
+        } catch (e) {}
+      if (!isServerScript) {
+        let cleanContent = content.replace(/^\s*const\s*\{[^}]+\}\s*=\s*window\.stx\s*;?\s*\n?/gm, "");
+        const hasMustache = cleanContent.includes("{{") && cleanContent.includes("}}"), hasRawMarker = cleanContent.includes("{!!") && cleanContent.includes("!!}");
+        if (hasMustache || hasRawMarker)
+          cleanContent = interpolateScriptExpressions(cleanContent, componentContext);
+        const cleanAttrs = attrs.replace(/\s*\bts\b/g, "").replace(/\s*\blang\s*=\s*["']?(ts|typescript)["']?/gi, "");
+        clientScripts.push(`<script${cleanAttrs}>${cleanContent}</script>`);
+      }
+    }
+    const styleMatch = componentContent.match(/<style\b([^>]*)>([\s\S]*?)<\/style>/i), styleAttrs = styleMatch ? styleMatch[1] : "", styleContent = styleMatch ? styleMatch[2] : "";
+    let preservedStyle = "";
+    const hasScopedStyle = styleAttrs && /\bscoped\b/i.test(styleAttrs);
+    if (styleMatch)
+      preservedStyle = `<style${styleAttrs}>${styleContent}</style>`;
+    let templateContent = workingContent;
+    templateContent = templateContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+    if (styleMatch)
+      templateContent = templateContent.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+    {
+      const pushStyleRe = /@push\s*\(\s*['"]styles['"]\s*\)([\s\S]*?)@endpush/gi, collectedStyles = [];
+      templateContent = templateContent.replace(pushStyleRe, (_full, inner) => {
+        const styleInPush = inner.match(/<style\b([^>]*)>([\s\S]*?)<\/style>/i);
+        if (styleInPush)
+          collectedStyles.push(`<style${styleInPush[1]}>${styleInPush[2]}</style>`);
+        return "";
+      });
+      templateContent = templateContent.replace(/@push\s*\(\s*['"][^'"]+['"]\s*\)[\s\S]*?@endpush/gi, "");
+      if (collectedStyles.length > 0)
+        preservedStyle = `${preservedStyle}${collectedStyles.join(`
+`)}`;
+    }
+    if (slotContent && templateContent.includes("{{ text || slot }}"))
+      templateContent = templateContent.replace(/\{\{\s*text\s*\|\|\s*slot\s*\}\}/g, () => slotContent);
+    const { applySlots } = await importOnce("stx/slots", () => import("./slots.js")), { defaultSlot, namedSlots } = parsedSlotContent;
+    templateContent = await applySlots(templateContent, defaultSlot, namedSlots, componentContext);
+    const hasSignalScripts = clientScripts.some((s) => /\b(?:state|derived|effect|ref|reactive|computed|watch|watchEffect|useReactiveProp|defineProps|withDefaults|defineEmits|defineExpose|defineSlots)\s*(?:<[^<>()]*>)?\s*\(/.test(s)), clientSignalNames = componentClientSignalNames(clientScripts), inheritedClientSignalNames = Array.isArray(componentContext.__stx_client_signal_names) ? componentContext.__stx_client_signal_names : [];
+    if (clientSignalNames.length > 0 || inheritedClientSignalNames.length > 0)
+      componentContext.__stx_client_signal_names = [...new Set([...inheritedClientSignalNames, ...clientSignalNames])];
+    const componentOptions = {
+      ...options,
+      _rootComponentsDir: options._rootComponentsDir || options.componentsDir,
+      componentsDir: path.dirname(componentFilePath),
+      skipSignalsRuntime: !0,
+      skipEventDirectives: hasSignalScripts || clientScripts.length === 0,
+      defaultLayout: void 0
+    };
+    componentContext.__stxProcessingDepth = (parentContext.__stxProcessingDepth || 0) + 1;
+    const result = await processDirectives(templateContent, componentContext, componentFilePath, componentOptions, dependencies), preservedExpressions = new Set(Array.isArray(parentContext.__stx_preserved_client_expressions) ? parentContext.__stx_preserved_client_expressions : []);
+    for (const match of result.matchAll(/\{\{([\s\S]*?)\}\}/g))
+      preservedExpressions.add(match[1].trim());
+    if (preservedExpressions.size > 0)
+      parentContext.__stx_preserved_client_expressions = [...preservedExpressions];
+    const scopeId = componentUid;
+    let output = result;
+    if (hasSignalScripts) {
+      let propsJson = "";
+      if (Object.keys(props).length > 0)
+        try {
+          propsJson = ` data-stx-props="${escapeAttr(JSON.stringify(props))}"`;
+        } catch {}
+      const hydrateJson = hydrateTrigger ? ` stx-hydrate="${escapeAttr(hydrateTrigger)}"` : "";
+      output = `<div data-stx-scope="${scopeId}"${propsJson}${hydrateJson}>${result}</div>`;
+      const scopedScripts = await Promise.all(clientScripts.map(async (script) => {
+        const scriptMatch = script.match(/<script([^>]*)>([\s\S]*)<\/script>/i);
+        if (!scriptMatch)
+          return script;
+        const [, attrs, rawContent] = scriptMatch, { vendorStyleTags, factoryBody } = await buildComponentIsland(rawContent, componentFilePath, options.buildMode === "compile"), factoryId = hydrateTrigger ? null : registerComponentClientFactory(parentContext, factoryBody), wrappedContent = factoryId ? `window.__stxComponentFactories[${JSON.stringify(factoryId)}](${JSON.stringify(scopeId)});` : `(${factoryBody})(${JSON.stringify(scopeId)});`;
+        if (hydrateTrigger)
+          return `${vendorStyleTags}<script type="stx/island" data-stx-island="${scopeId}" data-stx-scoped${attrs}>${wrappedContent}</script>`;
+        return `${vendorStyleTags}<script data-stx-scoped data-stx-run="always"${attrs}>${wrappedContent}</script>`;
+      }));
+      output = output + `
+` + scopedScripts.join(`
+`);
+      if (preservedStyle)
+        output += `
+` + preservedStyle;
+    } else {
+      if (preservedStyle)
+        output += `
+` + preservedStyle;
+      if (clientScripts.length > 0) {
+        const eventBindings = componentContext.__stx_event_bindings || [], serverData = extractBridgeData(componentContext), transformedScripts = await Promise.all(clientScripts.map(async (fullScript) => {
+          const contentMatch = fullScript.match(/<script\b[^>]*>([\s\S]*?)<\/script>/);
+          if (!contentMatch)
+            return fullScript;
+          return await processClientScript(contentMatch[1], { eventBindings, templateContent: output, filePath: componentFilePath, projectRoot: process.cwd(), serverData });
+        }));
+        output += `
+` + transformedScripts.join(`
+`);
+        componentContext.__stx_event_bindings = [];
+      }
+    }
+    if (hasScopedStyle) {
+      const scopedStyleResult = processScopedStyles(output, componentFilePath);
+      if (scopedStyleResult.hasScoped)
+        output = scopedStyleResult.html;
+    }
+    if (componentRenderCacheKey && dependencyBaseline) {
+      const preservedNow = Array.isArray(parentContext.__stx_preserved_client_expressions) ? parentContext.__stx_preserved_client_expressions : [];
+      componentRenderCache.set(componentRenderCacheKey, {
+        output,
+        dependencies: [...dependencies].filter((dependency) => !dependencyBaseline.has(dependency)),
+        clientFactories: clientFactoryBaseline ? componentClientFactoriesRegisteredSince(parentContext, clientFactoryBaseline) : [],
+        uidsConsumed: scopeSeq.n - uidBaseline,
+        preservedClientExpressions: preservedExpressionBaseline ? preservedNow.filter((expression) => !preservedExpressionBaseline.has(expression)) : []
+      });
+    }
+    return callerClientScripts.length > 0 ? `${output}
+${callerClientScripts.join(`
+`)}` : output;
+  } catch (error) {
+    return `[Error processing component: ${error instanceof Error ? error.message : String(error)}]`;
+  } finally {
+    components.delete(componentPath);
+  }
+}
+export async function fileExists(filePath) {
+  return Bun.file(filePath).exists();
+}
+function assertInsideRoot(resolvedAbsolute, root) {
+  const r = path.resolve(root), p = path.resolve(resolvedAbsolute), rWithSep = r.endsWith(path.sep) ? r : r + path.sep;
+  if (p === r || p.startsWith(rWithSep))
+    return p;
+  return null;
+}
+async function findLayoutIn(layoutsDir, templatePath, dependencies, debug) {
+  const stripped = templatePath.startsWith("layouts/") ? templatePath.slice(8) : templatePath, base = path.join(layoutsDir, stripped);
+  for (const candidate of base.endsWith(".stx") ? [base] : [base, `${base}.stx`])
+    if (await fileExists(candidate)) {
+      if (debug)
+        console.log(`Found layout in ${layoutsDir}: ${candidate}`);
+      dependencies?.add(candidate);
+      return candidate;
+    }
+  return null;
+}
+export async function resolveTemplatePath(templatePath, currentFilePath, options, dependencies) {
+  const result = await resolveTemplatePathInner(templatePath, currentFilePath, options, dependencies);
+  if (result === null)
+    return null;
+  const safeUnderCwd = assertInsideRoot(result, process.cwd());
+  if (safeUnderCwd)
+    return safeUnderCwd;
+  const trustedDirs = [options.root, options.layoutsDir, options.fallbackLayoutsDir, options.componentsDir, options.partialsDir, options.pagesDir].filter((d) => typeof d === "string" && d.length > 0);
+  for (const dir of trustedDirs) {
+    const resolvedDir = path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir);
+    if (assertInsideRoot(result, resolvedDir))
+      return path.resolve(result);
+  }
+  console.warn(`[stx] rejected resolved template path that escapes project root: ${result} (template: ${templatePath}, from: ${currentFilePath})`);
+  return null;
+}
+async function resolveTemplatePathInner(templatePath, currentFilePath, options, dependencies) {
+  if (options.debug)
+    console.log(`Resolving template path: ${templatePath} from ${currentFilePath}`);
+  const dirPath = path.dirname(currentFilePath), projectRoot = process.cwd();
+  if (templatePath.startsWith("/")) {
+    const absolutePath = path.join(projectRoot, templatePath), safe = assertInsideRoot(absolutePath, projectRoot);
+    if (!safe) {
+      console.warn(`[stx] rejected template path that escapes project root: ${templatePath} (from ${currentFilePath})`);
+      return null;
+    }
+    if (options.debug)
+      console.log(`Checking absolute path: ${safe}`);
+    if (await fileExists(safe) && dependencies)
+      dependencies.add(safe);
+    return safe;
+  }
+  const directPath = path.join(dirPath, templatePath);
+  if (await fileExists(directPath)) {
+    if (options.debug)
+      console.log(`Found direct path: ${directPath}`);
+    if (dependencies)
+      dependencies.add(directPath);
+    return directPath;
+  }
+  if (!templatePath.endsWith(".stx") && !templatePath.endsWith(".jsx") && !templatePath.endsWith(".tsx"))
+    for (const ext of [".stx", ".tsx", ".jsx"]) {
+      const pathWithExt = `${directPath}${ext}`;
+      if (await fileExists(pathWithExt)) {
+        if (options.debug)
+          console.log(`Found direct path with extension: ${pathWithExt}`);
+        if (dependencies)
+          dependencies.add(pathWithExt);
+        return pathWithExt;
+      }
+    }
+  const layoutSearchDirs = [];
+  if (options.layoutsDir)
+    layoutSearchDirs.push(path.isAbsolute(options.layoutsDir) ? options.layoutsDir : path.resolve(process.cwd(), options.layoutsDir));
+  let searchDir = path.resolve(dirPath);
+  const rootDir = process.cwd();
+  for (let i = 0;i < 10; i++) {
+    const candidate = path.join(searchDir, "layouts");
+    let candidateExists = !1;
+    try {
+      candidateExists = fs.statSync(candidate, { throwIfNoEntry: !1 })?.isDirectory() ?? !1;
+    } catch {}
+    if (candidateExists) {
+      layoutSearchDirs.push(candidate);
+      break;
+    }
+    const parent = path.dirname(searchDir);
+    if (parent === searchDir || parent.length < rootDir.length)
+      break;
+    searchDir = parent;
+  }
+  for (const dir of layoutSearchDirs) {
+    const found = await findLayoutIn(dir, templatePath, dependencies, options.debug);
+    if (found)
+      return found;
+  }
+  if (options.fallbackLayoutsDir) {
+    const resolvedFallback = path.isAbsolute(options.fallbackLayoutsDir) ? options.fallbackLayoutsDir : path.resolve(process.cwd(), options.fallbackLayoutsDir), strippedPath = templatePath.startsWith("layouts/") ? templatePath.slice(8) : templatePath, candidates = [path.join(resolvedFallback, strippedPath)];
+    if (!templatePath.endsWith(".stx"))
+      candidates.push(`${candidates[0]}.stx`);
+    for (const candidate of candidates)
+      if (await fileExists(candidate)) {
+        if (options.debug)
+          console.log(`Found in options.fallbackLayoutsDir: ${candidate}`);
+        if (dependencies)
+          dependencies.add(candidate);
+        return candidate;
+      }
+  }
+  if (templatePath.startsWith("layouts/") || templatePath.includes("/layouts/")) {
+    const parts = templatePath.split("layouts/"), layoutsPath = path.join(options.partialsDir || dirPath, "layouts", parts[1]);
+    if (await fileExists(layoutsPath)) {
+      if (options.debug)
+        console.log(`Found in layouts path: ${layoutsPath}`);
+      if (dependencies)
+        dependencies.add(layoutsPath);
+      return layoutsPath;
+    }
+    if (!layoutsPath.endsWith(".stx")) {
+      const layoutsPathWithExt = `${layoutsPath}.stx`;
+      if (await fileExists(layoutsPathWithExt)) {
+        if (options.debug)
+          console.log(`Found in layouts path with extension: ${layoutsPathWithExt}`);
+        if (dependencies)
+          dependencies.add(layoutsPathWithExt);
+        return layoutsPathWithExt;
+      }
+    }
+  }
+  if (options.partialsDir) {
+    const partialsLayoutsDir = path.join(options.partialsDir, "layouts");
+    if (await fileExists(partialsLayoutsDir)) {
+      const fromPartialsLayouts = path.join(partialsLayoutsDir, templatePath);
+      if (await fileExists(fromPartialsLayouts)) {
+        if (options.debug)
+          console.log(`Found in partials layouts dir: ${fromPartialsLayouts}`);
+        if (dependencies)
+          dependencies.add(fromPartialsLayouts);
+        return fromPartialsLayouts;
+      }
+      if (!templatePath.endsWith(".stx")) {
+        const fromPartialsLayoutsWithExt = `${fromPartialsLayouts}.stx`;
+        if (await fileExists(fromPartialsLayoutsWithExt)) {
+          if (options.debug)
+            console.log(`Found in partials layouts dir with extension: ${fromPartialsLayoutsWithExt}`);
+          if (dependencies)
+            dependencies.add(fromPartialsLayoutsWithExt);
+          return fromPartialsLayoutsWithExt;
+        }
+      }
+    }
+  }
+  const viewsPath = options.partialsDir || path.join(process.cwd(), "views"), fromRoot = path.join(viewsPath, templatePath);
+  if (await fileExists(fromRoot)) {
+    if (options.debug)
+      console.log(`Found in views path: ${fromRoot}`);
+    if (dependencies)
+      dependencies.add(fromRoot);
+    return fromRoot;
+  }
+  if (!templatePath.endsWith(".stx")) {
+    const fromRootWithExt = `${fromRoot}.stx`;
+    if (await fileExists(fromRootWithExt)) {
+      if (options.debug)
+        console.log(`Found in views path with extension: ${fromRootWithExt}`);
+      if (dependencies)
+        dependencies.add(fromRootWithExt);
+      return fromRootWithExt;
+    }
+  }
+  if (dirPath.includes("temp")) {
+    const tempDirLayouts = path.join(path.dirname(dirPath), "layouts", templatePath);
+    if (await fileExists(tempDirLayouts)) {
+      if (options.debug)
+        console.log(`Found in temp layouts dir: ${tempDirLayouts}`);
+      if (dependencies)
+        dependencies.add(tempDirLayouts);
+      return tempDirLayouts;
+    }
+    if (!templatePath.endsWith(".stx")) {
+      const tempDirLayoutsWithExt = `${tempDirLayouts}.stx`;
+      if (await fileExists(tempDirLayoutsWithExt)) {
+        if (options.debug)
+          console.log(`Found in temp layouts dir with extension: ${tempDirLayoutsWithExt}`);
+        if (dependencies)
+          dependencies.add(tempDirLayoutsWithExt);
+        return tempDirLayoutsWithExt;
+      }
+    }
+  }
+  if (options.debug)
+    console.warn(`Template not found after trying all paths: ${templatePath} (referenced from ${currentFilePath})`);
+  else
+    console.warn(`Template not found: ${templatePath} (referenced from ${currentFilePath})`);
+  return null;
+}
+export function getSourceLineInfo(template, errorPosition, errorPattern) {
+  let lineNumber = 0, lineContent = "", context = "";
+  try {
+    if (typeof errorPosition === "number" && errorPosition >= 0) {
+      const lines = template.split(`
+`);
+      let currentPos = 0;
+      for (let i = 0;i < lines.length; i++) {
+        currentPos += lines[i].length + 1;
+        if (currentPos >= errorPosition) {
+          lineNumber = i + 1;
+          lineContent = lines[i].trim();
+          const start = Math.max(0, i - 2), end = Math.min(lines.length, i + 3);
+          context = lines.slice(start, end).map((line, idx) => {
+            const contextLineNum = start + idx + 1;
+            return `${contextLineNum === lineNumber ? "> " : "  "}${contextLineNum}: ${line}`;
+          }).join(`
+`);
+          break;
+        }
+      }
+    } else if (errorPattern) {
+      const patternPos = template.indexOf(errorPattern);
+      if (patternPos >= 0)
+        return getSourceLineInfo(template, patternPos);
+    }
+  } catch {}
+  return { lineNumber, lineContent, context };
+}
+const colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+export function createDetailedErrorMessage(errorType, errorMessage, filePath, template, errorPosition, errorPattern) {
+  const { lineNumber, context } = getSourceLineInfo(template, errorPosition, errorPattern), fileName = filePath.split("/").pop();
+  let column = 0;
+  if (typeof errorPosition === "number" && errorPosition >= 0 && template) {
+    const lastNl = template.lastIndexOf(`
+`, Math.max(0, errorPosition - 1));
+    column = errorPosition - (lastNl + 1) + 1;
+  }
+  let detailedMessage = "";
+  if (lineNumber > 0)
+    detailedMessage += `
+${filePath}:${lineNumber}${column > 0 ? `:${column}` : ""}: ${errorType.toLowerCase()} error: ${errorMessage}
+`;
+  detailedMessage += `
+${colors.bold}${colors.red}\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E${colors.reset}
+`;
+  detailedMessage += `${colors.bold}${colors.red}\u2502${colors.reset} ${colors.bold}${colors.bgRed} ERROR ${colors.reset} ${colors.red}${errorType} Error${colors.reset}${" ".repeat(Math.max(0, 43 - errorType.length))}${colors.bold}${colors.red}\u2502${colors.reset}
+`;
+  detailedMessage += `${colors.bold}${colors.red}\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F${colors.reset}
+`;
+  detailedMessage += `
+${colors.cyan}${colors.bold}File:${colors.reset} ${colors.dim}${fileName}${colors.reset}`;
+  if (lineNumber > 0)
+    detailedMessage += ` ${colors.gray}(line ${lineNumber}${column > 0 ? `, col ${column}` : ""})${colors.reset}`;
+  detailedMessage += `
+${colors.yellow}${colors.bold}Message:${colors.reset} ${errorMessage}
+`;
+  if (context)
+    detailedMessage += `
+${colors.blue}${colors.bold}Context:${colors.reset}
+${colors.dim}${context}${colors.reset}
+`;
+  return detailedMessage;
+}
+export function clearComponentCache() {
+  componentsCache.clear();
+  componentResolutionCache.clear();
+  componentRenderCache.clear();
+}
+export function getComponentCacheStats() {
+  return {
+    size: componentsCache.size,
+    maxSize: 500
+  };
+}
+const componentIslands = renderMemo(128);
+async function buildComponentIsland(rawContent, componentFilePath, minify) {
+  const key = contentKey(rawContent, componentFilePath, minify), remembered = componentIslands.get(key);
+  if (remembered) {
+    if (depsUnchanged(remembered.deps))
+      return remembered;
+    componentIslands.delete(key);
+  }
+  const cssExtraction = extractAndStripCssImports(rawContent, {
+    filePath: componentFilePath,
+    projectRoot: process.cwd()
+  });
+  let bundledContent = cssExtraction.code;
+  const vendorStyleTags = renderVendorStyleTags(cssExtraction.styles);
+  bundledContent = injectBrowserCoreAutoImports(bundledContent).code;
+  const { hasUserImports, bundleClientScript } = await importOnce("stx/client-script-bundler", () => import("./client-script-bundler.js")), bundleInputs = [];
+  let bundleFellBack = !1;
+  if (hasUserImports(bundledContent)) {
+    const unbundled = bundledContent;
+    bundledContent = await bundleClientScript(unbundled, componentFilePath, {
+      projectRoot: process.cwd(),
+      minify,
+      collectInputs: bundleInputs
+    });
+    bundleFellBack = bundledContent === unbundled;
+  }
+  const { stripStxRuntimeImports } = await importOnce("stx/signal-processing", () => import("./signal-processing.js"));
+  bundledContent = stripStxRuntimeImports(bundledContent);
+  const content = transformStoreImports(bundledContent), componentLocalNames = extractVariableNames(content), factoryBody = `function(__scopeId) {
+  ${buildRuntimeGlobalsDestructure("const", [...COMPONENT_SCOPE_LOCAL_GLOBALS, ...componentLocalNames], content)}
+  const __scope = window.stx._scopes = window.stx._scopes || {};
+  const __scopeVars = __scope[__scopeId] = __scope[__scopeId] || {};
+  __scopeVars.$refs = __scopeVars.$refs || {};
+  const __previousCurrentElement = window.__STX_CURRENT_ELEMENT__;
+  window.__STX_CURRENT_ELEMENT__ = document.querySelector('[data-stx-scope="' + __scopeId + '"]');
+
+  // Scope-specific lifecycle callbacks
+  __scopeVars.__mountCallbacks = __scopeVars.__mountCallbacks || [];
+  __scopeVars.__destroyCallbacks = __scopeVars.__destroyCallbacks || [];
+  const onMount = (fn) => __scopeVars.__mountCallbacks.push(fn);
+  const onDestroy = (fn) => __scopeVars.__destroyCallbacks.push(fn);
+
+try {
+${content}
+
+  // Register all defined signals and functions in this scope
+  const __localVars = {};
+  try {
+    ${componentLocalNames.map((v) => `if (typeof ${v} !== 'undefined') __localVars['${v}'] = ${v};`).join(`
+    `)}
+  }
+catch (e) {}
+  Object.assign(__scopeVars, __localVars);
+}
+finally {
+  window.__STX_CURRENT_ELEMENT__ = __previousCurrentElement;
+}
+}`, island = {
+    vendorStyleTags,
+    factoryBody,
+    deps: snapshotDeps([...bundleInputs, ...cssExtraction.styles.map((style) => style.resolvedPath)])
+  };
+  if (!bundleFellBack && cssExtraction.unresolved.length === 0)
+    componentIslands.set(key, island);
+  return island;
+}