@stacksjs/stx 0.2.152 → 0.2.154

package/dist/dynamic-components.js

@@ -3,6 +3,115 @@ import { safeEvaluate } from "./safe-evaluator.js";
 function escapeHtmlComment(value) {
   return value.replace(/--/g, "- -").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+const HTML_TAGS = new Set([
+  "a",
+  "abbr",
+  "address",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "main",
+  "mark",
+  "menu",
+  "meter",
+  "nav",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "section",
+  "select",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "u",
+  "ul",
+  "video"
+]), VOID_TAGS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+function resolveIsName(expr, context) {
+  const mustache = /^\s*\{\{\s*([\s\S]+?)\s*\}\}\s*$/.exec(expr), source = mustache ? mustache[1] : expr, evaluated = safeEvaluate(source, context);
+  if (evaluated && typeof evaluated === "string")
+    return evaluated;
+  const literal = source.trim();
+  return HTML_TAGS.has(literal) ? literal : null;
+}
+function displayExpression(expr) {
+  const mustache = /^\s*\{\{\s*([\s\S]+?)\s*\}\}\s*$/.exec(expr);
+  return mustache ? mustache[1] : expr;
+}
+function renderAsElement(name, attrs, slotContent) {
+  const cleanedAttrs = attrs.replace(/\s*(?::is|v-bind:is)\s*=\s*"[^"]*"/gi, "").trim(), open = cleanedAttrs ? `<${name} ${cleanedAttrs}>` : `<${name}>`;
+  if (VOID_TAGS.has(name))
+    return cleanedAttrs ? `<${name} ${cleanedAttrs}>` : `<${name}>`;
+  return `${open}${slotContent}</${name}>`;
+}
 export async function processDynamicComponents(template, context, filePath, options, dependencies) {
   let result = template;
   const componentPattern = /<component\s+(?::is|v-bind:is)\s*=\s*"([^"]*)"([^>]*)>([\s\S]*?)<\/component>/gi, matches = [];
@@ -18,12 +127,17 @@ export async function processDynamicComponents(template, context, filePath, opti
   for (let i = matches.length - 1;i >= 0; i--) {
     const m = matches[i];
     try {
-      const componentName = safeEvaluate(m.expr, context);
+      const componentName = resolveIsName(m.expr, context);
       if (!componentName || typeof componentName !== "string") {
-        const replacement = `<!-- dynamic component: could not resolve "${escapeHtmlComment(m.expr)}" -->`;
+        const replacement = `<!-- dynamic component: could not resolve "${escapeHtmlComment(displayExpression(m.expr))}" -->`;
         result = result.slice(0, m.index) + replacement + result.slice(m.index + m.full.length);
         continue;
       }
+      if (HTML_TAGS.has(componentName)) {
+        const rendered = renderAsElement(componentName, m.attrs, m.slotContent);
+        result = result.slice(0, m.index) + rendered + result.slice(m.index + m.full.length);
+        continue;
+      }
       const propsStr = m.attrs.trim(), props = {}, propsPattern = /(?::([a-zA-Z_][a-zA-Z0-9_-]*)|([a-zA-Z_][a-zA-Z0-9_-]*))\s*=\s*"([^"]*)"/g;
       let propMatch;
       while ((propMatch = propsPattern.exec(propsStr)) !== null) {
@@ -61,12 +175,17 @@ async function processSelfClosingDynamicComponents(template, context, filePath,
   for (let i = matches.length - 1;i >= 0; i--) {
     const m = matches[i];
     try {
-      const componentName = safeEvaluate(m.expr, context);
+      const componentName = resolveIsName(m.expr, context);
       if (!componentName || typeof componentName !== "string") {
-        const replacement = `<!-- dynamic component: could not resolve "${escapeHtmlComment(m.expr)}" -->`;
+        const replacement = `<!-- dynamic component: could not resolve "${escapeHtmlComment(displayExpression(m.expr))}" -->`;
         result = result.slice(0, m.index) + replacement + result.slice(m.index + m.full.length);
         continue;
       }
+      if (HTML_TAGS.has(componentName)) {
+        const rendered = renderAsElement(componentName, m.attrs, "");
+        result = result.slice(0, m.index) + rendered + result.slice(m.index + m.full.length);
+        continue;
+      }
       const componentsDir = options.componentsDir || "components", rendered = await renderComponentWithSlot(componentName, {}, "", componentsDir, context, filePath, options, new Set, dependencies ?? new Set);
       result = result.slice(0, m.index) + rendered + result.slice(m.index + m.full.length);
     } catch (error) {

package/dist/events.d.ts

@@ -1,3 +1,29 @@
+/**
+ * `@click="doThing"` names a function, so it must be INVOKED — not evaluated.
+ *
+ * The declarative runtime learned this in #1695: without it the expression falls
+ * through to a generic `new Function` and runs as a discarded identifier
+ * statement, so the click silently does nothing. Every IMPERATIVE binding path
+ * still evaluated it, in three separate places — the inline `else` branch
+ * emitted by client-script.ts, the `__stx_runHandler` fallback below, and
+ * `__stx_execute` in the x-data bridge — so the declarative path disagreed with
+ * all three (#1824).
+ *
+ * Normalising here, at emit time, rather than inside each of those runtimes:
+ * the handler text is already known when it is emitted, so one transform covers
+ * every path, and the rule stays out of the generated template literals.
+ *
+ * Restricted to a plain identifier, matching the runtime's own check exactly —
+ * a dotted path would require `obj` to exist before `typeof obj.fn` could be
+ * asked. The `_isSignal` exclusion is the runtime's too, and it matters because
+ * signals ARE functions: without it `@click="count"` would read the signal
+ * instead of doing nothing.
+ */
+export declare function asInvocableStatement(handler: string): string;
+/**
+ * Generate the complete runtime script
+ */
+export declare function generateRuntimeScript(events: ParsedEvent[]): string;
 /**
  * Extract and process event attributes from a template without generating
  * a standalone script. Returns the modified template (with @event attributes
@@ -33,55 +59,6 @@ export declare function processEventDirectives(template: string, context: Record
  * Check if a template contains event directives
  */
 export declare function hasEventDirectives(template: string): boolean;
-/* eslint-disable prefer-const, style/max-statements-per-line, no-super-linear-backtracking, regexp/no-unused-capturing-group */
-/**
- * Event Directives Module
- *
- * Provides Alpine.js-style event handling for STX templates.
- * Transforms `@click`, `@keydown.enter`, etc. into client-side event listeners.
- *
- * ## Supported Syntax
- *
- * ### Basic Events
- * ```html
- * <button @click="count++">Increment</button>
- * <button @click="handleClick()">Click me</button>
- * <form @submit="handleSubmit()">...</form>
- * ```
- *
- * ### Event Modifiers
- * ```html
- * <form @submit.prevent="handleSubmit()">...</form>
- * <a @click.prevent.stop="navigate()">Link</a>
- * <button @click.once="initialize()">Init</button>
- * <div @click.self="onlyThis()">...</div>
- * <input @keydown.capture="log()">
- * ```
- *
- * ### Key Modifiers
- * ```html
- * <input @keydown.enter="submit()">
- * <input @keyup.escape="cancel()">
- * <input @keydown.space="toggle()">
- * <input @keydown.ctrl.s="save()">
- * <input @keydown.meta.enter="send()">
- * ```
- *
- * ### Mouse Modifiers
- * ```html
- * <div @click.left="handleLeft()">
- * <div @click.right="handleRight()">
- * <div @click.middle="handleMiddle()">
- * ```
- *
- * ### Special Variables
- * ```html
- * <input @input="value = $event.target.value">
- * <button @click="handleClick($el)">Uses element</button>
- * ```
- *
- * @module events
- */
 // =============================================================================
 // Types
 // =============================================================================

package/dist/events.js

@@ -1,3 +1,4 @@
+import { templateHasReactiveContext } from "./runtime-globals.js";
 const DOM_EVENTS = new Set([
   "click",
   "dblclick",
@@ -185,8 +186,14 @@ function wrapHandler(handler, modifiers) {
     wrapped = `__stx_throttle(() => { ${wrapped} }, ${modifiers.throttle})`;
   return wrapped;
 }
+export function asInvocableStatement(handler) {
+  const name = handler.trim();
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name))
+    return handler;
+  return `if (typeof ${name} === 'function' && !${name}._isSignal) ${name}($event);`;
+}
 function generateEventListener(event) {
-  const { modifiers } = event, elementId = event.elementId.replace(/\\/g, "\\\\").replace(/'/g, "\\'"), checks = generateModifierChecks(event), handler = wrapHandler(event.handler, modifiers), options = [];
+  const { modifiers } = event, elementId = event.elementId.replace(/\\/g, "\\\\").replace(/'/g, "\\'"), checks = generateModifierChecks(event), handler = wrapHandler(asInvocableStatement(event.handler), modifiers), options = [];
   if (modifiers.once)
     options.push("once: true");
   if (modifiers.capture)
@@ -254,8 +261,8 @@ else {
     }${optionsStr});
   })();`;
 }
-function generateRuntimeScript(elements) {
-  if (elements.length === 0)
+export function generateRuntimeScript(events) {
+  if (events.length === 0)
     return "";
   return `
 <script data-stx-events>
@@ -284,9 +291,16 @@ function generateRuntimeScript(elements) {
     };
   }
 
-  // Non-reactive fallback runner. The handler is embedded HTML-entity-encoded so
-  // the surrounding <script> can never contain raw markup (e.g. </script>); we
-  // decode it to JS only in memory here, then run it with $event/$el in scope.
+  // Non-reactive fallback runner. The handler is embedded HTML-entity-encoded
+  // so the surrounding script element can never contain raw markup, including
+  // its own closing tag; we decode it to JS only in memory here, then run it
+  // with $event/$el in scope.
+  //
+  // This comment must not spell that closing tag out. It used to, as an
+  // example, and a browser ends the script element at the FIRST one it sees \u2014
+  // so everything below this line, __stx_runHandler included, was emitted as
+  // page text and no listener was ever bound. The comment about escaping was
+  // the thing that needed escaping.
   function __stx_runHandler(h, $event, $el) {
     var code = h
       .replace(/&lt;/g, '<')
@@ -305,7 +319,7 @@ function generateRuntimeScript(elements) {
   }
 
   // Event listeners
-  ${elements.flatMap((el) => el.events).map(generateEventListener).join(`
+  ${events.map(generateEventListener).join(`
 `)}
 })();
 </script>`;
@@ -338,7 +352,7 @@ export function extractAndProcessEvents(template) {
   return { template: output, bindings: allBindings };
 }
 export function processEventDirectives(template, context, _filePath) {
-  if (/\b(?:state|derived|effect)\s*(?:<[^<>()]*>)?\s*\(/.test(template) || /@(?:model|show|for|if)\s*=/.test(template) || /data-stx(?:-auto)?(?![-\w])/.test(template))
+  if (templateHasReactiveContext(template))
     return template;
   if (context.__stx_sfc_mode) {
     if (/x-data\s*=\s*["']/.test(template))
@@ -369,7 +383,7 @@ export function processEventDirectives(template, context, _filePath) {
     }
     output = output.slice(0, element.startIndex) + newTag + output.slice(element.endIndex);
   }
-  const script = generateRuntimeScript(elements), bodyIdx = output.lastIndexOf("</body>");
+  const script = generateRuntimeScript(elements.flatMap((el) => el.events)), bodyIdx = output.lastIndexOf("</body>");
   if (bodyIdx !== -1)
     output = output.slice(0, bodyIdx) + script + `
 ` + output.slice(bodyIdx);

package/dist/expressions.d.ts

@@ -80,7 +80,7 @@ export declare function interpolateScriptsInTemplate(template: string, context:
 /**
  * Process template expressions including variables, filters, and operations
  */
-export declare function processExpressions(template: string, context: Record<string, any>, filePath: string, options?: { forceSignals?: boolean }): string;
+export declare function processExpressions(template: string, context: Record<string, any>, filePath: string): string;
 /**
  * Apply filters to a value
  */

package/dist/expressions.js

@@ -318,7 +318,7 @@ export function interpolateScriptExpressions(scriptBody, context) {
       const value = evaluateExpression(expr, context);
       if (value === void 0)
         return match;
-      return JSON.stringify(value);
+      return JSON.stringify(value).replace(/</g, "\\u003c");
     } catch {
       return match;
     }
@@ -344,7 +344,7 @@ export function interpolateScriptsInTemplate(template, context, options = {}) {
   });
   return restoreStashedScripts(output, interpolatedScripts);
 }
-export function processExpressions(template, context, filePath, options) {
+export function processExpressions(template, context, filePath) {
   let output = template;
   const styleMatcher = (html, i) => {
     const end = matchStyleElement(html, i);
@@ -359,7 +359,7 @@ export function processExpressions(template, context, filePath, options) {
   output = maskInto(output, styleMatcher, styleBlocks, (n) => `<!--__STX_STYLE_${n}__-->`);
   const scriptBlocks = [];
   output = maskInto(output, matchScriptElement, scriptBlocks, (n) => `<!--__STX_SCRIPT_EXPR_${n}__-->`);
-  const hasSignals = options?.forceSignals === !0 || context?.__stx_force_signals === !0 || Array.isArray(context?.__stx_client_signal_names) || usesSignalsInScript(template), clientSignalNames = new Set(Array.isArray(context?.__stx_client_signal_names) ? context.__stx_client_signal_names : []), preservedClientExpressions = new Set(Array.isArray(context?.__stx_preserved_client_expressions) ? context.__stx_preserved_client_expressions : []);
+  const hasSignals = context?.__stx_signals_gate === !0 || usesSignalsInScript(template), clientSignalNames = new Set(Array.isArray(context?.__stx_client_signal_names) ? context.__stx_client_signal_names : []), preservedClientExpressions = new Set(Array.isArray(context?.__stx_preserved_client_expressions) ? context.__stx_preserved_client_expressions : []);
   output = output.replace(/\{\{\{([\s\S]*?)\}\}\}/g, (match, expr, offset) => {
     try {
       const value = evaluateExpression(expr, context);

package/dist/framework-composables.d.ts

@@ -0,0 +1,41 @@
+/** Clear the cache. Dev HMR calls this when composables change on disk. */
+export declare function clearFrameworkComposableCache(): void;
+/**
+ * Choose which files in the composables directory carry runtime code.
+ *
+ * This ran against a `*.ts` glob, which is only ever right when stx runs from
+ * `src/`. A released package runs from `dist/`, where the directory holds 37
+ * `.js` files and 37 `.d.ts` files and not one plain `.ts` — so every file the
+ * bundler opened was type-only, nothing was ever emitted, and every requested
+ * name was reported as unbundlable. The one configuration where the old glob
+ * worked is the one the repo's own tests run in, which is why it never showed
+ * up here (stacksjs/stx#1832).
+ *
+ * Two compounding details, both fixed by going through this function:
+ *
+ *  - `.d.ts` can never contribute runtime code, so it is excluded outright
+ *    rather than left to be caught downstream.
+ *  - The barrel exclusion compared `endsWith('index.ts')`, and `'index.d.ts'`
+ *    does not end with that. The one file the filter existed to skip was the
+ *    only one it let through — and being a barrel of `export … from …`, it was
+ *    also the one shape the export-stripping below cannot parse.
+ *
+ * Exported so the selection can be tested against a dist-shaped listing without
+ * a built package.
+ */
+export declare function selectComposableFiles(files: string[]): string[];
+/**
+ * Which framework composables does this source actually call?
+ *
+ * Restricted to the server-only set, so a page calling `useLocalStorage` (which
+ * the runtime provides) never drags in a module copy.
+ */
+export declare function referencedFrameworkComposables(source: string): string[];
+/**
+ * Build a script exposing `names` on `window.stx` and as bare globals.
+ *
+ * Returns null when nothing is needed.
+ */
+export declare function getFrameworkComposableScript(source: string, composablesDir?: string): Promise<string | null>;
+/** @internal test-only — declare names the runtime provides. */
+export declare function __setRuntimeOwnedForTest(names: string[]): void;

package/dist/framework-composables.js

@@ -0,0 +1,115 @@
+import path from "node:path";
+import { getPublicEnvDefine } from "./public-env.js";
+import { SERVER_ONLY_COMPOSABLES } from "./unresolved-identifiers.js";
+const _cache = new Map, RUNTIME_OWNED = new Set, SERVER_ONLY = new Set(SERVER_ONLY_COMPOSABLES);
+export function clearFrameworkComposableCache() {
+  _cache.clear();
+}
+export function selectComposableFiles(files) {
+  const byBase = new Map;
+  for (const file of files) {
+    const base = path.basename(file);
+    if (base.endsWith(".d.ts"))
+      continue;
+    const stem = base.replace(/\.[jt]s$/, "");
+    if (stem === "index")
+      continue;
+    if (stem === base)
+      continue;
+    const existing = byBase.get(stem);
+    if (existing && !existing.endsWith(".js"))
+      continue;
+    byBase.set(stem, file);
+  }
+  return [...byBase.values()].sort();
+}
+function declaresLocally(source, name) {
+  const escaped = name.replace(/[$()*+.?[\\\]^{|}-]/g, "\\$&");
+  return new RegExp(`(?:^|[^\\w$.])(?:const|let|var|function|class)\\s+${escaped}\\b`).test(source);
+}
+export function referencedFrameworkComposables(source) {
+  if (!source)
+    return [];
+  const authored = source.replace(/<script\b[^>]*\bdata-stx-runtime\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\bdata-stx-framework-composables\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\bdata-stx-stores\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\bdata-stx-composables\b[^>]*>[\s\S]*?<\/script>/gi, ""), found = [];
+  for (const name of SERVER_ONLY) {
+    if (RUNTIME_OWNED.has(name))
+      continue;
+    const escaped = name.replace(/[$()*+.?[\\\]^{|}-]/g, "\\$&");
+    if (new RegExp(`(^|[^\\w$.])${escaped}\\s*\\(`).test(authored))
+      found.push(name);
+  }
+  return found.sort();
+}
+export async function getFrameworkComposableScript(source, composablesDir) {
+  const names = referencedFrameworkComposables(source);
+  if (names.length === 0)
+    return null;
+  const dir = composablesDir ?? path.join(import.meta.dir, "composables"), key = `${dir}\x00${names.join(",")}`, cached = _cache.get(key);
+  if (cached !== void 0)
+    return cached || null;
+  const transpiler = new Bun.Transpiler({ loader: "ts", target: "browser", define: getPublicEnvDefine() }), wanted = new Set(names), chunks = [], emitted = new Set;
+  let files = [];
+  try {
+    const glob = new Bun.Glob("*.{ts,js}");
+    for await (const file of glob.scan({ cwd: dir, absolute: !0 }))
+      files.push(file);
+  } catch {
+    _cache.set(key, "");
+    return null;
+  }
+  files = selectComposableFiles(files);
+  for (const file of files) {
+    let code;
+    try {
+      code = await Bun.file(file).text();
+    } catch {
+      continue;
+    }
+    let exports = [];
+    try {
+      exports = transpiler.scan(code).exports.filter((n) => n !== "default");
+    } catch {
+      continue;
+    }
+    if (!exports.some((n) => wanted.has(n)))
+      continue;
+    try {
+      code = code.replace(/^import\s+.*from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+      code = code.replace(/^import\s+type\s+.*$/gm, "");
+      code = code.replace(/^export\s+\*\s+(?:as\s+\w+\s+)?from\s*['"][^'"]+['"]\s*;?\s*$/gm, "");
+      code = code.replace(/^export\s+(?:type\s+)?\{[\s\S]*?\}\s*(?:from\s*['"][^'"]+['"]\s*)?;?\s*$/gm, "");
+      code = code.replace(/^export\s+default\s+/gm, "");
+      code = code.replace(/^export\s+(?=(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface|enum)\b)/gm, "");
+      chunks.push(`// ${path.basename(file).replace(/\.[jt]s$/, "")}
+${transpiler.transformSync(code).trim()}`);
+      for (const name of exports)
+        emitted.add(name);
+    } catch (error) {
+      console.warn(`[stx] framework composable ${path.basename(file)} could not be bundled:`, error);
+    }
+  }
+  const missing = names.filter((n) => !emitted.has(n) && !declaresLocally(source, n));
+  if (missing.length > 0)
+    console.warn(`[stx] could not bundle ${missing.join(", ")} from @stacksjs/stx/composables \u2014 ` + "calls to them will throw ReferenceError in the browser. Import them explicitly so the bundler inlines them, or use a runtime equivalent from window.stx.");
+  if (chunks.length === 0) {
+    _cache.set(key, "");
+    return null;
+  }
+  const assignments = [...emitted].map((name) => `  try { if (!(${JSON.stringify(name)} in __s)) { __s[${JSON.stringify(name)}] = ${name}; if (!(${JSON.stringify(name)} in window)) window[${JSON.stringify(name)}] = ${name}; } } catch (e) {}`).join(`
+`), script = `<script data-stx-framework-composables>
+;(function(){
+  var __s = window.stx = window.stx || {};
+${chunks.join(`
+
+`)}
+${assignments}
+})();
+</script>`;
+  _cache.set(key, script);
+  return script;
+}
+export function __setRuntimeOwnedForTest(names) {
+  RUNTIME_OWNED.clear();
+  for (const n of names)
+    RUNTIME_OWNED.add(n);
+}

package/dist/head.js

@@ -194,7 +194,11 @@ export function applyHead(config = currentHead) {
   }
   if (config.htmlAttrs)
     for (const [key, value] of Object.entries(config.htmlAttrs))
-      document.documentElement.setAttribute(key, value);
+      if (key === "class")
+        for (const cls of String(value).split(/\s+/).filter(Boolean))
+          document.documentElement.classList.add(cls);
+      else
+        document.documentElement.setAttribute(key, value);
   if (config.bodyAttrs)
     for (const [key, value] of Object.entries(config.bodyAttrs))
       document.body.setAttribute(key, value);

package/dist/hot-reload.js

@@ -198,8 +198,14 @@ catch (e) {
             console.log('[stx] Reloading...', msg.path || '');
             // Use SPA router for progressive update instead of full page reload.
             // Falls back to hard reload only when the router isn't available.
-            if (typeof window.navigate === 'function') {
-              window.navigate(window.location.pathname + window.location.search, false, true);
+            // Call the ROUTER directly, not window.navigate: the runtime helper
+            // takes (url, options) and silently dropped the third argument, so
+            // force never arrived and the same-URL early return made this a
+            // no-op on every page that had the router (#1807). pushState=false
+            // keeps the address bar untouched (this is a reload, not a
+            // navigation) and force=true bypasses the early return.
+            if (window.stxRouter && typeof window.stxRouter.navigate === 'function') {
+              window.stxRouter.navigate(window.location.pathname + window.location.search, false, true);
             } else {
               window.location.reload();
             }

package/dist/includes.js

@@ -560,6 +560,7 @@ export async function processIncludes(template, context, filePath, options, depe
       workingContent = workingContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
       workingContent = workingContent.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
       const includeContext = { ...context };
+      includeContext.__stx_signals_gate = usesSignalsInScript(partialContent);
       for (const [key, value] of Object.entries(localVars))
         includeContext[key] = value;
       const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, scriptMatches = [...partialContent.matchAll(scriptRegex)];
@@ -597,7 +598,7 @@ export async function processIncludes(template, context, filePath, options, depe
         if (isSignalScript && !isServerScript) {
           signalScopeId = `stx_scope_${path.basename(includeFilePath, ".stx").replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeIdCounter}`;
           const resolvedContent = transformStoreImports(scriptContent), transformedScript = transformSignalScript(resolvedContent, signalScopeId);
-          preservedScript += `${vendorStyleTags}<script data-stx-scoped>${transformedScript}</script>
+          preservedScript += `${vendorStyleTags}<script data-stx-scoped data-stx-run="always">${transformedScript}</script>
 `;
           continue;
         }
@@ -613,7 +614,7 @@ export async function processIncludes(template, context, filePath, options, depe
           const extraAttrs = scriptAttrs.replace(/\bclient\b/i, "").trim();
           signalScopeId = `stx_scope_${path.basename(includeFilePath, ".stx").replace(/[^a-zA-Z0-9]/g, "_")}_${++scopeIdCounter}`;
           const resolvedContent = transformStoreImports(scriptContent), tail = buildScopeRegistrationTail(resolvedContent, signalScopeId), wrapped = wrapClientScript(resolvedContent, tail);
-          preservedScript += `${vendorStyleTags}<script data-stx-scoped${extraAttrs ? ` ${extraAttrs}` : ""}>${wrapped}</script>
+          preservedScript += `${vendorStyleTags}<script data-stx-scoped data-stx-run="always"${extraAttrs ? ` ${extraAttrs}` : ""}>${wrapped}</script>
 `;
         }
       }
@@ -630,8 +631,7 @@ export async function processIncludes(template, context, filePath, options, depe
       const { processLoops } = await import("./loops.js");
       let processedContent = processLoops(workingContent, includeContext, includeFilePath);
       processedContent = processConditionals(processedContent, includeContext, includeFilePath);
-      const partialHasSignals = usesSignalsInScript(partialContent);
-      processedContent = processExpressions(processedContent, includeContext, includeFilePath, { forceSignals: partialHasSignals });
+      processedContent = processExpressions(processedContent, includeContext, includeFilePath);
       if (preservedStyle)
         processedContent += `
 ` + preservedStyle;

package/dist/index.d.ts

@@ -28,6 +28,22 @@ export { type HydrationOptions } from './hydration';
 // shapes with different field sets; those are kept private to their modules
 // to avoid silently shadowing the user-facing one. Surfaced by stacksjs/stx#1707.
 export { type CookieOptions } from './composables/use-cookie';
+// Storage composables were reachable ONLY via the './composables' subpath, so
+// `import { useLocalStorage } from '@stacksjs/stx'` failed with TS2614 while
+// `state`/`derived` imported fine — and a `functions/` composable (which the
+// docs recommend for anything with persistence) had to reach for the subpath,
+// where the same identifier used to return a different shape. See #1797.
+export {
+  clearStorage,
+  getStorageKeys,
+  getStorageSize,
+  type StorageRef,
+  type StorageType,
+  useLocalStorage,
+  useSessionStorage,
+  useStorage,
+  type UseStorageOptions,
+} from './composables/use-storage';
 export { formatSize, getTotalSize } from './deploy/index';
 export { type ImageRenderResult, type ImageVariant, type ProcessedImage, clearImageCache, getFallbackVariant, getMimeType, groupVariantsByFormat, optimizeImage, processImage } from './image-optimization/index';
 export { type AnalysisResult } from './analyzer';
@@ -62,6 +78,7 @@ export * from './async-components';
 export * from './auth';
 export * from './build';
 export * from './build-assets';
+export * from './build-id';
 export * from './build-mode-detector';
 export * from './build-optimizer';
 export * from './broadcasting';

package/dist/index.js

@@ -1,3 +1,11 @@
+export {
+  clearStorage,
+  getStorageKeys,
+  getStorageSize,
+  useLocalStorage,
+  useSessionStorage,
+  useStorage
+} from "./composables/use-storage.js";
 export { formatSize, getTotalSize } from "./deploy/index.js";
 export { clearImageCache, getFallbackVariant, getMimeType, groupVariantsByFormat, optimizeImage, processImage } from "./image-optimization/index.js";
 export { fileExists } from "./utils.js";
@@ -21,6 +29,7 @@ export * from "./async-components.js";
 export * from "./auth.js";
 export * from "./build.js";
 export * from "./build-assets.js";
+export * from "./build-id.js";
 export * from "./build-mode-detector.js";
 export * from "./build-optimizer.js";
 export * from "./broadcasting.js";

package/dist/isolated-build.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Run `build` over `entrypoints`, falling back to one-at-a-time on failure.
+ *
+ * @param entrypoints absolute paths to build
+ * @param build performs a Bun.build over the given subset; should throw or
+ * reject on failure, which is what Bun.build does by default
+ */
+export declare function buildIsolatingFailures(entrypoints: string[], build: (subset: string[]) => Promise<unknown>): Promise<IsolatedBuildResult>;
+export declare interface IsolatedBuildResult {
+  succeeded: string[]
+  failed: Array<{ entrypoint: string, error: string }>
+}

package/dist/isolated-build.js

@@ -0,0 +1,18 @@
+import { formatBuildFailure } from "./build-message.js";
+export async function buildIsolatingFailures(entrypoints, build) {
+  if (entrypoints.length === 0)
+    return { succeeded: [], failed: [] };
+  try {
+    await build(entrypoints);
+    return { succeeded: [...entrypoints], failed: [] };
+  } catch {}
+  const succeeded = [], failed = [];
+  for (const entrypoint of entrypoints)
+    try {
+      await build([entrypoint]);
+      succeeded.push(entrypoint);
+    } catch (error) {
+      failed.push({ entrypoint, error: formatBuildFailure(error, entrypoint) });
+    }
+  return { succeeded, failed };
+}