@stacksjs/stx 0.2.155 → 0.2.156

package/dist/plugin-system.d.ts

@@ -1,4 +1,195 @@
+/**
+ * Plugin System for stx
+ *
+ * Provides a robust plugin architecture with lifecycle hooks for extending
+ * the template processing pipeline.
+ *
+ * ## Plugin Lifecycle
+ *
+ * Plugins can hook into various stages of template processing:
+ *
+ * 1. **beforeProcess** - Before any directive processing begins
+ * 2. **afterParse** - After template is parsed but before directives run
+ * 3. **beforeDirective** - Before each directive type is processed
+ * 4. **afterDirective** - After each directive type is processed
+ * 5. **beforeRender** - Before final output is generated
+ * 6. **afterRender** - After final output is generated
+ * 7. **onError** - When an error occurs during processing
+ *
+ * ## Example Plugin
+ *
+ * ```typescript
+ * const myPlugin: StxPlugin = {
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *
+ *   beforeProcess({ template, context }) {
+ *     // Add global variables
+ *     context.myPluginData = { initialized: true }
+ *     return { template, context }
+ *   },
+ *
+ *   registerDirectives() {
+ *     return [{
+ *       name: 'myDirective',
+ *       handler: (content, params) => content.toUpperCase(),
+ *       hasEndTag: true
+ *     }]
+ *   }
+ * }
+ * ```
+ *
+ * @module plugin-system
+ */
 import type { CustomDirective, StxOptions } from './types';
+/**
+ * Context passed to lifecycle hooks
+ */
+export interface PluginContext {
+    /** Current template content */
+    template: string;
+    /** Template context/variables */
+    context: Record<string, unknown>;
+    /** Source file path */
+    filePath: string;
+    /** Stx options */
+    options: StxOptions;
+    /** Dependencies tracked during processing */
+    dependencies: Set<string>;
+    /** Metadata for plugin communication */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Result from a lifecycle hook
+ */
+export interface PluginHookResult {
+    /** Modified template (optional) */
+    template?: string;
+    /** Modified context (optional) */
+    context?: Record<string, unknown>;
+    /** Whether to skip further processing (optional) */
+    skip?: boolean;
+    /** Additional metadata to pass along */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Error context passed to onError hook
+ */
+export interface PluginErrorContext extends PluginContext {
+    /** The error that occurred */
+    error: Error;
+    /** Phase where error occurred */
+    phase: string;
+    /** Directive being processed (if applicable) */
+    directive?: string;
+}
+/**
+ * Directive type identifier for beforeDirective/afterDirective hooks
+ */
+export type DirectivePhase = 'comments' | 'escaped' | 'stacks' | 'layouts' | 'includes' | 'js' | 'ts' | 'custom' | 'components' | 'animation' | 'routes' | 'auth' | 'csrf' | 'method' | 'loops' | 'conditionals' | 'forms' | 'markdown' | 'i18n' | 'a11y' | 'seo' | 'expressions';
+/**
+ * Plugin definition interface
+ */
+export interface StxPlugin {
+    /** Unique plugin name */
+    name: string;
+    /** Plugin version (semver) */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /** Plugin dependencies (other plugin names) */
+    dependencies?: string[];
+    /** Order priority (lower runs first, default: 100) */
+    priority?: number;
+    /**
+     * Called before any template processing begins.
+     * Use this to initialize plugin state or modify the initial template.
+     */
+    beforeProcess?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called after the template is parsed but before directives are processed.
+     * Useful for template analysis or pre-processing.
+     */
+    afterParse?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called before a specific directive type is processed.
+     * @param phase - The directive phase being processed
+     * @param ctx - Plugin context
+     */
+    beforeDirective?: (phase: DirectivePhase, ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called after a specific directive type is processed.
+     * @param phase - The directive phase that was processed
+     * @param ctx - Plugin context
+     */
+    afterDirective?: (phase: DirectivePhase, ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called before the final render output is generated.
+     */
+    beforeRender?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called after the final render output is generated.
+     */
+    afterRender?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Called when an error occurs during processing.
+     * Can return a recovery template or rethrow the error.
+     */
+    onError?: (ctx: PluginErrorContext) => PluginHookResult | Promise<PluginHookResult> | void;
+    /**
+     * Register custom directives provided by this plugin.
+     * Called during plugin initialization.
+     */
+    registerDirectives?: () => CustomDirective[];
+    /**
+     * Register custom expression filters.
+     * Called during plugin initialization.
+     */
+    registerFilters?: () => Record<string, (value: unknown, ...args: unknown[]) => unknown>;
+    /**
+     * Called when the plugin is registered.
+     * Use for one-time initialization.
+     */
+    onRegister?: (options: StxOptions) => void | Promise<void>;
+    /**
+     * Called when the plugin is unregistered.
+     * Use for cleanup.
+     */
+    onUnregister?: () => void | Promise<void>;
+    /** Directory of .stx components — auto-registered, available in all templates */
+    /**
+     * Component directory, or directories.
+     *
+     * An array lets one package register several roots — @stacksjs/components
+     * ships src/ui and src/components as siblings (#1823).
+     */
+    components?: string | string[];
+    /** Directory of composable functions — importable via @/functions/ */
+    functions?: string;
+    /** Directory of store definitions — auto-registered */
+    stores?: string;
+    /** Directory of page templates — merged into file-based routing */
+    pages?: string;
+    /** Directory of route middleware */
+    middleware?: string;
+    /** Setup function called when plugin is loaded — receives options and stx context */
+    setup?: (options: Record<string, any>, stx: PluginSetupContext) => void | Promise<void>;
+}
+/**
+ * Context passed to plugin setup() function
+ */
+export interface PluginSetupContext {
+    /** Register a custom directive */
+    addDirective: (directive: CustomDirective) => void;
+    /** Register an API route handler */
+    addRoute: (path: string, handler: (req: Request) => Response | Promise<Response>) => void;
+    /** Register route middleware */
+    addMiddleware: (middleware: any) => void;
+    /** The resolved plugin directory path */
+    pluginDir: string;
+    /** The stx config */
+    config: StxOptions;
+}
 /**
  * Define an stx plugin with type safety.
  *
@@ -18,21 +209,84 @@ import type { CustomDirective, StxOptions } from './types';
  */
 export declare function definePlugin(config: StxPlugin): StxPlugin;
 /**
- * Create a simple directive plugin
+ * Plugin manager that handles registration, lifecycle, and execution
  */
-export declare function createDirectivePlugin(name: string, directives: CustomDirective[], options?: Partial<Omit<StxPlugin, 'name' | 'registerDirectives'>>): StxPlugin;
+export declare class PluginManager {
+    private plugins;
+    private sortedPlugins;
+    private initialized;
+    /**
+     * Register a plugin
+     */
+    register(plugin: StxPlugin, options: StxOptions): Promise<void>;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): Promise<boolean>;
+    /**
+     * Get a registered plugin by name
+     */
+    get(name: string): StxPlugin | undefined;
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered plugins (sorted by priority)
+     */
+    getAll(): StxPlugin[];
+    /**
+     * Get all custom directives from all plugins
+     */
+    getAllDirectives(): CustomDirective[];
+    /**
+     * Get all filters from all plugins
+     */
+    getAllFilters(): Record<string, (value: unknown, ...args: unknown[]) => unknown>;
+    /**
+     * Run beforeProcess hooks on all plugins
+     */
+    runBeforeProcess(ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run afterParse hooks on all plugins
+     */
+    runAfterParse(ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run beforeDirective hooks on all plugins
+     */
+    runBeforeDirective(phase: DirectivePhase, ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run afterDirective hooks on all plugins
+     */
+    runAfterDirective(phase: DirectivePhase, ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run beforeRender hooks on all plugins
+     */
+    runBeforeRender(ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run afterRender hooks on all plugins
+     */
+    runAfterRender(ctx: PluginContext): Promise<PluginContext>;
+    /**
+     * Run onError hooks on all plugins
+     */
+    runOnError(ctx: PluginErrorContext): Promise<PluginContext | null>;
+    private sortPlugins;
+    private runHooks;
+    private runDirectiveHooks;
+}
 /**
- * Create a simple filter plugin
+ * Global plugin manager instance
  */
-export declare function createFilterPlugin(name: string, filters: Record<string, (value: unknown, ...args: unknown[]) => unknown>, options?: Partial<Omit<StxPlugin, 'name' | 'registerFilters'>>): StxPlugin;
+export declare const pluginManager: PluginManager;
 /**
- * Variables plugin that adds common variables to context
+ * Create a simple directive plugin
  */
-export declare function createVariablesPlugin(variables: Record<string, unknown>): StxPlugin;
+export declare function createDirectivePlugin(name: string, directives: CustomDirective[], options?: Partial<Omit<StxPlugin, 'name' | 'registerDirectives'>>): StxPlugin;
 /**
- * Global plugin manager instance
+ * Create a simple filter plugin
  */
-export declare const pluginManager: PluginManager;
+export declare function createFilterPlugin(name: string, filters: Record<string, (value: unknown, ...args: unknown[]) => unknown>, options?: Partial<Omit<StxPlugin, 'name' | 'registerFilters'>>): StxPlugin;
 /**
  * Debug plugin that logs all lifecycle events
  */
@@ -42,111 +296,6 @@ export declare const debugPlugin: StxPlugin;
  */
 export declare const timingPlugin: StxPlugin;
 /**
- * Context passed to lifecycle hooks
- */
-export declare interface PluginContext {
-  template: string
-  context: Record<string, unknown>
-  filePath: string
-  options: StxOptions
-  dependencies: Set<string>
-  metadata: Record<string, unknown>
-}
-/**
- * Result from a lifecycle hook
- */
-export declare interface PluginHookResult {
-  template?: string
-  context?: Record<string, unknown>
-  skip?: boolean
-  metadata?: Record<string, unknown>
-}
-/**
- * Error context passed to onError hook
- */
-export declare interface PluginErrorContext extends PluginContext {
-  error: Error
-  phase: string
-  directive?: string
-}
-/**
- * Plugin definition interface
- */
-export declare interface StxPlugin {
-  name: string
-  version?: string
-  description?: string
-  dependencies?: string[]
-  priority?: number
-  beforeProcess?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  afterParse?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  beforeDirective?: (phase: DirectivePhase, ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  afterDirective?: (phase: DirectivePhase, ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  beforeRender?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  afterRender?: (ctx: PluginContext) => PluginHookResult | Promise<PluginHookResult> | void
-  onError?: (ctx: PluginErrorContext) => PluginHookResult | Promise<PluginHookResult> | void
-  registerDirectives?: () => CustomDirective[]
-  registerFilters?: () => Record<string, (value: unknown, ...args: unknown[]) => unknown>
-  onRegister?: (options: StxOptions) => void | Promise<void>
-  onUnregister?: () => void | Promise<void>
-  components?: string | string[]
-  functions?: string
-  stores?: string
-  pages?: string
-  middleware?: string
-  setup?: (options: Record<string, any>, stx: PluginSetupContext) => void | Promise<void>
-}
-/**
- * Context passed to plugin setup() function
- */
-export declare interface PluginSetupContext {
-  addDirective: (directive: CustomDirective) => void
-  addRoute: (path: string, handler: (req: Request) => Response | Promise<Response>) => void
-  addMiddleware: (middleware: any) => void
-  pluginDir: string
-  config: StxOptions
-}
-/**
- * Directive type identifier for beforeDirective/afterDirective hooks
- */
-export type DirectivePhase = | 'comments'
-  | 'escaped'
-  | 'stacks'
-  | 'layouts'
-  | 'includes'
-  | 'js'
-  | 'ts'
-  | 'custom'
-  | 'components'
-  | 'animation'
-  | 'routes'
-  | 'auth'
-  | 'csrf'
-  | 'method'
-  | 'loops'
-  | 'conditionals'
-  | 'forms'
-  | 'markdown'
-  | 'i18n'
-  | 'a11y'
-  | 'seo'
-  | 'expressions';
-/**
- * Plugin manager that handles registration, lifecycle, and execution
+ * Variables plugin that adds common variables to context
  */
-export declare class PluginManager {
-  register(plugin: StxPlugin, options: StxOptions): Promise<void>;
-  unregister(name: string): Promise<boolean>;
-  get(name: string): StxPlugin | undefined;
-  has(name: string): boolean;
-  getAll(): StxPlugin[];
-  getAllDirectives(): CustomDirective[];
-  getAllFilters(): Record<string, (value: unknown, ...args: unknown[]) => unknown>;
-  runBeforeProcess(ctx: PluginContext): Promise<PluginContext>;
-  runAfterParse(ctx: PluginContext): Promise<PluginContext>;
-  runBeforeDirective(phase: DirectivePhase, ctx: PluginContext): Promise<PluginContext>;
-  runAfterDirective(phase: DirectivePhase, ctx: PluginContext): Promise<PluginContext>;
-  runBeforeRender(ctx: PluginContext): Promise<PluginContext>;
-  runAfterRender(ctx: PluginContext): Promise<PluginContext>;
-  runOnError(ctx: PluginErrorContext): Promise<PluginContext | null>;
-}
+export declare function createVariablesPlugin(variables: Record<string, unknown>): StxPlugin;

package/dist/process.d.ts

@@ -1,11 +1,16 @@
-import { processJsonDirective, processOnceDirective } from './misc-directives';
-import { validateClientScript } from './script-validation';
-import type { StxOptions } from './types';
 /**
- * Process all template directives with enhanced error handling and performance monitoring
+ * Core Template Processing Pipeline
+ *
+ * Orchestrates the full directive processing pipeline for STX templates.
+ * Delegates to specialized modules for signals, components, runtime injection, etc.
+ *
+ * @module process
  */
-export declare function processDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
-// Re-export public API from extracted modules (preserves backwards compatibility)
+import type { StxOptions } from './types';
 export { injectRouterScript } from './runtime-injection';
 export { processJsonDirective, processOnceDirective } from './misc-directives';
 export { validateClientScript } from './script-validation';
+/**
+ * Process all template directives with enhanced error handling and performance monitoring
+ */
+export declare function processDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;

package/dist/process.js

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { injectCrosswindCSS } from "./dev-server/crosswind.js";
 import { matchHtmlComment, matchStyleElement, maskAtElementPosition, stashScriptElements } from "./html-masking.js";
@@ -9,6 +10,7 @@ import { injectHeatmap } from "./heatmap.js";
 import { processAnimationDirectives } from "./animation.js";
 import { generateRuntimeScript, processEventDirectives } from "./events.js";
 import { extractBridgeData, processClientScript } from "./client-script.js";
+import { extractPageMetaFromSource, pageMetaLayout } from "./page-meta.js";
 import { processReactiveDirectives } from "./reactive.js";
 import { processMarkdownFileDirectives } from "./assets.js";
 import { processAuthDirectives, processConditionals, processEnvDirective, processIssetEmptyDirectives } from "./conditionals.js";
@@ -391,13 +393,19 @@ async function processDirectivesInternal(template, context, filePath, options, d
   output = processStackPushDirectives(output, stacks);
   const sections = { ...context.__sections || {} };
   let layoutPath = "";
-  const hasNoLayout = /@nolayout\b/.test(output);
-  if (hasNoLayout)
+  const declaredLayout = pageMetaLayout(extractPageMetaFromSource(template)), hasNoLayout = /@nolayout\b/.test(output) || declaredLayout === !1;
+  if (/@nolayout\b/.test(output))
     output = output.replace(/@nolayout\b\s*/g, "");
   const layoutMatch = output.match(/@(?:layout|extends)\(\s*['"]([^'"]+)['"]\s*\)/);
   if (layoutMatch) {
     layoutPath = layoutMatch[1];
     output = output.replace(/@(?:layout|extends)\(\s*['"]([^'"]+)['"]\s*\)/g, "");
+  } else if (typeof declaredLayout === "string") {
+    layoutPath = declaredLayout;
+    if (!/@section\s*\(/.test(output))
+      output = `@section('content')
+${output.trim()}
+@endsection`;
   }
   if (!layoutPath && !hasNoLayout && opts.defaultLayout) {
     const isDocument = startsDocument(output), hasSections = /@section\s*\(/.test(output);
@@ -488,8 +496,17 @@ ${joined}` : joined;
           throw new StxRuntimeError(`Failed to resolve layout path: ${layoutPath}`, filePath, void 0, void 0, `Layout referenced from ${filePath}`);
         });
       if (!layoutFullPath) {
-        const warning = `Layout not found: ${layoutPath} (referenced from ${filePath})`;
-        errorLogger.log(Error(warning), { layoutPath, filePath }, "warning");
+        let available = [];
+        try {
+          const dir = resolvedOptions.layoutsDir;
+          if (dir) {
+            const abs = path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir);
+            available = fs.readdirSync(abs).filter((f) => f.endsWith(".stx")).map((f) => f.replace(/\.stx$/, "")).sort();
+          }
+        } catch {}
+        const warning = `Layout not found: ${layoutPath} (referenced from ${filePath})` + (available.length > 0 ? `. Available layouts: ${available.join(", ")}` : resolvedOptions.layoutsDir ? `. No .stx layouts found in ${resolvedOptions.layoutsDir}` : "");
+        errorLogger.log(Error(warning), { layoutPath, filePath, available }, "error");
+        console.error(`[stx] ${warning}`);
         if (resolvedOptions.debug)
           throw new StxRuntimeError(warning, filePath);
         return output;

package/dist/production-builder.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { CONVENTIONAL_ASSET_OUTPUT, CONVENTIONAL_ASSET_ROOT, resolveConventionalAssetRoot } from "./asset-roots.js";
 import { createRouter } from "./router.js";
 import { buildRuntimeAsset, buildRouterAsset } from "./build-assets.js";
 import { compileTemplate } from "./template-compiler.js";
@@ -121,6 +122,12 @@ export async function buildForProduction(options = {}) {
     if (copied > 0)
       console.log(`[stx build] Copied ${copied} public asset${copied === 1 ? "" : "s"} (${(bytes / 1024).toFixed(1)}KB) from ${publicDir}/`);
   }
+  const conventionalAssetSrc = resolveConventionalAssetRoot(root);
+  if (conventionalAssetSrc) {
+    const { copied, bytes } = copyPublicAssets(conventionalAssetSrc, path.join(outputDir, "public", CONVENTIONAL_ASSET_OUTPUT));
+    if (copied > 0)
+      console.log(`[stx build] Copied ${copied} asset${copied === 1 ? "" : "s"} (${(bytes / 1024).toFixed(1)}KB) from ${CONVENTIONAL_ASSET_ROOT}/`);
+  }
   const assets = {
     runtime: runtimeAsset.filename,
     router: routerAsset.filename

package/dist/prop-sentinels.d.ts

@@ -1,13 +1,3 @@
-/** Is this value the bare-boolean-attribute marker? */
-export declare function isBooleanAttributeSentinel(value: unknown): boolean;
-/**
- * Last-resort guard for anything about to be written into a response.
- *
- * Nothing should reach output carrying a NUL, but the cost of one escaping is
- * an invalid document and a silent grep, which is far worse than the cost of
- * this check.
- */
-export declare function stripControlChars(value: string): string;
 /**
  * Sentinel values used while resolving component props.
  *
@@ -28,4 +18,14 @@ export declare function stripControlChars(value: string): string;
  * verification step that greps rendered HTML returns an empty string and reads
  * as a pass (stacksjs/stx#1816).
  */
-export declare const BOOLEAN_ATTRIBUTE_SENTINEL: '\0stx-boolean-attribute';
+export declare const BOOLEAN_ATTRIBUTE_SENTINEL = "\0stx-boolean-attribute";
+/** Is this value the bare-boolean-attribute marker? */
+export declare function isBooleanAttributeSentinel(value: unknown): boolean;
+/**
+ * Last-resort guard for anything about to be written into a response.
+ *
+ * Nothing should reach output carrying a NUL, but the cost of one escaping is
+ * an invalid document and a silent grep, which is far worse than the cost of
+ * this check.
+ */
+export declare function stripControlChars(value: string): string;

package/dist/public-env.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Public env exposure for client bundles
+ *
+ * Mirrors the server-side `$env` template context (process.ts:762) onto the
+ * client side via build-time substitution. Any env var matching `envPrefix`
+ * (default `STX_PUBLIC_`) gets inlined as `import.meta.env.STX_PUBLIC_*` in
+ * scripts bundled for the browser.
+ *
+ *   .env:    STX_PUBLIC_API_URL=https://api.example.com
+ *   store:   const api = import.meta.env.STX_PUBLIC_API_URL
+ *   built:   const api = "https://api.example.com"
+ *
+ * Vite-style. Build-time, zero runtime cost.
+ */
 /**
  * Build the `define` map every client bundler/transpiler should pass to
  * Bun.build / new Bun.Transpiler({ define }).

package/dist/pwa/directives.d.ts

@@ -1,8 +1,13 @@
-import type { CustomDirective } from '../types';
 /**
- * Register all PWA directives with the config
+ * PWA Template Directives
+ *
+ * Provides template directives for PWA functionality:
+ * - @pwa.installButton - Install prompt button
+ * - @pwa.updatePrompt - Update notification UI
+ * - @pwa.offlineIndicator - Offline status indicator
+ * - @pwa.pushSubscribe - Push notification subscription button
  */
-export declare function registerPwaDirectives(customDirectives: CustomDirective[]): CustomDirective[];
+import type { CustomDirective } from '../types';
 /**
  * PWA Install Button Directive
  * Usage: @pwa.installButton ... @endpwa.installButton
@@ -27,3 +32,7 @@ export declare const pwaPushDirective: CustomDirective;
  * All PWA directives
  */
 export declare const pwaDirectives: CustomDirective[];
+/**
+ * Register all PWA directives with the config
+ */
+export declare function registerPwaDirectives(customDirectives: CustomDirective[]): CustomDirective[];

package/dist/pwa/inject.d.ts

@@ -1,3 +1,13 @@
+/**
+ * PWA HTML Tag Injection
+ *
+ * Injects PWA-related meta tags, links, and scripts into HTML output.
+ * Handles:
+ * - manifest.json link
+ * - theme-color meta tag
+ * - Apple touch icons
+ * - Service worker registration script
+ */
 import type { StxOptions } from '../types';
 /**
  * Generate PWA HTML tags for injection into <head>

package/dist/pwa/precache.d.ts

@@ -1,4 +1,26 @@
+/**
+ * PWA Auto-Precaching
+ *
+ * Automatically discovers and precaches build output files.
+ * Scans the output directory and generates a precache manifest.
+ */
 import type { StxOptions } from '../types';
+/**
+ * Precache manifest entry
+ */
+export interface PrecacheEntry {
+    url: string;
+    revision: string;
+    size: number;
+}
+/**
+ * Precache manifest result
+ */
+export interface PrecacheManifest {
+    entries: PrecacheEntry[];
+    totalSize: number;
+    fileCount: number;
+}
 /**
  * Generate precache manifest from build output directory
  */
@@ -11,19 +33,3 @@ export declare function generatePrecacheManifestJs(manifest: PrecacheManifest):
  * Get human-readable size
  */
 export declare function formatSize(bytes: number): string;
-/**
- * Precache manifest entry
- */
-export declare interface PrecacheEntry {
-  url: string
-  revision: string
-  size: number
-}
-/**
- * Precache manifest result
- */
-export declare interface PrecacheManifest {
-  entries: PrecacheEntry[]
-  totalSize: number
-  fileCount: number
-}

package/dist/pwa/service-worker.d.ts

@@ -1,3 +1,15 @@
+/**
+ * PWA Service Worker Generation
+ *
+ * Generates a service worker JavaScript file with configurable caching strategies.
+ * Supports: cache-first, network-first, stale-while-revalidate, network-only, cache-only
+ *
+ * Additional features:
+ * - Push notifications handling
+ * - Background sync for form submissions
+ * - Cache storage limits and purge strategies
+ * - Update notifications
+ */
 import type { StxOptions } from '../types';
 /**
  * Generate the service worker JavaScript code