@stati/core 1.20.3 → 1.22.0

package/dist/core/isg/dev-server-lock.js

@@ -0,0 +1,248 @@
+import { writeFile, readFile, pathExists, remove, ensureDir } from '../utils/index.js';
+import { join, dirname } from 'node:path';
+import { hostname } from 'node:os';
+import { unlinkSync, existsSync } from 'node:fs';
+/**
+ * Manages dev server locking to prevent multiple dev servers from running in the same directory.
+ * Uses a simple file-based locking mechanism with process ID tracking.
+ */
+export class DevServerLockManager {
+    lockPath;
+    isLocked = false;
+    cleanupHandlersRegistered = false;
+    constructor(cacheDir) {
+        this.lockPath = join(cacheDir, '.dev-server-lock');
+    }
+    /**
+     * Attempts to acquire a dev server lock.
+     * Throws an error if another dev server is already running.
+     *
+     * @throws {Error} When lock cannot be acquired
+     *
+     * @example
+     * ```typescript
+     * const lockManager = new DevServerLockManager('.stati');
+     * try {
+     *   await lockManager.acquireLock();
+     *   // Start dev server
+     * } finally {
+     *   await lockManager.releaseLock();
+     * }
+     * ```
+     */
+    async acquireLock() {
+        try {
+            // Check if lock file exists
+            if (await pathExists(this.lockPath)) {
+                const existingLock = await this.readLockFile();
+                if (existingLock) {
+                    // Check if the process is still running
+                    if (await this.isProcessRunning(existingLock.pid)) {
+                        const hostname = existingLock.hostname || 'unknown';
+                        const isSameHost = hostname === this.getHostname();
+                        const location = isSameHost ? 'this machine' : `${hostname}`;
+                        throw new Error(`A dev server is already running in this directory (PID ${existingLock.pid} on ${location}, started ${existingLock.timestamp}).\n` +
+                            `Please stop the existing dev server before starting a new one.\n` +
+                            `If you're sure no dev server is running, delete: ${this.lockPath}`);
+                    }
+                    else {
+                        // Process is dead, remove stale lock
+                        console.warn(`Removing stale dev server lock (PID ${existingLock.pid} no longer running)`);
+                        await this.forceRemoveLock();
+                    }
+                }
+            }
+            // Try to create the lock
+            await this.createLockFile();
+            this.isLocked = true;
+            // Register cleanup handlers to ensure lock is released on process exit
+            this.registerCleanupHandlers();
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === 'EEXIST') {
+                throw new Error(`Another dev server is starting in this directory.\n` +
+                    `Please wait a moment and try again, or delete: ${this.lockPath}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Releases the dev server lock if this process owns it.
+     *
+     * @example
+     * ```typescript
+     * await lockManager.releaseLock();
+     * ```
+     */
+    async releaseLock() {
+        if (!this.isLocked) {
+            return;
+        }
+        try {
+            // Verify we still own the lock before removing it
+            const currentLock = await this.readLockFile();
+            if (currentLock && currentLock.pid === process.pid) {
+                await remove(this.lockPath);
+            }
+        }
+        catch (error) {
+            // Don't throw on release errors, just warn
+            console.warn(`Warning: Failed to release dev server lock: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.isLocked = false;
+        }
+    }
+    /**
+     * Checks if a dev server lock is currently held by any process.
+     *
+     * @returns True if a lock exists and the owning process is running
+     */
+    async isLockHeld() {
+        try {
+            if (!(await pathExists(this.lockPath))) {
+                return false;
+            }
+            const lock = await this.readLockFile();
+            if (!lock) {
+                return false;
+            }
+            return await this.isProcessRunning(lock.pid);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Gets information about the current lock holder.
+     *
+     * @returns Lock information or null if no lock exists
+     */
+    async getLockInfo() {
+        try {
+            if (!(await pathExists(this.lockPath))) {
+                return null;
+            }
+            return await this.readLockFile();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Force removes the lock file without checking ownership.
+     * Should only be used in error recovery scenarios.
+     */
+    async forceRemoveLock() {
+        try {
+            await remove(this.lockPath);
+        }
+        catch {
+            // Ignore errors when force removing
+        }
+    }
+    /**
+     * Creates a new lock file with current process information.
+     */
+    async createLockFile() {
+        const lockInfo = {
+            pid: process.pid,
+            timestamp: new Date().toISOString(),
+            hostname: this.getHostname(),
+        };
+        // Ensure the cache directory exists before creating the lock file
+        await ensureDir(dirname(this.lockPath));
+        // Use 'wx' flag to create file exclusively (fails if exists)
+        await writeFile(this.lockPath, JSON.stringify(lockInfo, null, 2), { flag: 'wx' });
+    }
+    /**
+     * Reads and parses the lock file.
+     */
+    async readLockFile() {
+        try {
+            const content = await readFile(this.lockPath, 'utf-8');
+            if (!content) {
+                return null;
+            }
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Checks if a process with the given PID is currently running.
+     */
+    async isProcessRunning(pid) {
+        try {
+            // On Unix systems, sending signal 0 checks if process exists without affecting it
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            const nodeError = error;
+            // ESRCH means process doesn't exist
+            return nodeError.code !== 'ESRCH';
+        }
+    }
+    /**
+     * Gets the hostname for lock identification.
+     */
+    getHostname() {
+        try {
+            return hostname();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Registers process exit handlers to ensure lock is released.
+     * This prevents accidentally leaving the lock file behind.
+     */
+    registerCleanupHandlers() {
+        if (this.cleanupHandlersRegistered) {
+            return;
+        }
+        this.cleanupHandlersRegistered = true;
+        const cleanup = async () => {
+            await this.releaseLock();
+        };
+        // Handle various exit scenarios
+        process.on('exit', () => {
+            // Synchronous cleanup on exit
+            if (this.isLocked) {
+                try {
+                    if (existsSync(this.lockPath)) {
+                        unlinkSync(this.lockPath);
+                    }
+                }
+                catch {
+                    // Ignore errors during synchronous cleanup
+                }
+            }
+        });
+        // Handle Ctrl+C
+        process.on('SIGINT', async () => {
+            await cleanup();
+            process.exit(0);
+        });
+        // Handle kill command
+        process.on('SIGTERM', async () => {
+            await cleanup();
+            process.exit(0);
+        });
+        // Handle uncaught errors
+        process.on('uncaughtException', async (error) => {
+            console.error('Uncaught exception:', error);
+            await cleanup();
+            process.exit(1);
+        });
+        process.on('unhandledRejection', async (reason) => {
+            console.error('Unhandled rejection:', reason);
+            await cleanup();
+            process.exit(1);
+        });
+    }
+}

package/dist/core/isg/hash.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Clears the file hash cache. Should be called at the start of each build.
+ */
+export declare function clearFileHashCache(): void;
 /**
  * Computes a SHA-256 hash of page content and front matter.
  * Used to detect when page content has changed.

package/dist/core/isg/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiBhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAKnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CAqCnE"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/core/isg/hash.ts"],"names":[],"mappings":"AA+BA;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiBhG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA8B9E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAKnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CAqCnE"}

package/dist/core/isg/hash.js

@@ -19,6 +19,18 @@ function createSha256Hash(data) {
     }
     return `sha256-${hash.digest('hex')}`;
 }
+/**
+ * Per-build cache for file hashes to avoid recomputing the same file hash
+ * multiple times during a single build.
+ * Key: normalized file path, Value: computed hash or null if file doesn't exist
+ */
+const fileHashCache = new Map();
+/**
+ * Clears the file hash cache. Should be called at the start of each build.
+ */
+export function clearFileHashCache() {
+    fileHashCache.clear();
+}
 /**
  * Computes a SHA-256 hash of page content and front matter.
  * Used to detect when page content has changed.
@@ -66,18 +78,29 @@ export function computeContentHash(content, frontMatter) {
  * ```
  */
 export async function computeFileHash(filePath) {
+    // Normalize path for consistent cache key
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    // Check cache first
+    if (fileHashCache.has(normalizedPath)) {
+        return fileHashCache.get(normalizedPath) ?? null;
+    }
     try {
         if (!(await pathExists(filePath))) {
+            fileHashCache.set(normalizedPath, null);
             return null;
         }
         const content = await readFile(filePath, 'utf-8');
         if (!content) {
+            fileHashCache.set(normalizedPath, null);
             return null;
         }
-        return createSha256Hash(content);
+        const hash = createSha256Hash(content);
+        fileHashCache.set(normalizedPath, hash);
+        return hash;
     }
     catch (error) {
         console.warn(`Failed to compute hash for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        fileHashCache.set(normalizedPath, null);
         return null;
     }
 }

package/dist/core/isg/index.d.ts

@@ -9,8 +9,9 @@
 export { loadCacheManifest, saveCacheManifest, createEmptyManifest } from './manifest.js';
 export { shouldRebuildPage, createCacheEntry, updateCacheEntry } from './builder.js';
 export { BuildLockManager, withBuildLock } from './build-lock.js';
-export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath } from './deps.js';
-export { computeContentHash, computeFileHash, computeInputsHash, computeNavigationHash, } from './hash.js';
+export { DevServerLockManager } from './dev-server-lock.js';
+export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath, clearTemplatePathCache, } from './deps.js';
+export { computeContentHash, computeFileHash, computeInputsHash, computeNavigationHash, clearFileHashCache, } from './hash.js';
 export { getSafeCurrentTime, parseSafeDate, computeEffectiveTTL, computeNextRebuildAt, isPageFrozen, applyAgingRules, } from './ttl.js';
 export { ISGConfigurationError, validateISGConfig, validatePageISGOverrides, extractNumericOverride, } from './validation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/isg/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/isg/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrF,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGlE,OAAO,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAGpG,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/isg/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAG1F,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrF,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC"}

package/dist/core/isg/index.js

@@ -12,10 +12,11 @@ export { loadCacheManifest, saveCacheManifest, createEmptyManifest } from './man
 export { shouldRebuildPage, createCacheEntry, updateCacheEntry } from './builder.js';
 // Build locking
 export { BuildLockManager, withBuildLock } from './build-lock.js';
+export { DevServerLockManager } from './dev-server-lock.js';
 // Dependency tracking
-export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath } from './deps.js';
+export { CircularDependencyError, trackTemplateDependencies, resolveTemplatePath, clearTemplatePathCache, } from './deps.js';
 // Hash computation
-export { computeContentHash, computeFileHash, computeInputsHash, computeNavigationHash, } from './hash.js';
+export { computeContentHash, computeFileHash, computeInputsHash, computeNavigationHash, clearFileHashCache, } from './hash.js';
 // TTL and aging
 export { getSafeCurrentTime, parseSafeDate, computeEffectiveTTL, computeNextRebuildAt, isPageFrozen, applyAgingRules, } from './ttl.js';
 // Validation

package/dist/core/markdown.d.ts

@@ -9,9 +9,15 @@ export interface MarkdownResult {
     /** Table of contents entries extracted from headings */
     toc: TocEntry[];
 }
+/**
+ * Clear the cached markdown processor.
+ * Call this when the config changes or when starting a fresh build.
+ */
+export declare function clearMarkdownProcessorCache(): void;
 /**
  * Creates and configures a MarkdownIt processor based on the provided configuration.
  * Supports both plugin array format and configure function format.
+ * In development mode, caches the processor to avoid recreating it on each rebuild.
  */
 export declare function createMarkdownProcessor(config: StatiConfig): Promise<MarkdownIt>;
 /**

package/dist/core/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAG/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,GAAG,EAAE,QAAQ,EAAE,CAAC;CACjB;AAmBD;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAuCtF;AA6ED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,QAAQ,EAAE,CAGtE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,UAAU,EACd,UAAU,GAAE,OAAc,GACzB,cAAc,CAWhB"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/core/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,aAAa,CAAC;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAI/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,GAAG,EAAE,QAAQ,EAAE,CAAC;CACjB;AAQD;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAmBD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAkDtF;AA6ED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,QAAQ,EAAE,CAGtE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,UAAU,EACd,UAAU,GAAE,OAAc,GACzB,cAAc,CAWhB"}

package/dist/core/markdown.js

@@ -3,6 +3,19 @@ import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import path from 'node:path';
 import { slugify } from './utils/index.js';
+import { isDevelopment } from '../env.js';
+/**
+ * Cached markdown processor for dev mode to avoid re-creating on each rebuild.
+ * This significantly improves rebuild performance by avoiding repeated plugin loading.
+ */
+let cachedMarkdownProcessor = null;
+/**
+ * Clear the cached markdown processor.
+ * Call this when the config changes or when starting a fresh build.
+ */
+export function clearMarkdownProcessorCache() {
+    cachedMarkdownProcessor = null;
+}
 /**
  * Load a markdown plugin, trying different resolution strategies
  */
@@ -22,8 +35,14 @@ async function loadMarkdownPlugin(pluginName) {
 /**
  * Creates and configures a MarkdownIt processor based on the provided configuration.
  * Supports both plugin array format and configure function format.
+ * In development mode, caches the processor to avoid recreating it on each rebuild.
  */
 export async function createMarkdownProcessor(config) {
+    // In dev mode, return cached processor if available
+    // This avoids recreating the processor and reloading plugins on each rebuild
+    if (isDevelopment() && cachedMarkdownProcessor) {
+        return cachedMarkdownProcessor;
+    }
     const md = new MarkdownIt({
         html: true,
         linkify: true,
@@ -61,6 +80,10 @@ export async function createMarkdownProcessor(config) {
     if (config.markdown?.configure) {
         config.markdown.configure(md);
     }
+    // Cache in dev mode
+    if (isDevelopment()) {
+        cachedMarkdownProcessor = md;
+    }
     return md;
 }
 /**

package/dist/core/preview.js

@@ -141,7 +141,7 @@ export async function createPreviewServer(options = {}) {
             });
             logger.success?.(`Preview server running at ${url}`);
             logger.info?.(`\nServing:`);
-            logger.info?.(`  📁 ${outDir}`);
+            logger.info?.(`  • ${outDir}`);
             // Open browser if requested
             if (open) {
                 try {

package/dist/core/templates.js

@@ -4,7 +4,7 @@ import glob from 'fast-glob';
 import { createFallbackLogger } from './utils/index.js';
 import { TEMPLATE_EXTENSION } from '../constants.js';
 import { getStatiVersion, isCollectionIndexPage, discoverLayout, getCollectionPathForPage, resolveSrcDir, createTemplateError, createValidatingPartialsProxy, propValue, wrapPartialsAsCallable, createNavigationHelpers, } from './utils/index.js';
-import { getEnv } from '../env.js';
+import { isDevelopment, isProduction } from '../env.js';
 import { generateSEO } from '../seo/index.js';
 /**
  * Groups pages by their tags for aggregation purposes.
@@ -177,8 +177,8 @@ export function createTemplateEngine(config) {
     const templateDir = resolveSrcDir(config);
     const eta = new Eta({
         views: templateDir,
-        cache: getEnv() === 'production',
-        cacheFilepaths: getEnv() === 'production',
+        cache: isProduction(),
+        cacheFilepaths: isProduction(),
         varName: 'stati',
     });
     return eta;
@@ -278,7 +278,7 @@ export async function renderPage(page, body, config, eta, navigation, allPages,
                 if (pass === maxPasses - 1) {
                     log.warning(`Failed to render partial ${partialName} at ${partialPath}: ${error instanceof Error ? error.message : String(error)}`);
                     // In development mode, throw enhanced template error for partials too
-                    if (getEnv() === 'development') {
+                    if (isDevelopment()) {
                         const templateError = createTemplateError(error instanceof Error ? error : new Error(String(error)), partialPath);
                         throw templateError;
                     }
@@ -327,7 +327,7 @@ export async function renderPage(page, body, config, eta, navigation, allPages,
     catch (error) {
         log.error(`Error rendering layout ${layoutPath || 'unknown'}: ${error instanceof Error ? error.message : String(error)}`);
         // In development mode, throw enhanced template error for better debugging
-        if (getEnv() === 'development') {
+        if (isDevelopment()) {
             const templateError = createTemplateError(error instanceof Error ? error : new Error(String(error)), layoutPath || undefined);
             throw templateError;
         }

package/dist/core/utils/bundle-matching.utils.d.ts

@@ -42,6 +42,8 @@ export interface CompiledBundleInfo {
     filename: string;
     /** The full path to the bundle (e.g., '/_assets/core-a1b2c3d4.js') */
     path: string;
+    /** The size of the compiled bundle in bytes */
+    sizeInBytes?: number;
 }
 /**
  * Determines which bundles should be included on a specific page.

package/dist/core/utils/bundle-matching.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle-matching.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/bundle-matching.utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,UAAU,EAAE,MAAM,EAAE;CAOjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,IAAI,CAqBvE;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,MAAM,EAAE,YAAY,CAAC;IACrB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,YAAY,EAAE,GACtB,YAAY,EAAE,CAyBhB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,kBAAkB,EAAE,GACpC,MAAM,EAAE,CAaV"}
+{"version":3,"file":"bundle-matching.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/bundle-matching.utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,UAAU,EAAE,MAAM,EAAE;CAOjC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,IAAI,CAqBvE;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,MAAM,EAAE,YAAY,CAAC;IACrB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,YAAY,EAAE,GACtB,YAAY,EAAE,CAyBhB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,kBAAkB,EAAE,GACpC,MAAM,EAAE,CAaV"}

package/dist/core/utils/index.d.ts

@@ -22,7 +22,7 @@ export { globToRegex, matchesGlob } from './glob-patterns.utils.js';
 export { matchBundlesForPage, getBundlePathsForPage, validateUniqueBundleNames, DuplicateBundleNameError, } from './bundle-matching.utils.js';
 export type { CompiledBundleInfo } from './bundle-matching.utils.js';
 export { createFallbackLogger } from './logger.utils.js';
-export { compileTypeScript, createTypeScriptWatcher, compileStatiConfig, cleanupCompiledConfig, autoInjectBundles, } from './typescript.utils.js';
+export { compileTypeScript, createTypeScriptWatcher, compileStatiConfig, cleanupCompiledConfig, autoInjectBundles, formatBytes, detectExistingBundles, } from './typescript.utils.js';
 export type { CompileOptions, WatchOptions } from './typescript.utils.js';
 export { findHeadClosePosition, injectBeforeHeadClose } from './html.utils.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,GACL,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAG7C,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3F,YAAY,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAG/F,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAGxE,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGpE,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1E,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,GACL,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAG7C,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3F,YAAY,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAG/F,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAGxE,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGpE,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,EACX,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1E,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/core/utils/index.js

@@ -35,6 +35,6 @@ export { matchBundlesForPage, getBundlePathsForPage, validateUniqueBundleNames,
 // Logger utilities
 export { createFallbackLogger } from './logger.utils.js';
 // TypeScript compilation utilities
-export { compileTypeScript, createTypeScriptWatcher, compileStatiConfig, cleanupCompiledConfig, autoInjectBundles, } from './typescript.utils.js';
+export { compileTypeScript, createTypeScriptWatcher, compileStatiConfig, cleanupCompiledConfig, autoInjectBundles, formatBytes, detectExistingBundles, } from './typescript.utils.js';
 // HTML manipulation utilities
 export { findHeadClosePosition, injectBeforeHeadClose } from './html.utils.js';

package/dist/core/utils/logger.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/logger.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAY7C"}
+{"version":3,"file":"logger.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/logger.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAa7C"}

package/dist/core/utils/logger.utils.js

@@ -11,6 +11,7 @@ export function createFallbackLogger() {
         success: (msg) => console.log(msg),
         error: (msg) => console.error(msg),
         warning: (msg) => console.warn(msg),
+        status: (msg) => console.log(msg),
         building: (msg) => console.log(msg),
         processing: (msg) => console.log(msg),
         stats: (msg) => console.log(msg),

package/dist/core/utils/partial-validation.utils.js

@@ -1,4 +1,4 @@
-import { getEnv } from '../../env.js';
+import { isProduction } from '../../env.js';
 /**
  * Creates inline error overlay HTML for missing partials
  */
@@ -91,7 +91,7 @@ function findSimilarPartialNames(targetName, availableNames) {
 export function createValidatingPartialsProxy(partials) {
     // In production, return partials as-is
     // Only skip validation if explicitly set to production
-    if (getEnv() === 'production') {
+    if (isProduction()) {
         return partials;
     }
     // If there are no partials, return the empty object as-is

package/dist/core/utils/paths.utils.d.ts

@@ -71,6 +71,15 @@ export declare function resolveStaticPath(config: StatiConfig, relativePath: str
  * This utility ensures that paths from different sources (file watchers, cache manifest,
  * glob results) can be reliably compared even when they use different representations.
  *
+ * **WARNING: This function is for STRING COMPARISON ONLY.**
+ * **DO NOT use the returned path for file system operations.**
+ *
+ * The normalization uppercases Windows drive letters (c: → C:) for consistent
+ * comparison on case-insensitive Windows file systems. However, this can break
+ * file operations in case-sensitive environments like WSL or Unix systems mounted
+ * on Windows. Always use the original path for actual file system operations
+ * (fs.readFile, fs.writeFile, etc.).
+ *
  * @param filePath - Path to normalize (can be relative or absolute, Windows or POSIX)
  * @param basePath - Optional base path to resolve relative paths against (defaults to cwd)
  * @returns Normalized absolute path with forward slashes and no trailing slashes
@@ -88,6 +97,15 @@ export declare function resolveStaticPath(config: StatiConfig, relativePath: str
  * // Already POSIX path
  * normalizePathForComparison('/project/site/layout.eta')
  * // Returns: '/project/site/layout.eta'
+ *
+ * // CORRECT: Use for comparison
+ * const normalized1 = normalizePathForComparison(watcherPath);
+ * const normalized2 = normalizePathForComparison(cachedPath);
+ * if (normalized1 === normalized2) { ... }
+ *
+ * // WRONG: Do not use for file operations
+ * const normalized = normalizePathForComparison(filePath);
+ * await fs.readFile(normalized); // BAD! Use original filePath instead
  * ```
  */
 export declare function normalizePathForComparison(filePath: string, basePath?: string): string;

package/dist/core/utils/paths.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/paths.utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW;;;;EAMlD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAuBtF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAYlF"}
+{"version":3,"file":"paths.utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/paths.utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE5D;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW;;;;EAMlD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA6BtF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAYlF"}

package/dist/core/utils/paths.utils.js

@@ -90,6 +90,15 @@ export function resolveStaticPath(config, relativePath) {
  * This utility ensures that paths from different sources (file watchers, cache manifest,
  * glob results) can be reliably compared even when they use different representations.
  *
+ * **WARNING: This function is for STRING COMPARISON ONLY.**
+ * **DO NOT use the returned path for file system operations.**
+ *
+ * The normalization uppercases Windows drive letters (c: → C:) for consistent
+ * comparison on case-insensitive Windows file systems. However, this can break
+ * file operations in case-sensitive environments like WSL or Unix systems mounted
+ * on Windows. Always use the original path for actual file system operations
+ * (fs.readFile, fs.writeFile, etc.).
+ *
  * @param filePath - Path to normalize (can be relative or absolute, Windows or POSIX)
  * @param basePath - Optional base path to resolve relative paths against (defaults to cwd)
  * @returns Normalized absolute path with forward slashes and no trailing slashes
@@ -107,6 +116,15 @@ export function resolveStaticPath(config, relativePath) {
  * // Already POSIX path
  * normalizePathForComparison('/project/site/layout.eta')
  * // Returns: '/project/site/layout.eta'
+ *
+ * // CORRECT: Use for comparison
+ * const normalized1 = normalizePathForComparison(watcherPath);
+ * const normalized2 = normalizePathForComparison(cachedPath);
+ * if (normalized1 === normalized2) { ... }
+ *
+ * // WRONG: Do not use for file operations
+ * const normalized = normalizePathForComparison(filePath);
+ * await fs.readFile(normalized); // BAD! Use original filePath instead
  * ```
  */
 export function normalizePathForComparison(filePath, basePath) {
@@ -120,6 +138,11 @@ export function normalizePathForComparison(filePath, basePath) {
         // Use the already-normalized path to avoid reintroducing backslashes
         normalized = join(base, normalized).replace(/\\/g, '/');
     }
+    // Normalize Windows drive letter to uppercase for consistent comparison
+    // File system is case-insensitive on Windows, but string comparison is case-sensitive
+    if (/^[a-z]:/.test(normalized)) {
+        normalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    }
     // Use posix.normalize to clean up any '..' or '.' segments and remove redundant separators
     normalized = posix.normalize(normalized);
     // Remove trailing slash (except for root path)

package/dist/core/utils/tailwind-inventory.utils.d.ts

@@ -72,20 +72,5 @@ export declare function getInventorySize(): number;
  * @returns True if tracking is enabled
  */
 export declare function isTrackingEnabled(): boolean;
-/**
- * Writes the Tailwind class inventory to an HTML file that Tailwind can scan.
- *
- * The generated file contains all tracked classes in a hidden div.
- * This file should be added to Tailwind's content configuration.
- *
- * @param cacheDir - Directory where the inventory file should be written (typically .stati/)
- * @returns Path to the generated inventory file
- *
- * @example
- * ```typescript
- * const inventoryPath = await writeTailwindClassInventory('/path/to/project/.stati');
- * // File written to: /path/to/project/.stati/tailwind-classes.html
- * ```
- */
-export declare function writeTailwindClassInventory(cacheDir: string): Promise<string>;
+export declare function writeTailwindClassInventory(cacheDir: string, skipIfUnchanged?: boolean): Promise<string>;
 //# sourceMappingURL=tailwind-inventory.utils.d.ts.map