bun-plugin-stx 0.2.571 → 0.2.573

package/dist/preload.d.ts

@@ -1 +1 @@
-
+export {};

package/dist/serve.js

@@ -8,19 +8,19 @@ import {
 
 // src/serve.ts
 var {serve: bunServe, Glob } = globalThis.Bun;
-import { existsSync as existsSync2, watch as fsWatch, realpathSync, statSync as statSync3 } from "fs";
+import { existsSync as existsSync2, watch as fsWatch, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
 import nodeFs from "fs/promises";
 import nodePath from "path";
-import process19 from "process";
+import process20 from "process";
 
 // ../../node_modules/bunfig/dist/index.js
 import { existsSync, statSync } from "fs";
 import { resolve } from "path";
 import process from "process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname4, resolve as resolve12 } from "path";
-import process20 from "process";
+import process19 from "process";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -77,9 +77,12 @@ import { createGzip as createGzip3 } from "zlib";
 import process16 from "process";
 import process15 from "process";
 import process18 from "process";
-import { existsSync as existsSync10 } from "fs";
+import { readFileSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import { existsSync as existsSync10, statSync as statSync3 } from "fs";
 import { resolve as resolve10 } from "path";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 class ConfigCache {
   cache = new Map;
   totalHits = 0;
@@ -2665,7 +2668,7 @@ class Logger2 {
                 const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
                 console.error(`Network error during write attempt ${retries + 1}/${maxRetries}:`, errorMessage);
                 const delay = backoffDelay * 2 ** retries;
-                await new Promise((resolve522) => setTimeout(resolve522, delay));
+                await new Promise((resolve52) => setTimeout(resolve52, delay));
                 retries++;
                 continue;
               }
@@ -2693,7 +2696,7 @@ class Logger2 {
           }
           retries++;
           const delay = backoffDelay * 2 ** (retries - 1);
-          await new Promise((resolve522) => setTimeout(resolve522, delay));
+          await new Promise((resolve52) => setTimeout(resolve52, delay));
         }
       }
     })();
@@ -2823,11 +2826,11 @@ class Logger2 {
     };
   }
   async compressData(data) {
-    return new Promise((resolve522, reject) => {
+    return new Promise((resolve52, reject) => {
       const gzip = createGzip2();
       const chunks = [];
       gzip.on("data", (chunk2) => chunks.push(chunk2));
-      gzip.on("end", () => resolve522(Buffer2.from(Buffer2.concat(chunks))));
+      gzip.on("end", () => resolve52(Buffer2.from(Buffer2.concat(chunks))));
       gzip.on("error", reject);
       gzip.write(data);
       gzip.end();
@@ -3516,7 +3519,7 @@ class Logger2 {
     if (isBrowserProcess2()) {
       return Promise.resolve(true);
     }
-    return new Promise((resolve522) => {
+    return new Promise((resolve52) => {
       console.error(`${styles2.cyan("?")} ${message} (y/n) `);
       const onData = (data) => {
         const input = data.toString().trim().toLowerCase();
@@ -3528,7 +3531,7 @@ class Logger2 {
         } catch {}
         process11.stdin.pause();
         console.error("");
-        resolve522(input === "y" || input === "yes");
+        resolve52(input === "y" || input === "yes");
       };
       try {
         if (typeof process11.stdin.setRawMode === "function") {
@@ -3694,7 +3697,7 @@ async function withErrorRecovery(fn, options = {}) {
         break;
       }
       if (retryDelay > 0) {
-        await new Promise((resolve522) => setTimeout(resolve522, retryDelay));
+        await new Promise((resolve52) => setTimeout(resolve52, retryDelay));
       }
     }
   }
@@ -4323,8 +4326,8 @@ class ConfigFileLoader {
   }
   async getFileModificationTime(filePath) {
     try {
-      const { statSync: statSync22 } = await import("fs");
-      const stats = statSync22(filePath);
+      const { statSync: statSync2 } = await import("fs");
+      const stats = statSync2(filePath);
       return stats.mtime;
     } catch {
       return null;
@@ -5538,7 +5541,7 @@ var init_dist = __esm(async () => {
     error: bgRed2(white2(bold2(" ERROR ")))
   };
   logger2 = new Logger2("stacks");
-  BunfigError = class BunfigError2 extends Error {
+  BunfigError = class BunfigError extends Error {
     timestamp;
     context;
     constructor(message, context = {}) {
@@ -5565,7 +5568,7 @@ var init_dist = __esm(async () => {
       return `${this.name} [${this.code}]: ${this.message}${contextStr}`;
     }
   };
-  ConfigNotFoundError = class ConfigNotFoundError2 extends BunfigError {
+  ConfigNotFoundError = class ConfigNotFoundError extends BunfigError {
     code = "CONFIG_NOT_FOUND";
     constructor(configName, searchPaths, alias) {
       const aliasStr = alias ? ` or alias "${alias}"` : "";
@@ -5577,7 +5580,7 @@ var init_dist = __esm(async () => {
       });
     }
   };
-  ConfigLoadError = class ConfigLoadError2 extends BunfigError {
+  ConfigLoadError = class ConfigLoadError extends BunfigError {
     code = "CONFIG_LOAD_ERROR";
     constructor(configPath, cause, configName) {
       super(`Failed to load configuration from "${configPath}": ${cause.message}`, {
@@ -5589,7 +5592,7 @@ var init_dist = __esm(async () => {
       this.cause = cause;
     }
   };
-  ConfigValidationError = class ConfigValidationError2 extends BunfigError {
+  ConfigValidationError = class ConfigValidationError extends BunfigError {
     code = "CONFIG_VALIDATION_ERROR";
     constructor(configPath, validationErrors, configName) {
       super(`Configuration validation failed for "${configPath}"`, {
@@ -5600,7 +5603,7 @@ var init_dist = __esm(async () => {
       });
     }
   };
-  ConfigMergeError = class ConfigMergeError2 extends BunfigError {
+  ConfigMergeError = class ConfigMergeError extends BunfigError {
     code = "CONFIG_MERGE_ERROR";
     constructor(sourcePath, targetPath, cause, configName) {
       super(`Failed to merge configuration from "${sourcePath}" with "${targetPath}": ${cause.message}`, {
@@ -5613,7 +5616,7 @@ var init_dist = __esm(async () => {
       this.cause = cause;
     }
   };
-  EnvVarError = class EnvVarError2 extends BunfigError {
+  EnvVarError = class EnvVarError extends BunfigError {
     code = "ENV_VAR_ERROR";
     constructor(envKey, envValue, expectedType, configName) {
       super(`Failed to parse environment variable "${envKey}" with value "${envValue}" as ${expectedType}`, {
@@ -5624,7 +5627,7 @@ var init_dist = __esm(async () => {
       });
     }
   };
-  FileSystemError = class FileSystemError2 extends BunfigError {
+  FileSystemError = class FileSystemError extends BunfigError {
     code = "FILE_SYSTEM_ERROR";
     constructor(operation, path, cause) {
       super(`File system ${operation} failed for "${path}": ${cause.message}`, {
@@ -5636,7 +5639,7 @@ var init_dist = __esm(async () => {
       this.cause = cause;
     }
   };
-  TypeGenerationError = class TypeGenerationError2 extends BunfigError {
+  TypeGenerationError = class TypeGenerationError extends BunfigError {
     code = "TYPE_GENERATION_ERROR";
     constructor(configDir, outputPath, cause) {
       super(`Failed to generate types from "${configDir}" to "${outputPath}": ${cause.message}`, {
@@ -5648,7 +5651,7 @@ var init_dist = __esm(async () => {
       this.cause = cause;
     }
   };
-  SchemaValidationError = class SchemaValidationError2 extends BunfigError {
+  SchemaValidationError = class SchemaValidationError extends BunfigError {
     code = "SCHEMA_VALIDATION_ERROR";
     constructor(schemaPath, validationErrors, configName) {
       super(`Schema validation failed${configName ? ` for config "${configName}"` : ""}`, {
@@ -5659,7 +5662,7 @@ var init_dist = __esm(async () => {
       });
     }
   };
-  BrowserConfigError = class BrowserConfigError2 extends BunfigError {
+  BrowserConfigError = class BrowserConfigError extends BunfigError {
     code = "BROWSER_CONFIG_ERROR";
     constructor(endpoint, status, statusText, configName) {
       super(`Failed to fetch configuration from "${endpoint}": ${status} ${statusText}`, {
@@ -5670,7 +5673,7 @@ var init_dist = __esm(async () => {
       });
     }
   };
-  PluginError = class PluginError2 extends BunfigError {
+  PluginError = class PluginError extends BunfigError {
     code = "PLUGIN_ERROR";
     constructor(pluginName, operation, cause) {
       super(`Plugin "${pluginName}" failed during ${operation}: ${cause.message}`, {
@@ -7106,6 +7109,7 @@ class BunfigError2 extends Error {
 }
 
 class ConfigNotFoundError2 extends BunfigError2 {
+  name = "ConfigNotFoundError";
   code = "CONFIG_NOT_FOUND";
   constructor(configName, searchPaths, alias) {
     const aliasList = alias === undefined ? [] : Array.isArray(alias) ? alias.filter(Boolean) : [alias];
@@ -7124,6 +7128,7 @@ class ConfigNotFoundError2 extends BunfigError2 {
 }
 
 class ConfigLoadError2 extends BunfigError2 {
+  name = "ConfigLoadError";
   code = "CONFIG_LOAD_ERROR";
   constructor(configPath, cause, configName) {
     super(`Failed to load configuration from "${configPath}": ${cause.message}`, {
@@ -7137,6 +7142,7 @@ class ConfigLoadError2 extends BunfigError2 {
 }
 
 class ConfigValidationError2 extends BunfigError2 {
+  name = "ConfigValidationError";
   code = "CONFIG_VALIDATION_ERROR";
   constructor(configPath, validationErrors, configName) {
     super(`Configuration validation failed for "${configPath}"`, {
@@ -7149,6 +7155,7 @@ class ConfigValidationError2 extends BunfigError2 {
 }
 
 class ConfigMergeError2 extends BunfigError2 {
+  name = "ConfigMergeError";
   code = "CONFIG_MERGE_ERROR";
   constructor(sourcePath, targetPath, cause, configName) {
     super(`Failed to merge configuration from "${sourcePath}" with "${targetPath}": ${cause.message}`, {
@@ -7163,6 +7170,7 @@ class ConfigMergeError2 extends BunfigError2 {
 }
 
 class EnvVarError2 extends BunfigError2 {
+  name = "EnvVarError";
   code = "ENV_VAR_ERROR";
   constructor(envKey, envValue, expectedType, configName) {
     super(`Failed to parse environment variable "${envKey}" with value "${envValue}" as ${expectedType}`, {
@@ -7175,6 +7183,7 @@ class EnvVarError2 extends BunfigError2 {
 }
 
 class FileSystemError2 extends BunfigError2 {
+  name = "FileSystemError";
   code = "FILE_SYSTEM_ERROR";
   constructor(operation, path, cause) {
     super(`File system ${operation} failed for "${path}": ${cause.message}`, {
@@ -7188,6 +7197,7 @@ class FileSystemError2 extends BunfigError2 {
 }
 
 class TypeGenerationError2 extends BunfigError2 {
+  name = "TypeGenerationError";
   code = "TYPE_GENERATION_ERROR";
   constructor(configDir, outputPath, cause) {
     super(`Failed to generate types from "${configDir}" to "${outputPath}": ${cause.message}`, {
@@ -7201,6 +7211,7 @@ class TypeGenerationError2 extends BunfigError2 {
 }
 
 class SchemaValidationError2 extends BunfigError2 {
+  name = "SchemaValidationError";
   code = "SCHEMA_VALIDATION_ERROR";
   constructor(schemaPath, validationErrors, configName) {
     super(`Schema validation failed${configName ? ` for config "${configName}"` : ""}`, {
@@ -7213,6 +7224,7 @@ class SchemaValidationError2 extends BunfigError2 {
 }
 
 class BrowserConfigError2 extends BunfigError2 {
+  name = "BrowserConfigError";
   code = "BROWSER_CONFIG_ERROR";
   constructor(endpoint, status, statusText, configName) {
     super(`Failed to fetch configuration from "${endpoint}": ${status} ${statusText}`, {
@@ -7225,6 +7237,7 @@ class BrowserConfigError2 extends BunfigError2 {
 }
 
 class PluginError2 extends BunfigError2 {
+  name = "PluginError";
   code = "PLUGIN_ERROR";
   constructor(pluginName, operation, cause) {
     super(`Plugin "${pluginName}" failed during ${operation}: ${cause.message}`, {
@@ -7285,7 +7298,7 @@ async function withErrorRecovery2(fn, options = {}) {
         break;
       }
       if (retryDelay > 0) {
-        await new Promise((resolve10) => setTimeout(resolve10, retryDelay));
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
       }
     }
   }
@@ -7343,7 +7356,7 @@ class EnvProcessor2 {
       }
     ];
   }
-  async applyEnvironmentVariables(configName, config5, options = {}) {
+  async applyEnvironmentVariables(configName, config, options = {}) {
     const {
       prefix,
       useCamelCase = true,
@@ -7355,12 +7368,12 @@ class EnvProcessor2 {
     const operation = async () => {
       if (!configName) {
         return {
-          config: config5,
+          config,
           source: { type: "environment", priority: 50, timestamp: new Date }
         };
       }
       const envPrefix = prefix || this.generateEnvPrefix(configName);
-      const result = { ...config5 };
+      const result = { ...config };
       this.processObject(result, [], envPrefix, {
         useCamelCase,
         useBackwardCompatibility,
@@ -7462,11 +7475,11 @@ class EnvProcessor2 {
       errors
     };
   }
-  generateEnvVarDocs(configName, defaultConfig4, options = {}) {
+  generateEnvVarDocs(configName, defaultConfig, options = {}) {
     const { prefix, format = "text" } = options;
     const envPrefix = prefix || this.generateEnvPrefix(configName);
     const envVars = [];
-    this.extractEnvVarInfo(defaultConfig4, [], envPrefix, envVars);
+    this.extractEnvVarInfo(defaultConfig, [], envPrefix, envVars);
     switch (format) {
       case "markdown":
         return this.formatAsMarkdown(envVars, configName);
@@ -7533,6 +7546,39 @@ class EnvProcessor2 {
     return result;
   }
 }
+var configurationRequire = createRequire(import.meta.url);
+var pendingImports = new Map;
+var rejectedImports = new Set;
+function isMissingConfigPath(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function importFreshConfiguration(path) {
+  const canonicalPath = realpathSync(path);
+  const previous = pendingImports.get(canonicalPath);
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  pendingImports.set(canonicalPath, current);
+  await previous;
+  try {
+    readFileSync(canonicalPath);
+    if (configurationRequire.cache[canonicalPath]?.loaded === true || rejectedImports.has(canonicalPath))
+      delete configurationRequire.cache[canonicalPath];
+    try {
+      const imported = await import(pathToFileURL(canonicalPath).href);
+      rejectedImports.delete(canonicalPath);
+      return imported;
+    } catch (error) {
+      rejectedImports.add(canonicalPath);
+      throw error;
+    }
+  } finally {
+    release();
+    if (pendingImports.get(canonicalPath) === current)
+      pendingImports.delete(canonicalPath);
+  }
+}
 function deepMerge4(target, source, options = {}) {
   const visited = new WeakMap;
   return deepMergeWithVisited2(target, source, options, visited);
@@ -7705,13 +7751,14 @@ function isObject4(item) {
 
 class ConfigFileLoader2 {
   extensions = CONFIG_FILE_EXTENSIONS;
-  async loadFromPath(configPath, defaultConfig4, options = {}) {
+  async loadFromPath(configPath, defaultConfig, options = {}) {
     const {
       arrayStrategy = "replace",
       useCache = true,
       cacheTtl,
       trackPerformance = true,
-      verbose = false
+      verbose = false,
+      strictDiscovery = false
     } = options;
     if (useCache) {
       const cached = globalCache.getWithFileCheck("file", configPath);
@@ -7723,22 +7770,25 @@ class ConfigFileLoader2 {
       }
     }
     const loadOperation = async () => {
-      if (!existsSync10(configPath)) {
-        return null;
-      }
       try {
-        const cacheBuster = `?t=${Date.now()}`;
-        const importedConfig = await import(configPath + cacheBuster);
-        const loadedConfig = importedConfig.default || importedConfig;
-        const hasDefaultExport = "default" in importedConfig;
+        try {
+          statSync3(configPath);
+        } catch (error) {
+          if (isMissingConfigPath(error) || !strictDiscovery)
+            return null;
+          throw error;
+        }
+        const importedConfig = await importFreshConfiguration(configPath);
+        const hasDefaultExport = Object.hasOwn(importedConfig, "default");
         const hasNamedExports = Object.keys(importedConfig).length > 0;
+        const loadedConfig = hasDefaultExport ? importedConfig.default : importedConfig;
         if (!hasDefaultExport && !hasNamedExports) {
           throw new ConfigLoadError2(configPath, new Error("Configuration file is empty and exports nothing"), "unknown");
         }
         if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig)) {
           throw new ConfigLoadError2(configPath, new Error("Configuration must export a valid object"), "unknown");
         }
-        const mergedConfig = deepMergeWithArrayStrategy3(defaultConfig4, loadedConfig, arrayStrategy);
+        const mergedConfig = deepMergeWithArrayStrategy3(defaultConfig, loadedConfig, arrayStrategy);
         const source = {
           type: "file",
           path: configPath,
@@ -7760,15 +7810,15 @@ class ConfigFileLoader2 {
     }
     return loadOperation();
   }
-  async tryLoadFromPaths(configPaths, defaultConfig4, options = {}) {
+  async tryLoadFromPaths(configPaths, defaultConfig, options = {}) {
     for (const configPath of configPaths) {
       try {
-        const result = await this.loadFromPath(configPath, defaultConfig4, options);
+        const result = await this.loadFromPath(configPath, defaultConfig, options);
         if (result) {
           return result;
         }
       } catch (error) {
-        if (error instanceof Error && error.name === "ConfigLoadError") {
+        if (error instanceof ConfigLoadError2) {
           throw error;
         }
         if (options.verbose) {
@@ -7810,8 +7860,8 @@ class ConfigFileLoader2 {
       }
     } else {
       try {
-        const { readdirSync: readdirSync4 } = await import("fs");
-        const files = readdirSync4(directory);
+        const { readdirSync } = await import("fs");
+        const files = readdirSync(directory);
         for (const file of files) {
           if (this.looksLikeConfigFile(file)) {
             const filePath = resolve10(directory, file);
@@ -7842,12 +7892,12 @@ class ConfigFileLoader2 {
         return errors;
       }
       const imported = await import(filePath);
-      const config5 = imported.default || imported;
-      if (config5 === undefined) {
+      const config = imported.default || imported;
+      if (config === undefined) {
         errors.push("Configuration file must export a default value or named exports");
-      } else if (typeof config5 !== "object" || config5 === null) {
+      } else if (typeof config !== "object" || config === null) {
         errors.push("Configuration must be an object");
-      } else if (Array.isArray(config5)) {
+      } else if (Array.isArray(config)) {
         errors.push("Configuration cannot be an array at the root level");
       }
       if (filePath.endsWith(".json")) {
@@ -7866,8 +7916,8 @@ class ConfigFileLoader2 {
   }
   async getFileModificationTime(filePath) {
     try {
-      const { statSync: statSync3 } = await import("fs");
-      const stats = statSync3(filePath);
+      const { statSync } = await import("fs");
+      const stats = statSync(filePath);
       return stats.mtime;
     } catch {
       return null;
@@ -7893,7 +7943,7 @@ class ConfigFileLoader2 {
 var URL_PATTERN2 = /^https?:\/\//;
 
 class ConfigValidator2 {
-  async validateConfiguration(config5, schema, options = {}) {
+  async validateConfiguration(config, schema, options = {}) {
     const {
       stopOnFirstError = false,
       validateRequired = true,
@@ -7915,11 +7965,11 @@ class ConfigValidator2 {
       };
       try {
         if (typeof schema === "string") {
-          return await this.validateWithSchemaFile(config5, schema, resolvedOptions);
+          return await this.validateWithSchemaFile(config, schema, resolvedOptions);
         } else if (Array.isArray(schema)) {
-          return this.validateWithRules(config5, [...schema, ...customRules], resolvedOptions);
+          return this.validateWithRules(config, [...schema, ...customRules], resolvedOptions);
         } else {
-          return this.validateWithJSONSchema(config5, schema, resolvedOptions);
+          return this.validateWithJSONSchema(config, schema, resolvedOptions);
         }
       } catch (error) {
         errors.push({
@@ -7936,26 +7986,28 @@ class ConfigValidator2 {
     }
     return operation();
   }
-  async validateWithSchemaFile(config5, schemaPath, options) {
+  async validateWithSchemaFile(config, schemaPath, options) {
     try {
-      if (!existsSync12(schemaPath)) {
+      if (!existsSync11(schemaPath)) {
         throw new SchemaValidationError2(schemaPath, [{ path: "", message: "Schema file does not exist" }]);
       }
-      const schemaModule = await import(schemaPath);
-      const schema = schemaModule.default || schemaModule;
+      const schemaModule = await importFreshConfiguration(schemaPath);
+      const schema = Object.hasOwn(schemaModule, "default") ? schemaModule.default : schemaModule;
       if (Array.isArray(schema)) {
-        return this.validateWithRules(config5, schema, options);
+        return this.validateWithRules(config, schema, options);
       } else {
-        return this.validateWithJSONSchema(config5, schema, options);
+        if (typeof schema !== "object" || schema === null)
+          throw new Error("Schema must export an object or validation rule array");
+        return this.validateWithJSONSchema(config, schema, options);
       }
     } catch (error) {
       throw new SchemaValidationError2(schemaPath, [{ path: "", message: `Failed to load schema: ${error}` }]);
     }
   }
-  validateWithJSONSchema(config5, schema, options) {
+  validateWithJSONSchema(config, schema, options) {
     const errors = [];
     const warnings = [];
-    this.validateObjectAgainstSchema(config5, schema, "", errors, warnings, options);
+    this.validateObjectAgainstSchema(config, schema, "", errors, warnings, options);
     return {
       isValid: errors.length === 0,
       errors,
@@ -8089,12 +8141,12 @@ class ConfigValidator2 {
       }
     }
   }
-  validateWithRules(config5, rules, options) {
+  validateWithRules(config, rules, options) {
     const errors = [];
     const warnings = [];
     for (const rule of rules) {
       try {
-        const value = this.getValueByPath(config5, rule.path);
+        const value = this.getValueByPath(config, rule.path);
         const ruleErrors = this.validateWithRule(value, rule, rule.path);
         errors.push(...ruleErrors);
         if (options.stopOnFirstError && errors.length > 0) {
@@ -8286,8 +8338,9 @@ class ConfigLoader2 {
       validate: customValidator,
       ...baseOptions
     } = options;
+    const effectiveCache = baseOptions.errorPolicy === "throw" ? { ...cache, enabled: false } : cache;
     try {
-      if (cache?.enabled) {
+      if (effectiveCache?.enabled) {
         const cached = this.checkCache(baseOptions.name || "", baseOptions);
         if (cached) {
           return cached;
@@ -8295,13 +8348,13 @@ class ConfigLoader2 {
       }
       let result;
       try {
-        result = await this.loadConfigurationStrategies(baseOptions, true, cache);
+        result = await this.loadConfigurationStrategies(baseOptions, true, effectiveCache);
       } catch (error) {
-        if (baseOptions.configFile)
+        if (baseOptions.configFile || baseOptions.errorPolicy === "throw" && !(error instanceof ConfigNotFoundError2))
           throw error;
         const isStrictMode = baseOptions.__strictErrorHandling;
-        if (error instanceof Error && error.name === "ConfigNotFoundError") {
-          if (isStrictMode) {
+        if (error instanceof ConfigNotFoundError2) {
+          if (isStrictMode && baseOptions.errorPolicy !== "throw") {
             throw error;
           }
           const envResult = await this.applyEnvironmentVariables(baseOptions.name || "", baseOptions.defaultConfig, baseOptions.checkEnv !== false, baseOptions.verbose || false);
@@ -8309,7 +8362,7 @@ class ConfigLoader2 {
             ...envResult,
             warnings: [`No configuration file found for "${baseOptions.name || "config"}", using defaults with environment variables`]
           };
-        } else if (error instanceof Error && error.name === "ConfigLoadError") {
+        } else if (error instanceof ConfigLoadError2) {
           const isPermissionError = error.message.includes("EACCES") || error.message.includes("EPERM") || error.message.includes("permission denied");
           const isSyntaxError = !isPermissionError && (error.message.includes("syntax") || error.message.includes("Expected") || error.message.includes("Unexpected") || error.message.includes("BuildMessage") || error.message.includes("errors building"));
           const isStructureError = error.message.includes("Configuration must export a valid object") || error.message.includes("Configuration file is empty and exports nothing");
@@ -8342,8 +8395,8 @@ class ConfigLoader2 {
       if (schema || customValidator) {
         await this.validateConfiguration(result.config, schema, customValidator, baseOptions.name);
       }
-      if (cache?.enabled && result) {
-        this.cacheResult(baseOptions.name || "", result, cache, baseOptions);
+      if (effectiveCache?.enabled && result) {
+        this.cacheResult(baseOptions.name || "", result, effectiveCache, baseOptions);
       }
       if (performance2?.enabled) {
         const metrics = {
@@ -8362,7 +8415,7 @@ class ConfigLoader2 {
       }
       return result;
     } catch (error) {
-      if (error instanceof Error && error.name === "ConfigNotFoundError")
+      if (error instanceof ConfigNotFoundError2)
         throw error;
       const duration = Date.now() - startTime;
       log3.error(`Configuration loading failed after ${duration}ms:`, [error instanceof Error ? error : new Error(String(error))]);
@@ -8376,35 +8429,35 @@ class ConfigLoader2 {
       configFile,
       cwd,
       configDir,
-      defaultConfig: defaultConfig4,
+      defaultConfig,
       checkEnv = true,
       arrayStrategy = "replace",
       verbose = false
     } = options;
-    const baseDir = cwd || process20.cwd();
+    const baseDir = cwd || process19.cwd();
     const searchPaths = [];
     if (configFile) {
       const explicitPath = resolve12(baseDir, configFile);
       searchPaths.push(explicitPath);
-      const envDefaults = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig4, verbose) : defaultConfig4;
-      const explicitResult = await this.fileLoader.tryLoadFromPaths([explicitPath], envDefaults, { arrayStrategy, verbose, cacheTtl: cacheOptions?.ttl, useCache: !cacheOptions?.ttl || cacheOptions.ttl > 100 });
+      const envDefaults = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig, verbose) : defaultConfig;
+      const explicitResult = await this.fileLoader.tryLoadFromPaths([explicitPath], envDefaults, { arrayStrategy, verbose, cacheTtl: cacheOptions?.ttl, useCache: cacheOptions?.enabled !== false && (!cacheOptions?.ttl || cacheOptions.ttl > 100), strictDiscovery: true });
       if (!explicitResult)
         throw ErrorFactory2.configNotFound(name || configFile, searchPaths, alias);
       if (verbose)
         log3.success(`Configuration loaded from explicit path: ${explicitPath}`);
       return this.finalizeResult(explicitResult, searchPaths, checkEnv, name, verbose);
     }
-    const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig4, arrayStrategy, verbose, checkEnv, cacheOptions);
+    const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig, arrayStrategy, verbose, checkEnv, cacheOptions, options.errorPolicy === "throw");
     if (localResult) {
       searchPaths.push(...this.getLocalSearchPaths(name, alias, baseDir, configDir));
       return this.finalizeResult(localResult, searchPaths, checkEnv, name, verbose);
     }
-    const homeResult = await this.loadHomeConfiguration(name, alias, defaultConfig4, arrayStrategy, verbose, checkEnv);
+    const homeResult = await this.loadHomeConfiguration(name, alias, defaultConfig, arrayStrategy, verbose, checkEnv, cacheOptions, options.errorPolicy === "throw");
     if (homeResult) {
       searchPaths.push(...this.getHomeSearchPaths(name, alias));
       return this.finalizeResult(homeResult, searchPaths, checkEnv, name, verbose);
     }
-    const packageResult = await this.loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig4, arrayStrategy, verbose, checkEnv);
+    const packageResult = await this.loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig, arrayStrategy, verbose, checkEnv, options.errorPolicy);
     if (packageResult) {
       searchPaths.push(resolve12(baseDir, "package.json"));
       return this.finalizeResult(packageResult, searchPaths, checkEnv, name, verbose);
@@ -8413,14 +8466,14 @@ class ConfigLoader2 {
     if (throwOnNotFound) {
       throw ErrorFactory2.configNotFound(name, searchPaths, alias);
     }
-    const envResult = await this.applyEnvironmentVariables(name, defaultConfig4, checkEnv, verbose);
+    const envResult = await this.applyEnvironmentVariables(name, defaultConfig, checkEnv, verbose);
     return {
       ...envResult,
       warnings: [`No configuration file found for "${name}"${formatAliasSuffix(alias)}, using defaults with environment variables`]
     };
   }
-  async loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig4, arrayStrategy, verbose, checkEnv, cacheOptions) {
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig4, verbose) : defaultConfig4;
+  async loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig, arrayStrategy, verbose, checkEnv, cacheOptions, strictDiscovery = false) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig, verbose) : defaultConfig;
     const searchDirectories = this.getLocalDirectories(baseDir, configDir);
     for (const directory of searchDirectories) {
       if (verbose) {
@@ -8431,7 +8484,8 @@ class ConfigLoader2 {
         arrayStrategy,
         verbose,
         cacheTtl: cacheOptions?.ttl,
-        useCache: !cacheOptions?.ttl || cacheOptions.ttl > 100
+        useCache: cacheOptions?.enabled !== false && (!cacheOptions?.ttl || cacheOptions.ttl > 100),
+        strictDiscovery
       });
       if (result) {
         if (verbose) {
@@ -8442,10 +8496,10 @@ class ConfigLoader2 {
     }
     return null;
   }
-  async loadHomeConfiguration(name, alias, defaultConfig4, arrayStrategy, verbose, checkEnv) {
+  async loadHomeConfiguration(name, alias, defaultConfig, arrayStrategy, verbose, checkEnv, cacheOptions, strictDiscovery = false) {
     if (!name)
       return null;
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig4, verbose) : defaultConfig4;
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig, verbose) : defaultConfig;
     const homeDirectories = [
       resolve12(homedir3(), ".config", name),
       resolve12(homedir3(), ".config"),
@@ -8456,7 +8510,7 @@ class ConfigLoader2 {
         log3.info(`Checking home directory: ${directory}`);
       }
       const configPaths = this.fileLoader.generateConfigPaths(name, directory, alias);
-      const result = await this.fileLoader.tryLoadFromPaths(configPaths, envDefaultConfig, { arrayStrategy, verbose });
+      const result = await this.fileLoader.tryLoadFromPaths(configPaths, envDefaultConfig, { arrayStrategy, verbose, cacheTtl: cacheOptions?.ttl, useCache: cacheOptions?.enabled !== false && (!cacheOptions?.ttl || cacheOptions.ttl > 100), strictDiscovery });
       if (result) {
         if (verbose) {
           log3.success(`Configuration loaded from home directory: ${result.source.path}`);
@@ -8466,62 +8520,48 @@ class ConfigLoader2 {
     }
     return null;
   }
-  async loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig4, arrayStrategy, verbose, checkEnv) {
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig4, verbose) : defaultConfig4;
+  async loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig, arrayStrategy, verbose, checkEnv, errorPolicy) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig3(name, defaultConfig, verbose) : defaultConfig;
+    const pkgPath = resolve12(baseDir, "package.json");
+    const strict = errorPolicy === "throw";
     try {
-      const pkgPath = resolve12(baseDir, "package.json");
-      if (!existsSync13(pkgPath)) {
+      const parsed = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new Error("package.json must contain an object");
+      const pkg = parsed;
+      const aliases = alias === undefined ? [] : Array.isArray(alias) ? alias : [alias];
+      const names = [name, ...aliases.filter(Boolean)];
+      const usedName = names.find((candidate) => Object.hasOwn(pkg, candidate) && (strict || Boolean(pkg[candidate])));
+      if (usedName === undefined)
         return null;
-      }
-      let pkg = {};
-      try {
-        pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-      } catch (parseError) {
-        if (verbose) {
-          log3.warn(`Failed to parse package.json:`, [parseError instanceof Error ? parseError : new Error(String(parseError))]);
-        }
-        return null;
-      }
-      let pkgConfig = pkg[name];
-      let usedName = name;
-      if (!pkgConfig && alias) {
-        const aliases = Array.isArray(alias) ? alias : [alias];
-        for (const a of aliases) {
-          if (!a)
-            continue;
-          if (pkg[a]) {
-            pkgConfig = pkg[a];
-            usedName = a;
-            break;
-          }
-        }
-      }
-      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
-        if (verbose) {
-          log3.success(`Configuration loaded from package.json: ${usedName}`);
+      const pkgConfig = pkg[usedName];
+      if (typeof pkgConfig !== "object" || pkgConfig === null || Array.isArray(pkgConfig))
+        throw new Error(`Configuration field "${usedName}" must contain an object`);
+      if (verbose)
+        log3.success(`Configuration loaded from package.json: ${usedName}`);
+      return {
+        config: deepMergeWithArrayStrategy3(envDefaultConfig, pkgConfig, arrayStrategy),
+        source: {
+          type: "package.json",
+          path: pkgPath,
+          priority: 30,
+          timestamp: new Date
         }
-        const mergedConfig = deepMergeWithArrayStrategy3(envDefaultConfig, pkgConfig, arrayStrategy);
-        return {
-          config: mergedConfig,
-          source: {
-            type: "package.json",
-            path: pkgPath,
-            priority: 30,
-            timestamp: new Date
-          }
-        };
-      }
+      };
     } catch (error) {
-      if (verbose) {
+      if (isMissingConfigPath(error))
+        return null;
+      if (strict)
+        throw ErrorFactory2.configLoad(pkgPath, error instanceof Error ? error : new Error(String(error)));
+      if (verbose)
         log3.warn(`Failed to load package.json:`, [error instanceof Error ? error : new Error(String(error))]);
-      }
+      return null;
     }
-    return null;
   }
-  async applyEnvironmentVariables(name, config5, checkEnv, verbose) {
-    if (!checkEnv || !name || typeof config5 !== "object" || config5 === null || Array.isArray(config5)) {
+  async applyEnvironmentVariables(name, config, checkEnv, verbose) {
+    if (!checkEnv || !name || typeof config !== "object" || config === null || Array.isArray(config)) {
       return {
-        config: config5,
+        config,
         source: {
           type: "default",
           priority: 10,
@@ -8529,7 +8569,7 @@ class ConfigLoader2 {
         }
       };
     }
-    const processedConfig = applyEnvVarsToConfig3(name, config5, verbose);
+    const processedConfig = applyEnvVarsToConfig3(name, config, verbose);
     return {
       config: processedConfig,
       source: {
@@ -8546,16 +8586,16 @@ class ConfigLoader2 {
       path: result.source.path
     };
   }
-  async validateConfiguration(config5, schema, customValidator, configName) {
+  async validateConfiguration(config, schema, customValidator, configName) {
     const errors = [];
     if (customValidator) {
-      const customErrors = customValidator(config5);
+      const customErrors = customValidator(config);
       if (customErrors) {
         errors.push(...customErrors);
       }
     }
     if (schema) {
-      const validationResult = await this.validator.validateConfiguration(config5, schema);
+      const validationResult = await this.validator.validateConfiguration(config, schema);
       if (!validationResult.isValid) {
         errors.push(...validationResult.errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message));
       }
@@ -8627,7 +8667,7 @@ class ConfigLoader2 {
 }
 var globalConfigLoader2 = new ConfigLoader2;
 async function loadConfig6(options) {
-  const defaultConfig4 = "defaultConfig" in options && options.defaultConfig !== undefined ? options.defaultConfig : {};
+  const defaultConfig = "defaultConfig" in options && options.defaultConfig !== undefined ? options.defaultConfig : {};
   const isEnhanced = "cache" in options || "performance" in options || "schema" in options || "validate" in options;
   try {
     let result;
@@ -8636,36 +8676,35 @@ async function loadConfig6(options) {
     } else {
       result = await globalConfigLoader2.loadConfig({
         ...options,
-        defaultConfig: defaultConfig4,
+        defaultConfig,
         cache: { enabled: true },
         performance: { enabled: false }
       });
     }
-    return result?.config ?? defaultConfig4;
+    return result?.config ?? defaultConfig;
   } catch (error) {
-    if (options.configFile)
+    if (options.configFile || options.errorPolicy === "throw")
       throw error;
-    const errorName = error instanceof Error ? error.name : "UnknownError";
     const errorMessage = error instanceof Error ? error.message : String(error);
-    const isConfigError = errorName === "ConfigNotFoundError" || errorName === "ConfigLoadError" || errorName === "ConfigValidationError" || errorMessage.includes("config");
+    const isConfigError = error instanceof ConfigNotFoundError2 || error instanceof ConfigLoadError2 || error instanceof ConfigValidationError2 || errorMessage.includes("config");
     if (!isConfigError && options.verbose) {
       log3.warn(`Unexpected error loading config, using defaults:`, [error instanceof Error ? error : new Error(String(error))]);
     }
-    const configOptions = isEnhanced ? { ...options, defaultConfig: defaultConfig4 } : {
+    const configOptions = isEnhanced ? { ...options, defaultConfig } : {
       ...options,
-      defaultConfig: defaultConfig4,
+      defaultConfig,
       cache: { enabled: true },
       performance: { enabled: false }
     };
     const shouldCheckEnv = "checkEnv" in options ? options.checkEnv !== false : true;
     if (shouldCheckEnv) {
-      const envResult = await globalConfigLoader2.applyEnvironmentVariables(configOptions.name || "", defaultConfig4, true, configOptions.verbose || false);
-      return envResult?.config ?? defaultConfig4;
+      const envResult = await globalConfigLoader2.applyEnvironmentVariables(configOptions.name || "", defaultConfig, true, configOptions.verbose || false);
+      return envResult?.config ?? defaultConfig;
     }
-    return defaultConfig4;
+    return defaultConfig;
   }
 }
-function applyEnvVarsToConfig3(name, config6, verbose = false) {
+function applyEnvVarsToConfig3(name, config, verbose = false) {
   const _envProcessor = new EnvProcessor2;
   const envPrefix = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   function processConfigLevel(obj, path = []) {
@@ -8680,7 +8719,7 @@ function applyEnvVarsToConfig3(name, config6, verbose = false) {
       let envValue;
       let usedKey;
       for (const envKey of envKeys) {
-        envValue = process20.env[envKey];
+        envValue = process19.env[envKey];
         if (envValue !== undefined) {
           usedKey = envKey;
           break;
@@ -8710,10 +8749,10 @@ function applyEnvVarsToConfig3(name, config6, verbose = false) {
     }
     return result;
   }
-  return processConfigLevel(config6);
+  return processConfigLevel(config);
 }
-var defaultConfigDir4 = /* @__PURE__ */ resolve12(process20.cwd(), "config");
-var defaultGeneratedDir4 = /* @__PURE__ */ resolve12(process20.cwd(), "src/generated");
+var defaultConfigDir4 = /* @__PURE__ */ resolve12(process19.cwd(), "config");
+var defaultGeneratedDir4 = /* @__PURE__ */ resolve12(process19.cwd(), "src/generated");
 
 // src/serve.ts
 import { BUILD_ID_HEADER, decodeTitleEntities, externalScriptsOutsideContainer, extractPageResponseStatus, findContainerRegion, FRAGMENT_CACHE_CONTROL, getBuildId, mergeCssConfig, readResponseHeaders, readResponseStatus, renderFontCSS, SPA_NAV_HEADER, spaNavVaryHeaders, stateDir, stateDirName } from "@stacksjs/stx";
@@ -9061,13 +9100,13 @@ function publicFileExists(requestPath, publicDir) {
   }
   if (decoded.includes("\x00"))
     return false;
-  const publicRoot = nodePath.resolve(process19.cwd(), publicDir);
+  const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
   const resolved = nodePath.resolve(publicRoot, `.${decoded}`);
   const inside = resolved === publicRoot || resolved.startsWith(`${publicRoot}${nodePath.sep}`);
   if (!inside)
     return false;
   try {
-    return existsSync2(resolved) && !statSync3(resolved).isDirectory();
+    return existsSync2(resolved) && !statSync4(resolved).isDirectory();
   } catch {
     return false;
   }
@@ -9076,8 +9115,8 @@ function escapeHtml(input) {
   return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 function isProductionServe() {
-  const node = (process19.env.NODE_ENV || "").toLowerCase();
-  const app = (process19.env.APP_ENV || "").toLowerCase();
+  const node = (process20.env.NODE_ENV || "").toLowerCase();
+  const app = (process20.env.APP_ENV || "").toLowerCase();
   const devEnvs = new Set(["development", "dev", "local", "test", "testing"]);
   return !(devEnvs.has(node) || devEnvs.has(app));
 }
@@ -9215,11 +9254,11 @@ function boundedCache(limit) {
     }
   };
 }
-function pageExcluder(exclude, cwd = process19.cwd()) {
+function pageExcluder(exclude, cwd = process20.cwd()) {
   const canonical = (entry) => {
     const resolved = nodePath.resolve(cwd, entry);
     try {
-      return realpathSync(resolved);
+      return realpathSync2(resolved);
     } catch {
       return resolved;
     }
@@ -9372,7 +9411,7 @@ async function serve(options) {
   const stxConfig = await loadConfig6({
     name: "stx",
     alias: ["ui"],
-    cwd: process19.cwd(),
+    cwd: process20.cwd(),
     defaultConfig: defaultStxConfig,
     checkEnv: false,
     verbose: false
@@ -9381,7 +9420,7 @@ async function serve(options) {
   try {
     const stxMod = options.stxModule ? options.stxModule : await defaultStxModule;
     if (stxMod && typeof stxMod.resolveStxDirectories === "function")
-      stxMod.resolveStxDirectories(stxConfig, process19.cwd());
+      stxMod.resolveStxDirectories(stxConfig, process20.cwd());
   } catch {}
   try {
     const stxMod = options.stxModule ? options.stxModule : await defaultStxModule;
@@ -9429,9 +9468,9 @@ async function serve(options) {
     });
   }
   const stxModule = options.stxModule ? Promise.resolve(options.stxModule) : defaultStxModule;
-  const imageCacheDir = process19.env.STX_IMAGE_CACHE_DIR?.trim();
-  const imageDeliveryOutputDir = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-delivery") : stateDir(process19.cwd(), "image-delivery");
-  const imagePlaceholderCachePath = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-placeholders.json") : stateDir(process19.cwd(), "image-placeholders.json");
+  const imageCacheDir = process20.env.STX_IMAGE_CACHE_DIR?.trim();
+  const imageDeliveryOutputDir = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-delivery") : stateDir(process20.cwd(), "image-delivery");
+  const imagePlaceholderCachePath = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-placeholders.json") : stateDir(process20.cwd(), "image-placeholders.json");
   const imageDeliveryRoot = nodePath.join(imageDeliveryOutputDir, "_stx", "images");
   let resolvedStxModule = null;
   Promise.resolve(stxModule).then((m) => {
@@ -9604,7 +9643,7 @@ function __stxOverlay(errs){
   const writeLayoutTypes = async () => {
     try {
       const stxMod = options.stxModule ? options.stxModule : await defaultStxModule;
-      stxMod?.generateLayoutTypes?.(layoutsDir, stxMod?.stateDir?.(process19.cwd()));
+      stxMod?.generateLayoutTypes?.(layoutsDir, stxMod?.stateDir?.(process20.cwd()));
     } catch {}
   };
   await writeLayoutTypes();
@@ -9935,7 +9974,7 @@ function __stxOverlay(errs){
     try {
       const { Router } = await import("./chunk-zv29b5s3.js");
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
-      const router = new Router(process19.cwd(), { pagesDirs, stateDir: stateDirName(), exclude: options.exclude });
+      const router = new Router(process20.cwd(), { pagesDirs, stateDir: stateDirName(), exclude: options.exclude });
       if (!options.quiet)
         console.log(`[stx] Generated ${router.routes.length} routes \u2192 ${nodePath.join(stateDirName(), "routes.ts")}`);
     } catch (e) {}
@@ -9946,7 +9985,7 @@ function __stxOverlay(errs){
       return;
     assetsInitialized = true;
     const assetsDir = "./resources/assets";
-    const targetAssetsDir = stateDir(process19.cwd(), "assets");
+    const targetAssetsDir = stateDir(process20.cwd(), "assets");
     try {
       const assetsExist = await nodeFs.stat(assetsDir).then(() => true).catch(() => false);
       if (assetsExist) {
@@ -9981,7 +10020,7 @@ function __stxOverlay(errs){
     if (cssLoadAttempted)
       return cssModule;
     cssLoadAttempted = true;
-    let dir = process19.cwd();
+    let dir = process20.cwd();
     while (dir !== nodePath.dirname(dir)) {
       for (const store of ["node_modules", "pantry"]) {
         for (const entry of ENGINE_PACKAGE_ENTRIES) {
@@ -10009,7 +10048,7 @@ function __stxOverlay(errs){
       } catch {}
     }
     try {
-      const localPath = nodePath.join(process19.env.HOME || "", "Code/Tools/crosswind/packages/toolkit/src/engine/index.ts");
+      const localPath = nodePath.join(process20.env.HOME || "", "Code/Tools/crosswind/packages/toolkit/src/engine/index.ts");
       const mod = await import(localPath);
       cssModule = { CSSGenerator: mod.CSSGenerator, config: mod.config };
       return cssModule;
@@ -10052,7 +10091,7 @@ function __stxOverlay(errs){
       if (!cssUserConfigPromise) {
         cssUserConfigPromise = loadConfig6({
           name: "css",
-          cwd: process19.cwd(),
+          cwd: process20.cwd(),
           defaultConfig: {},
           checkEnv: false,
           verbose: false
@@ -10173,7 +10212,7 @@ function __stxOverlay(errs){
     context.__stx_head_preset = true;
     const config = {
       ...defaultConfig,
-      root: process19.cwd(),
+      root: process20.cwd(),
       ...componentsDir && { componentsDir },
       ...layoutsDir && { layoutsDir },
       ...fallbackLayoutsDir && { fallbackLayoutsDir },
@@ -10387,7 +10426,7 @@ function __stxOverlay(errs){
       context.__stx_head_preset = true;
       const config = {
         ...defaultConfig,
-        root: process19.cwd(),
+        root: process20.cwd(),
         ...componentsDir && { componentsDir },
         ...layoutsDir && { layoutsDir },
         ...fallbackLayoutsDir && { fallbackLayoutsDir },
@@ -10557,7 +10596,7 @@ ${block}`;
       console.warn(`\x1B[2m${error.stack}\x1B[0m`);
   }
   async function runImageWarmup() {
-    const imageWarmupEnabled = imageWarmupSetting === "auto" ? await projectUsesImageBuiltins(process19.cwd()) : imageWarmupSetting !== false;
+    const imageWarmupEnabled = imageWarmupSetting === "auto" ? await projectUsesImageBuiltins(process20.cwd()) : imageWarmupSetting !== false;
     if (!imageWarmupEnabled) {
       placeholdersAreReady = true;
       markPlaceholdersReady();
@@ -10565,7 +10604,7 @@ ${block}`;
     }
     try {
       const stx = await stxModule;
-      const publicRoot = nodePath.resolve(process19.cwd(), publicDir);
+      const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
       const [placeholderResult, deliveryResult] = await Promise.allSettled([
         stx.warmImagePlaceholders(publicRoot, {
           cachePath: imagePlaceholderCachePath,
@@ -10938,7 +10977,7 @@ ${block}`;
                     }
                     const body = await req.json();
                     const { Database } = await import("bun:sqlite");
-                    const dbPath = nodePath.resolve(process19.cwd(), "database/stacks.sqlite");
+                    const dbPath = nodePath.resolve(process20.cwd(), "database/stacks.sqlite");
                     const db = new Database(dbPath);
                     try {
                       const tableInfo = db.query(`PRAGMA table_info("${tableName}")`).all();
@@ -11206,7 +11245,7 @@ ${trailingPageScripts.join(`
                 }
                 if (path.startsWith("/chunk-") || path.endsWith(".js") || path.endsWith(".css")) {
                   try {
-                    const buildFile = Bun.file(stateDir(process19.cwd(), path));
+                    const buildFile = Bun.file(stateDir(process20.cwd(), path));
                     if (await buildFile.exists()) {
                       const ext = path.split(".").pop()?.toLowerCase();
                       const contentType = ext === "css" ? "text/css" : ext === "js" ? "application/javascript" : "text/plain";
@@ -11231,7 +11270,7 @@ ${trailingPageScripts.join(`
                     return new Response("Invalid asset path", { status: 400 });
                   for (const assetPath of assetRequestPaths(assetPathname)) {
                     try {
-                      const filePath = nodePath.resolve(process19.cwd(), `.${assetPath}`);
+                      const filePath = nodePath.resolve(process20.cwd(), `.${assetPath}`);
                       const file = Bun.file(filePath);
                       if (await file.exists()) {
                         const ext = getAssetExtension(assetPath);
@@ -11250,7 +11289,7 @@ ${trailingPageScripts.join(`
                   }
                 }
                 if ((req.method === "GET" || req.method === "HEAD") && path !== "/") {
-                  const publicRoot = nodePath.resolve(process19.cwd(), publicDir);
+                  const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
                   let safePathname;
                   try {
                     safePathname = decodeURIComponent(path);
@@ -11399,10 +11438,10 @@ ${trailingPageScripts.join(`
     })().catch(() => {});
   }
   if (options.reusePort) {
-    const graceMs = Number(process19.env.SHUTDOWN_GRACE_MS) || 15000;
-    process19.once("SIGTERM", () => {
-      setTimeout(() => process19.exit(0), graceMs).unref();
-      Promise.resolve(_server?.stop()).then(() => process19.exit(0));
+    const graceMs = Number(process20.env.SHUTDOWN_GRACE_MS) || 15000;
+    process20.once("SIGTERM", () => {
+      setTimeout(() => process20.exit(0), graceMs).unref();
+      Promise.resolve(_server?.stop()).then(() => process20.exit(0));
     });
   }
   if (!options.quiet) {
@@ -11421,17 +11460,17 @@ ${trailingPageScripts.join(`
     console.log(`  \x1B[2mPress\x1B[0m o + Enter \x1B[2mto open in browser\x1B[0m`);
     console.log(`  \x1B[2mPress\x1B[0m q + Enter \x1B[2mto quit\x1B[0m`);
     console.log();
-    if (process19.stdin.isTTY) {
-      process19.stdin.setRawMode(false);
+    if (process20.stdin.isTTY) {
+      process20.stdin.setRawMode(false);
       const rl = await import("readline");
-      const reader = rl.createInterface({ input: process19.stdin });
+      const reader = rl.createInterface({ input: process20.stdin });
       reader.on("line", (line) => {
         const cmd = line.trim().toLowerCase();
         if (cmd === "o") {
-          const openCmd = process19.platform === "darwin" ? "open" : process19.platform === "win32" ? "start" : "xdg-open";
+          const openCmd = process20.platform === "darwin" ? "open" : process20.platform === "win32" ? "start" : "xdg-open";
           Bun.spawn([openCmd, openUrl]);
         } else if (cmd === "q") {
-          process19.exit(0);
+          process20.exit(0);
         }
       });
     }
@@ -11439,7 +11478,7 @@ ${trailingPageScripts.join(`
   await Bun.sleep(Number.POSITIVE_INFINITY);
 }
 async function main() {
-  const args = process19.argv.slice(2);
+  const args = process20.argv.slice(2);
   if (args[0] === "serve") {
     args.shift();
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.571",
+  "version": "0.2.573",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -74,7 +74,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/stx": "0.2.571",
-    "stx-router": "0.2.571"
+    "@stacksjs/stx": "0.2.573",
+    "stx-router": "0.2.573"
   }
 }