@stacksjs/stx 0.2.155 → 0.2.157

package/dist/stx-virtual-ts.js

@@ -0,0 +1,372 @@
+import { STX_RUNTIME_GLOBALS } from "./runtime-globals.js";
+const SCRIPT_RE = /<script(\s[^>]*)?>([\s\S]*?)<\/script>/gi;
+export function extractScriptBlocks(source) {
+  const blocks = [];
+  SCRIPT_RE.lastIndex = 0;
+  let match;
+  while ((match = SCRIPT_RE.exec(source)) !== null) {
+    const attrs = (match[1] || "").trim(), body = match[2] ?? "";
+    if (/\bsrc\s*=/.test(attrs))
+      continue;
+    const typeMatch = attrs.match(/\btype\s*=\s*["']([^"']+)["']/i);
+    if (typeMatch && !/^(?:module|text\/(?:javascript|typescript))$/i.test(typeMatch[1]))
+      continue;
+    const kind = /\bserver\b/.test(attrs) ? "server" : /\bclient\b/.test(attrs) ? "client" : "plain", openTag = match[0].match(/^<script[^>]*>/i)?.[0] ?? "<script>", startLine = lineAt(source, match.index + openTag.length);
+    blocks.push({ kind, code: body, startLine, attrs });
+  }
+  return blocks;
+}
+function lineAt(source, offset) {
+  let line = 1;
+  for (let i = 0;i < offset && i < source.length; i++)
+    if (source.charCodeAt(i) === 10)
+      line++;
+  return line;
+}
+function columnAt(source, offset) {
+  const lineStart = source.lastIndexOf(`
+`, offset - 1) + 1;
+  return offset - lineStart + 1;
+}
+export function maskNonTemplateRegions(source) {
+  const chars = source.split(""), blank = (start, end) => {
+    for (let i = start;i < end && i < chars.length; i++)
+      if (chars[i] !== `
+`)
+        chars[i] = " ";
+  }, regions = [
+    /<script(?:\s[^>]*)?>[\s\S]*?<\/script>/gi,
+    /<style(?:\s[^>]*)?>[\s\S]*?<\/style>/gi,
+    /<!--[\s\S]*?-->/g,
+    /\{\{--[\s\S]*?--\}\}/g,
+    /@verbatim\b[\s\S]*?@endverbatim\b/g
+  ];
+  for (const re of regions) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(source)) !== null)
+      blank(m.index, m.index + m[0].length);
+  }
+  return chars.join("");
+}
+export function stripFilterChain(expression) {
+  let depth = 0, quote = "";
+  for (let i = 0;i < expression.length; i++) {
+    const ch = expression[i];
+    if (quote) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      if (expression[i + 1] === "|") {
+        i++;
+        continue;
+      }
+      if (expression[i - 1] === "|")
+        continue;
+      return expression.slice(0, i);
+    }
+  }
+  return expression;
+}
+const FOR_ATTRS = new Set([":for", "x-for", "v-for"]), DIRECTIVE_ATTR_RE = /(?:^|\s)((?::|x-|v-|@)[\w.:-]+)\s*=\s*(["'])([\s\S]*?)\2/g;
+export const INTERPOLATION_PLACEHOLDER = "__stx_interpolated", ELEMENT_HELPER = "__StxElement", UNWRAP_HELPER = "__StxTemplateValue";
+const UNWRAP_HELPER_DECL = `type ${UNWRAP_HELPER}<T> = T extends { readonly _isSignal: true } | { readonly _isDerived: true } ? (T extends () => infer V ? T & V : T) : T`;
+export function substituteInterpolations(value) {
+  return value.replace(/\{\{[\s\S]*?\}\}/g, INTERPOLATION_PLACEHOLDER).replace(/\{!![\s\S]*?!!\}/g, INTERPOLATION_PLACEHOLDER);
+}
+const NON_EXPRESSION_ATTRS = new Set([
+  "x-cloak",
+  "x-ref",
+  "x-transition",
+  "x-teleport",
+  "v-slot",
+  "x-hydrate",
+  ":key"
+]);
+export function extractTemplateExpressions(source) {
+  const masked = maskNonTemplateRegions(source), found = [], interpolation = /(@?)\{\{([\s\S]*?)\}\}|(@?)\{!!([\s\S]*?)!!\}/g;
+  let m;
+  while ((m = interpolation.exec(masked)) !== null) {
+    if (m[1] || m[3])
+      continue;
+    const raw = m[2] ?? m[4] ?? "", openLength = m[2] !== void 0 ? 2 : 3, code = stripFilterChain(raw);
+    if (!code.trim())
+      continue;
+    const offset = m.index + openLength + (code.length - code.trimStart().length);
+    found.push({
+      code: code.trim(),
+      line: lineAt(masked, offset),
+      column: columnAt(masked, offset),
+      kind: "interpolation"
+    });
+  }
+  DIRECTIVE_ATTR_RE.lastIndex = 0;
+  while ((m = DIRECTIVE_ATTR_RE.exec(masked)) !== null) {
+    const name = m[1], value = m[3] ?? "", base = name.replace(/\..*$/, "");
+    if (NON_EXPRESSION_ATTRS.has(base) || NON_EXPRESSION_ATTRS.has(name))
+      continue;
+    if (!value.trim())
+      continue;
+    const offset = m.index + m[0].indexOf(m[2], m[0].indexOf(name) + name.length) + 1;
+    if (FOR_ATTRS.has(base)) {
+      const inMatch = value.match(/\s+(?:in|of)\s+/);
+      if (!inMatch || inMatch.index === void 0)
+        continue;
+      const iterable = value.slice(inMatch.index + inMatch[0].length), iterableStart = inMatch.index + inMatch[0].length + (iterable.length - iterable.trimStart().length);
+      found.push({
+        code: substituteInterpolations(iterable.trim()),
+        line: lineAt(masked, offset + iterableStart),
+        column: columnAt(masked, offset + iterableStart),
+        kind: "directive",
+        attribute: base
+      });
+      continue;
+    }
+    const lead = value.length - value.trimStart().length;
+    found.push({
+      code: substituteInterpolations(value.trim()),
+      line: lineAt(masked, offset + lead),
+      column: columnAt(masked, offset + lead),
+      kind: "directive",
+      attribute: base
+    });
+  }
+  found.sort((a, b) => a.line - b.line || a.column - b.column);
+  return found;
+}
+export function collectTemplateBindings(source) {
+  const bindings = new Map, add = (raw, iterable) => {
+    const parts = raw.split(/[,[\]{}()\s]+/).filter(Boolean);
+    for (const part of parts) {
+      const name = part.replace(/^\.\.\./, "").trim();
+      if (!/^\$?[A-Z_$][\w$]*$/i.test(name))
+        continue;
+      const typed = parts.length === 1 ? iterable : void 0, existing = bindings.get(name);
+      if (!existing)
+        bindings.set(name, { name, iterable: typed });
+      else if (existing.iterable !== typed)
+        existing.iterable = void 0;
+    }
+  }, IDENTIFIER = /^\$?[A-Z_$][\w$]*$/i, iterableOf = (raw) => {
+    const trimmed = raw.trim();
+    return IDENTIFIER.test(trimmed) ? trimmed : void 0;
+  };
+  for (const m of source.matchAll(/@for(?:each|else)\s*\(([\s\S]*?)\)/g)) {
+    const asMatch = m[1].match(/^([\s\S]*?)\bas\b([\s\S]*)$/);
+    if (!asMatch)
+      continue;
+    add(asMatch[2].replace(/=>/g, " "), iterableOf(asMatch[1]));
+  }
+  for (const m of source.matchAll(/@for\s*\(\s*(?:let|const|var)\s+([\w$]+)/g))
+    add(m[1]);
+  const masked = maskNonTemplateRegions(source);
+  DIRECTIVE_ATTR_RE.lastIndex = 0;
+  let m;
+  while ((m = DIRECTIVE_ATTR_RE.exec(masked)) !== null) {
+    const base = m[1].replace(/\..*$/, "");
+    if (!FOR_ATTRS.has(base))
+      continue;
+    const inMatch = m[3].match(/\s+(?:in|of)\s+/);
+    if (!inMatch || inMatch.index === void 0)
+      continue;
+    add(m[3].slice(0, inMatch.index), iterableOf(m[3].slice(inMatch.index + inMatch[0].length)));
+  }
+  for (const block of source.matchAll(/@(?:php|js|ts)\b([\s\S]*?)@end(?:php|js|ts)\b/g))
+    for (const decl of block[1].matchAll(/\b(?:const|let|var|function|class)\s+([\w$]+)/g))
+      add(decl[1]);
+  return [...bindings.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function collectBlockDeclarations(code) {
+  const names = new Set;
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:const|let|var)\s+([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:async\s+)?function\s*\*?\s*([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?class\s+([\w$]+)/gm))
+    names.add(m[1]);
+  for (const m of code.matchAll(/^\s*(?:export\s+)?(?:const|let|var)\s*[[{]([^\]}]*)[\]}]/gm))
+    for (const part of m[1].split(",")) {
+      const name = part.split(":").pop().split("=")[0].replace(/^\.\.\./, "").trim();
+      if (/^[A-Z_$][\w$]*$/i.test(name))
+        names.add(name);
+    }
+  return [...names].sort();
+}
+const IMPORT_LINE_RE = /^\s*import\s[\s\S]*?(?:$|;)/;
+export function runtimeGlobalDeclarations() {
+  return [
+    "declare var window: any",
+    ...STX_RUNTIME_GLOBALS.map((name) => `declare var ${name}: any`)
+  ].join(`
+`);
+}
+export const STX_SERVER_CONTEXT = [
+  "params",
+  "query",
+  "cookies",
+  "host",
+  "ip",
+  "setResponseStatus",
+  "setResponseHeader",
+  "request",
+  "url",
+  "definePageMeta"
+];
+export function serverContextDeclarations() {
+  return STX_SERVER_CONTEXT.map((name) => `declare var ${name}: any`).join(`
+`);
+}
+export const STX_TEMPLATE_GLOBALS = [
+  "$env",
+  "$user",
+  "$slot",
+  "$slots",
+  "$attrs",
+  "$props",
+  "$page",
+  "$route",
+  "$loop",
+  "$errors",
+  "$csrf",
+  "props",
+  "slot"
+];
+export function crossScopeCollisions(blocks) {
+  const server = new Set, client = new Set;
+  for (const block of blocks) {
+    const target = block.kind === "server" ? server : client;
+    for (const name of collectBlockDeclarations(block.code))
+      target.add(name);
+  }
+  return [...server].filter((name) => client.has(name)).sort();
+}
+const DIRECT_ASSIGNMENT_RE = /^\s*[A-Z_$][\w$]*\s*=[^=]/i;
+export function expressionStatement(expression) {
+  const code = expression.code.trim();
+  if (!code)
+    return null;
+  if (expression.attribute?.startsWith("@")) {
+    if (DIRECT_ASSIGNMENT_RE.test(code))
+      return null;
+    const prefix = ";(($event: any): void => { ";
+    return { text: `${prefix}${code} });`, prefixLength: prefix.length };
+  }
+  const prefix = ";void ((";
+  return { text: `${prefix}${code}));`, prefixLength: prefix.length };
+}
+export function buildVirtualTypeScript(source, options = {}) {
+  const blocks = extractScriptBlocks(source), sourceLines = source.split(`
+`), lines = Array.from({ length: sourceLines.length }, () => ""), lineMap = new Map;
+  for (const block of blocks)
+    block.code.split(`
+`).forEach((text, i) => {
+      const index = block.startLine - 1 + i;
+      if (index < lines.length)
+        lines[index] = text;
+    });
+  const append = (text, origin) => {
+    lines.push(text);
+    if (origin)
+      lineMap.set(lines.length, origin);
+  };
+  if (options.globals !== !1) {
+    append("");
+    if (options.runtimeGlobals !== !1)
+      for (const decl of runtimeGlobalDeclarations().split(`
+`))
+        append(decl);
+    for (const decl of serverContextDeclarations().split(`
+`))
+      append(decl);
+    for (const name of STX_TEMPLATE_GLOBALS)
+      append(`declare var ${name}: any`);
+    append(`declare var ${INTERPOLATION_PLACEHOLDER}: any`);
+    const declared = new Set(blocks.flatMap((block) => collectBlockDeclarations(block.code)));
+    append(`type ${ELEMENT_HELPER}<T> = T extends readonly (infer E)[] ? E : T extends Iterable<infer E2> ? E2 : any`);
+    for (const binding of collectTemplateBindings(source)) {
+      if (declared.has(binding.name))
+        continue;
+      const type = binding.iterable && declared.has(binding.iterable) ? `${ELEMENT_HELPER}<typeof ${binding.iterable}>` : "any";
+      append(`declare var ${binding.name}: ${type}`);
+    }
+  }
+  if (options.templateExpressions !== !1) {
+    const statements = extractTemplateExpressions(source).map((expression) => ({ expression, statement: expressionStatement(expression) })).filter((entry) => entry.statement !== null);
+    if (statements.length > 0) {
+      const shadowed = [...new Set(blocks.flatMap((block) => collectBlockDeclarations(block.code)))].filter((name) => /^[A-Z_$][\w$]*$/i.test(name));
+      let indent = 0;
+      if (shadowed.length > 0) {
+        append(UNWRAP_HELPER_DECL);
+        for (const name of shadowed)
+          append(`type __StxT_${name} = ${UNWRAP_HELPER}<typeof ${name}>`);
+        append(`;((${shadowed.map((name) => `${name}: __StxT_${name}`).join(", ")}) => {`);
+        indent = 1;
+      }
+      for (const { expression, statement } of statements) {
+        const pad = "  ".repeat(indent);
+        append(pad + statement.text, {
+          line: expression.line,
+          column: expression.column,
+          expression,
+          prefixLength: statement.prefixLength + pad.length
+        });
+      }
+      if (indent > 0)
+        append("});");
+    }
+  }
+  append("export {}");
+  return { text: lines.join(`
+`), lineMap, sourceLineCount: sourceLines.length };
+}
+export function lineStarts(text) {
+  const starts = [0];
+  for (let i = 0;i < text.length; i++)
+    if (text.charCodeAt(i) === 10)
+      starts.push(i + 1);
+  return starts;
+}
+export function offsetToPosition(starts, offset) {
+  let low = 0, high = starts.length - 1;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (starts[mid] <= offset)
+      low = mid;
+    else
+      high = mid - 1;
+  }
+  return { line: low + 1, column: offset - starts[low] + 1 };
+}
+export function positionToOffset(starts, line, column) {
+  const index = Math.min(Math.max(line, 1), starts.length) - 1, next = index + 1 < starts.length ? starts[index + 1] - 1 : Number.MAX_SAFE_INTEGER;
+  return Math.min(starts[index] + Math.max(column, 1) - 1, next);
+}
+export function resolvePosition(virtual, line, column) {
+  const mapped = virtual.lineMap.get(line);
+  if (!mapped)
+    return line <= virtual.sourceLineCount ? { line, column } : null;
+  const within = Math.max(0, column - 1 - (mapped.prefixLength ?? 0));
+  return {
+    line: mapped.line,
+    column: mapped.column + within,
+    expression: mapped.expression
+  };
+}

package/dist/stx.d.ts

@@ -124,9 +124,24 @@ interface StxNavigateOptions {
  * shape that actually shipped — but keeping it out of the type means nothing
  * that type-checks today changes meaning (#1807).
  */
-declare function navigate(_url: string, _options?: StxNavigateOptions): void
+declare function navigate<T extends string>(
+  _url: T & import('@stacksjs/stx').CheckHref<T>,
+  _options?: StxNavigateOptions,
+): void
 declare function goBack(): void
 declare function goForward(): void
+
+/**
+ * Re-run the current route against the server and swap the result, without a
+ * document load. Use after a mutation that changed server-rendered content.
+ */
+declare function refresh(): Promise<boolean>
+
+/**
+ * Expire one cached route so the next visit re-fetches it. Defaults to the
+ * current path.
+ */
+declare function invalidateRoute(_url?: string): void
 declare function useRoute(): {
   path: string
   params: Record<string, string>
@@ -134,6 +149,17 @@ declare function useRoute(): {
   hash: string
 }
 declare function setRouteParams(_params: Record<string, string>): void
+
+/**
+ * Reactive access to the current route's dynamic segments.
+ *
+ * Published on `window.stx` by 5daaba1f9b but never added to the auto-imported
+ * list, so it was reachable only as `window.stx.useRouteParams()` — exactly the
+ * authoring-surface gap in #1846.
+ */
+declare function useRouteParams(): StxSignal<Record<string, string>>
+/** One dynamic segment, as a signal. */
+declare function useRouteParam(_name: string, _defaultValue?: string): StxSignal<string>
 /** How a search-param mutation is written to session history (#1825). */
 interface StxSearchParamsCommitOptions {
   /** Replace the current history entry instead of pushing a new one. */
@@ -190,6 +216,52 @@ interface StxMutationResult<T> {
 declare function useFetch<T = any>(_url: string, _options?: any): StxQueryResult<T>
 declare function useQuery<T = any>(_url: string, _options?: any): StxQueryResult<T>
 declare function useMutation<T = any>(_url: string, _options?: any): StxMutationResult<T>
+
+/** Context handed to a request interceptor. Mutate it; the return is ignored. */
+interface StxFetchRequestContext {
+  /** Which primitive made the call: 'useFetch' | 'useQuery' | 'useMutation'. */
+  source: string
+  /** Reassignable, so a hook can prefix a baseURL. */
+  url: string
+  /** `headers` is normalised to an object before the hook runs. */
+  options: RequestInit & { headers: Record<string, string> }
+}
+
+/** Context handed to a response interceptor. */
+interface StxFetchResponseContext extends StxFetchRequestContext {
+  response: Response
+}
+
+/**
+ * Context handed to an error interceptor. `response` is the non-ok Response, or
+ * null when the fetch itself threw (a network failure); `error` is set only in
+ * the latter case.
+ */
+interface StxFetchErrorContext extends StxFetchRequestContext {
+  response: Response | null
+  error: Error | null
+}
+
+/**
+ * Install request/response interceptors for every stx data primitive.
+ *
+ * All three funnel through one internal fetch, so a single pair of hooks
+ * carries an auth header or observes a 401 across `useFetch`, `useQuery` and
+ * `useMutation`. Calling this again REPLACES the hooks rather than adding to
+ * them, so a re-evaluated module cannot install the same interceptor twice.
+ *
+ * `onResponseError` fires for a non-ok response and for a thrown fetch. Return
+ * a Response to replace the failed one — the shape a 401 -> refresh -> retry
+ * takes: refresh the token, re-issue the request with a plain `fetch()` (not
+ * this data layer, so it does not re-enter the hook), and return that Response.
+ * Return nothing to let the original error stand.
+ */
+declare function configureFetch(_config: {
+  onRequest?: (_ctx: StxFetchRequestContext) => void | Promise<void>
+  onResponse?: (_ctx: StxFetchResponseContext) => void | Promise<void>
+  onResponseError?: (_ctx: StxFetchErrorContext) => void | Response | Promise<void | Response>
+}): void
+
 declare function useOptimistic<T = any, A = any>(
   _base: StxSignal<T> | (() => T) | T,
   _reducer: (_current: T, _action: A) => T,
@@ -591,14 +663,19 @@ interface StxRuntimeRegistry {
   useRef: typeof useRef
   useQuery: typeof useQuery
   useMutation: typeof useMutation
+  configureFetch: typeof configureFetch
   useOptimistic: typeof useOptimistic
 
   // Routing
   navigate: typeof navigate
   goBack: typeof goBack
   goForward: typeof goForward
+  refresh: typeof refresh
+  invalidateRoute: typeof invalidateRoute
   useRoute: typeof useRoute
   setRouteParams: typeof setRouteParams
+  useRouteParams: typeof useRouteParams
+  useRouteParam: typeof useRouteParam
   useSearchParams: typeof useSearchParams
 
   // Composition

package/dist/style-scoping.d.ts

@@ -1,3 +1,20 @@
+/**
+ * SFC Style Scoping
+ *
+ * Processes `<style scoped>` blocks in `.stx` single-file components.
+ * Scopes CSS selectors to the component using a deterministic hash attribute,
+ * preventing style leakage between components.
+ *
+ * Uses the CSS scoping utilities from `web-components/css-scoping.ts`.
+ *
+ * @module style-scoping
+ */
+export interface ScopedStyleResult {
+    /** The modified HTML with scope attributes added to root elements and scoped style tags */
+    html: string;
+    /** Whether any scoped styles were found and processed */
+    hasScoped: boolean;
+}
 /**
  * Keep one copy of each rendered scoped stylesheet.
  *
@@ -23,7 +40,3 @@ export declare function dedupeScopedStyles(html: string): string;
  * @returns Processed template with scoped styles
  */
 export declare function processScopedStyles(template: string, filePath: string): ScopedStyleResult;
-export declare interface ScopedStyleResult {
-  html: string
-  hasScoped: boolean
-}

package/dist/suspense.d.ts

@@ -1,3 +1,58 @@
+/**
+ * STX Suspense
+ *
+ * Coordinates async loading across component trees, showing a fallback
+ * until all async children are resolved.
+ *
+ * @module suspense
+ *
+ * @example
+ * ```html
+ * @suspense
+ *   <UserProfile :id="userId" />
+ *   <UserActivity :id="userId" />
+ *   <UserStats :id="userId" />
+ * @fallback
+ *   <PageSkeleton />
+ * @endsuspense
+ * ```
+ */
+export interface SuspenseOptions {
+    /** Custom ID for tracking */
+    id?: string;
+    /** Timeout before showing error (ms) */
+    timeout?: number;
+    /** Callback when all children resolve */
+    onResolve?: () => void;
+    /** Callback when any child rejects */
+    onError?: (error: Error) => void;
+    /** Callback when loading starts */
+    onPending?: () => void;
+}
+export interface SuspenseState {
+    /** Current state */
+    status: 'pending' | 'resolved' | 'rejected';
+    /** Pending async children */
+    pending: Set<string>;
+    /** Resolved async children */
+    resolved: Set<string>;
+    /** First error encountered */
+    error: Error | null;
+}
+export interface SuspenseBoundary {
+    /** Unique boundary ID */
+    id: string;
+    /** Current state */
+    state: SuspenseState;
+    /** Register an async child */
+    register: (childId: string) => void;
+    /** Mark a child as resolved */
+    resolve: (childId: string) => void;
+    /** Mark a child as rejected */
+    reject: (childId: string, error: Error) => void;
+    /** Reset the boundary */
+    reset: () => void;
+}
 /**
  * Process @suspense directives in templates.
  *
@@ -12,6 +67,14 @@
  *   @suspense(timeout: 10000)
  */
 export declare function processSuspenseDirectives(template: string, _context?: Record<string, unknown>, _filePath?: string): string;
+/**
+ * Server-side suspense boundary for SSR streaming.
+ */
+export interface SSRSuspenseBoundary {
+    id: string;
+    fallback: string;
+    content: Promise<string>;
+}
 /**
  * Create an SSR suspense boundary.
  * Returns the fallback immediately, then streams the content when ready.
@@ -21,7 +84,10 @@ export declare function createSSRSuspense(id: string, contentPromise: Promise<st
  * Render SSR suspense boundaries for streaming.
  * Returns initial HTML with fallbacks, plus a script to replace them when content loads.
  */
-export declare function renderSSRSuspense(boundaries: SSRSuspenseBoundary[]): Promise<{ initial: string; streaming: AsyncGenerator<string> }>;
+export declare function renderSSRSuspense(boundaries: SSRSuspenseBoundary[]): Promise<{
+    initial: string;
+    streaming: AsyncGenerator<string>;
+}>;
 /**
  * Generate CSS for suspense styling.
  */
@@ -30,54 +96,3 @@ export declare function generateSuspenseCSS(): string;
  * Generate client-side runtime for suspense.
  */
 export declare function generateSuspenseRuntime(): string;
-/**
- * STX Suspense
- *
- * Coordinates async loading across component trees, showing a fallback
- * until all async children are resolved.
- *
- * @module suspense
- *
- * @example
- * ```html
- * @suspense
- *   <UserProfile :id="userId" />
- *   <UserActivity :id="userId" />
- *   <UserStats :id="userId" />
- * @fallback
- *   <PageSkeleton />
- * @endsuspense
- * ```
- */
-// =============================================================================
-// Types
-// =============================================================================
-export declare interface SuspenseOptions {
-  id?: string
-  timeout?: number
-  onResolve?: () => void
-  onError?: (error: Error) => void
-  onPending?: () => void
-}
-export declare interface SuspenseState {
-  status: 'pending' | 'resolved' | 'rejected'
-  pending: Set<string>
-  resolved: Set<string>
-  error: Error | null
-}
-export declare interface SuspenseBoundary {
-  id: string
-  state: SuspenseState
-  register: (childId: string) => void
-  resolve: (childId: string) => void
-  reject: (childId: string, error: Error) => void
-  reset: () => void
-}
-/**
- * Server-side suspense boundary for SSR streaming.
- */
-export declare interface SSRSuspenseBoundary {
-  id: string
-  fallback: string
-  content: Promise<string>
-}

package/dist/teleport.d.ts

@@ -1,3 +1,25 @@
+/**
+ * Teleport Directive
+ *
+ * Moves content to a different location in the DOM.
+ * Useful for modals, tooltips, notifications that need to escape
+ * their parent's stacking context.
+ *
+ * Usage:
+ * @teleport('#modals')
+ *   <div class="modal">Modal content</div>
+ * @endteleport
+ *
+ * With disabled state:
+ * @teleport('#modals', disabled: isInline)
+ *   <div class="modal">Modal content</div>
+ * @endteleport
+ *
+ * Multiple targets:
+ * @teleport('body')  - Appends to body
+ * @teleport('#app')  - Appends to #app element
+ * @teleport('.modals-container')  - Appends to first matching element
+ */
 /**
  * Process @teleport directives in template
  */