@stacksjs/stx 0.2.155 → 0.2.156

package/dist/runtime-globals.d.ts

@@ -1,27 +1,3 @@
-/**
- * Build the destructuring statement that pulls {@link STX_RUNTIME_GLOBALS} into
- * a generated client script's scope.
- *
- * @param declaration `var` for scripts that reassign a binding (the `@include`
- * wrapper rebinds `onDestroy` to tee into its teardown channel — an assignment,
- * which `var` permits), `const` otherwise.
- * @param exclude names the generated wrapper or user script declares itself.
- * A local declaration is intentionally allowed to shadow a runtime convenience
- * global, just as an explicit import would. Omitting it from this destructure
- * prevents duplicate-binding syntax errors.
- * @param source optionally limits bindings to identifiers referenced by one
- * component script. Page-level callers omit it and retain the full authoring
- * surface.
- */
-export declare function buildRuntimeGlobalsDestructure(declaration?: 'const' | 'var', exclude?: readonly string[], source?: string): string;
-/**
- * Does this script call anything that needs the reactive runtime?
- *
- * Matches a CALL, not a mention: a bare word can be a property, a string or a
- * comment. Tolerates a generic argument list, since `state<Foo>(…)` is valid
- * TypeScript and common.
- */
-export declare function usesReactiveRuntime(source: string): boolean;
 /**
  * Runtime Globals
  *
@@ -78,6 +54,22 @@ export declare const STX_RUNTIME_GLOBALS: readonly string[];
  * #1785 fixed, so it is declared here rather than left implicit.
  */
 export declare const COMPONENT_SCOPE_LOCAL_GLOBALS: readonly string[];
+/**
+ * Build the destructuring statement that pulls {@link STX_RUNTIME_GLOBALS} into
+ * a generated client script's scope.
+ *
+ * @param declaration `var` for scripts that reassign a binding (the `@include`
+ * wrapper rebinds `onDestroy` to tee into its teardown channel — an assignment,
+ * which `var` permits), `const` otherwise.
+ * @param exclude names the generated wrapper or user script declares itself.
+ * A local declaration is intentionally allowed to shadow a runtime convenience
+ * global, just as an explicit import would. Omitting it from this destructure
+ * prevents duplicate-binding syntax errors.
+ * @param source optionally limits bindings to identifiers referenced by one
+ * component script. Page-level callers omit it and retain the full authoring
+ * surface.
+ */
+export declare function buildRuntimeGlobalsDestructure(declaration?: 'const' | 'var', exclude?: readonly string[], source?: string): string;
 /**
  * Runtime globals that are COMPILE-TIME macros rather than reactive APIs.
  *
@@ -86,6 +78,33 @@ export declare const COMPONENT_SCOPE_LOCAL_GLOBALS: readonly string[];
  * below must not treat them as evidence that a block needs mounting.
  */
 export declare const COMPILE_TIME_ONLY_GLOBALS: readonly string[];
+/**
+ * Public authoring primitives that are NOT reachable as a bare identifier in a
+ * `<script client>` block, each tagged with WHY — so the client/server boundary
+ * is discoverable in source instead of inferred from a `ReferenceError` at
+ * runtime (stacksjs/stx#1846).
+ *
+ * Paired with the export-side guard in `authoring-surface.test.ts`: a newly
+ * exported composable that is reachable by neither client path — a bare global
+ * in {@link STX_RUNTIME_GLOBALS} (path 1), nor the demand-bundle allowlist
+ * `SERVER_ONLY_COMPOSABLES` (path 2) — must be classified here, or the test
+ * fails. Same "force a decision" contract that COMPILE_TIME_ONLY_GLOBALS and
+ * DELIBERATELY_NOT_GLOBAL already apply in their own directions.
+ *
+ * `client-gap` is deliberately distinct from `server-only`: it marks a primitive
+ * that SHOULD be callable from a client script but is not yet wired into either
+ * client path — a tracked gap, not a boundary.
+ *
+ * `isomorphic-import` is distinct again: the primitive is pure and WOULD run in a
+ * browser, but the project has decided it is not part of the auto-delivered
+ * client surface — an app imports it explicitly. Not a gap to close; a boundary
+ * drawn on purpose.
+ */
+export type NonClientCategory = 'server-only' | 'builtin-component' | 'compile-time-directive' | 'browser-composable' | 'client-gap' | 'isomorphic-import';
+export declare const NON_CLIENT_PRIMITIVES: Readonly<Record<string, {
+    category: NonClientCategory;
+    reason: string;
+}>>;
 /**
  * Names whose presence in a client script means it needs the signals runtime
  * and an `stx.mount()` wrapper.
@@ -100,3 +119,107 @@ export declare const COMPILE_TIME_ONLY_GLOBALS: readonly string[];
  * Exactly the drift #1804 removed for STX_AUTO_IMPORTS, one file away.
  */
 export declare const REACTIVE_RUNTIME_GLOBALS: readonly string[];
+/**
+ * Does this script call anything that needs the reactive runtime?
+ *
+ * Matches a CALL, not a mention: a bare word can be a property, a string or a
+ * comment. Tolerates a generic argument list, since `state<Foo>(…)` is valid
+ * TypeScript and common.
+ */
+export declare function usesReactiveRuntime(source: string): boolean;
+/**
+ * Does this template have a reactive context — a signal, a bound attribute, a
+ * reactive directive, or a client script — that will own its event handlers?
+ *
+ * This is the question `processEventDirectives` (events.ts) needs. It decides
+ * whether to leave `@click` in the markup for the signals runtime to bind, or to
+ * strip it and bind it imperatively through `__stx_runHandler`.
+ *
+ * It used to answer that with its own regex matching only `state`/`derived`/
+ * `effect` plus four directives, so a client block built out of `useStore` (or
+ * any of the other ~65 reactive globals) failed it. The handler was stripped and
+ * rebound to code that resolves it through a `[data-stx-scope]` ancestor that
+ * page-level client blocks never get, then fell back to evaluating the bare
+ * name — which lives inside the setup closure and is not a global. Every handler
+ * on the page died with a ReferenceError on click (#1824).
+ *
+ * Note this is NOT the same question as {@link templateNeedsRuntime}: a template
+ * whose only client-side behaviour is `<button @click="doIt()">` needs the
+ * runtime injected, but has no reactive scope to own the handler, so events.ts
+ * must still bind it imperatively. Conflating the two makes that fallback
+ * unreachable.
+ */
+export declare function templateHasReactiveContext(template: string): boolean;
+/**
+ * Will this template get the client signals runtime?
+ *
+ * A reactive context needs it, and so does a lone event handler — something has
+ * to bind that, and the runtime is what binds it when a reactive scope exists.
+ *
+ * This had three independent implementations that disagreed, and every
+ * disagreement was a bug: `hasSignalsSyntax` (signal-processing.ts) decides
+ * whether to INJECT the runtime; the auto-mount test (client-script.ts) decides
+ * whether to wrap a client block in `stx.mount()` — when it said yes and the
+ * first said no, the page emitted `stx.mount(...)` with nothing to mount onto
+ * (#1819, #1820); and events.ts asked the related-but-distinct question above
+ * (#1824).
+ *
+ * They live here because events.ts is a leaf module and importing
+ * signal-processing.ts would close a cycle through client-script.ts.
+ */
+export declare function templateNeedsRuntime(template: string): boolean;
+/**
+ * `x-` attributes the signals runtime consumes itself.
+ *
+ * The runtime treats any unrecognised `x-foo` as a generic attribute binding
+ * (`x-href`, `x-src`, `x-alt` all work that way), so the ones it handles
+ * through their own code paths have to be excluded — that exclusion is what
+ * this list is.
+ *
+ * It is also what decides whether a component may carry the attribute, which
+ * is why it lives here rather than only inside the generated runtime. Those
+ * were two hand-maintained lists, and they disagreed about exactly two names:
+ * `x-tooltip` and `x-tooltip-position`, the most recently added pair (#1673).
+ * Putting one on a COMPONENT rewrote it to `:tooltip="Settings"`, a signal
+ * binding over an identifier that does not exist — so the tooltip silently
+ * vanished AND the page reported a hydration invariant failure naming the
+ * tooltip's text rather than the tooltip (#1830). The same attribute on a
+ * plain element worked, which made it unguessable from the authoring side.
+ */
+export declare const RUNTIME_HANDLED_X_ATTRS: readonly string[];
+/**
+ * `x-` attributes owned by the Alpine-style reactive bridge, not the signals
+ * runtime. They never reach `X_HANDLED`, but must still survive on a component
+ * for the bridge to find them on the rendered element.
+ */
+export declare const ALPINE_BRIDGE_X_ATTRS: readonly string[];
+/**
+ * Every `x-` attribute that must reach the rendered DOM element untouched when
+ * it is written on a component, rather than being captured as a prop binding.
+ */
+export declare const COMPONENT_PASSTHROUGH_X_ATTRS: readonly string[];
+/** The `X_HANDLED` lookup the generated runtime embeds, as JS source. */
+export declare function runtimeHandledXAttrsLiteral(): string;
+/**
+ * Blank the parts of an HTML template that cannot carry a live directive,
+ * for DETECTION only — never for output.
+ *
+ * `hasSignalsSyntax` and friends scan raw template text, so a documentation
+ * page quoting stx syntax inside a code sample counted as reactive and shipped
+ * the whole ~159KB signals runtime for markup that is inert text
+ * (stacksjs/stx#1835).
+ *
+ * Only TEXT is blanked, and only inside `<pre>` / `<code>` and HTML comments.
+ * Tags are kept intact, including their attributes, because that is where a
+ * directive actually lives:
+ *
+ *   <pre><code>&lt;div :if="open"&gt;</code></pre>   -> blanked, it is text
+ *   <pre><code><span>&lt;div :if="x"&gt;</span></pre> -> span kept, text blanked
+ *   <pre><button @click="go()">run</button></pre>     -> kept, it is a real button
+ *
+ * Dropping whole regions instead would have been simpler and wrong in the
+ * expensive direction: a page whose only reactive element sits inside a `<pre>`
+ * would lose its runtime and break, which is worse than shipping bytes it does
+ * not need.
+ */
+export declare function blankInertHtmlRegions(html: string): string;

package/dist/runtime-globals.js

@@ -1,6 +1,7 @@
 export const STX_RUNTIME_GLOBALS = [
   "batch",
   "computed",
+  "configureFetch",
   "defineEmits",
   "defineExpose",
   "definePageMeta",
@@ -12,6 +13,7 @@ export const STX_RUNTIME_GLOBALS = [
   "goBack",
   "goForward",
   "inject",
+  "invalidateRoute",
   "isDerived",
   "isSignal",
   "navigate",
@@ -26,6 +28,7 @@ export const STX_RUNTIME_GLOBALS = [
   "provide",
   "reactive",
   "ref",
+  "refresh",
   "registerStoresClient",
   "setRouteParams",
   "state",
@@ -56,6 +59,8 @@ export const STX_RUNTIME_GLOBALS = [
   "useReactiveProp",
   "useRef",
   "useRoute",
+  "useRouteParam",
+  "useRouteParams",
   "useScrollLock",
   "useSearchParams",
   "useSeoMeta",
@@ -87,7 +92,17 @@ export const COMPILE_TIME_ONLY_GLOBALS = [
   "defineProps",
   "defineSlots",
   "withDefaults"
-], REACTIVE_RUNTIME_GLOBALS = STX_RUNTIME_GLOBALS.filter((name) => !COMPILE_TIME_ONLY_GLOBALS.includes(name));
+], NON_CLIENT_PRIMITIVES = {
+  redirect: { category: "server-only", reason: "returns an HTTP Response for <script server>/edge/build; use navigate() on the client." },
+  useAsyncData: { category: "browser-composable", reason: "inlined on demand from src/composables when a script references it; reachable, not a bare global." },
+  Teleport: { category: "compile-time-directive", reason: "template tag resolved by processTeleportDirectives; not a script callable." },
+  StxModalBuiltin: { category: "builtin-component", reason: "builtin component used as a template tag; drive open/close from the modal store." },
+  StxToastBuiltin: { category: "builtin-component", reason: "builtin component used as a template tag; push toasts via the toast store." },
+  useForm: { category: "browser-composable", reason: "reactive form primitive; lives in src/composables/use-form.ts and is inlined on demand when a <script client> references it (#1846)." },
+  defineForm: { category: "browser-composable", reason: "deprecated alias of useForm, kept for a minor (#1843). Same delivery path \u2014 inlined on demand from src/composables/use-form.ts." },
+  validateFields: { category: "isomorphic-import", reason: "pure validation helper; import it directly, not auto-delivered to <script client> (per client-api-delivery.test.ts)." },
+  validateField: { category: "isomorphic-import", reason: "singular pure validation helper; same explicit-import boundary as validateFields." }
+}, REACTIVE_RUNTIME_GLOBALS = STX_RUNTIME_GLOBALS.filter((name) => !COMPILE_TIME_ONLY_GLOBALS.includes(name));
 export function usesReactiveRuntime(source) {
   if (!source)
     return !1;

package/dist/runtime-injection.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Runtime Injection Module
+ *
+ * Handles injecting the signals runtime, browser runtime, and SPA router
+ * script into rendered HTML templates.
+ *
+ * @module runtime-injection
+ */
 import type { StxOptions } from './types';
 /**
  * Inject an @stacksjs/browser initialization input into a template that will

package/dist/runtime-injection.js

@@ -1,3 +1,5 @@
+import { getOwnedRouteMatchers } from "./owned-routes.js";
+import { toScriptJson } from "./script-json.js";
 export function injectBrowserRuntime(template) {
   if (template.includes("window.StacksBrowser") || template.includes("StacksBrowser ="))
     return template;
@@ -126,32 +128,39 @@ export async function injectRouterScript(template, options) {
     return template;
   const routerConfig = options?.router;
   let configScript = "";
-  if (routerConfig) {
+  {
     const configObj = {};
-    if (routerConfig.container)
-      configObj.container = routerConfig.container;
-    if (routerConfig.interceptAllLinks !== void 0)
-      configObj.interceptAllLinks = routerConfig.interceptAllLinks;
-    if (routerConfig.progress !== void 0)
-      configObj.progress = routerConfig.progress;
-    if (routerConfig.viewTransitions !== void 0)
-      configObj.viewTransitions = routerConfig.viewTransitions;
-    if (routerConfig.viewTransitionDuration !== void 0)
-      configObj.viewTransitionDuration = routerConfig.viewTransitionDuration;
-    if (routerConfig.viewTransitionEasing !== void 0)
-      configObj.viewTransitionEasing = routerConfig.viewTransitionEasing;
-    if (routerConfig.scrollToTop !== void 0)
-      configObj.scrollToTop = routerConfig.scrollToTop;
-    if (routerConfig.prefetch !== void 0)
-      configObj.prefetch = routerConfig.prefetch;
-    if (routerConfig.cache !== void 0)
-      configObj.cache = routerConfig.cache;
-    if (routerConfig.progressColor !== void 0)
-      configObj.progressColor = routerConfig.progressColor;
-    if (routerConfig.progressHeight !== void 0)
-      configObj.progressHeight = routerConfig.progressHeight;
+    if (routerConfig) {
+      if (routerConfig.container)
+        configObj.container = routerConfig.container;
+      if (routerConfig.interceptAllLinks !== void 0)
+        configObj.interceptAllLinks = routerConfig.interceptAllLinks;
+      if (routerConfig.progress !== void 0)
+        configObj.progress = routerConfig.progress;
+      if (routerConfig.viewTransitions !== void 0)
+        configObj.viewTransitions = routerConfig.viewTransitions;
+      if (routerConfig.viewTransitionDuration !== void 0)
+        configObj.viewTransitionDuration = routerConfig.viewTransitionDuration;
+      if (routerConfig.viewTransitionEasing !== void 0)
+        configObj.viewTransitionEasing = routerConfig.viewTransitionEasing;
+      if (routerConfig.scrollToTop !== void 0)
+        configObj.scrollToTop = routerConfig.scrollToTop;
+      if (routerConfig.prefetch !== void 0)
+        configObj.prefetch = routerConfig.prefetch;
+      if (routerConfig.cache !== void 0)
+        configObj.cache = routerConfig.cache;
+      if (routerConfig.progressColor !== void 0)
+        configObj.progressColor = routerConfig.progressColor;
+      if (routerConfig.progressHeight !== void 0)
+        configObj.progressHeight = routerConfig.progressHeight;
+    }
+    try {
+      const owned = await getOwnedRouteMatchers(options?.pagesDir);
+      if (owned.length > 0)
+        configObj.ownedRoutes = owned;
+    } catch {}
     if (Object.keys(configObj).length > 0)
-      configScript = `<script>window.__stxRouterConfig=${JSON.stringify(configObj)};</script>
+      configScript = `<script>window.__stxRouterConfig=${toScriptJson(configObj)};</script>
 `;
   }
   const { getCachedRouterScript } = await import("./caching.js"), routerScript = options?.buildMode === "compile" ? '<script data-stx-router src="/__stx/router.__STX_HASH__.js"></script>' : options?.buildMode === "serve" ? '<script data-stx-router src="/_stx/router.js"></script>' : `<script data-stx-router>${await getCachedRouterScript()}</script>`, bodyCloseIdx = template.lastIndexOf("</body>");

package/dist/script-emit.d.ts

@@ -1,3 +1,33 @@
+/**
+ * Escape script bodies at EMIT time (stacksjs/stx#1792, part one item 2).
+ *
+ * A `</script>` anywhere inside a script body — in a string, a comment, or a
+ * runtime value — ends the element as far as the HTML parser is concerned. The
+ * rest of the script is then painted onto the page as text, and everything
+ * defined below the offending line silently does not exist.
+ *
+ * The documented workaround is to write `<\/script>` in the source. It does not
+ * work, and that is the crux of the report: `transpileTypeScript` runs every
+ * non-server block through Bun's transpiler, which NORMALISES the escape away
+ * before the browser ever sees it.
+ *
+ *   in : const s = "<\/script>"
+ *   out: const s = "</script>";
+ *
+ * So the escape protects the source from stx's own scanners and is then
+ * stripped, leaving the HTML parser to apply exactly the rule it was meant to
+ * dodge. Escaping on emit is the only place the protection can survive, because
+ * it happens after the transpiler.
+ *
+ * The transform is semantically inert for JavaScript: `\/` inside a string, a
+ * template literal, a regex literal or a comment parses as `/`. It is also
+ * valid inside JSON, where `\/` is an explicit escape — so a JSON-LD or
+ * importmap body would survive it, though those bodies are excluded upstream
+ * and never reach here.
+ *
+ * This is a leaf module on purpose: no stx imports, so every emit site can use
+ * it without creating a cycle.
+ */
 /**
  * Neutralise closing script tags in a JavaScript body about to be embedded in
  * an HTML `<script>` element.

package/dist/script-json.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Embed JSON inside a `<script>` tag safely.
+ *
+ * `JSON.stringify` alone is not enough for script content, in two ways that both
+ * end with the browser parsing something the author did not write:
+ *
+ *  - A `</script>` sequence inside any string value closes the tag early. The
+ *    rest of the JSON then lands in the document as markup, so whoever controls
+ *    that string controls the page.
+ *  - U+2028 and U+2029 are literal line terminators in JavaScript, though legal
+ *    unescaped in JSON. A value containing one splits the statement it sits in.
+ *
+ * This existed as five separate private copies — `spa-shell.ts`,
+ * `appearance-bootstrap.ts`, `color-mode-boot.ts`, `misc-directives.ts` and
+ * `bun-plugin/src/serve.ts`. That is the shape of bug this repo keeps paying
+ * for: a sixth injection site (`runtime-injection.ts`, added with the
+ * `ownedRoutes` table in #1864) had no escaping at all, because nothing
+ * connected it to the others.
+ *
+ * The escapes below are written as `\u` sequences rather than literal
+ * characters, and that is load-bearing. Writing a raw U+2028 inside the regex
+ * terminates the line mid-literal and the file stops parsing — this module's
+ * own first draft did exactly that, which is a fair demonstration of why the
+ * function needs to exist.
+ *
+ * @module script-json
+ */
+/**
+ * Escape an already-serialised JSON string for inclusion in a `<script>` body.
+ *
+ * `<` and `>` are escaped rather than only the `</script>` sequence, so no
+ * variant spelling (`</SCRIPT`, `</script foo`) can slip through.
+ */
+export declare function escapeJsonForScript(json: string): string;
+/** Serialise a value and escape it for a `<script>` body in one step. */
+export declare function toScriptJson(value: unknown): string;

package/dist/script-json.js

@@ -0,0 +1,6 @@
+export function escapeJsonForScript(json) {
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+export function toScriptJson(value) {
+  return escapeJsonForScript(JSON.stringify(value));
+}

package/dist/script-validation.d.ts

@@ -1,4 +1,20 @@
+/**
+ * Script validation module for STX templates.
+ *
+ * Validates client-side script content against prohibited DOM API patterns,
+ * enforcing the use of STX composables and Vue-style alternatives instead
+ * of raw browser APIs.
+ */
 import type { StrictModeConfig } from './types';
+/**
+ * Prohibited DOM API patterns in client scripts.
+ * STX provides Vue-style alternatives via the STX global object.
+ */
+export declare const PROHIBITED_DOM_PATTERNS: Array<{
+    pattern: RegExp;
+    message: string;
+    suggestion: string;
+}>;
 /**
  * Validate client script content for prohibited DOM API patterns.
  * When strict mode is enabled with `failOnViolation`, throws an error.
@@ -8,9 +24,10 @@ import type { StrictModeConfig } from './types';
  * @param filePath - The file path for error reporting
  * @param strict - Strict mode configuration
  */
-export declare function validateClientScript(content: string, filePath: string, strict?: boolean | StrictModeConfig): void;
+export declare function validateClientScript(content: string, filePath: string, strict?: boolean | StrictModeConfig, 
 /**
- * Prohibited DOM API patterns in client scripts.
- * STX provides Vue-style alternatives via the STX global object.
+ * The view this script was authored in, when `filePath` is a layout that view
+ * was composed into. Reported alongside, because naming only the layout sends
+ * the reader to a file that does not contain the offending code (#1836).
  */
-export declare const PROHIBITED_DOM_PATTERNS: readonly [unknown];
+originFilePath?: string): void;

package/dist/seo.d.ts

@@ -1,3 +1,59 @@
+/**
+ * SEO (Search Engine Optimization) Module
+ *
+ * Provides directives and utilities for generating SEO-related HTML:
+ * - `@meta('name', 'content')` - Generate meta tags
+ * - `@metaTag({ name, property, content })` - Meta tags with full control
+ * - `@structuredData({ ... })` - JSON-LD structured data
+ * - `@seo({ title, description, ... })` - Comprehensive SEO generation
+ *
+ * Also provides:
+ * - Automatic SEO tag injection via `injectSeoTags()`
+ * - Sitemap generation via `generateSitemap()`, `scanForSitemapEntries()`
+ * - robots.txt generation via `generateRobotsTxt()`
+ *
+ * ## Sitemap Generation
+ *
+ * ```typescript
+ * import { generateSitemap, scanForSitemapEntries } from 'stx'
+ *
+ * // Manual entries
+ * const sitemap = generateSitemap([
+ *   { loc: '/', priority: 1.0 },
+ *   { loc: '/about', priority: 0.8 },
+ * ], { baseUrl: 'https://example.com' })
+ *
+ * // Auto-scan directory
+ * const entries = await scanForSitemapEntries('./pages', {
+ *   baseUrl: 'https://example.com'
+ * })
+ * ```
+ *
+ * ## Robots.txt Generation
+ *
+ * ```typescript
+ * import { generateRobotsTxt } from 'stx'
+ *
+ * const robotsTxt = generateRobotsTxt({
+ *   rules: [{ userAgent: '*', allow: ['/'], disallow: ['/admin'] }],
+ *   sitemap: 'https://example.com/sitemap.xml'
+ * })
+ * ```
+ *
+ * ## Configuration
+ *
+ * Default SEO values can be set in `stx.config.ts`:
+ * ```typescript
+ * export default {
+ *   defaultTitle: 'My Site',
+ *   defaultDescription: 'Site description',
+ *   seo: {
+ *     enabled: true,
+ *     defaultConfig: { ... }
+ *   }
+ * }
+ * ```
+ */
 import type { CustomDirective, StxOptions } from './types';
 /**
  * Process @meta directive for generating meta tags.
@@ -20,10 +76,44 @@ export declare function processSeoDirective(template: string, context: Record<st
  * Respects seo.enabled config and skipDefaultSeoTags option.
  */
 export declare function injectSeoTags(html: string, context: Record<string, any>, options: StxOptions): string;
+/**
+ * SEO meta directive for basic meta tag generation
+ */
+export declare const metaDirective: CustomDirective;
+/**
+ * SEO structured data directive for JSON-LD generation
+ */
+export declare const structuredDataDirective: CustomDirective;
 /**
  * Register SEO directives
  */
 export declare function registerSeoDirectives(): CustomDirective[];
+/**
+ * URL entry for sitemap
+ */
+export interface SitemapEntry {
+    /** Full URL of the page */
+    loc: string;
+    /** Last modification date (ISO 8601 format) */
+    lastmod?: string;
+    /** Change frequency */
+    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    /** Priority (0.0 to 1.0) */
+    priority?: number;
+}
+/**
+ * Sitemap generation options
+ */
+export interface SitemapOptions {
+    /** Base URL for the site (e.g., 'https://example.com') */
+    baseUrl: string;
+    /** Default change frequency */
+    defaultChangefreq?: SitemapEntry['changefreq'];
+    /** Default priority */
+    defaultPriority?: number;
+    /** Whether to include lastmod for all entries */
+    includeLastmod?: boolean;
+}
 /**
  * Generate an XML sitemap from a list of URL entries.
  *
@@ -60,10 +150,34 @@ export declare function generateSitemapIndex(sitemaps: string[], baseUrl: string
  * @returns Array of sitemap entries
  */
 export declare function scanForSitemapEntries(directory: string, options: {
-    extensions?: string[]
-    ignore?: string[]
-    baseUrl: string
-  }): Promise<SitemapEntry[]>;
+    extensions?: string[];
+    ignore?: string[];
+    baseUrl: string;
+}): Promise<SitemapEntry[]>;
+/**
+ * Robots.txt rule
+ */
+export interface RobotsRule {
+    /** User agent (e.g., '*', 'Googlebot', 'Bingbot') */
+    userAgent: string;
+    /** Allowed paths */
+    allow?: string[];
+    /** Disallowed paths */
+    disallow?: string[];
+    /** Crawl delay in seconds */
+    crawlDelay?: number;
+}
+/**
+ * Robots.txt generation options
+ */
+export interface RobotsOptions {
+    /** Array of rules */
+    rules: RobotsRule[];
+    /** Sitemap URL(s) */
+    sitemap?: string | string[];
+    /** Host directive (for Yandex) */
+    host?: string;
+}
 /**
  * Generate a robots.txt file content.
  *
@@ -97,46 +211,3 @@ export declare function generateRobotsTxt(options: RobotsOptions): string;
  * @returns robots.txt content string
  */
 export declare function generateDefaultRobotsTxt(sitemapUrl?: string): string;
-/**
- * SEO meta directive for basic meta tag generation
- */
-export declare const metaDirective: CustomDirective;
-/**
- * SEO structured data directive for JSON-LD generation
- */
-export declare const structuredDataDirective: CustomDirective;
-/**
- * URL entry for sitemap
- */
-export declare interface SitemapEntry {
-  loc: string
-  lastmod?: string
-  changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never'
-  priority?: number
-}
-/**
- * Sitemap generation options
- */
-export declare interface SitemapOptions {
-  baseUrl: string
-  defaultChangefreq?: SitemapEntry['changefreq']
-  defaultPriority?: number
-  includeLastmod?: boolean
-}
-/**
- * Robots.txt rule
- */
-export declare interface RobotsRule {
-  userAgent: string
-  allow?: string[]
-  disallow?: string[]
-  crawlDelay?: number
-}
-/**
- * Robots.txt generation options
- */
-export declare interface RobotsOptions {
-  rules: RobotsRule[]
-  sitemap?: string | string[]
-  host?: string
-}

package/dist/server-bindings.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Server-Side Attribute Binding Resolution
+ *
+ * Resolves `:attr="expr"` bindings server-side when the expression can be
+ * evaluated in the server context. This allows Vue-style shorthand binding
+ * syntax to work in server-rendered templates without client-side JS.
+ *
+ * Supported patterns:
+ * - `:src="imageUrl"` → `src="https://example.com/image.png"`
+ * - `:href="link.url"` → `href="/about"`
+ * - `:class="isActive ? 'active' : ''"` → `class="active"`
+ * - `:class="{ active: isActive, hidden: !show }"` → `class="active"`
+ * - `:class="[baseClass, isActive && 'active']"` → `class="btn active"`
+ * - `:disabled="isLoading"` → `disabled` (boolean attributes)
+ * - `:id="'item-' + item.id"` → `id="item-42"`
+ *
+ * Bindings that can't be resolved server-side (e.g., referencing signals or
+ * undefined variables) are left intact for client-side processing.
+ *
+ * @module server-bindings
+ */
 /**
  * Process server-side `:attr="expr"` bindings in a template.
  *