@stacksjs/stx 0.2.94 → 0.2.96

package/dist/errors/codes.js

@@ -1,2 +1,97 @@
-// @bun
-import{Ny as a,Oy as b,Py as c,Qy as d,Ry as e,Sy as f,Ty as g,Uy as h}from"../chunk-cz25azze.js";import"../chunk-3jm3snz8.js";export{a as setErrorLocale,c as registerErrorMessages,e as getErrorMessage,b as getErrorLocale,h as getErrorCodeName,f as formatLocalizedError,d as clearErrorMessages,g as ErrorCodes};
+const defaultErrorMessages = {
+  1001: { message: "Unclosed directive: {{directive}}", help: "Make sure to close the directive with the appropriate end tag" },
+  1002: { message: "Unclosed expression at position {{position}}", help: "Check for missing closing braces }}" },
+  1003: { message: "Invalid directive syntax: {{directive}}", help: "Review the directive documentation for correct syntax" },
+  1004: { message: "Malformed expression: {{expression}}", help: "Check for syntax errors in your expression" },
+  1005: { message: "Unexpected token: {{token}}", help: "Remove or fix the unexpected token" },
+  1101: { message: "Undefined variable: {{variable}}", help: "Make sure the variable is defined in the template context" },
+  1102: { message: "Type error: {{details}}", help: "Check that you are using the correct types" },
+  1103: { message: "Evaluation error: {{details}}", help: "Review the expression for errors" },
+  1104: { message: "Infinite loop detected in {{location}}", help: "Check your loop conditions" },
+  1105: { message: "Circular reference detected: {{path}}", help: "Remove the circular dependency" },
+  1201: { message: "Unsafe expression blocked: {{expression}}", help: "This expression contains potentially dangerous code" },
+  1202: { message: "Path traversal attempt blocked: {{path}}", help: "Use only relative paths within allowed directories" },
+  1203: { message: "Potential XSS attempt blocked", help: "Sanitize user input before rendering" },
+  1204: { message: "Code injection attempt blocked: {{code}}", help: "Avoid executing dynamic code" },
+  1205: { message: "Prohibited DOM API usage: {{api}}", help: "Use STX.useRefs(), STX.useRef(), STX.el() and other STX helpers instead of direct DOM manipulation" },
+  1301: { message: "File not found: {{path}}", help: "Check that the file exists and the path is correct" },
+  1302: { message: "Error reading file: {{path}}", help: "Check file permissions and encoding" },
+  1303: { message: "Invalid file path: {{path}}", help: "Use a valid file path" },
+  1304: { message: "Permission denied: {{path}}", help: "Check file permissions" },
+  1401: { message: "Invalid configuration: {{details}}", help: "Review your stx.config.ts file" },
+  1402: { message: "Missing required configuration: {{key}}", help: "Add the required configuration option" },
+  1403: { message: "Deprecated configuration: {{key}}", help: "Update to the new configuration format" },
+  1501: { message: "Component not found: {{name}}", help: "Check that the component exists in your components directory" },
+  1502: { message: "Invalid props for component {{name}}: {{details}}", help: "Check the component prop requirements" },
+  1503: { message: "Error rendering component {{name}}: {{details}}", help: "Check the component template for errors" },
+  1601: { message: "Filter not found: {{filter}}", help: "Register the filter or check the filter name" },
+  1602: { message: "Invalid arguments for filter {{filter}}: {{details}}", help: "Check the filter documentation for correct arguments" },
+  1603: { message: "Expression evaluation timed out", help: "Simplify the expression or increase the timeout" }
+};
+let customErrorMessages = {}, currentLocale = "en";
+export function setErrorLocale(locale) {
+  currentLocale = locale;
+}
+export function getErrorLocale() {
+  return currentLocale;
+}
+export function registerErrorMessages(messages) {
+  customErrorMessages = { ...customErrorMessages, ...messages };
+}
+export function clearErrorMessages() {
+  customErrorMessages = {};
+}
+export function getErrorMessage(code, params = {}) {
+  const template = customErrorMessages[code] || defaultErrorMessages[code] || {
+    message: `Unknown error (code: ${code})`
+  };
+  let { message, help } = template;
+  for (const [key, value] of Object.entries(params)) {
+    const placeholder = `{{${key}}}`;
+    message = message.replace(new RegExp(placeholder, "g"), value);
+    if (help)
+      help = help.replace(new RegExp(placeholder, "g"), value);
+  }
+  return { message, help };
+}
+export function formatLocalizedError(code, params = {}) {
+  const { message, help } = getErrorMessage(code, params);
+  return help ? `${message}
+  Help: ${help}` : message;
+}
+export const ErrorCodes = {
+  UNCLOSED_DIRECTIVE: 1001,
+  UNCLOSED_EXPRESSION: 1002,
+  INVALID_DIRECTIVE_SYNTAX: 1003,
+  MALFORMED_EXPRESSION: 1004,
+  UNEXPECTED_TOKEN: 1005,
+  UNDEFINED_VARIABLE: 1101,
+  TYPE_ERROR: 1102,
+  EVALUATION_ERROR: 1103,
+  INFINITE_LOOP: 1104,
+  CIRCULAR_REFERENCE: 1105,
+  UNSAFE_EXPRESSION: 1201,
+  PATH_TRAVERSAL: 1202,
+  XSS_ATTEMPT: 1203,
+  CODE_INJECTION: 1204,
+  DOM_API_VIOLATION: 1205,
+  FILE_NOT_FOUND: 1301,
+  FILE_READ_ERROR: 1302,
+  INVALID_FILE_PATH: 1303,
+  PERMISSION_DENIED: 1304,
+  INVALID_CONFIG: 1401,
+  MISSING_REQUIRED_CONFIG: 1402,
+  DEPRECATED_CONFIG: 1403,
+  COMPONENT_NOT_FOUND: 1501,
+  INVALID_PROPS: 1502,
+  COMPONENT_RENDER_ERROR: 1503,
+  FILTER_NOT_FOUND: 1601,
+  INVALID_FILTER_ARGS: 1602,
+  EXPRESSION_TIMEOUT: 1603
+};
+export function getErrorCodeName(code) {
+  for (const [name, value] of Object.entries(ErrorCodes))
+    if (value === code)
+      return name;
+  return;
+}

package/dist/errors/formatter.js

@@ -1,2 +1,196 @@
-// @bun
-import{qy as a,ry as b,sy as c,ty as d,uy as e,vy as f}from"../chunk-jjvp4t5w.js";import"../chunk-ht4j68cs.js";import"../chunk-fch9tk1k.js";import"../chunk-cz25azze.js";import"../chunk-3jm3snz8.js";export{f as safeExecuteAsync,e as safeExecute,b as inlineError,a as formatError,d as createEnhancedError,c as consoleError};
+import { getErrorCodeName } from "./codes.js";
+import { formatFilePath } from "./types.js";
+export function formatError(options) {
+  const {
+    type,
+    message,
+    code,
+    filePath,
+    line,
+    column,
+    template,
+    offset,
+    snippet,
+    suggestion,
+    format = "text"
+  } = options;
+  let actualLine = line, actualColumn = column;
+  if (!actualLine && template && offset !== void 0) {
+    const position = getLineAndColumn(template, offset);
+    actualLine = position.line;
+    actualColumn = position.column;
+  }
+  const displayPath = filePath ? formatFilePath(filePath) : void 0, codeName = code ? getErrorCodeName(code) : void 0, data = {
+    type,
+    code,
+    codeName,
+    message,
+    filePath: displayPath,
+    line: actualLine,
+    column: actualColumn,
+    snippet,
+    suggestion,
+    timestamp: new Date().toISOString()
+  };
+  let formatted;
+  switch (format) {
+    case "html":
+      formatted = formatErrorAsHtml(data);
+      break;
+    case "json":
+      formatted = JSON.stringify(data, null, 2);
+      break;
+    case "console":
+      formatted = formatErrorAsConsole(data, template, offset);
+      break;
+    case "text":
+    default:
+      formatted = formatErrorAsText(data, template, offset);
+      break;
+  }
+  return { formatted, data };
+}
+function formatErrorAsText(data, template, _offset) {
+  const parts = [], codeStr = data.code ? ` [${data.codeName || data.code}]` : "";
+  parts.push(`[${data.type} Error${codeStr}]`);
+  if (data.filePath) {
+    let location = data.filePath;
+    if (data.line) {
+      location += `:${data.line}`;
+      if (data.column)
+        location += `:${data.column}`;
+    }
+    parts.push(`at ${location}`);
+  }
+  parts.push(`
+${data.message}`);
+  if (template && data.line) {
+    const contextLines = getContextLines(template, data.line, 2);
+    if (contextLines)
+      parts.push(`
+${contextLines}`);
+  }
+  if (data.snippet)
+    parts.push(`
+Snippet: ${data.snippet}`);
+  if (data.suggestion)
+    parts.push(`
+Suggestion: ${data.suggestion}`);
+  return parts.join(" ");
+}
+function formatErrorAsHtml(data) {
+  const codeStr = data.code ? ` [${data.code}]` : "", locationStr = data.filePath ? ` in ${data.filePath}${data.line ? `:${data.line}` : ""}` : "";
+  let html = `<!-- [${data.type} Error${codeStr}]${locationStr}: ${escapeHtmlComment(data.message)}`;
+  if (data.suggestion)
+    html += ` | Suggestion: ${escapeHtmlComment(data.suggestion)}`;
+  html += " -->";
+  return html;
+}
+function formatErrorAsConsole(data, template, _offset) {
+  const red = "\x1B[31m", yellow = "\x1B[33m", cyan = "\x1B[36m", gray = "\x1B[90m", bold = "\x1B[1m", reset = "\x1B[0m", parts = [], codeStr = data.code ? ` [${data.codeName || data.code}]` : "";
+  parts.push(`${bold}${red}\u2501\u2501\u2501 ${data.type} Error${codeStr} \u2501\u2501\u2501${reset}`);
+  if (data.filePath) {
+    let location = `${cyan}${data.filePath}${reset}`;
+    if (data.line) {
+      location += `${gray}:${data.line}${reset}`;
+      if (data.column)
+        location += `${gray}:${data.column}${reset}`;
+    }
+    parts.push(`
+${gray}at${reset} ${location}`);
+  }
+  parts.push(`
+
+${data.message}`);
+  if (template && data.line) {
+    const contextLines = getContextLinesColored(template, data.line, 2);
+    if (contextLines)
+      parts.push(`
+
+${gray}Context:${reset}
+${contextLines}`);
+  }
+  if (data.suggestion)
+    parts.push(`
+
+${yellow}Suggestion:${reset} ${data.suggestion}`);
+  parts.push(`
+${red}\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501${reset}`);
+  return parts.join("");
+}
+function getContextLines(template, errorLine, contextSize) {
+  const lines = template.split(`
+`), startLine = Math.max(0, errorLine - contextSize - 1), endLine = Math.min(lines.length - 1, errorLine + contextSize - 1), result = [];
+  for (let i = startLine;i <= endLine; i++) {
+    const lineNum = (i + 1).toString().padStart(4), indicator = i === errorLine - 1 ? ">" : " ";
+    result.push(`${indicator}${lineNum} | ${lines[i]}`);
+  }
+  return result.join(`
+`);
+}
+function getContextLinesColored(template, errorLine, contextSize) {
+  const lines = template.split(`
+`), startLine = Math.max(0, errorLine - contextSize - 1), endLine = Math.min(lines.length - 1, errorLine + contextSize - 1), gray = "\x1B[90m", red = "\x1B[31m", reset = "\x1B[0m", result = [];
+  for (let i = startLine;i <= endLine; i++) {
+    const lineNum = (i + 1).toString().padStart(4), isErrorLine = i === errorLine - 1, indicator = isErrorLine ? `${red}>${reset}` : " ", lineContent = isErrorLine ? `${red}${lines[i]}${reset}` : `${gray}${lines[i]}${reset}`;
+    result.push(`${indicator}${gray}${lineNum}${reset} | ${lineContent}`);
+  }
+  return result.join(`
+`);
+}
+function escapeHtmlComment(str) {
+  return str.replace(/--/g, "- -").replace(/>/g, "&gt;");
+}
+function getLineAndColumn(text, offset) {
+  const lines = text.substring(0, offset).split(`
+`);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length
+  };
+}
+export function inlineError(type, message, code) {
+  return formatError({ type, message, code, format: "html" }).formatted;
+}
+export function consoleError(type, message, filePath, line, code) {
+  return formatError({ type, message, code, filePath, line, format: "console" }).formatted;
+}
+export function createEnhancedError(type, message, context) {
+  const lines = context.template.split(`
+`), position = getLineAndColumn(context.template, context.offset);
+  let errorOutput = `[${type} Error at line ${position.line} in ${context.filePath}]: ${message}
+
+`;
+  const startLine = Math.max(0, position.line - 3), endLine = Math.min(lines.length - 1, position.line + 2);
+  errorOutput += `Context:
+`;
+  for (let i = startLine;i <= endLine; i++) {
+    const lineNum = i + 1, line = lines[i] || "", indicator = i === position.line - 1 ? ">" : " ";
+    errorOutput += `${indicator} ${lineNum.toString().padStart(3)}: ${line}
+`;
+  }
+  if (position.line - 1 < lines.length) {
+    const padding = " ".repeat(position.column + 5);
+    errorOutput += `${padding}^
+`;
+  }
+  return errorOutput;
+}
+export function safeExecute(operation, fallback, errorHandler) {
+  try {
+    return operation();
+  } catch (error) {
+    if (errorHandler && error instanceof Error)
+      errorHandler(error);
+    return fallback;
+  }
+}
+export async function safeExecuteAsync(operation, fallback, errorHandler) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (errorHandler && error instanceof Error)
+      errorHandler(error);
+    return fallback;
+  }
+}

package/dist/errors/index.js

@@ -1,2 +1,44 @@
-// @bun
-import{ky as C,ly as D,my as E,ny as F,oy as G,py as H}from"../chunk-48cw2nde.js";import{qy as s,ry as t,sy as u,ty as v,uy as w,vy as x}from"../chunk-jjvp4t5w.js";import{wy as y,xy as z,yy as A,zy as B}from"../chunk-94g3cahw.js";import{Ay as i,By as j,Cy as k,Dy as l,Ey as m,Fy as n,Gy as o,Hy as p,Iy as q,Jy as r}from"../chunk-ht4j68cs.js";import"../chunk-fch9tk1k.js";import{Ny as a,Oy as b,Py as c,Qy as d,Ry as e,Sy as f,Ty as g,Uy as h}from"../chunk-cz25azze.js";import"../chunk-3jm3snz8.js";export{H as validators,a as setErrorLocale,G as sanitizeFilePath,F as sanitizeExpression,E as sanitizeDirectiveParams,D as sanitizeDirectiveParam,C as sanitizeComponentProps,x as safeExecuteAsync,w as safeExecute,k as resetErrorConfig,c as registerErrorMessages,t as inlineError,e as getErrorMessage,b as getErrorLocale,j as getErrorConfig,h as getErrorCodeName,f as formatLocalizedError,l as formatFilePath,s as formatError,y as errorRecovery,A as errorLogger,B as devHelpers,v as createEnhancedError,u as consoleError,i as configureErrorHandling,d as clearErrorMessages,r as StxValidationError,n as StxSyntaxError,p as StxSecurityError,o as StxRuntimeError,q as StxFileError,m as StxError,z as ErrorLogger,g as ErrorCodes};
+export {
+  clearErrorMessages,
+  ErrorCodes,
+  formatLocalizedError,
+  getErrorCodeName,
+  getErrorLocale,
+  getErrorMessage,
+  registerErrorMessages,
+  setErrorLocale
+} from "./codes.js";
+export {
+  consoleError,
+  createEnhancedError,
+  formatError,
+  inlineError,
+  safeExecute,
+  safeExecuteAsync
+} from "./formatter.js";
+export {
+  devHelpers,
+  ErrorLogger,
+  errorLogger,
+  errorRecovery
+} from "./logger.js";
+export {
+  sanitizeComponentProps,
+  sanitizeDirectiveParam,
+  sanitizeDirectiveParams,
+  sanitizeExpression,
+  sanitizeFilePath,
+  validators
+} from "./sanitizer.js";
+export {
+  configureErrorHandling,
+  formatFilePath,
+  getErrorConfig,
+  resetErrorConfig,
+  StxError,
+  StxFileError,
+  StxRuntimeError,
+  StxSecurityError,
+  StxSyntaxError,
+  StxValidationError
+} from "./types.js";

package/dist/errors/logger.js

@@ -1,2 +1,250 @@
-// @bun
-import{wy as a,xy as b,yy as c,zy as d}from"../chunk-94g3cahw.js";import"../chunk-ht4j68cs.js";import"../chunk-fch9tk1k.js";import"../chunk-cz25azze.js";import"../chunk-3jm3snz8.js";export{a as errorRecovery,c as errorLogger,d as devHelpers,b as ErrorLogger};
+import { isDevelopment } from "../env.js";
+import { getErrorConfig } from "./types.js";
+export const errorRecovery = {
+  isEnabled() {
+    return getErrorConfig().enableAutoRecovery;
+  },
+  fixCommonSyntaxErrors(template) {
+    const config = getErrorConfig();
+    if (!config.enableAutoRecovery)
+      return { fixed: template, fixes: [] };
+    let fixed = template;
+    const fixes = [], openBraces = (fixed.match(/\{\{/g) || []).length, closeBraces = (fixed.match(/\}\}/g) || []).length;
+    if (openBraces > closeBraces) {
+      const missing = openBraces - closeBraces;
+      fixed += "}}".repeat(missing);
+      fixes.push(`Added ${missing} missing closing braces '}}'`);
+    }
+    const unclosedDirectives = ["if", "foreach", "for", "switch", "section"];
+    for (const directive of unclosedDirectives) {
+      const openCount = (fixed.match(new RegExp(`@${directive}\\b`, "g")) || []).length, closeCount = (fixed.match(new RegExp(`@end${directive}\\b`, "g")) || []).length;
+      if (openCount > closeCount) {
+        const missing = openCount - closeCount;
+        for (let i = 0;i < missing; i++)
+          fixed += `
+@end${directive}`;
+        fixes.push(`Added ${missing} missing @end${directive}`);
+      }
+    }
+    if (fixes.length > 0 && config.logRecoveryWarnings) {
+      console.warn("[stx] Auto-recovery applied fixes:");
+      fixes.forEach((fix) => console.warn(`  - ${fix}`));
+      console.warn("  Consider fixing these issues in your template.");
+    }
+    return { fixed, fixes };
+  },
+  createFallbackContent(sectionType, error) {
+    if (isDevelopment())
+      return `<!-- ${sectionType} failed: ${error.message} -->`;
+    return "<!-- stx rendering error -->";
+  }
+};
+
+export class ErrorLogger {
+  errors = [];
+  maxErrors;
+  enableFileLogging;
+  logFilePath;
+  logFormat;
+  maxFileSize;
+  maxLogFiles;
+  minLevel;
+  writeQueue = Promise.resolve();
+  constructor(options = {}) {
+    this.maxErrors = options.maxErrors ?? 1000;
+    this.enableFileLogging = options.enableFileLogging ?? !1;
+    this.logFilePath = options.logFilePath ?? ".stx/errors.log";
+    this.logFormat = options.logFormat ?? "json";
+    this.maxFileSize = options.maxFileSize ?? 10485760;
+    this.maxLogFiles = options.maxLogFiles ?? 5;
+    this.minLevel = options.minLevel ?? "all";
+  }
+  configure(options) {
+    if (options.maxErrors !== void 0)
+      this.maxErrors = options.maxErrors;
+    if (options.enableFileLogging !== void 0)
+      this.enableFileLogging = options.enableFileLogging;
+    if (options.logFilePath !== void 0)
+      this.logFilePath = options.logFilePath;
+    if (options.logFormat !== void 0)
+      this.logFormat = options.logFormat;
+    if (options.maxFileSize !== void 0)
+      this.maxFileSize = options.maxFileSize;
+    if (options.maxLogFiles !== void 0)
+      this.maxLogFiles = options.maxLogFiles;
+    if (options.minLevel !== void 0)
+      this.minLevel = options.minLevel;
+  }
+  log(error, context, level = "error") {
+    const entry = {
+      timestamp: new Date,
+      error,
+      context,
+      level
+    };
+    this.errors.push(entry);
+    if (this.errors.length > this.maxErrors)
+      this.errors = this.errors.slice(-this.maxErrors);
+    if (this.enableFileLogging && this.shouldLog(level))
+      this.writeToFile(entry);
+  }
+  shouldLog(level) {
+    if (this.minLevel === "all")
+      return !0;
+    if (this.minLevel === "warning")
+      return level === "error" || level === "warning";
+    if (this.minLevel === "error")
+      return level === "error";
+    return !0;
+  }
+  formatEntry(entry) {
+    if (this.logFormat === "json")
+      return JSON.stringify({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level || "error",
+        type: entry.error.constructor.name,
+        message: entry.error.message,
+        stack: entry.error.stack,
+        context: entry.context
+      });
+    const lines = [
+      `[${entry.timestamp.toISOString()}] [${(entry.level || "error").toUpperCase()}] ${entry.error.constructor.name}: ${entry.error.message}`
+    ];
+    if (entry.error.stack)
+      lines.push(`  Stack: ${entry.error.stack.split(`
+`).slice(1).join(`
+  `)}`);
+    if (entry.context)
+      lines.push(`  Context: ${JSON.stringify(entry.context)}`);
+    return lines.join(`
+`);
+  }
+  writeToFile(entry) {
+    this.writeQueue = this.writeQueue.then(async () => {
+      try {
+        const fs = await import("node:fs"), dir = (await import("node:path")).dirname(this.logFilePath);
+        if (!fs.existsSync(dir))
+          fs.mkdirSync(dir, { recursive: !0 });
+        await this.rotateIfNeeded(fs);
+        const logLine = `${this.formatEntry(entry)}
+`;
+        fs.appendFileSync(this.logFilePath, logLine, "utf-8");
+      } catch (err) {
+        if (process.env.STX_DEBUG === "true")
+          console.error("Failed to write to error log:", err);
+      }
+    });
+  }
+  async rotateIfNeeded(fs) {
+    try {
+      if (!fs.existsSync(this.logFilePath))
+        return;
+      if (fs.statSync(this.logFilePath).size < this.maxFileSize)
+        return;
+      for (let i = this.maxLogFiles - 1;i >= 1; i--) {
+        const oldPath = `${this.logFilePath}.${i}`, newPath = `${this.logFilePath}.${i + 1}`;
+        if (fs.existsSync(oldPath))
+          if (i >= this.maxLogFiles - 1)
+            fs.unlinkSync(oldPath);
+          else
+            fs.renameSync(oldPath, newPath);
+      }
+      if (this.maxLogFiles <= 1)
+        fs.writeFileSync(this.logFilePath, "");
+      else
+        fs.renameSync(this.logFilePath, `${this.logFilePath}.1`);
+    } catch (err) {
+      if (process.env.STX_DEBUG === "true")
+        console.error("Failed to rotate error logs:", err);
+    }
+  }
+  getRecentErrors(limit = 10) {
+    return this.errors.slice(-limit);
+  }
+  getErrorsByType(errorType) {
+    return this.errors.filter((item) => item.error.constructor.name === errorType);
+  }
+  getErrorsByLevel(level) {
+    return this.errors.filter((item) => item.level === level);
+  }
+  clear() {
+    this.errors.length = 0;
+  }
+  async clearLogFile() {
+    try {
+      const fs = await import("node:fs");
+      if (fs.existsSync(this.logFilePath))
+        fs.writeFileSync(this.logFilePath, "", "utf-8");
+    } catch (err) {
+      if (process.env.STX_DEBUG === "true")
+        console.error("Failed to clear error log:", err);
+    }
+  }
+  getStats() {
+    const byType = {}, byLevel = { error: 0, warning: 0, info: 0 };
+    for (const item of this.errors) {
+      const type = item.error.constructor.name;
+      byType[type] = (byType[type] || 0) + 1;
+      const level = item.level || "error";
+      byLevel[level] = (byLevel[level] || 0) + 1;
+    }
+    return {
+      total: this.errors.length,
+      byType,
+      byLevel
+    };
+  }
+  async exportToFile(filePath, format = "json") {
+    const fs = await import("node:fs"), dir = (await import("node:path")).dirname(filePath);
+    if (!fs.existsSync(dir))
+      fs.mkdirSync(dir, { recursive: !0 });
+    if (format === "json") {
+      const data = this.errors.map((entry) => ({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level || "error",
+        type: entry.error.constructor.name,
+        message: entry.error.message,
+        stack: entry.error.stack,
+        context: entry.context
+      }));
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    } else {
+      const lines = this.errors.map((entry) => this.formatEntry(entry));
+      fs.writeFileSync(filePath, lines.join(`
+
+`), "utf-8");
+    }
+  }
+  async flush() {
+    await this.writeQueue;
+  }
+}
+export const errorLogger = new ErrorLogger, devHelpers = {
+  isDevelopment() {
+    return isDevelopment();
+  },
+  logDetailedError(error, context) {
+    if (!this.isDevelopment())
+      return;
+    console.error("=== stx Detailed Error ===");
+    console.error("Error:", error.message);
+    console.error("Stack:", error.stack);
+    if (context)
+      console.error("Context:", context);
+    console.error("========================");
+  },
+  createErrorReport(error, context) {
+    const report = [
+      "=== stx Error Report ===",
+      `Time: ${new Date().toISOString()}`,
+      `Error: ${error.message}`,
+      `Type: ${error.constructor.name}`,
+      `Stack: ${error.stack}`
+    ];
+    if (context)
+      report.push(`Context: ${JSON.stringify(context, null, 2)}`);
+    report.push("========================");
+    return report.join(`
+`);
+  }
+};