@stacksjs/stx 0.2.94 → 0.2.96

package/dist/edge-runtime.js

@@ -1,2 +1,539 @@
-// @bun
-import{An as l,Bn as m,Cn as n,Dn as o,En as p,Fn as q,Gn as r,Hn as s,pn as a,qn as b,rn as c,sn as d,tn as e,un as f,vn as g,wn as h,xn as i,yn as j,zn as k}from"./chunk-b3kkjcdh.js";import"./chunk-3jm3snz8.js";export{j as stringToStream,r as redirect,o as parseCookies,s as notFound,q as jsonResponse,c as isServerEnvironment,b as isEdgeEnvironment,a as detectRuntime,m as createVercelHandler,i as createTextEncoderStream,h as createStreamingResponse,n as createNetlifyHandler,e as createKVNamespace,d as createEnvAccessor,g as createEdgeHandler,f as createEdgeCache,l as createDenoHandler,p as createCookie,k as createCloudflareHandler};
+import nodeProcess from "node:process";
+export function detectRuntime() {
+  if (typeof globalThis < "u" && "caches" in globalThis && "CF" in globalThis)
+    return {
+      platform: "cloudflare",
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !0,
+      supportsCache: !0,
+      capabilities: ["kv", "r2", "d1", "durable-objects", "queues"]
+    };
+  if (typeof globalThis < "u" && "Deno" in globalThis)
+    return {
+      platform: "deno",
+      version: globalThis.Deno.version?.deno,
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !0,
+      supportsCache: !0,
+      capabilities: ["kv", "deploy", "ffi"]
+    };
+  if (typeof globalThis < "u" && "Bun" in globalThis)
+    return {
+      platform: "bun",
+      version: globalThis.Bun.version,
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !1,
+      supportsCache: !1,
+      capabilities: ["sqlite", "ffi", "native-modules"]
+    };
+  if (typeof globalThis < "u" && "EdgeRuntime" in globalThis)
+    return {
+      platform: "vercel",
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !0,
+      supportsCache: !0,
+      capabilities: ["edge-config", "blob"]
+    };
+  if (typeof globalThis < "u" && "Netlify" in globalThis)
+    return {
+      platform: "netlify",
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !0,
+      supportsCache: !1,
+      capabilities: ["blobs", "edge-functions"]
+    };
+  if (typeof globalThis < "u" && "fastly" in globalThis)
+    return {
+      platform: "fastly",
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !0,
+      supportsCache: !0,
+      capabilities: ["dictionary", "backend", "geolocation"]
+    };
+  if (nodeProcess.versions?.node)
+    return {
+      platform: "node",
+      version: nodeProcess.versions.node,
+      supportsStreaming: !0,
+      supportsCrypto: !0,
+      supportsKV: !1,
+      supportsCache: !1,
+      capabilities: ["fs", "child-process", "native-modules"]
+    };
+  return {
+    platform: "unknown",
+    supportsStreaming: !1,
+    supportsCrypto: !1,
+    supportsKV: !1,
+    supportsCache: !1,
+    capabilities: []
+  };
+}
+export function isEdgeEnvironment() {
+  const runtime = detectRuntime();
+  return ["cloudflare", "deno", "vercel", "netlify", "fastly"].includes(runtime.platform);
+}
+export function isServerEnvironment() {
+  return detectRuntime().platform !== "unknown";
+}
+export function createEnvAccessor(platformEnv) {
+  return {
+    get(key) {
+      if (platformEnv && key in platformEnv) {
+        const value = platformEnv[key];
+        return typeof value === "string" ? value : void 0;
+      }
+      if (typeof globalThis < "u" && "Deno" in globalThis)
+        return globalThis.Deno.env.get(key);
+      if (nodeProcess.env)
+        return nodeProcess.env[key];
+      return;
+    },
+    getOrThrow(key) {
+      const value = this.get(key);
+      if (value === void 0)
+        throw Error(`Environment variable "${key}" is not set`);
+      return value;
+    },
+    has(key) {
+      return this.get(key) !== void 0;
+    },
+    all() {
+      const result = {};
+      if (platformEnv) {
+        for (const [key, value] of Object.entries(platformEnv))
+          if (typeof value === "string")
+            result[key] = value;
+      }
+      if (typeof globalThis < "u" && "Deno" in globalThis) {
+        const denoEnv = globalThis.Deno.env.toObject();
+        Object.assign(result, denoEnv);
+      }
+      if (nodeProcess.env) {
+        for (const [key, value] of Object.entries(nodeProcess.env))
+          if (value !== void 0)
+            result[key] = value;
+      }
+      return result;
+    }
+  };
+}
+export function createKVNamespace(platformKV) {
+  const runtime = detectRuntime();
+  if (runtime.platform === "cloudflare" && platformKV)
+    return platformKV;
+  if (runtime.platform === "deno" && "Deno" in globalThis)
+    return createDenoKVAdapter();
+  if (runtime.platform === "node" || runtime.platform === "bun")
+    return createInMemoryKV();
+  return;
+}
+function createDenoKVAdapter() {
+  let kvInstance = null;
+  const getKV = async () => {
+    if (!kvInstance)
+      kvInstance = await globalThis.Deno.openKv();
+    return kvInstance;
+  };
+  return {
+    async get(key) {
+      return (await (await getKV()).get(["stx", key])).value;
+    },
+    async getWithMetadata(key) {
+      const kv = await getKV(), result = await kv.get(["stx", key]), metaResult = await kv.get(["stx-meta", key]);
+      return {
+        value: result.value,
+        metadata: metaResult.value
+      };
+    },
+    async put(key, value, options) {
+      const kv = await getKV(), expireIn = options?.expirationTtl ? options.expirationTtl * 1000 : void 0;
+      await kv.set(["stx", key], value, expireIn ? { expireIn } : void 0);
+      if (options?.metadata)
+        await kv.set(["stx-meta", key], options.metadata, expireIn ? { expireIn } : void 0);
+    },
+    async delete(key) {
+      const kv = await getKV();
+      await kv.delete(["stx", key]);
+      await kv.delete(["stx-meta", key]);
+    },
+    async list(options) {
+      const kv = await getKV(), prefix = options?.prefix ? ["stx", options.prefix] : ["stx"], iter = kv.list({ prefix, limit: options?.limit || 100 }), keys = [];
+      for await (const entry of iter) {
+        const name = entry.key.slice(1).join("/");
+        if (!name.startsWith("stx-meta/"))
+          keys.push({ name });
+      }
+      return { keys, list_complete: !0 };
+    }
+  };
+}
+function createInMemoryKV() {
+  const store = new Map, cleanup = () => {
+    const now = Date.now();
+    for (const [key, data] of store.entries())
+      if (data.expiration && data.expiration < now)
+        store.delete(key);
+  };
+  return {
+    async get(key) {
+      cleanup();
+      const data = store.get(key);
+      if (!data)
+        return null;
+      if (data.expiration && data.expiration < Date.now()) {
+        store.delete(key);
+        return null;
+      }
+      return data.value;
+    },
+    async getWithMetadata(key) {
+      cleanup();
+      const data = store.get(key);
+      if (!data)
+        return { value: null, metadata: null };
+      if (data.expiration && data.expiration < Date.now()) {
+        store.delete(key);
+        return { value: null, metadata: null };
+      }
+      return { value: data.value, metadata: data.metadata || null };
+    },
+    async put(key, value, options) {
+      const expiration = options?.expiration ? options.expiration * 1000 : options?.expirationTtl ? Date.now() + options.expirationTtl * 1000 : void 0;
+      store.set(key, { value, metadata: options?.metadata, expiration });
+    },
+    async delete(key) {
+      store.delete(key);
+    },
+    async list(options) {
+      cleanup();
+      const keys = [];
+      for (const [name, data] of store.entries()) {
+        if (options?.prefix && !name.startsWith(options.prefix))
+          continue;
+        keys.push({ name, expiration: data.expiration, metadata: data.metadata });
+        if (options?.limit && keys.length >= options.limit)
+          break;
+      }
+      return { keys, list_complete: !0 };
+    }
+  };
+}
+export function createEdgeCache() {
+  const runtime = detectRuntime();
+  if (runtime.platform === "cloudflare" && "caches" in globalThis)
+    return createCacheAPIAdapter();
+  if (runtime.supportsStreaming)
+    return createInMemoryCache();
+  return;
+}
+function createCacheAPIAdapter() {
+  return {
+    async match(request) {
+      return (await caches.default).match(request);
+    },
+    async put(request, response) {
+      await (await caches.default).put(request, response.clone());
+    },
+    async delete(request) {
+      return (await caches.default).delete(request);
+    }
+  };
+}
+function createInMemoryCache() {
+  const cache = new Map, DEFAULT_TTL = 60000;
+  return {
+    async match(request) {
+      const key = request.url, entry = cache.get(key);
+      if (!entry)
+        return;
+      if (Date.now() > entry.expiration) {
+        cache.delete(key);
+        return;
+      }
+      return entry.response.clone();
+    },
+    async put(request, response) {
+      const key = request.url, cacheControl = response.headers.get("Cache-Control");
+      let ttl = DEFAULT_TTL;
+      if (cacheControl) {
+        const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+        if (maxAgeMatch)
+          ttl = Number.parseInt(maxAgeMatch[1], 10) * 1000;
+      }
+      cache.set(key, {
+        response: response.clone(),
+        expiration: Date.now() + ttl
+      });
+    },
+    async delete(request) {
+      return cache.delete(request.url);
+    }
+  };
+}
+function generateRequestId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function extractGeoInfo(request, runtime) {
+  if (runtime.platform === "cloudflare") {
+    const cf = request.cf;
+    if (cf)
+      return {
+        city: cf.city,
+        country: cf.country,
+        countryCode: cf.country,
+        region: cf.region,
+        latitude: cf.latitude ? Number.parseFloat(cf.latitude) : void 0,
+        longitude: cf.longitude ? Number.parseFloat(cf.longitude) : void 0,
+        timezone: cf.timezone
+      };
+  }
+  if (runtime.platform === "vercel") {
+    const geo = {}, city = request.headers.get("x-vercel-ip-city"), country = request.headers.get("x-vercel-ip-country"), region = request.headers.get("x-vercel-ip-country-region"), lat = request.headers.get("x-vercel-ip-latitude"), lng = request.headers.get("x-vercel-ip-longitude");
+    if (city)
+      geo.city = decodeURIComponent(city);
+    if (country)
+      geo.countryCode = country;
+    if (region)
+      geo.region = region;
+    if (lat)
+      geo.latitude = Number.parseFloat(lat);
+    if (lng)
+      geo.longitude = Number.parseFloat(lng);
+    return Object.keys(geo).length > 0 ? geo : void 0;
+  }
+  if (runtime.platform === "netlify") {
+    const geo = {}, city = request.headers.get("x-nf-geo-city"), country = request.headers.get("x-nf-geo-country");
+    if (city)
+      geo.city = city;
+    if (country)
+      geo.countryCode = country;
+    return Object.keys(geo).length > 0 ? geo : void 0;
+  }
+  return;
+}
+function applyCorsHeaders(response, config, origin) {
+  const headers = new Headers(response.headers);
+  if (config.origins === "*")
+    headers.set("Access-Control-Allow-Origin", "*");
+  else if (config.origins && origin && config.origins.includes(origin)) {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.set("Vary", "Origin");
+  }
+  if (config.methods)
+    headers.set("Access-Control-Allow-Methods", config.methods.join(", "));
+  if (config.headers)
+    headers.set("Access-Control-Allow-Headers", config.headers.join(", "));
+  if (config.exposeHeaders)
+    headers.set("Access-Control-Expose-Headers", config.exposeHeaders.join(", "));
+  if (config.credentials)
+    headers.set("Access-Control-Allow-Credentials", "true");
+  if (config.maxAge)
+    headers.set("Access-Control-Max-Age", String(config.maxAge));
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+export function createEdgeHandler(config) {
+  const runtime = detectRuntime();
+  return async (request, platformContext) => {
+    const startTime = performance.now(), requestId = generateRequestId(), context = {
+      runtime,
+      platform: platformContext || {},
+      requestId,
+      geo: extractGeoInfo(request, runtime),
+      timing: {
+        start: startTime,
+        getElapsed: () => performance.now() - startTime
+      },
+      kv: createKVNamespace(platformContext?.KV),
+      cache: createEdgeCache(),
+      env: createEnvAccessor(platformContext?.env)
+    };
+    try {
+      if (request.method === "OPTIONS" && config.cors) {
+        let response = new Response(null, { status: 204 });
+        response = applyCorsHeaders(response, config.cors, request.headers.get("Origin") || void 0);
+        return response;
+      }
+      if (config.cache?.enabled && request.method === "GET" && context.cache) {
+        if (shouldCacheRequest(request, config.cache)) {
+          const cached = await context.cache.match(request);
+          if (cached) {
+            const response = new Response(cached.body, cached);
+            response.headers.set("X-Cache", "HIT");
+            response.headers.set("X-Request-Id", requestId);
+            return config.cors ? applyCorsHeaders(response, config.cors, request.headers.get("Origin") || void 0) : response;
+          }
+        }
+      }
+      let response;
+      if (config.middleware && config.middleware.length > 0)
+        response = await executeMiddleware(request, context, config.middleware, async () => {
+          const result = await config.render(request, context);
+          return typeof result === "string" ? new Response(result, { headers: { "Content-Type": "text/html; charset=utf-8" } }) : result;
+        });
+      else {
+        const result = await config.render(request, context);
+        response = typeof result === "string" ? new Response(result, { headers: { "Content-Type": "text/html; charset=utf-8" } }) : result;
+      }
+      response.headers.set("X-Request-Id", requestId);
+      response.headers.set("X-Response-Time", `${context.timing.getElapsed().toFixed(2)}ms`);
+      if (config.cache?.enabled && request.method === "GET" && context.cache) {
+        if (shouldCacheRequest(request, config.cache) && response.status === 200) {
+          const ttl = config.cache.ttl || 60, cacheResponse = response.clone();
+          cacheResponse.headers.set("Cache-Control", `public, max-age=${ttl}`);
+          await context.cache.put(request, cacheResponse);
+          response.headers.set("X-Cache", "MISS");
+        }
+      }
+      if (config.cors)
+        response = applyCorsHeaders(response, config.cors, request.headers.get("Origin") || void 0);
+      return response;
+    } catch (error) {
+      const err = error instanceof Error ? error : Error(String(error));
+      if (config.onError)
+        return config.onError(err, request);
+      return new Response(`Internal Server Error: ${err.message}`, {
+        status: 500,
+        headers: {
+          "Content-Type": "text/plain",
+          "X-Request-Id": requestId
+        }
+      });
+    }
+  };
+}
+function shouldCacheRequest(request, config) {
+  const path = new URL(request.url).pathname;
+  if (config.excludePaths) {
+    for (const pattern of config.excludePaths)
+      if (pattern.test(path))
+        return !1;
+  }
+  if (config.includePaths) {
+    for (const pattern of config.includePaths)
+      if (pattern.test(path))
+        return !0;
+    return !1;
+  }
+  return !0;
+}
+async function executeMiddleware(request, context, middleware, final) {
+  let index = 0;
+  const next = async () => {
+    if (index >= middleware.length)
+      return final();
+    const mw = middleware[index];
+    index++;
+    return mw(request, context, next);
+  };
+  return next();
+}
+export function createStreamingResponse(stream, options) {
+  const headers = new Headers(options?.headers);
+  headers.set("Content-Type", "text/html; charset=utf-8");
+  headers.set("Transfer-Encoding", "chunked");
+  return new Response(stream, {
+    ...options,
+    headers
+  });
+}
+export function createTextEncoderStream() {
+  const encoder = new TextEncoder;
+  return new TransformStream({
+    transform(chunk, controller) {
+      controller.enqueue(encoder.encode(chunk));
+    }
+  });
+}
+export function stringToStream(strings) {
+  const encoder = new TextEncoder;
+  return new ReadableStream({
+    async start(controller) {
+      for await (const str of strings)
+        controller.enqueue(encoder.encode(str));
+      controller.close();
+    }
+  });
+}
+export function createCloudflareHandler(config) {
+  const handler = createEdgeHandler(config);
+  return {
+    async fetch(request, env, ctx) {
+      return handler(request, { env, ctx, KV: env.KV });
+    }
+  };
+}
+export function createDenoHandler(config) {
+  const handler = createEdgeHandler(config);
+  return (request) => handler(request, {});
+}
+export function createVercelHandler(config) {
+  const handler = createEdgeHandler(config);
+  return (request) => handler(request, {});
+}
+export function createNetlifyHandler(config) {
+  const handler = createEdgeHandler(config);
+  return (request, context) => {
+    return handler(request, { netlifyContext: context });
+  };
+}
+export function parseCookies(request) {
+  const cookieHeader = request.headers.get("Cookie");
+  if (!cookieHeader)
+    return {};
+  const cookies = {};
+  for (const pair of cookieHeader.split(";")) {
+    const [key, value] = pair.split("=").map((s) => s.trim());
+    if (key && value)
+      cookies[key] = decodeURIComponent(value);
+  }
+  return cookies;
+}
+export function createCookie(name, value, options) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options?.maxAge !== void 0)
+    cookie += `; Max-Age=${options.maxAge}`;
+  if (options?.expires)
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options?.path)
+    cookie += `; Path=${options.path}`;
+  if (options?.domain)
+    cookie += `; Domain=${options.domain}`;
+  if (options?.secure)
+    cookie += "; Secure";
+  if (options?.httpOnly)
+    cookie += "; HttpOnly";
+  if (options?.sameSite)
+    cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
+}
+export function jsonResponse(data, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Content-Type", "application/json; charset=utf-8");
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers
+  });
+}
+export function redirect(url, status = 302) {
+  return new Response(null, {
+    status,
+    headers: { Location: url }
+  });
+}
+export function notFound(message = "Not Found") {
+  return new Response(message, {
+    status: 404,
+    headers: { "Content-Type": "text/plain" }
+  });
+}

package/dist/env.js

@@ -1,2 +1,9 @@
-// @bun
-import{Ky as a,Ly as b,My as c}from"./chunk-fch9tk1k.js";import"./chunk-3jm3snz8.js";export{c as isTest,a as isProduction,b as isDevelopment};
+export function isProduction() {
+  return !1;
+}
+export function isDevelopment() {
+  return !isProduction() || process.env.STX_DEBUG === "true";
+}
+export function isTest() {
+  return !1;
+}

package/dist/error-boundaries.js

@@ -1,17 +1,45 @@
-// @bun
-import"./chunk-3jm3snz8.js";var N=0;function P(){return`eb-${++N}-${Date.now().toString(36)}`}function W(q,z={},A){let j=/@errorBoundary(?:\s*\(([^)]*)\))?\s*([\s\S]*?)@fallback\s*([\s\S]*?)@enderrorBoundary/gi;return q.replace(j,(D,F,J,K)=>{let L=P(),M=Q(F||"");return T(L,J.trim(),K.trim(),M)})}function Q(q){let z={},A=/(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|(\w+))/g,j;while((j=A.exec(q))!==null){let D=j[1],F=j[2]||j[3]||j[4];switch(D){case"id":z.id=F;break;case"logErrors":z.logErrors=F==="true";break}}return z}function T(q,z,A,j){let D=j.logErrors!==!1;return`
-<div class="stx-error-boundary" data-boundary-id="${q}" data-has-error="false">
-  <div class="stx-error-boundary-content" data-boundary-content="${q}">
-    ${z}
+let boundaryIdCounter = 0;
+function generateBoundaryId() {
+  return `eb-${++boundaryIdCounter}-${Date.now().toString(36)}`;
+}
+export function processErrorBoundaryDirectives(template, context = {}, _filePath) {
+  const boundaryRegex = /@errorBoundary(?:\s*\(([^)]*)\))?\s*([\s\S]*?)@fallback\s*([\s\S]*?)@enderrorBoundary/gi;
+  return template.replace(boundaryRegex, (_match, optionsStr, content, fallback) => {
+    const boundaryId = generateBoundaryId(), options = parseErrorBoundaryOptions(optionsStr || "");
+    return generateErrorBoundaryHtml(boundaryId, content.trim(), fallback.trim(), options);
+  });
+}
+function parseErrorBoundaryOptions(optionsStr) {
+  const options = {}, keyValueRegex = /(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|(\w+))/g;
+  let match;
+  while ((match = keyValueRegex.exec(optionsStr)) !== null) {
+    const key = match[1], value = match[2] || match[3] || match[4];
+    switch (key) {
+      case "id":
+        options.id = value;
+        break;
+      case "logErrors":
+        options.logErrors = value === "true";
+        break;
+    }
+  }
+  return options;
+}
+function generateErrorBoundaryHtml(boundaryId, content, fallback, options) {
+  const logErrors = options.logErrors !== !1;
+  return `
+<div class="stx-error-boundary" data-boundary-id="${boundaryId}" data-has-error="false">
+  <div class="stx-error-boundary-content" data-boundary-content="${boundaryId}">
+    ${content}
   </div>
-  <div class="stx-error-boundary-fallback" data-boundary-fallback="${q}" style="display: none;">
-    ${A}
+  <div class="stx-error-boundary-fallback" data-boundary-fallback="${boundaryId}" style="display: none;">
+    ${fallback}
   </div>
 </div>
 <script>
 (function() {
-  const boundaryId = '${q}';
-  const logErrors = ${D};
+  const boundaryId = '${boundaryId}';
+  const logErrors = ${logErrors};
   const boundary = document.querySelector('[data-boundary-id="' + boundaryId + '"]');
   const contentEl = document.querySelector('[data-boundary-content="' + boundaryId + '"]');
   const fallbackEl = document.querySelector('[data-boundary-fallback="' + boundaryId + '"]');
@@ -119,7 +147,25 @@ import"./chunk-3jm3snz8.js";var N=0;function P(){return`eb-${++N}-${Date.now().t
   };
 })();
 </script>
-`}async function U(q,z,A){try{return await q()}catch(j){if(A)A(j instanceof Error?j:Error(String(j)));else console.error("[stx:errorBoundary] SSR Error:",j);return z}}function X(q,z={}){let A=z.onError?(j)=>z.onError(j,{timestamp:Date.now(),boundaryId:"ssr"}):void 0;return(j)=>U(j,q,A)}function Y(){return`
+`;
+}
+export async function withErrorBoundary(render, fallback, onError) {
+  try {
+    return await render();
+  } catch (error) {
+    if (onError)
+      onError(error instanceof Error ? error : Error(String(error)));
+    else
+      console.error("[stx:errorBoundary] SSR Error:", error);
+    return fallback;
+  }
+}
+export function createErrorBoundary(fallback, options = {}) {
+  const onError = options.onError ? (error) => options.onError(error, { timestamp: Date.now(), boundaryId: "ssr" }) : void 0;
+  return (render) => withErrorBoundary(render, fallback, onError);
+}
+export function generateErrorBoundaryCSS() {
+  return `
 /* STX Error Boundary Styles */
 .stx-error-boundary {
   position: relative;
@@ -163,7 +209,10 @@ import"./chunk-3jm3snz8.js";var N=0;function P(){return`eb-${++N}-${Date.now().t
     color: #fecaca;
   }
 }
-`}function Z(){return`
+`;
+}
+export function generateErrorBoundaryRuntime() {
+  return `
 // STX Error Boundary Runtime
 (function() {
   if (typeof window === 'undefined') return;
@@ -228,4 +277,5 @@ import"./chunk-3jm3snz8.js";var N=0;function P(){return`eb-${++N}-${Date.now().t
 
   console.log('[stx] Error boundary runtime initialized');
 })();
-`}export{U as withErrorBoundary,W as processErrorBoundaryDirectives,Z as generateErrorBoundaryRuntime,Y as generateErrorBoundaryCSS,X as createErrorBoundary};
+`;
+}

package/dist/error-handling.js

@@ -1,2 +1 @@
-// @bun
-import"./chunk-1zgsgk4b.js";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 * from "./errors/index.js";