@jqhtml/core 2.2.222

package/dist/load-coordinator.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Load Coordinator - Request deduplication for component on_load() calls
+ *
+ * Coordinates parallel component loading to prevent duplicate requests.
+ * When multiple components with identical names and args load simultaneously,
+ * only the first (leader) executes on_load(). Others (followers) wait for
+ * the leader's result.
+ *
+ * Key Concepts:
+ * - **INVOCATION_KEY**: Unique identifier for component name + args combination
+ * - **Leader**: First component to reach on_load() for a given INVOCATION_KEY
+ * - **Follower**: Subsequent components that wait for leader's result
+ *
+ * Lifecycle:
+ * 1. Leader reaches on_load() → create coordination entry
+ * 2. Followers reach on_load() → join waiting queue
+ * 3. Leader completes → distribute data to all followers
+ * 4. Clear coordination entry (no caching)
+ *
+ * @internal This class is not exposed in the public API
+ */
+import type { Jqhtml_Component } from './component.js';
+export interface InvocationKeyResult {
+    key: string | null;
+    uncacheable_property?: string;
+}
+export declare class Load_Coordinator {
+    private static _registry;
+    /**
+     * Generate INVOCATION_KEY from component name and args
+     * Uses deterministic JSON serialization (sorted keys)
+     * Excludes internal properties (those starting with _)
+     *
+     * For functions/objects:
+     * - Checks for ._jqhtml_cache_id property (assigned by RSpade)
+     * - Falls back to .jqhtml_cache_id() method if property doesn't exist
+     * - If neither exists, marks property as uncacheable
+     *
+     * Returns object with:
+     * - key: Cache key string, or null if uncacheable
+     * - uncacheable_property: Name of first property that prevented caching (for debugging)
+     */
+    static generate_invocation_key(component_name: string, args: any): InvocationKeyResult;
+    /**
+     * Check if a component should execute on_load() or wait for existing request
+     * Returns true if component should execute (is leader), false if should wait (is follower)
+     */
+    static should_execute_on_load(component: Jqhtml_Component): boolean;
+    /**
+     * Register a leader component that will execute on_load()
+     * Creates coordination entry and returns a function to call when on_load() completes
+     */
+    static register_leader(component: Jqhtml_Component, on_load_promise: Promise<void>): () => void;
+    /**
+     * Get the coordination promise for a follower component
+     * Returns a promise that resolves when the leader completes
+     */
+    static get_coordination_promise(component: Jqhtml_Component): Promise<void> | null;
+    /**
+     * Complete coordination after leader's on_load() finishes
+     * Distributes data to all waiting followers and cleans up entry
+     * @private
+     */
+    private static _complete_coordination;
+    /**
+     * Handle leader on_load() error
+     * Propagates error to all followers and cleans up entry
+     */
+    static handle_leader_error(component: Jqhtml_Component, error: Error): void;
+    /**
+     * Get current registry state (for debugging)
+     */
+    static get_registry_state(): any;
+    /**
+     * Clear all coordination entries (for testing/debugging)
+     */
+    static clear_all(): void;
+}
+//# sourceMappingURL=load-coordinator.d.ts.map

package/dist/load-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-coordinator.d.ts","sourceRoot":"","sources":["../src/load-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAWvD,MAAM,WAAW,mBAAmB;IAChC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6C;IAErE;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,uBAAuB,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,mBAAmB;IAqEtF;;;OAGG;IACH,MAAM,CAAC,sBAAsB,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO;IAoBnE;;;OAGG;IACH,MAAM,CAAC,eAAe,CAClB,SAAS,EAAE,gBAAgB,EAC3B,eAAe,EAAE,OAAO,CAAC,IAAI,CAAC,GAC/B,MAAM,IAAI;IAkBb;;;OAGG;IACH,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAWlF;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IA8CrC;;;OAGG;IACH,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAuC3E;;OAEG;IACH,MAAM,CAAC,kBAAkB,IAAI,GAAG;IAahC;;OAEG;IACH,MAAM,CAAC,SAAS,IAAI,IAAI;CAG3B"}

package/dist/local-storage.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Jqhtml_Local_Storage - Scoped local storage for JQHTML component caching
+ *
+ * Provides safe, scoped access to localStorage with automatic handling of
+ * unavailable storage, quota exceeded errors, and scope invalidation.
+ *
+ * Key Features:
+ * - **Manual scoping**: Cache key must be set via set_cache_key() before use
+ * - **Graceful degradation**: Returns null when storage unavailable or cache key not set
+ * - **Quota management**: Auto-clears storage when full and retries operation
+ * - **Scope validation**: Clears storage when cache key changes
+ * - **Developer-friendly keys**: Scoped suffix allows easy inspection in dev tools
+ *
+ * Scoping Strategy:
+ * Storage is scoped by a user-provided cache key (typically a session identifier,
+ * user ID, or combination of relevant scope factors). This scope is stored in
+ * `_jqhtml_cache_key`. If the cache key changes between page loads, all JQHTML
+ * storage is cleared to prevent stale data from different sessions/users.
+ *
+ * Key Format:
+ * Keys are stored as: `jqhtml::developer_key::cache_key`
+ * Example: `jqhtml::User_Profile_data::user_123`
+ *
+ * The `jqhtml::` prefix identifies JQHTML keys, allowing safe clearing of only our keys
+ * without affecting other JavaScript libraries. This enables transparent coexistence
+ * with third-party libraries that also use browser storage.
+ *
+ * Quota Exceeded Handling:
+ * When storage quota is exceeded during a set operation, only JQHTML keys (prefixed with
+ * `jqhtml::`) are cleared, preserving other libraries' data. The operation is then retried
+ * once. This ensures the application continues functioning even when storage is full.
+ *
+ * Usage:
+ *   // Must set cache key first (typically done once on page load)
+ *   Jqhtml_Local_Storage.set_cache_key('user_123');
+ *
+ *   // Then use storage normally
+ *   Jqhtml_Local_Storage.set('cached_component', {html: '...', timestamp: Date.now()});
+ *   const cached = Jqhtml_Local_Storage.get('cached_component');
+ *   Jqhtml_Local_Storage.remove('cached_component');
+ *
+ * IMPORTANT - Volatile Storage:
+ * Storage can be cleared at any time due to:
+ * - User clearing browser data
+ * - Private browsing mode restrictions
+ * - Quota exceeded errors
+ * - Cache key changes
+ * - Browser storage unavailable
+ *
+ * Therefore, NEVER store critical data. Only use for:
+ * - Cached component HTML (performance optimization)
+ * - Transient UI state (convenience, not required)
+ *
+ * @internal This class is not exposed in the public API
+ */
+export declare class Jqhtml_Local_Storage {
+    private static _cache_key;
+    private static _storage_available;
+    private static _initialized;
+    /**
+     * Set the cache key and initialize storage
+     * Must be called before any get/set operations
+     * @param {string} cache_key - Unique identifier for this cache scope
+     */
+    static set_cache_key(cache_key: string): void;
+    /**
+     * Check if cache key has been set
+     * @returns {boolean} True if cache key is configured
+     */
+    static has_cache_key(): boolean;
+    /**
+     * Initialize storage system and validate scope
+     * Called automatically after cache key is set
+     * @private
+     */
+    private static _init;
+    /**
+     * Check if localStorage is available
+     * @returns {boolean}
+     * @private
+     */
+    private static _is_storage_available;
+    /**
+     * Validate storage scope and clear JQHTML keys if cache key changed
+     * Only clears keys prefixed with 'jqhtml::' to preserve other libraries' data
+     * @private
+     */
+    private static _validate_scope;
+    /**
+     * Clear only JQHTML keys from storage (keys starting with 'jqhtml::')
+     * Preserves keys from other libraries
+     * @private
+     */
+    private static _clear_jqhtml_keys;
+    /**
+     * Build scoped key with JQHTML namespace prefix
+     * @param {string} key - Developer-provided key
+     * @returns {string}
+     * @private
+     */
+    private static _build_key;
+    /**
+     * Check if storage is ready for use
+     * @returns {boolean}
+     * @private
+     */
+    private static _is_ready;
+    /**
+     * Set item in localStorage
+     * @param {string} key - Storage key
+     * @param {*} value - Value to store (will be JSON serialized)
+     */
+    static set(key: string, value: any): void;
+    /**
+     * Get item from localStorage
+     * @param {string} key - Storage key
+     * @returns {*|null} Parsed value or null if not found/unavailable
+     */
+    static get(key: string): any | null;
+    /**
+     * Remove item from localStorage
+     * @param {string} key - Storage key
+     */
+    static remove(key: string): void;
+    /**
+     * Internal set implementation with scope validation and quota handling
+     * @param {string} key
+     * @param {*} value - Original value (not used, kept for clarity)
+     * @param {string} serialized - Pre-serialized JSON string
+     * @private
+     */
+    private static _set_item;
+    /**
+     * Internal get implementation
+     * @param {string} key
+     * @returns {*|null}
+     * @private
+     */
+    private static _get_item;
+    /**
+     * Internal remove implementation
+     * @param {string} key
+     * @private
+     */
+    private static _remove_item;
+}
+//# sourceMappingURL=local-storage.d.ts.map

package/dist/local-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage.d.ts","sourceRoot":"","sources":["../src/local-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuB;IAChD,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAwB;IACzD,OAAO,CAAC,MAAM,CAAC,YAAY,CAAkB;IAE7C;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAK7C;;;OAGG;IACH,MAAM,CAAC,aAAa,IAAI,OAAO;IAI/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK;IAepB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAYpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IA4B9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IA2BjC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAIxB;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAqBzC;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI;IAQnC;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IA4BxB;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAexB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;CAS9B"}

package/dist/template-renderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JQHTML v2 Template Renderer
+ *
+ * Connects compiled templates to components
+ * Processes instruction arrays and handles bindings
+ */
+import type { Jqhtml_Component } from './component.js';
+/**
+ * Render a template for a component
+ * Templates are functions that return [instructions, context] tuples
+ */
+export declare function render_template(component: Jqhtml_Component, template_fn?: Function): Promise<void>;
+/**
+ * Helper to escape HTML for safe output
+ */
+export declare function escape_html(str: string): string;
+//# sourceMappingURL=template-renderer.d.ts.map

package/dist/template-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderer.d.ts","sourceRoot":"","sources":["../src/template-renderer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA2EvD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,gBAAgB,EAC3B,WAAW,CAAC,EAAE,QAAQ,GACrB,OAAO,CAAC,IAAI,CAAC,CAqDf;AA6KD;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C"}

package/laravel-bridge/README.md

@@ -0,0 +1,242 @@
+# JQHTML Laravel Bridge
+
+Laravel integration package for JQHTML template error reporting with source map support.
+
+## Installation
+
+```bash
+composer require jqhtml/laravel-bridge
+```
+
+## Configuration
+
+Publish the configuration file:
+
+```bash
+php artisan vendor:publish --tag=jqhtml-config
+```
+
+## Usage
+
+### Basic Setup
+
+The package automatically registers its service provider and exception handler extensions. No additional setup is required for basic functionality.
+
+### Error Handling
+
+When a JQHTML template error occurs, the package will:
+
+1. Parse the error message to extract template location information
+2. Load source maps if available
+3. Format the error for Laravel's exception handler
+4. Display enhanced error information in debug mode
+
+### Middleware
+
+To automatically catch and format JQHTML errors, add the middleware to your route groups:
+
+```php
+// In app/Http/Kernel.php
+protected $middlewareGroups = [
+    'web' => [
+        // ...
+        \Jqhtml\LaravelBridge\Middleware\JqhtmlErrorMiddleware::class,
+    ],
+];
+```
+
+### Manual Exception Creation
+
+```php
+use Jqhtml\LaravelBridge\JqhtmlException;
+
+// Create from JavaScript error data
+$jsError = json_decode($errorJson, true);
+$exception = JqhtmlException::createFromJsError($jsError);
+
+// Create manually
+$exception = new JqhtmlException(
+    'Unclosed component definition',
+    'templates/user-card.jqhtml',  // template file
+    42,                             // line number
+    15,                             // column number
+    $sourceCode,                    // template source
+    'Did you forget </Define:UserCard>?'  // suggestion
+);
+```
+
+### Integration with Node.js Compiler
+
+When compiling JQHTML templates with Node.js, catch errors and pass them to Laravel:
+
+```javascript
+// Node.js side
+try {
+    const compiled = jqhtml.compile(template);
+} catch (error) {
+    // Send error details to Laravel
+    const errorData = {
+        message: error.message,
+        filename: error.filename,
+        line: error.line,
+        column: error.column,
+        source: error.source,
+        suggestion: error.suggestion
+    };
+
+    // Pass to Laravel via API or process communication
+    sendToLaravel(errorData);
+}
+```
+
+```php
+// Laravel side - Best Practice
+use Jqhtml\LaravelBridge\JqhtmlException;
+
+// Parse compiler JSON output
+$errorData = json_decode($compiler_output, true);
+
+if ($errorData && isset($errorData['error'])) {
+    // JqhtmlException extends ViewException, so this will show
+    // the template file as the error source in Laravel/Ignition
+    $exception = JqhtmlException::createFromJsError(
+        $errorData['error'],
+        $templatePath // Pass the actual template path
+    );
+    throw $exception;
+}
+
+// Alternative: Direct ViewException usage (if not using the bridge)
+if ($errorData && isset($errorData['error'])) {
+    $error = $errorData['error'];
+    $line = $error['line'] ?? 1;
+
+    throw new \Illuminate\View\ViewException(
+        $error['message'],
+        0,                    // code
+        1,                    // severity
+        $templatePath,        // file
+        $line,               // line
+        null                 // previous
+    );
+}
+```
+
+### Source Map Support
+
+The package supports source maps for mapping compiled JavaScript back to original JQHTML templates:
+
+```php
+// Configure source map storage location
+config(['jqhtml.source_maps_path' => storage_path('sourcemaps')]);
+
+// The formatter will automatically look for source maps
+// when an error includes a compiled file reference
+$exception->setCompiledFile('/path/to/compiled.js');
+```
+
+### Custom Error Views
+
+Create a custom error view at `resources/views/jqhtml/error.blade.php`:
+
+```blade
+@extends('errors::layout')
+
+@section('title', 'JQHTML Template Error')
+
+@section('message')
+    <div class="jqhtml-error">
+        <h2>{{ $exception->getMessage() }}</h2>
+
+        @if($exception->getSuggestion())
+            <div class="suggestion">
+                💡 {{ $exception->getSuggestion() }}
+            </div>
+        @endif
+
+        @if($exception->getTemplateFile())
+            <div class="location">
+                📍 {{ $exception->getTemplateFile() }}:{{ $exception->getTemplateLine() }}:{{ $exception->getTemplateColumn() }}
+            </div>
+        @endif
+
+        @if(isset($error_data['source_context']))
+            <div class="source-context">
+                <pre><code>@foreach($error_data['source_context'] as $line)
+@if($line['is_error_line'])<strong>> {{ $line['line_number'] }} | {{ $line['content'] }}
+@if($line['error_column']){{ str_repeat(' ', $line['error_column'] + 8) }}{{ str_repeat('^', 20) }}@endif</strong>
+@else  {{ $line['line_number'] }} | {{ $line['content'] }}
+@endif
+@endforeach</code></pre>
+            </div>
+        @endif
+    </div>
+@endsection
+```
+
+## Configuration Options
+
+```php
+return [
+    // Where to store source map files
+    'source_maps_path' => storage_path('jqhtml-sourcemaps'),
+
+    // Show source code context in errors
+    'show_source_context' => env('APP_DEBUG', false),
+
+    // Lines of context to show
+    'context_lines' => 5,
+
+    // Cache compiled templates
+    'cache_compiled' => !env('APP_DEBUG', false),
+
+    // Where to store compiled templates
+    'compiled_path' => storage_path('jqhtml-compiled'),
+
+    // Enable source map generation
+    'enable_source_maps' => env('APP_DEBUG', false),
+
+    // Source map mode: 'inline', 'external', or 'both'
+    'source_map_mode' => 'external',
+];
+```
+
+## Laravel Ignition Integration
+
+The package automatically integrates with Laravel Ignition (if installed) to provide enhanced error display:
+
+- Template file location with line and column numbers
+- Source code context with error highlighting
+- Helpful suggestions for common mistakes
+- Source map resolution for compiled files
+
+## API Reference
+
+### JqhtmlException
+
+Main exception class for JQHTML template errors. **Extends Laravel's `ViewException`** for optimal integration with Laravel's error handling and Ignition error pages.
+
+When thrown, this exception ensures:
+- The template file appears as the error source in Laravel/Ignition
+- Line numbers point to the actual template location
+- The error page shows your JQHTML template, not the PHP processor
+
+### JqhtmlErrorFormatter
+
+Formats exceptions for display with source context and source map support.
+
+### JqhtmlExceptionRenderer
+
+Renders exceptions for web and JSON responses.
+
+### JqhtmlServiceProvider
+
+Registers services and extends Laravel's exception handler.
+
+### JqhtmlErrorMiddleware
+
+Middleware for catching and wrapping JQHTML errors.
+
+## License
+
+MIT

package/laravel-bridge/autoload.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * JQHTML Laravel Bridge Autoloader
+ *
+ * Include this file from your Laravel project to load the JQHTML error handling bridge:
+ *
+ *   require_once base_path('node_modules/@jqhtml/core/laravel-bridge/autoload.php');
+ *
+ * Or if using in a service provider:
+ *
+ *   require_once dirname(__DIR__, 3) . '/node_modules/@jqhtml/core/laravel-bridge/autoload.php';
+ */
+
+// This is a Laravel bridge - it REQUIRES Laravel to function
+if (!class_exists('Illuminate\\Support\\ServiceProvider')) {
+    throw new \RuntimeException(
+        'JQHTML Laravel Bridge requires Laravel. ' .
+        'This file should only be included from within a Laravel application.'
+    );
+}
+
+// Register the autoloader for JQHTML Laravel Bridge classes
+spl_autoload_register(function ($class) {
+    // Check if the class is in the Jqhtml\LaravelBridge namespace
+    $prefix = 'Jqhtml\\LaravelBridge\\';
+    $len = strlen($prefix);
+
+    if (strncmp($prefix, $class, $len) !== 0) {
+        return;
+    }
+
+    // Get the relative class name
+    $relative_class = substr($class, $len);
+
+    // Replace namespace separators with directory separators
+    $file = __DIR__ . '/src/' . str_replace('\\', '/', $relative_class) . '.php';
+
+    // If the file exists, require it
+    if (file_exists($file)) {
+        require $file;
+    }
+});
+
+// Auto-register the service provider if in Laravel application context
+if (function_exists('app') && app() instanceof \Illuminate\Foundation\Application) {
+    app()->register(\Jqhtml\LaravelBridge\JqhtmlServiceProvider::class);
+}
+
+// Return the namespace for convenience
+return 'Jqhtml\\LaravelBridge';

package/laravel-bridge/composer.json

@@ -0,0 +1,34 @@
+{
+  "name": "jqhtml/laravel-bridge",
+  "description": "Laravel integration bridge for JQHTML template error reporting and source maps",
+  "type": "library",
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "JQHTML Team"
+    }
+  ],
+  "require": {
+    "php": "^7.4|^8.0",
+    "illuminate/support": "^8.0|^9.0|^10.0|^11.0"
+  },
+  "autoload": {
+    "psr-4": {
+      "Jqhtml\\LaravelBridge\\": "src/"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "Jqhtml\\LaravelBridge\\Tests\\": "tests/"
+    }
+  },
+  "extra": {
+    "laravel": {
+      "providers": [
+        "Jqhtml\\LaravelBridge\\JqhtmlServiceProvider"
+      ]
+    }
+  },
+  "minimum-stability": "stable",
+  "prefer-stable": true
+}

package/laravel-bridge/config/jqhtml.php

@@ -0,0 +1,82 @@
+<?php
+
+return [
+    /*
+    |--------------------------------------------------------------------------
+    | JQHTML Source Maps Path
+    |--------------------------------------------------------------------------
+    |
+    | This option defines where JQHTML source map files should be stored.
+    | Source maps help map compiled JavaScript back to original JQHTML templates
+    | for better error reporting and debugging.
+    |
+    */
+    'source_maps_path' => storage_path('jqhtml-sourcemaps'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Show Source Context
+    |--------------------------------------------------------------------------
+    |
+    | When enabled, error messages will include the surrounding source code
+    | context to help identify the exact location and nature of the error.
+    |
+    */
+    'show_source_context' => env('APP_DEBUG', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Error Context Lines
+    |--------------------------------------------------------------------------
+    |
+    | Number of lines to show before and after the error line when displaying
+    | source context in error messages.
+    |
+    */
+    'context_lines' => 5,
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cache Compiled Templates
+    |--------------------------------------------------------------------------
+    |
+    | When enabled, compiled JQHTML templates will be cached to improve
+    | performance. Disable during development for immediate template updates.
+    |
+    */
+    'cache_compiled' => env('JQHTML_CACHE', !env('APP_DEBUG', false)),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Compiled Templates Path
+    |--------------------------------------------------------------------------
+    |
+    | Directory where compiled JQHTML templates should be stored.
+    |
+    */
+    'compiled_path' => storage_path('jqhtml-compiled'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Enable Source Maps
+    |--------------------------------------------------------------------------
+    |
+    | Whether to generate source maps for compiled templates. Source maps
+    | increase compilation time slightly but provide better debugging.
+    |
+    */
+    'enable_source_maps' => env('APP_DEBUG', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Source Map Mode
+    |--------------------------------------------------------------------------
+    |
+    | How source maps should be generated:
+    | - 'inline': Embed source map directly in compiled file
+    | - 'external': Save source map as separate .map file
+    | - 'both': Generate both inline and external source maps
+    |
+    */
+    'source_map_mode' => 'external',
+];