@stacksjs/stx 0.2.155 → 0.2.156

package/dist/crosswind-config.d.ts

@@ -0,0 +1,58 @@
+/**
+ * One merge for the crosswind config, used by every render path.
+ *
+ * There were two, and they disagreed (stacksjs/stx#1867). The dev-server path
+ * read only `theme.extend` and pinned the result after the user spread, so a
+ * project writing `theme: { colors: { … } }` the Tailwind-classic way lost its
+ * entire theme with no error and no warning. The serve path shallow-spread the
+ * same key instead, so there the user's `colors` replaced the whole stock
+ * palette — the opposite failure, from the same config file, decided by which
+ * binary rendered the page. It also read only `safelist`, `shortcuts` and
+ * `theme`, dropping `darkMode`, `preflights`, `cssVariables`, `rules`,
+ * `blocklist` and `variants` entirely.
+ *
+ * ## Why theme keys merge instead of replacing
+ *
+ * Tailwind treats a non-`extend` `theme.colors` as a replacement for the
+ * default palette. That semantic depends on generation being driven by
+ * globbing source files: an unused default color costs bytes, so dropping the
+ * stock palette is the point.
+ *
+ * Here it is driven by scanning the rendered page — a color nothing references
+ * generates nothing, so carrying the base palette along is free. Replacement
+ * would mean adding one token to `theme.colors` silently kills `bg-red-500`
+ * everywhere, which is a far worse failure than an unused key costing nothing.
+ * So base and user theme keys deep-merge, and `extend` is passed through
+ * untouched for CSSGenerator to apply on top.
+ *
+ * @module crosswind-config
+ */
+type Dict = Record<string, any>;
+/**
+ * Deep-merge `source` over `target`, recursing into plain objects only.
+ *
+ * Arrays replace rather than concatenate — a theme's `fontFamily: ['Inter',
+ * 'sans-serif']` is a complete stack, not an addition to one.
+ */
+export declare function deepMergeThemes(target: Dict, source: Dict): Dict;
+export interface MergedCrosswindConfig {
+    /** Ready to hand to `new CSSGenerator(...)`. */
+    config: Dict;
+    /** Merged safelist, also needed by callers to pre-generate those classes. */
+    safelist: string[];
+    /** Merged shortcuts, needed by callers that emit grouped shortcut rules. */
+    shortcuts: Record<string, string>;
+    /** Honours the user's `preflight` key (default true). */
+    includePreflight: boolean;
+    /** Honours the user's `minify` key (default false). */
+    minify: boolean;
+}
+/**
+ * Merge a project's crosswind config over the package defaults.
+ *
+ * `content` and `output` are stx-owned and pinned last: classes come from
+ * scanning the rendered page, not from globbing, and the CSS is returned rather
+ * than written to disk (#1822).
+ */
+export declare function mergeCrosswindConfig(base?: Dict, user?: Dict): MergedCrosswindConfig;
+export {};

package/dist/crosswind-config.js

@@ -0,0 +1,40 @@
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function deepMergeThemes(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source))
+    out[key] = isPlainObject(value) && isPlainObject(out[key]) ? deepMergeThemes(out[key], value) : value;
+  return out;
+}
+export function mergeCrosswindConfig(base = {}, user = {}) {
+  const baseTheme = base.theme || {}, userTheme = user.theme || {}, { extend: userExtend, ...userThemeKeys } = userTheme, { extend: baseExtend, ...baseThemeKeys } = baseTheme, theme = deepMergeThemes(baseThemeKeys, userThemeKeys), extend = deepMergeThemes(baseExtend || {}, userExtend || {});
+  if (Object.keys(extend).length > 0)
+    theme.extend = extend;
+  const safelist = [
+    ...base.safelist || [],
+    ...user.safelist || []
+  ], shortcuts = {
+    ...base.shortcuts || {},
+    ...user.shortcuts || {}
+  }, preflights = [
+    ...base.preflights || [],
+    ...user.preflights || []
+  ];
+  return {
+    config: {
+      ...base,
+      ...user,
+      theme,
+      safelist,
+      shortcuts,
+      ...preflights.length > 0 ? { preflights } : {},
+      content: [],
+      output: ""
+    },
+    safelist,
+    shortcuts,
+    includePreflight: user.preflight !== !1,
+    minify: user.minify === !0
+  };
+}

package/dist/csp.d.ts

@@ -1,3 +1,69 @@
+/**
+ * Content Security Policy (CSP) Module
+ *
+ * Provides utilities for generating and managing Content Security Policy headers
+ * and meta tags to protect against XSS and other injection attacks.
+ *
+ * ## Features
+ *
+ * - Generate CSP headers from configuration
+ * - Inject CSP meta tags into HTML
+ * - Nonce generation for inline scripts/styles
+ * - Preset configurations for common use cases
+ * - Template directives for CSP integration
+ *
+ * ## Usage
+ *
+ * ### Configuration in stx.config.ts
+ *
+ * ```typescript
+ * export default {
+ *   csp: {
+ *     enabled: true,
+ *     directives: {
+ *       'default-src': ["'self'"],
+ *       'script-src': ["'self'", "'strict-dynamic'"],
+ *       'style-src': ["'self'", "'unsafe-inline'"],
+ *       'img-src': ["'self'", 'data:', 'https:'],
+ *       'connect-src': ["'self'", 'https://api.example.com'],
+ *     },
+ *     useNonce: true,
+ *     addMetaTag: true,
+ *   }
+ * }
+ * ```
+ *
+ * ### Using Presets
+ *
+ * ```typescript
+ * import { getCspPreset, generateCspHeader } from 'stx'
+ *
+ * const config = getCspPreset('strict')
+ * const header = generateCspHeader(config.directives)
+ * ```
+ *
+ * ### Template Directives
+ *
+ * ```html
+ * <!-- Insert CSP meta tag -->
+ * @csp
+ *
+ * <!-- Get current nonce for inline scripts -->
+ * <script nonce="{{ cspNonce }}">
+ *   console.log('Safe inline script')
+ * </script>
+ * ```
+ *
+ * ### HTTP Headers
+ *
+ * ```typescript
+ * import { generateCspHeader } from 'stx'
+ *
+ * // In your server handler
+ * const cspHeader = generateCspHeader(config.csp.directives)
+ * response.setHeader('Content-Security-Policy', cspHeader)
+ * ```
+ */
 import type { CspConfig, CspDirectives, CspPreset, CustomDirective, StxOptions } from './types';
 /**
  * Generate a cryptographically secure nonce for CSP
@@ -72,6 +138,37 @@ export declare function generateCspHeader(directives: CspDirectives, nonce?: str
  * ```
  */
 export declare function generateCspMetaTag(directives: CspDirectives, nonce?: string): string;
+/**
+ * Strict CSP preset - Maximum security, may require nonces for inline content
+ *
+ * - No unsafe-inline or unsafe-eval
+ * - Uses strict-dynamic for scripts
+ * - Blocks object/embed
+ * - Restricts form actions to same origin
+ */
+export declare const strictCspPreset: CspDirectives;
+/**
+ * Moderate CSP preset - Balanced security and compatibility
+ *
+ * - Allows unsafe-inline for styles (common requirement)
+ * - Blocks unsafe-eval
+ * - Allows data: URIs for images
+ */
+export declare const moderateCspPreset: CspDirectives;
+/**
+ * Relaxed CSP preset - Basic protection, maximum compatibility
+ *
+ * - Allows unsafe-inline for both scripts and styles
+ * - Still blocks unsafe-eval and object embeds
+ */
+export declare const relaxedCspPreset: CspDirectives;
+/**
+ * API-only CSP preset - For JSON API responses
+ *
+ * - Blocks all content loading (APIs shouldn't render HTML)
+ * - Prevents framing
+ */
+export declare const apiCspPreset: CspDirectives;
 /**
  * Get a CSP preset configuration by name
  *
@@ -140,6 +237,16 @@ export declare function addNonceToInlineContent(html: string, nonce: string): st
  * @returns Processed template
  */
 export declare function processCspDirectives(template: string, context: Record<string, any>, _filePath: string, options: StxOptions): string;
+/**
+ * CSP meta tag directive
+ * Usage: @csp
+ */
+export declare const cspDirective: CustomDirective;
+/**
+ * CSP nonce directive
+ * Usage: @cspNonce
+ */
+export declare const cspNonceDirective: CustomDirective;
 /**
  * Register CSP-related custom directives
  *
@@ -182,47 +289,6 @@ export declare function getCspHeaderName(reportOnly?: boolean): string;
  * ```
  */
 export declare function createCspHeaders(config: CspConfig, context?: object): Record<string, string>;
-/**
- * Strict CSP preset - Maximum security, may require nonces for inline content
- *
- * - No unsafe-inline or unsafe-eval
- * - Uses strict-dynamic for scripts
- * - Blocks object/embed
- * - Restricts form actions to same origin
- */
-export declare const strictCspPreset: CspDirectives;
-/**
- * Moderate CSP preset - Balanced security and compatibility
- *
- * - Allows unsafe-inline for styles (common requirement)
- * - Blocks unsafe-eval
- * - Allows data: URIs for images
- */
-export declare const moderateCspPreset: CspDirectives;
-/**
- * Relaxed CSP preset - Basic protection, maximum compatibility
- *
- * - Allows unsafe-inline for both scripts and styles
- * - Still blocks unsafe-eval and object embeds
- */
-export declare const relaxedCspPreset: CspDirectives;
-/**
- * API-only CSP preset - For JSON API responses
- *
- * - Blocks all content loading (APIs shouldn't render HTML)
- * - Prevents framing
- */
-export declare const apiCspPreset: CspDirectives;
-/**
- * CSP meta tag directive
- * Usage: @csp
- */
-export declare const cspDirective: CustomDirective;
-/**
- * CSP nonce directive
- * Usage: @cspNonce
- */
-export declare const cspNonceDirective: CustomDirective;
 /**
  * Default CSP configuration - moderate preset
  */

package/dist/defer.d.ts

@@ -1,3 +1,27 @@
+/**
+ * Defer Directive
+ *
+ * Lazy loads content based on various triggers.
+ *
+ * Usage:
+ * @defer(on: 'visible')
+ *   <HeavyComponent />
+ * @placeholder
+ *   <Skeleton />
+ * @loading
+ *   <Spinner />
+ * @error
+ *   <div>Failed to load</div>
+ * @enddefer
+ *
+ * Triggers:
+ * - 'visible' - Load when element enters viewport (IntersectionObserver)
+ * - 'idle' - Load when browser is idle (requestIdleCallback)
+ * - 'interaction' - Load on first interaction (click, focus)
+ * - 'hover' - Load on hover
+ * - 'timer(ms)' - Load after specified milliseconds
+ * - 'immediate' - Load immediately but async (default)
+ */
 /**
  * Process @defer directives in template
  */

package/dist/dev-server/crosswind.d.ts

@@ -1,3 +1,37 @@
+/**
+ * Crosswind CSS Generation Module
+ * Provides on-the-fly Tailwind CSS generation using Crosswind
+ */
+interface CrosswindModule {
+    CSSGenerator: new (config: CrosswindConfig) => CSSGenerator;
+    config: CrosswindConfig;
+    build?: (config: CrosswindConfig) => Promise<CrosswindBuildResult>;
+    defaultConfig?: CrosswindConfig;
+    /**
+     * Crosswind's own extractor. Preferred over the local fallback below —
+     * it is the authority on what counts as a class candidate, and it keeps
+     * up with syntax this package would otherwise have to mirror by hand.
+     */
+    extractClasses?: (content: string) => Set<string>;
+}
+interface CrosswindConfig {
+    content?: string[];
+    output?: string;
+    preflight?: boolean;
+    minify?: boolean;
+    preflights?: unknown[];
+    safelist?: string[];
+    [key: string]: unknown;
+}
+interface CrosswindBuildResult {
+    css: string;
+    classes: Set<string>;
+    duration: number;
+}
+interface CSSGenerator {
+    generate(className: string): void;
+    toCSS(preflight: boolean, minify: boolean): string;
+}
 export declare function getCrosswindServeAsset(hash: string): string | undefined;
 /**
  * Lazily load the Crosswind module
@@ -72,29 +106,4 @@ export declare function generateCrosswindCSS(htmlContent: string, appDir?: strin
  * Tries to inject before </head>, falls back to <body> or prepends
  */
 export declare function injectCrosswindCSS(htmlContent: string, appDir?: string, serveMode?: boolean): Promise<string>;
-// Type for Crosswind module
-declare interface CrosswindModule {
-  CSSGenerator: new (config: CrosswindConfig) => CSSGenerator
-  config: CrosswindConfig
-  build?: (config: CrosswindConfig) => Promise<CrosswindBuildResult>
-  defaultConfig?: CrosswindConfig
-  extractClasses?: (content: string) => Set<string>
-}
-declare interface CrosswindConfig {
-  content?: string[]
-  output?: string
-  preflight?: boolean
-  minify?: boolean
-  preflights?: unknown[]
-  safelist?: string[]
-  [key: string]: unknown
-}
-declare interface CrosswindBuildResult {
-  css: string
-  classes: Set<string>
-  duration: number
-}
-declare interface CSSGenerator {
-  generate(className: string): void
-  toCSS(preflight: boolean, minify: boolean): string
-}
+export {};

package/dist/dev-server/crosswind.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { hasLocalConfig } from "bunfig";
+import { mergeCrosswindConfig } from "../crosswind-config.js";
 import { stateDir } from "../state-dir.js";
 import { colors } from "./terminal-colors.js";
 let crosswindModule = null, crosswindLoadAttempted = !1, cachedConfig = null, cachedCSS = "", isBuilding = !1;
@@ -323,24 +324,7 @@ export async function generateCrosswindCSS(htmlContent, appDir) {
         configFingerprint = "unhashable";
       }
     }
-    const baseConfig = hw.defaultConfig || hw.config, userConfig = cachedConfig || {}, baseTheme = baseConfig.theme || {}, userExtend = (userConfig.theme || {}).extend || {}, theme = { ...baseTheme };
-    if (Object.keys(userExtend).length > 0)
-      theme.extend = userExtend;
-    const safelist = [
-      ...baseConfig.safelist || [],
-      ...userConfig.safelist || []
-    ], preflights = [
-      ...baseConfig.preflights || [],
-      ...userConfig.preflights || []
-    ], includePreflight = userConfig.preflight !== !1, minify = userConfig.minify === !0, crosswindConfig = {
-      ...baseConfig,
-      ...userConfig,
-      content: [],
-      output: "",
-      theme,
-      safelist,
-      ...preflights.length > 0 && { preflights }
-    }, generator = new hw.CSSGenerator(crosswindConfig);
+    const baseConfig = hw.defaultConfig || hw.config, userConfig = cachedConfig || {}, merged = mergeCrosswindConfig(baseConfig, userConfig), { safelist, includePreflight, minify } = merged, crosswindConfig = merged.config, generator = new hw.CSSGenerator(crosswindConfig);
     for (const cls of safelist)
       generator.generate(cls);
     for (const className of classes)

package/dist/dev-server/serve-app.js

@@ -24,7 +24,8 @@ import {
   clearMiddleware,
   getMiddlewareNames
 } from "../route-middleware.js";
-import { getPageMeta, resetHead } from "../head.js";
+import { resetHead } from "../head.js";
+import { extractPageMetaFromSource } from "../page-meta.js";
 import { clearComponentCache } from "../utils.js";
 import { extractPageResponseStatus } from "../page-response.js";
 import {
@@ -396,7 +397,7 @@ export async function serveApp(appDir = ".", options = {}) {
             builtPage = rebuilt;
         }
         if (builtPage) {
-          const responseStatus = builtPage.status ?? 200, pageMeta = getPageMeta();
+          const responseStatus = builtPage.status ?? 200, pageMeta = (routeMatch.route.filePath ? extractPageMetaFromSource(await Bun.file(routeMatch.route.filePath).text().catch(() => "")) : null) ?? {};
           if (pageMeta.validate) {
             if (!await pageMeta.validate({ params: routeMatch.params })) {
               const custom404 = await renderErrorPage(404);
@@ -414,7 +415,7 @@ export async function serveApp(appDir = ".", options = {}) {
             }
           }
           if (pageMeta.middleware) {
-            const toRoute = createRouteLocation(url.pathname, routeMatch.params, pageMeta, url.search), middlewareContext = createMiddlewareContext(toRoute, null, request), middlewareResult = await runMiddleware(pageMeta.middleware, middlewareContext);
+            const toRoute = createRouteLocation(url.pathname, routeMatch.params, pageMeta, url.search), middlewareContext = createMiddlewareContext(toRoute, null, request, { isServer: !0 }), middlewareResult = await runMiddleware(pageMeta.middleware, middlewareContext);
             if (middlewareResult.redirect) {
               const redirectUrl = middlewareResult.redirect.path, statusCode = middlewareResult.redirect.options.redirectCode || 302, headers = new Headers(middlewareResult.responseHeaders);
               headers.set("Location", redirectUrl);

package/dist/dev-server/terminal-colors.d.ts

@@ -1,3 +1,35 @@
+/**
+ * ANSI color codes for terminal output
+ * Provides consistent coloring for CLI messages
+ */
+export declare const colors: {
+    readonly reset: '\u001B[0m';
+    readonly bright: '\u001B[1m';
+    readonly dim: '\u001B[2m';
+    readonly underscore: '\u001B[4m';
+    readonly blink: '\u001B[5m';
+    readonly reverse: '\u001B[7m';
+    readonly hidden: '\u001B[8m';
+    readonly black: '\u001B[30m';
+    readonly red: '\u001B[31m';
+    readonly green: '\u001B[32m';
+    readonly yellow: '\u001B[33m';
+    readonly blue: '\u001B[34m';
+    readonly magenta: '\u001B[35m';
+    readonly cyan: '\u001B[36m';
+    readonly white: '\u001B[37m';
+    readonly gray: '\u001B[90m';
+    readonly bgBlack: '\u001B[40m';
+    readonly bgRed: '\u001B[41m';
+    readonly bgGreen: '\u001B[42m';
+    readonly bgYellow: '\u001B[43m';
+    readonly bgBlue: '\u001B[44m';
+    readonly bgMagenta: '\u001B[45m';
+    readonly bgCyan: '\u001B[46m';
+    readonly bgWhite: '\u001B[47m';
+    readonly bgGray: '\u001B[100m';
+};
+export type ColorName = keyof typeof colors;
 /**
  * Colorize a string with the specified color
  */
@@ -22,35 +54,3 @@ export declare function info(text: string): string;
  * Create a dim/muted message (gray)
  */
 export declare function dim(text: string): string;
-/**
- * ANSI color codes for terminal output
- * Provides consistent coloring for CLI messages
- */
-export declare const colors: {
-  reset: '\x1B[0m';
-  bright: '\x1B[1m';
-  dim: '\x1B[2m';
-  underscore: '\x1B[4m';
-  blink: '\x1B[5m';
-  reverse: '\x1B[7m';
-  hidden: '\x1B[8m';
-  black: '\x1B[30m';
-  red: '\x1B[31m';
-  green: '\x1B[32m';
-  yellow: '\x1B[33m';
-  blue: '\x1B[34m';
-  magenta: '\x1B[35m';
-  cyan: '\x1B[36m';
-  white: '\x1B[37m';
-  gray: '\x1B[90m';
-  bgBlack: '\x1B[40m';
-  bgRed: '\x1B[41m';
-  bgGreen: '\x1B[42m';
-  bgYellow: '\x1B[43m';
-  bgBlue: '\x1B[44m';
-  bgMagenta: '\x1B[45m';
-  bgCyan: '\x1B[46m';
-  bgWhite: '\x1B[47m';
-  bgGray: '\x1B[100m'
-};
-export type ColorName = keyof typeof colors;

package/dist/directive-api.d.ts

@@ -1,4 +1,88 @@
+/**
+ * STX Directive API
+ *
+ * Enhanced API for creating custom directives with lifecycle hooks,
+ * client-side support, and built-in utilities.
+ *
+ * @module directive-api
+ *
+ * @example
+ * ```typescript
+ * import { defineDirective } from 'stx'
+ *
+ * // Simple directive
+ * const uppercase = defineDirective({
+ *   name: 'uppercase',
+ *   transform: (content) => content.toUpperCase()
+ * })
+ *
+ * // Directive with parameters
+ * const highlight = defineDirective({
+ *   name: 'highlight',
+ *   transform: (content, { color = 'yellow' }) =>
+ *     `<mark style="background: ${color}">${content}</mark>`
+ * })
+ * ```
+ */
 import type { CustomDirective } from './types';
+/** Directive parameter types */
+export type DirectiveParams = Record<string, unknown>;
+/** Directive binding for client-side directives */
+export interface DirectiveBinding<T = unknown> {
+    /** The value passed to the directive */
+    value: T;
+    /** Previous value (for updates) */
+    oldValue?: T;
+    /** Argument passed after colon (v-directive:arg) */
+    arg?: string;
+    /** Modifiers passed after dots (v-directive.mod1.mod2) */
+    modifiers: Record<string, boolean>;
+    /** The directive instance */
+    instance: unknown;
+    /** The directive definition */
+    dir: ClientDirectiveDefinition<T>;
+}
+/** Server-side directive definition */
+export interface DirectiveDefinition<P extends DirectiveParams = DirectiveParams> {
+    /** Directive name (without @) */
+    name: string;
+    /** Whether directive has end tag (@name...@endname) */
+    hasEndTag?: boolean;
+    /** Description for documentation */
+    description?: string;
+    /** Transform content (server-side) */
+    transform?: (content: string, params: P, context: Record<string, unknown>, filePath: string) => string | Promise<string>;
+    /** Validate parameters */
+    validate?: (params: P) => boolean | string;
+    /** Default parameter values */
+    defaults?: Partial<P>;
+    /** Generate client-side code */
+    clientScript?: (params: P) => string;
+    /** Generate CSS */
+    css?: (params: P) => string;
+}
+/** Client-side directive hooks */
+export interface ClientDirectiveDefinition<T = unknown> {
+    /** Called when directive is first bound to element */
+    created?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called before element is inserted into DOM */
+    beforeMount?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called when element is inserted into DOM */
+    mounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called before the component is updated */
+    beforeUpdate?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called after the component has updated */
+    updated?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called before element is unmounted */
+    beforeUnmount?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+    /** Called when element is unmounted */
+    unmounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
+}
+/** Combined directive (server + client) */
+export interface FullDirectiveDefinition<P extends DirectiveParams = DirectiveParams, T = unknown> extends DirectiveDefinition<P> {
+    /** Client-side hooks */
+    client?: ClientDirectiveDefinition<T>;
+}
 /**
  * Register a directive globally.
  */
@@ -50,11 +134,11 @@ export declare function unregisterDirective(name: string): boolean;
  * })
  * ```
  */
-export declare function defineDirective<P extends DirectiveParams = DirectiveParams, T = unknown,>(definition: FullDirectiveDefinition<P, T>): CustomDirective;
+export declare function defineDirective<P extends DirectiveParams = DirectiveParams, T = unknown>(definition: FullDirectiveDefinition<P, T>): CustomDirective;
 /**
  * Define a client-only directive.
  */
-export declare function defineClientDirective<T = unknown>(name: string): ClientDirectiveDefinition<T>;
+export declare function defineClientDirective<T = unknown>(name: string, definition: ClientDirectiveDefinition<T> | ((el: HTMLElement, binding: DirectiveBinding<T>) => void)): ClientDirectiveDefinition<T>;
 /**
  * Create common built-in directives.
  */
@@ -68,44 +152,3 @@ export declare function generateDirectiveRuntime(): string;
  * Converts v-directive:arg.mod="value" to data attributes and client setup.
  */
 export declare function processDirectiveAttributes(template: string): string;
-/** Directive binding for client-side directives */
-export declare interface DirectiveBinding<T = unknown> {
-  value: T
-  oldValue?: T
-  arg?: string
-  modifiers: Record<string, boolean>
-  instance: unknown
-  dir: ClientDirectiveDefinition<T>
-}
-/** Server-side directive definition */
-export declare interface DirectiveDefinition<P extends DirectiveParams = DirectiveParams> {
-  name: string
-  hasEndTag?: boolean
-  description?: string
-  transform?: (
-    content: string,
-    params: P,
-    context: Record<string, unknown>,
-    filePath: string,
-  ) => string | Promise<string>
-  validate?: (params: P) => boolean | string
-  defaults?: Partial<P>
-  clientScript?: (params: P) => string
-  css?: (params: P) => string
-}
-/** Client-side directive hooks */
-export declare interface ClientDirectiveDefinition<T = unknown> {
-  created?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  beforeMount?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  mounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  beforeUpdate?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  updated?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  beforeUnmount?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-  unmounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void
-}
-/** Combined directive (server + client) */
-export declare interface FullDirectiveDefinition<P extends DirectiveParams = DirectiveParams, T = unknown,> extends DirectiveDefinition<P> {
-  client?: ClientDirectiveDefinition<T>
-}
-/** Directive parameter types */
-export type DirectiveParams = Record<string, unknown>;