@stacksjs/stx 0.2.155 → 0.2.157

package/dist/color-mode-boot.d.ts

@@ -1,57 +1,3 @@
-/**
- * Build the synchronous pre-paint `<script>`.
- *
- * Every storage access is wrapped: a sandboxed origin or disabled storage must
- * degrade to the default mode, never throw. A throw here is unusually costly
- * because the script sits above the application shell — an uncaught error would
- * block the rest of the document.
- */
-export declare function generateColorModeBootScript(options?: ColorModeBootConfig): string;
-/**
- * Insert the boot script as the first thing in `<head>`.
- *
- * Placement matters twice over: the script must run before the browser paints,
- * and a stylesheet `<link>` above it would block its execution (CSS blocks JS),
- * delaying the very thing it exists to make early.
- *
- * `<meta charset>` is stepped over when it leads the head, so the encoding
- * declaration keeps its place at the top of the document.
- *
- * Idempotent — a document that already carries the marker is returned
- * unchanged, so this is safe on paths that run it more than once.
- */
-export declare function injectColorModeBootScript(html: string, options?: ColorModeBootConfig): string;
-/**
- * Re-assert the ordering of the two head tags whose position is load-bearing:
- * `<meta charset>` first, then the color-mode boot script, then everything else.
- *
- * Run this LAST, after every other head injection. Ordering the injectors
- * against each other would hold only until the next one is added; re-asserting
- * the result once at the end holds regardless of what ran before.
- */
-export declare function normalizeCriticalHeadOrder(html: string): string;
-/**
- * Move an already-injected boot script back to the top of `<head>`.
- *
- * `injectColorModeBootScript` puts it first, but later stages of the pipeline
- * then insert *ahead* of it and push it down (#1803): the signals runtime is
- * relocated before the first `<script>` on the page — which is this one — and
- * the store and composable bundles anchor themselves to the runtime tag. The
- * boot script ended up fifth, behind all three.
- *
- * That is not merely a paint-timing problem. The bundles that overtook it read
- * `window.__STX_COLOR_MODE__`, which this script publishes, so a `useColorMode()`
- * inside a store saw `undefined` and silently fell back to the default storage
- * key and a null attribute — writing the user's preference somewhere the boot
- * script will never read it back, and never applying the configured attribute.
- *
- * Run this last, after every other head injection. Ordering the injectors
- * against each other would work only until the next one is added; re-asserting
- * the position once at the end holds regardless of what ran before.
- *
- * A no-op when the document has no boot script or it is already in place.
- */
-export declare function hoistColorModeBootScript(html: string): string;
 /**
  * Pre-paint color-mode bootstrap (stacksjs/stx#1794).
  *
@@ -103,22 +49,94 @@ export declare function hoistColorModeBootScript(html: string): string;
  * @module color-mode-boot
  */
 /** Marker attribute — makes injection idempotent and findable by tests. */
-export declare const COLOR_MODE_BOOT_MARKER: 'data-stx-color-mode-boot';
+export declare const COLOR_MODE_BOOT_MARKER = "data-stx-color-mode-boot";
 /** The global the boot script publishes its resolved config on. */
-export declare const COLOR_MODE_BOOT_GLOBAL: '__STX_COLOR_MODE__';
+export declare const COLOR_MODE_BOOT_GLOBAL = "__STX_COLOR_MODE__";
+export type ColorModeBootMode = 'light' | 'dark' | 'auto' | 'system';
+/** Spelling written to storage for "follow the system". */
+export type ColorModeBootAutoValue = 'auto' | 'system';
 /**
  * Pre-paint options. A strict subset of `ColorModeOptions` — only the fields
  * that affect what lands on the root element before paint. `disableTransitions`
  * is deliberately absent: nothing has painted yet, so there is no transition to
  * suppress, and forcing a reflow in the critical path would only cost time.
  */
-export declare interface ColorModeBootConfig {
-  storageKey?: string
-  initialMode?: ColorModeBootMode
-  darkClass?: string | null
-  attribute?: string | null
-  autoValue?: ColorModeBootAutoValue
+export interface ColorModeBootConfig {
+    /** localStorage key holding the preference. @default 'stx-color-mode' */
+    storageKey?: string;
+    /**
+     * Mode used when nothing valid is stored. @default 'auto'
+     * `'system'` is accepted as an alias for `'auto'`.
+     */
+    initialMode?: ColorModeBootMode;
+    /**
+     * Class applied to `<html>` when dark. @default 'dark'
+     * Pass `null` to opt out — the attribute alone then carries the mode.
+     */
+    darkClass?: string | null;
+    /**
+     * Attribute set to the resolved mode on `<html>`, e.g. `'data-theme'`.
+     * Applied *alongside* `darkClass`, mirroring `useColorMode` (#1788).
+     */
+    attribute?: string | null;
+    /**
+     * Spelling `useColorMode` writes back for "follow the system". Published to
+     * the client so the composable doesn't convert an app's existing `'system'`
+     * key to `'auto'`. @default whatever is stored, else 'auto'
+     */
+    autoValue?: ColorModeBootAutoValue;
 }
-export type ColorModeBootMode = 'light' | 'dark' | 'auto' | 'system';
-/** Spelling written to storage for "follow the system". */
-export type ColorModeBootAutoValue = 'auto' | 'system';
+/**
+ * Build the synchronous pre-paint `<script>`.
+ *
+ * Every storage access is wrapped: a sandboxed origin or disabled storage must
+ * degrade to the default mode, never throw. A throw here is unusually costly
+ * because the script sits above the application shell — an uncaught error would
+ * block the rest of the document.
+ */
+export declare function generateColorModeBootScript(options?: ColorModeBootConfig): string;
+/**
+ * Insert the boot script as the first thing in `<head>`.
+ *
+ * Placement matters twice over: the script must run before the browser paints,
+ * and a stylesheet `<link>` above it would block its execution (CSS blocks JS),
+ * delaying the very thing it exists to make early.
+ *
+ * `<meta charset>` is stepped over when it leads the head, so the encoding
+ * declaration keeps its place at the top of the document.
+ *
+ * Idempotent — a document that already carries the marker is returned
+ * unchanged, so this is safe on paths that run it more than once.
+ */
+export declare function injectColorModeBootScript(html: string, options?: ColorModeBootConfig): string;
+/**
+ * Re-assert the ordering of the two head tags whose position is load-bearing:
+ * `<meta charset>` first, then the color-mode boot script, then everything else.
+ *
+ * Run this LAST, after every other head injection. Ordering the injectors
+ * against each other would hold only until the next one is added; re-asserting
+ * the result once at the end holds regardless of what ran before.
+ */
+export declare function normalizeCriticalHeadOrder(html: string): string;
+/**
+ * Move an already-injected boot script back to the top of `<head>`.
+ *
+ * `injectColorModeBootScript` puts it first, but later stages of the pipeline
+ * then insert *ahead* of it and push it down (#1803): the signals runtime is
+ * relocated before the first `<script>` on the page — which is this one — and
+ * the store and composable bundles anchor themselves to the runtime tag. The
+ * boot script ended up fifth, behind all three.
+ *
+ * That is not merely a paint-timing problem. The bundles that overtook it read
+ * `window.__STX_COLOR_MODE__`, which this script publishes, so a `useColorMode()`
+ * inside a store saw `undefined` and silently fell back to the default storage
+ * key and a null attribute — writing the user's preference somewhere the boot
+ * script will never read it back, and never applying the configured attribute.
+ *
+ * Run this last, after every other head injection. Ordering the injectors
+ * against each other would work only until the next one is added; re-asserting
+ * the position once at the end holds regardless of what ran before.
+ *
+ * A no-op when the document has no boot script or it is already in place.
+ */
+export declare function hoistColorModeBootScript(html: string): string;

package/dist/component-client-factories.d.ts

@@ -1,9 +1,4 @@
+export declare const COMPONENT_CLIENT_FACTORIES_CONTEXT_KEY = "__stx_component_client_factories";
 export declare function initializeComponentClientFactories(context: Record<string, unknown>): void;
 export declare function registerComponentClientFactory(context: Record<string, unknown>, factoryBody: string): string | null;
 export declare function injectComponentClientFactories(html: string, context: Record<string, unknown>): string;
-export declare const COMPONENT_CLIENT_FACTORIES_CONTEXT_KEY: '__stx_component_client_factories';
-declare interface ComponentClientFactory {
-  body: string
-  instances: number
-}
-declare type ComponentClientFactoryRegistry = Map<string, ComponentClientFactory>;

package/dist/component-processing.d.ts

@@ -1,4 +1,10 @@
-import { restoreStashedScripts, stashScriptElements } from './html-masking';
+/**
+ * Component processing functions extracted from process.ts.
+ *
+ * Handles component tag parsing, attribute parsing, built-in STX components,
+ * @import directives, @component directives, and custom element resolution
+ * (kebab-case and PascalCase).
+ */
 import type { StxOptions } from './types';
 /**
  * Convert PascalCase to kebab-case with proper handling of consecutive uppercase letters.
@@ -16,6 +22,54 @@ import type { StxOptions } from './types';
  * 3. Convert to lowercase
  */
 export declare function pascalToKebab(str: string): string;
+import { restoreStashedScripts, stashScriptElements } from './html-masking';
+export { restoreStashedScripts, stashScriptElements };
+/**
+ * Parse HTML/JSX-like attributes from a string.
+ *
+ * Properly handles:
+ * - Simple attributes: `name="value"`
+ * - Boolean attributes: `disabled`
+ * - Dynamic values: `prop="{{ expr }}"` (evaluated at SSR)
+ * - Attributes with `=` in values: `url="https://example.com?a=1&b=2"`
+ * - Single and double quoted values
+ * - Escaped quotes within values
+ *
+ * ## Dynamic Data Syntax
+ *
+ * Use `{{ }}` for all dynamic data interpolation:
+ * ```html
+ * <Component title="{{ pageTitle }}" count="{{ items.length }}" />
+ * <div class="{{ isActive ? 'active' : '' }}">{{ content }}</div>
+ * ```
+ *
+ * ## Event Syntax (Alpine-style)
+ *
+ * ```html
+ * <button @click="handleClick()">Click me</button>
+ * <form @submit.prevent="handleSubmit()">...</form>
+ * <input @keydown.enter="send()" @keydown.escape="cancel()">
+ * ```
+ *
+ * @param attributesStr - The attributes portion of a tag (between tag name and closing)
+ * @returns Array of parsed attributes with name and value
+ */
+export interface ParsedAttribute {
+    name: string;
+    value: string | true;
+}
+/**
+ * Component tag match result
+ */
+export interface ComponentTagMatch {
+    fullMatch: string;
+    tagName: string;
+    attributes: string;
+    content: string;
+    startIndex: number;
+    endIndex: number;
+    isSelfClosing: boolean;
+}
 /**
  * Find component tags in HTML, properly handling quoted strings
  * This solves the issue where `>` inside attribute values would incorrectly end the tag
@@ -54,7 +108,9 @@ export declare function findComponentTags(html: string, tagPattern: RegExp, skip
  * live markup.
  */
 export declare function decodeAttributeEntities(value: string): string;
-export declare function decodeStxProp(attrValue: string, options?: { debug?: boolean }): unknown;
+export declare function decodeStxProp(attrValue: string, options?: {
+    debug?: boolean;
+}): unknown;
 /**
  * Parse multiline attributes from a component tag
  * Handles HTML content inside attribute values correctly
@@ -89,50 +145,3 @@ export declare function processComponentDirectives(template: string, context: Re
  * Uses a proper parser that handles HTML content inside attribute values
  */
 export declare function processCustomElements(template: string, context: Record<string, any>, filePath: string, componentsDir: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
-/**
- * Parse HTML/JSX-like attributes from a string.
- *
- * Properly handles:
- * - Simple attributes: `name="value"`
- * - Boolean attributes: `disabled`
- * - Dynamic values: `prop="{{ expr }}"` (evaluated at SSR)
- * - Attributes with `=` in values: `url="https://example.com?a=1&b=2"`
- * - Single and double quoted values
- * - Escaped quotes within values
- *
- * ## Dynamic Data Syntax
- *
- * Use `{{ }}` for all dynamic data interpolation:
- * ```html
- * <Component title="{{ pageTitle }}" count="{{ items.length }}" />
- * <div class="{{ isActive ? 'active' : '' }}">{{ content }}</div>
- * ```
- *
- * ## Event Syntax (Alpine-style)
- *
- * ```html
- * <button @click="handleClick()">Click me</button>
- * <form @submit.prevent="handleSubmit()">...</form>
- * <input @keydown.enter="send()" @keydown.escape="cancel()">
- * ```
- *
- * @param attributesStr - The attributes portion of a tag (between tag name and closing)
- * @returns Array of parsed attributes with name and value
- */
-export declare interface ParsedAttribute {
-  name: string
-  value: string | true
-}
-/**
- * Component tag match result
- */
-export declare interface ComponentTagMatch {
-  fullMatch: string
-  tagName: string
-  attributes: string
-  content: string
-  startIndex: number
-  endIndex: number
-  isSelfClosing: boolean
-}
-export { restoreStashedScripts, stashScriptElements };

package/dist/component-processing.js

@@ -14,7 +14,7 @@ export function findComponentTags(html, tagPattern, skipTags) {
     const tagStart = html.indexOf("<", pos);
     if (tagStart === -1)
       break;
-    const tagNameMatch = html.slice(tagStart + 1).match(new RegExp(`^(${tagPattern.source})`));
+    const tagNameMatch = html.slice(tagStart + 1).match(new RegExp(`^(${tagPattern.source})(?![\\w.:-])`));
     if (!tagNameMatch) {
       pos = tagStart + 1;
       continue;

package/dist/component-registry.d.ts

@@ -1,45 +1,80 @@
-import type { StxOptions } from './types';
 /**
- * Convert a kebab-case string to PascalCase.
+ * Component Registry
  *
- * @example kebabToPascal("stx-link") // "StxLink"
- */
-export declare function kebabToPascal(str: string): string;
-/**
- * Convert a PascalCase string to kebab-case.
+ * Handles resolution of both builtin and file-based STX components.
+ * Builtin components (e.g., StxLink, StxImage) are registered in-memory
+ * and render directly to HTML without requiring a .stx file on disk.
+ * File-based components are resolved through a multi-strategy search
+ * that mirrors the existing resolution logic in utils.ts.
  *
- * @example pascalToKebab("StxLink") // "stx-link"
+ * @module component-registry
  */
-export declare function pascalToKebab(str: string): string;
-/** Singleton registry instance shared across the framework */
-export declare const registry: ComponentRegistry;
+import type { StxOptions } from './types';
 /**
  * Context passed to builtin component render functions.
  */
-export declare interface RenderContext {
-  context: Record<string, any>
-  filePath: string
-  options: StxOptions
-  dependencies: Set<string>
+export interface RenderContext {
+    /** Template variable context */
+    context: Record<string, any>;
+    /** Path of the template invoking this component */
+    filePath: string;
+    /** Compiler options */
+    options: StxOptions;
+    /** Dependency set for cache invalidation tracking */
+    dependencies: Set<string>;
 }
 /**
  * Props resolved from component attributes, categorized by binding type.
  */
-export declare interface ResolvedProps {
-  static: Record<string, string | boolean>
-  staticNames: Record<string, string>
-  serverDynamic: Record<string, unknown>
-  clientReactive: Record<string, string>
-  events: Record<string, string>
+export interface ResolvedProps {
+    /** Static attribute values — e.g. title="Hello", disabled */
+    static: Record<string, string | boolean>;
+    /**
+     * Original attribute spelling for any `static` key that was camelized,
+     * keyed by the camelized name — e.g. `{ activeClass: 'active-class' }`.
+     *
+     * A static attribute is two things at once, and they disagree about naming.
+     * To a `.stx` component it is a prop, and `active-class` has to arrive as
+     * `$props.activeClass` because a kebab key cannot be destructured. To a
+     * builtin that forwards unconsumed attributes onto real markup it is an HTML
+     * attribute, and must go out spelled the way the author wrote it. Keeping the
+     * original here lets both be true; without it, forwarding emitted
+     * `activeClass="…"` and the browser saw an unknown attribute.
+     *
+     * Only present for names that actually changed, so `key in staticNames` is a
+     * meaningful test.
+     */
+    staticNames: Record<string, string>;
+    /** Server-side dynamic bindings — e.g. :count="items.length" (evaluated at compile time) */
+    serverDynamic: Record<string, unknown>;
+    /** Client-side reactive bindings — expression string preserved for signals */
+    clientReactive: Record<string, string>;
+    /** Event handler bindings — e.g. @click="handler()" */
+    events: Record<string, string>;
 }
 /**
  * Definition for a builtin component that renders without a .stx file.
  */
-export declare interface BuiltinComponentDef {
-  name: string
-  aliases: string[]
-  render(props: ResolvedProps, slotContent: string, ctx: RenderContext): string
+export interface BuiltinComponentDef {
+    /** Canonical component name (e.g. "StxLink") */
+    name: string;
+    /** Alternative names that resolve to this component (e.g. ["stx-link"]) */
+    aliases: string[];
+    /** Render the component to an HTML string */
+    render(props: ResolvedProps, slotContent: string, ctx: RenderContext): string;
 }
+/**
+ * Convert a kebab-case string to PascalCase.
+ *
+ * @example kebabToPascal("stx-link") // "StxLink"
+ */
+export declare function kebabToPascal(str: string): string;
+/**
+ * Convert a PascalCase string to kebab-case.
+ *
+ * @example pascalToKebab("StxLink") // "stx-link"
+ */
+export declare function pascalToKebab(str: string): string;
 /**
  * Central registry for STX components.
  *
@@ -47,9 +82,37 @@ export declare interface BuiltinComponentDef {
  * file-based component resolution with multi-directory search.
  */
 export declare class ComponentRegistry {
-  builtins: Map<string, BuiltinComponentDef>;
-  registerBuiltin(def: BuiltinComponentDef): void;
-  isBuiltin(name: string): boolean;
-  getBuiltin(name: string): BuiltinComponentDef | null;
-  resolveFile(name: string, fromFile: string, options: StxOptions, parentContext?: Record<string, any>): Promise<string | null>;
+    /** Map of lowercase name/alias → builtin definition */
+    builtins: Map<string, BuiltinComponentDef>;
+    /**
+     * Register a builtin component under its canonical name and all aliases.
+     */
+    registerBuiltin(def: BuiltinComponentDef): void;
+    /**
+     * Check whether a component name matches a registered builtin (case-insensitive).
+     */
+    isBuiltin(name: string): boolean;
+    /**
+     * Retrieve a builtin component definition by name (case-insensitive).
+     * Returns null if no matching builtin is found.
+     */
+    getBuiltin(name: string): BuiltinComponentDef | null;
+    /**
+     * Resolve a file-based component to an absolute file path.
+     *
+     * Resolution order:
+     * 1. Check `context.__importedComponents` Map (explicit @import directives)
+     * 2. Generate name variants: [baseName.stx, PascalCase.stx, kebab-case.stx]
+     * 3. Search directories in priority order:
+     *    - Page-relative components/
+     *    - Global componentsDir
+     *    - Parent-relative components/
+     *    - Project root src/components and components/
+     *    - Built-in STX components directory
+     * 4. Search subdirectories one level deep within each directory
+     * 5. Return null if not found
+     */
+    resolveFile(name: string, fromFile: string, options: StxOptions, parentContext?: Record<string, any>): Promise<string | null>;
 }
+/** Singleton registry instance shared across the framework */
+export declare const registry: ComponentRegistry;

package/dist/component-renderer.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Unified Component Renderer
+ *
+ * Replaces all existing component processing with a single `processComponents()`
+ * entry point. Handles:
+ *
+ * 1. Built-in components (StxLink, StxImage, StxLoadingIndicator) — resolved
+ *    via the component registry and rendered directly to HTML.
+ * 2. File-based user components — resolved from the filesystem and rendered
+ *    via `renderComponentWithSlot()`.
+ * 3. `@component` directives — `@component('name', { props })...@endcomponent`.
+ * 4. `@import` directives — `@import('ComponentName', './path/to/component')`.
+ *
+ * Props are categorized into static, serverDynamic, clientReactive, and events
+ * through `parseComponentProps()` before being passed to the appropriate renderer.
+ *
+ * @module component-renderer
+ */
 import type { StxOptions } from './types';
 /**
  * Process ES `import { A, B } from '<spec>'` statements inside `<script>` tags

package/dist/composable-loader.d.ts

@@ -1,3 +1,27 @@
+/**
+ * Composable Auto-Loader
+ *
+ * Discovers .ts files in `composablesDir`, bundles them into a single script,
+ * and exposes every exported binding on `window.__composables`. That object is
+ * what `import { useThing } from '@composables'` compiles to — store-imports.ts
+ * rewrites the import into `const { useThing } = window.__composables`, a plain
+ * destructure in the page's own scope, which is exactly where template
+ * directives can see it.
+ *
+ * Before this loader existed the rewrite had nothing feeding it: `@composables`
+ * imports compiled to a destructure of `undefined`, so every binding that
+ * referenced a composable silently did nothing — `@click` never fired, `@show`
+ * never flipped, and there was no console error or build warning to notice.
+ * Sharing client logic between pages was effectively impossible, so the same
+ * block got copy-pasted into page after page. See #1780.
+ *
+ * Mirrors store-loader.ts, with one deliberate difference: stores are
+ * side-effectful (running `defineStore(...)` registers them globally, so
+ * nothing needs to be exported), whereas composables are *values* — their
+ * exported names have to be collected and attached to `window.__composables`.
+ *
+ * @module composable-loader
+ */
 /**
  * Discover composable files and bundle them into a single script that
  * populates `window.__composables`.

package/dist/composable-loader.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { loadStxConfig } from "./config.js";
 import { getPublicEnvDefine } from "./public-env.js";
+import { readSigned, sourceSignature, writeSigned } from "./source-signature.js";
+import { stripModuleImports } from "./store-imports.js";
 import { STX_RUNTIME_GLOBALS } from "./runtime-globals.js";
 import { transformStoreImports } from "./store-imports.js";
 const _cachedComposableScripts = new Map, _cachedDirs = new Map, DEFAULT_DIR_CANDIDATES = ["composables", "functions"];
@@ -15,7 +17,8 @@ async function resolveComposablesDir(composablesDir) {
   if (cachedDir !== void 0)
     return cachedDir;
   const resolved = await probeDefaultDirs();
-  _cachedDirs.set(cacheKey, resolved);
+  if (resolved !== null)
+    _cachedDirs.set(cacheKey, resolved);
   return resolved;
 }
 async function probeDefaultDirs() {
@@ -37,9 +40,6 @@ export async function getComposableScript(composablesDir) {
   const resolvedDir = await resolveComposablesDir(composablesDir);
   if (!resolvedDir)
     return null;
-  const cached = _cachedComposableScripts.get(resolvedDir);
-  if (cached !== void 0)
-    return cached || null;
   const composableFiles = [];
   try {
     const glob = new Bun.Glob("**/*.ts");
@@ -49,11 +49,14 @@ export async function getComposableScript(composablesDir) {
       composableFiles.push(file);
     }
   } catch {
-    _cachedComposableScripts.set(resolvedDir, "");
+    writeSigned(_cachedComposableScripts, resolvedDir, "", "");
     return null;
   }
+  const signature = sourceSignature(composableFiles), cached = readSigned(_cachedComposableScripts, resolvedDir, signature);
+  if (cached !== void 0)
+    return cached || null;
   if (composableFiles.length === 0) {
-    _cachedComposableScripts.set(resolvedDir, "");
+    writeSigned(_cachedComposableScripts, resolvedDir, signature, "");
     return null;
   }
   composableFiles.sort();
@@ -71,7 +74,7 @@ export async function getComposableScript(composablesDir) {
             exportedNames.add(name);
       } catch {}
       code = transformStoreImports(code);
-      code = code.replace(/^import\s+.*from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+      code = stripModuleImports(code);
       code = code.replace(/^export\s+(default\s+)?/gm, "");
       code = transpiler.transformSync(code);
       chunks.push(`// Composable: ${composableName}
@@ -80,7 +83,7 @@ ${code.trim()}`);
       console.warn(`[stx] Failed to load composable ${file}:`, e);
     }
   if (chunks.length === 0 || exportedNames.size === 0) {
-    _cachedComposableScripts.set(resolvedDir, "");
+    writeSigned(_cachedComposableScripts, resolvedDir, signature, "");
     return null;
   }
   const assignments = [...exportedNames].map((name) => `  try { __c[${JSON.stringify(name)}] = ${name}; } catch (e) {}`).join(`
@@ -108,7 +111,7 @@ ${assignments}
     window[__n] = __c[__n];
   }
 })();`;
-  _cachedComposableScripts.set(resolvedDir, code);
+  writeSigned(_cachedComposableScripts, resolvedDir, signature, code);
   return code;
 }
 export function clearComposableCache() {

package/dist/composables/index.d.ts

@@ -408,3 +408,10 @@ export {
   type ColorModeRef,
   type DarkRef,
 } from './use-color-mode';
+// `defineForm` was reachable from a `<script client>` block (#1846) and listed
+// in SERVER_ONLY_COMPOSABLES, but never re-exported here. That list is checked
+// against this barrel — "exactly the composable exports the runtime does not
+// provide" — so an entry with no export behind it failed the guard, while
+// `framework-composables.ts` needs the entry to know to bundle it. One missing
+// re-export, two contradictory test suites. See #1849.
+export { defineForm, useForm } from './use-form';

package/dist/composables/index.js

@@ -219,3 +219,4 @@ export {
   useColorMode,
   useDark
 } from "./use-color-mode.js";
+export { defineForm, useForm } from "./use-form.js";

package/dist/composables/use-fetch.js

@@ -78,8 +78,36 @@ export function useFetch(url, options = {}) {
       clearTimeout(timeoutId);
       status.set(response.status);
       statusText.set(response.statusText);
-      if (!response.ok)
-        throw Error(`HTTP ${response.status}: ${response.statusText}`);
+      if (!response.ok) {
+        let body = null;
+        try {
+          const text = await response.text();
+          if (text)
+            try {
+              body = JSON.parse(text);
+            } catch {
+              body = text;
+            }
+        } catch {
+          body = null;
+        }
+        let detail = "";
+        if (body && typeof body === "object")
+          detail = String(body.message ?? body.error ?? "");
+        else if (typeof body === "string")
+          detail = body.slice(0, 200);
+        let message = `HTTP ${response.status}`;
+        if (response.statusText)
+          message += `: ${response.statusText}`;
+        if (detail)
+          message += ` - ${detail}`;
+        const httpError = Error(message);
+        httpError.status = response.status;
+        httpError.statusText = response.statusText;
+        httpError.data = body;
+        httpError.response = response;
+        throw httpError;
+      }
       let payload = await parseResponse(response);
       if (transform)
         payload = transform(payload);