devflare 1.0.0-next.16 → 1.0.0-next.17

package/dist/{index-43dq8yx8.js → index-ngbzr9gz.js}

@@ -4,10 +4,10 @@ import {
   listD1Databases,
   listHyperdrives,
   listKVNamespaces
-} from "./index-xk9djfjp.js";
+} from "./index-3egad6wm.js";
 import {
   materializePreviewScopedConfig
-} from "./index-6jef5emv.js";
+} from "./index-p296ban8.js";
 
 // src/config/schema-bindings.ts
 import { z } from "zod";
@@ -195,6 +195,12 @@ function getLocalHyperdriveConfigIdentifier(config) {
 // src/config/schema.ts
 import { z as z5 } from "zod";
 
+// src/config/compatibility.ts
+var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
+function normalizeCompatibilityFlags(flags = []) {
+  return [...new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags])];
+}
+
 // src/config/schema-build.ts
 import { z as z2 } from "zod";
 var rolldownOptionsSchema = z2.custom((value) => {
@@ -213,113 +219,89 @@ var viteConfigSchema = z2.object({
 }).catchall(z2.unknown()).optional();
 
 // src/config/schema-env.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
+var envConfigSchema = z3.lazy(() => z3.object(rootConfigShape).omit({ accountId: true, wsRoutes: true }).partial().strict());
+var envConfigSchemaInner = envConfigSchema;
 
 // src/config/schema-runtime.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-var compatibilityDateSchema = z3.string().regex(dateRegex, {
+var compatibilityDateSchema = z4.string().regex(dateRegex, {
   message: "Compatibility date must be in YYYY-MM-DD format"
 });
-var routesConfigSchema = z3.object({
-  dir: z3.string(),
-  prefix: z3.string().optional()
+var routesConfigSchema = z4.object({
+  dir: z4.string(),
+  prefix: z4.string().optional()
 });
-var filesSchema = z3.object({
-  fetch: z3.union([z3.string(), z3.literal(false)]).optional(),
-  queue: z3.union([z3.string(), z3.literal(false)]).optional(),
-  scheduled: z3.union([z3.string(), z3.literal(false)]).optional(),
-  email: z3.union([z3.string(), z3.literal(false)]).optional(),
-  durableObjects: z3.union([z3.string(), z3.literal(false)]).optional(),
-  entrypoints: z3.union([z3.string(), z3.literal(false)]).optional(),
-  workflows: z3.union([z3.string(), z3.literal(false)]).optional(),
-  routes: z3.union([routesConfigSchema, z3.literal(false)]).optional(),
-  transport: z3.union([z3.string(), z3.null()]).optional()
+var filesSchema = z4.object({
+  fetch: z4.union([z4.string(), z4.literal(false)]).optional(),
+  queue: z4.union([z4.string(), z4.literal(false)]).optional(),
+  scheduled: z4.union([z4.string(), z4.literal(false)]).optional(),
+  email: z4.union([z4.string(), z4.literal(false)]).optional(),
+  durableObjects: z4.union([z4.string(), z4.literal(false)]).optional(),
+  entrypoints: z4.union([z4.string(), z4.literal(false)]).optional(),
+  workflows: z4.union([z4.string(), z4.literal(false)]).optional(),
+  routes: z4.union([routesConfigSchema, z4.literal(false)]).optional(),
+  transport: z4.union([z4.string(), z4.null()]).optional()
 }).optional();
-var triggersSchema = z3.object({
-  crons: z3.array(z3.string()).optional()
+var triggersSchema = z4.object({
+  crons: z4.array(z4.string()).optional()
 }).optional();
-var previewsConfigSchema = z3.object({
-  includeCrons: z3.boolean().optional().default(false)
+var previewsConfigSchema = z4.object({
+  includeCrons: z4.boolean().optional().default(false)
 }).optional();
-var secretConfigSchema = z3.object({
-  required: z3.boolean().optional().default(true)
+var secretConfigSchema = z4.object({
+  required: z4.boolean().optional().default(true)
 });
-var routeConfigSchema = z3.object({
-  pattern: z3.string(),
-  zone_name: z3.string().optional(),
-  zone_id: z3.string().optional(),
-  custom_domain: z3.boolean().optional()
+var routeConfigSchema = z4.object({
+  pattern: z4.string(),
+  zone_name: z4.string().optional(),
+  zone_id: z4.string().optional(),
+  custom_domain: z4.boolean().optional()
 });
-var wsRouteConfigSchema = z3.object({
-  pattern: z3.string(),
-  doNamespace: z3.string(),
-  idParam: z3.string().default("id"),
-  forwardPath: z3.string().default("/websocket")
+var wsRouteConfigSchema = z4.object({
+  pattern: z4.string(),
+  doNamespace: z4.string(),
+  idParam: z4.string().default("id"),
+  forwardPath: z4.string().default("/websocket")
 });
-var assetsConfigSchema = z3.object({
-  directory: z3.string(),
-  binding: z3.string().optional()
+var assetsConfigSchema = z4.object({
+  directory: z4.string(),
+  binding: z4.string().optional()
 }).optional();
-var observabilitySchema = z3.object({
-  enabled: z3.boolean().optional(),
-  head_sampling_rate: z3.number().min(0).max(1).optional()
+var observabilitySchema = z4.object({
+  enabled: z4.boolean().optional(),
+  head_sampling_rate: z4.number().min(0).max(1).optional()
 }).optional();
-var limitsSchema = z3.object({
-  cpu_ms: z3.number().optional()
+var limitsSchema = z4.object({
+  cpu_ms: z4.number().optional()
 }).optional();
-var migrationSchema = z3.object({
-  tag: z3.string(),
-  new_classes: z3.array(z3.string()).optional(),
-  renamed_classes: z3.array(z3.object({
-    from: z3.string(),
-    to: z3.string()
+var migrationSchema = z4.object({
+  tag: z4.string(),
+  new_classes: z4.array(z4.string()).optional(),
+  renamed_classes: z4.array(z4.object({
+    from: z4.string(),
+    to: z4.string()
   })).optional(),
-  deleted_classes: z3.array(z3.string()).optional(),
-  new_sqlite_classes: z3.array(z3.string()).optional()
+  deleted_classes: z4.array(z4.string()).optional(),
+  new_sqlite_classes: z4.array(z4.string()).optional()
 });
-var wranglerConfigSchema = z3.object({
-  passthrough: z3.record(z3.string(), z3.unknown()).optional()
+var wranglerConfigSchema = z4.object({
+  passthrough: z4.record(z4.string(), z4.unknown()).optional()
 }).optional();
 
-// src/config/schema-env.ts
-var envConfigSchema = z4.object({
-  name: z4.string().optional(),
-  compatibilityDate: compatibilityDateSchema.optional(),
-  compatibilityFlags: z4.array(z4.string()).optional(),
-  previews: previewsConfigSchema,
-  files: filesSchema,
-  bindings: bindingsSchema,
-  triggers: triggersSchema,
-  vars: z4.record(z4.string(), z4.string()).optional(),
-  secrets: z4.record(z4.string(), secretConfigSchema).optional(),
-  routes: z4.array(routeConfigSchema).optional(),
-  assets: assetsConfigSchema,
-  limits: limitsSchema,
-  observability: observabilitySchema,
-  migrations: z4.array(migrationSchema).optional(),
-  rolldown: rolldownConfigSchema,
-  vite: viteConfigSchema,
-  wrangler: wranglerConfigSchema
-}).partial().strict();
-var envConfigSchemaInner = envConfigSchema;
-
 // src/config/schema.ts
 function getCurrentDate() {
   const now = new Date;
   return now.toISOString().split("T")[0];
 }
-var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
-var canonicalConfigSchema = z5.object({
+var rootConfigShape = {
   name: z5.string({
     required_error: "Worker name is required"
   }),
   accountId: z5.string().optional(),
   compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
-  compatibilityFlags: z5.array(z5.string()).optional().transform((flags = []) => {
-    const merged = new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags]);
-    return [...merged];
-  }),
+  compatibilityFlags: z5.array(z5.string()).optional().transform((flags = []) => normalizeCompatibilityFlags(flags)),
   previews: previewsConfigSchema,
   files: filesSchema,
   bindings: bindingsSchema,
@@ -334,11 +316,58 @@ var canonicalConfigSchema = z5.object({
   migrations: z5.array(migrationSchema).optional(),
   rolldown: rolldownConfigSchema,
   vite: viteConfigSchema,
-  env: z5.record(z5.string(), envConfigSchemaInner).optional(),
   wrangler: wranglerConfigSchema
+};
+var canonicalConfigSchema = z5.object({
+  ...rootConfigShape,
+  env: z5.record(z5.string(), envConfigSchemaInner).optional()
 });
 var configSchema = canonicalConfigSchema.strict();
 
+// src/config/resolve.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function mergeEnvironmentValue(base, override) {
+  if (override === undefined) {
+    return base;
+  }
+  if (Array.isArray(override)) {
+    return [...override];
+  }
+  if (isPlainObject(override)) {
+    const baseObject = isPlainObject(base) ? base : {};
+    const mergedObject = {
+      ...baseObject
+    };
+    for (const [key, value] of Object.entries(override)) {
+      mergedObject[key] = mergeEnvironmentValue(baseObject[key], value);
+    }
+    return mergedObject;
+  }
+  return override;
+}
+function mergeConfigForEnvironment(config, environment) {
+  if (!environment || !config.env?.[environment]) {
+    return config;
+  }
+  const mergedConfig = mergeEnvironmentValue(config, config.env[environment]);
+  return {
+    ...mergedConfig,
+    compatibilityFlags: normalizeCompatibilityFlags(mergedConfig.compatibilityFlags)
+  };
+}
+function resolveConfigForEnvironment(config, environment) {
+  const mergedConfig = mergeConfigForEnvironment(config, environment);
+  return materializePreviewScopedConfig(mergedConfig, {
+    environment
+  });
+}
+
 // src/config/loader.ts
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -571,18 +600,6 @@ ${issueMessages}`);
   }
 }
 
-// src/config/resolve.ts
-import { defu } from "defu";
-function mergeConfigForEnvironment(config, environment) {
-  return environment && config.env?.[environment] ? defu(config.env[environment], config) : config;
-}
-function resolveConfigForEnvironment(config, environment) {
-  const mergedConfig = mergeConfigForEnvironment(config, environment);
-  return materializePreviewScopedConfig(mergedConfig, {
-    environment
-  });
-}
-
 // src/config/resource-resolution.ts
 var defaultCloudflareApi = {
   getPrimaryAccount,
@@ -785,4 +802,4 @@ async function loadResolvedConfig(options = {}) {
   return resolveConfigResources(config, options);
 }
 
-export { getSingleBrowserBindingName, normalizeDOBinding, normalizeD1Binding, normalizeKVBinding, normalizeHyperdriveBinding, getLocalKVNamespaceIdentifier, getLocalD1DatabaseIdentifier, configSchema, mergeConfigForEnvironment, resolveConfigForEnvironment, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveMaterializedConfigResources, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };
+export { getSingleBrowserBindingName, normalizeDOBinding, normalizeD1Binding, normalizeKVBinding, normalizeHyperdriveBinding, getLocalKVNamespaceIdentifier, getLocalD1DatabaseIdentifier, getLocalHyperdriveConfigIdentifier, configSchema, mergeConfigForEnvironment, resolveConfigForEnvironment, ConfigResourceResolutionError, resolveConfigForLocalRuntime, resolveConfigResources, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };

package/dist/index-nh90nk7j.js

@@ -0,0 +1,380 @@
+import {
+  wrapEnvSendEmailBindings
+} from "./index-124e9t4t.js";
+
+// src/runtime/validation.ts
+class ContextAccessError extends Error {
+  contextName;
+  propertyName;
+  constructor(contextName, propertyName) {
+    super(`Cannot access ${contextName}.${propertyName} outside of an active Devflare handler trail.
+
+` + `This typically happens when:
+` + `  1. Accessing ${contextName} at module top-level (during import)
+` + `  2. Accessing ${contextName} in a callback that runs after the handler ends
+` + `  3. Accessing ${contextName} in a setTimeout/setInterval callback
+
+` + `Move the access inside your handler function or middleware.`);
+    this.name = "ContextAccessError";
+    this.contextName = contextName;
+    this.propertyName = propertyName;
+  }
+}
+function createContextProxy(getter, name) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      return ctx[prop];
+    },
+    set(_target, prop, value) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      ctx[prop] = value;
+      return true;
+    },
+    has(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return false;
+      }
+      return prop in ctx;
+    },
+    ownKeys(_target) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return [];
+      }
+      return Reflect.ownKeys(ctx);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return;
+      }
+      return Reflect.getOwnPropertyDescriptor(ctx, prop);
+    }
+  });
+}
+
+// src/runtime/context-events.ts
+function createLocals(locals) {
+  return locals ?? {};
+}
+function prepareEventShell(env, options = {}) {
+  return {
+    env: wrapEnvSendEmailBindings(env),
+    locals: createLocals(options.locals)
+  };
+}
+function createAugmentedTarget(target, extra) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop in extra) {
+        return extra[prop];
+      }
+      const value = Reflect.get(target2, prop, target2);
+      return typeof value === "function" ? value.bind(target2) : value;
+    },
+    has(target2, prop) {
+      return prop in extra || prop in target2;
+    },
+    ownKeys(target2) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target2),
+        ...Reflect.ownKeys(extra)
+      ]));
+    },
+    getOwnPropertyDescriptor(target2, prop) {
+      if (prop in extra) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: extra[prop]
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(target2, prop);
+    }
+  });
+}
+function createBaseEvent(type, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return {
+    type,
+    ctx,
+    ...shell,
+    request: options.request ?? null,
+    params: options.params
+  };
+}
+function createFetchEvent(request, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "fetch",
+    ctx,
+    ...shell,
+    url: new URL(request.url),
+    request,
+    params: options.params ?? {}
+  });
+}
+function createQueueEvent(batch, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(batch, {
+    type: "queue",
+    ctx,
+    ...shell,
+    batch
+  });
+}
+function createScheduledEvent(controller, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(controller, {
+    type: "scheduled",
+    ctx,
+    ...shell,
+    controller
+  });
+}
+function createEmailEvent(message, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(message, {
+    type: "email",
+    ctx,
+    ...shell,
+    message
+  });
+}
+function createTailEvent(events, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(events, {
+    type: "tail",
+    ctx,
+    ...shell,
+    events
+  });
+}
+function createDurableObjectFetchEvent(request, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "durable-object-fetch",
+    ctx: state,
+    state,
+    ...shell,
+    request
+  });
+}
+function createDurableObjectAlarmEvent(env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return {
+    type: "durable-object-alarm",
+    ctx: state,
+    state,
+    ...shell
+  };
+}
+function createDurableObjectWebSocketMessageEvent(ws, message, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-message",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    message
+  });
+}
+function createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-close",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    code,
+    reason,
+    wasClean
+  });
+}
+function createDurableObjectWebSocketErrorEvent(ws, error, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-error",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    error
+  });
+}
+function createDefaultEvent(env, ctx, request, type, locals) {
+  switch (type) {
+    case "fetch": {
+      if (request && ctx) {
+        return createFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
+    }
+    case "durable-object-fetch": {
+      if (request && ctx) {
+        return createDurableObjectFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
+    }
+    case "durable-object-alarm": {
+      if (ctx) {
+        return createDurableObjectAlarmEvent(env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals });
+    }
+    case "queue":
+    case "scheduled":
+    case "email":
+    case "tail":
+    case "durable-object-websocket-message":
+    case "durable-object-websocket-close":
+    case "durable-object-websocket-error":
+      return createBaseEvent(type, env, ctx, { locals, request });
+    default: {
+      const exhaustive = type;
+      throw new Error(`createDefaultEvent: unknown event type ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/runtime/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function createLocals2() {
+  return {};
+}
+function runWithContext(env, ctx, request, fn, type = "fetch") {
+  const locals = createLocals2();
+  const event = createDefaultEvent(env, ctx, request, type, locals);
+  return runWithEventContext(event, fn);
+}
+function runWithEventContext(event, fn) {
+  const context = {
+    env: event.env,
+    ctx: event.ctx,
+    request: event.request ?? null,
+    locals: event.locals,
+    type: event.type,
+    event
+  };
+  return storage.run(context, fn);
+}
+function getContext() {
+  const context = storage.getStore();
+  if (!context) {
+    throw new ContextUnavailableError;
+  }
+  return context;
+}
+function getContextOrNull() {
+  const context = storage.getStore();
+  return context ?? null;
+}
+function getEventContext() {
+  return getContext().event;
+}
+function getEventContextOrNull() {
+  return getContextOrNull()?.event ?? null;
+}
+function hasContext() {
+  return storage.getStore() !== undefined;
+}
+function createEventAccessor(name, matcher) {
+  const accessor = () => {
+    const currentEvent = getEventContextOrNull();
+    if (!currentEvent) {
+      throw new ContextUnavailableError;
+    }
+    if (!matcher(currentEvent)) {
+      throw new ContextUnavailableError(`${name} is not available in the current '${currentEvent.type}' context.
+
+Devflare stores event objects in AsyncLocalStorage so helpers called within a handler can reach the active event.
+Use ${name}.safe() to return null instead of throwing, or call the getter that matches the active surface.`);
+    }
+    return currentEvent;
+  };
+  accessor.safe = () => {
+    const currentEvent = getEventContextOrNull();
+    return currentEvent && matcher(currentEvent) ? currentEvent : null;
+  };
+  return accessor;
+}
+function isFetchEvent(event) {
+  return event.type === "fetch" && event.request instanceof Request;
+}
+function isQueueEvent(event) {
+  return event.type === "queue" && "batch" in event;
+}
+function isScheduledEvent(event) {
+  return event.type === "scheduled" && "controller" in event;
+}
+function isEmailEvent(event) {
+  return event.type === "email" && "message" in event;
+}
+function isTailEvent(event) {
+  return event.type === "tail" && Array.isArray(event) && "events" in event;
+}
+function isDurableObjectEvent(event) {
+  return event.type.startsWith("durable-object-") && "state" in event;
+}
+function isDurableObjectFetchEvent(event) {
+  return event.type === "durable-object-fetch" && event.request instanceof Request;
+}
+function isDurableObjectAlarmEvent(event) {
+  return event.type === "durable-object-alarm" && "state" in event;
+}
+function isDurableObjectWebSocketMessageEvent(event) {
+  return event.type === "durable-object-websocket-message" && "ws" in event && "message" in event;
+}
+function isDurableObjectWebSocketCloseEvent(event) {
+  return event.type === "durable-object-websocket-close" && "ws" in event && "code" in event;
+}
+function isDurableObjectWebSocketErrorEvent(event) {
+  return event.type === "durable-object-websocket-error" && "ws" in event && "error" in event;
+}
+var getFetchEvent = createEventAccessor("getFetchEvent()", isFetchEvent);
+var getQueueEvent = createEventAccessor("getQueueEvent()", isQueueEvent);
+var getScheduledEvent = createEventAccessor("getScheduledEvent()", isScheduledEvent);
+var getEmailEvent = createEventAccessor("getEmailEvent()", isEmailEvent);
+var getTailEvent = createEventAccessor("getTailEvent()", isTailEvent);
+var getDurableObjectEvent = createEventAccessor("getDurableObjectEvent()", isDurableObjectEvent);
+var getDurableObjectFetchEvent = createEventAccessor("getDurableObjectFetchEvent()", isDurableObjectFetchEvent);
+var getDurableObjectAlarmEvent = createEventAccessor("getDurableObjectAlarmEvent()", isDurableObjectAlarmEvent);
+var getDurableObjectWebSocketMessageEvent = createEventAccessor("getDurableObjectWebSocketMessageEvent()", isDurableObjectWebSocketMessageEvent);
+var getDurableObjectWebSocketCloseEvent = createEventAccessor("getDurableObjectWebSocketCloseEvent()", isDurableObjectWebSocketCloseEvent);
+var getDurableObjectWebSocketErrorEvent = createEventAccessor("getDurableObjectWebSocketErrorEvent()", isDurableObjectWebSocketErrorEvent);
+
+class ContextUnavailableError extends ContextAccessError {
+  code = "CONTEXT_UNAVAILABLE";
+  constructor(message) {
+    super("context", "<unavailable>");
+    if (message !== undefined) {
+      this.message = message;
+    } else {
+      this.message = `Context not available. Devflare uses AsyncLocalStorage to carry the active event through fetch, queue, scheduled, email, tail, and Durable Object handler call chains.
+
+` + `This usually means one of:
+
+` + `1. Accessing context at module top-level (runs at cold start, not per-request)
+` + `2. Accessing context in setTimeout/setInterval callbacks
+` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
+
+` + `Fix: Move the access inside your handler, middleware, or a helper called from that handler trail.
+` + `Learn more: https://devflare.dev/docs/context-errors`;
+    }
+    this.name = "ContextUnavailableError";
+  }
+}
+
+export { ContextAccessError, createContextProxy, createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, hasContext, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, ContextUnavailableError };