devflare 1.0.0-next.4 → 1.0.0-next.40

package/dist/runtime/context.d.ts

@@ -1,46 +1,22 @@
-/**
- * Context shape stored in AsyncLocalStorage
- */
-export interface RequestContext<TEnv = unknown, TLocals = Record<string, unknown>> {
-    env: TEnv;
-    ctx: ExecutionContext | null;
-    request: Request | null;
-    locals: TLocals;
-    type: 'fetch' | 'scheduled' | 'queue' | 'email' | 'tail';
-}
-/**
- * Run a function with context established
- *
- * @param env - Worker environment bindings
- * @param ctx - Execution context (null for DO methods)
- * @param request - Request object (null for non-HTTP handlers)
- * @param fn - Function to execute
- * @param type - Handler type
- * @returns Result of function
- */
-export declare function runWithContext<T, TEnv = unknown>(env: TEnv, ctx: ExecutionContext | null, request: Request | null, fn: () => T, type?: RequestContext['type']): T;
-/**
- * Get the current context
- *
- * @throws {ContextUnavailableError} When called outside of a request context
- * @returns Current context
- */
-export declare function getContext<TEnv = unknown, TLocals = Record<string, unknown>>(): RequestContext<TEnv, TLocals>;
-/**
- * Get the current context, or null if not available
- *
- * @returns Current context or null
- */
-export declare function getContextOrNull<TEnv = unknown, TLocals = Record<string, unknown>>(): RequestContext<TEnv, TLocals> | null;
-/**
- * Check if currently running within a context
- */
+import type { DurableObjectAlarmEvent, DurableObjectEvent, DurableObjectFetchEvent, DurableObjectWebSocketCloseEvent, DurableObjectWebSocketErrorEvent, DurableObjectWebSocketMessageEvent, EmailEvent, EventAccessor, EventContext, FetchEvent, QueueEvent, RequestContext, ScheduledEvent, TailEvent } from './context-types.js';
+export { createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent } from './context-events.js';
+export type { AnyEvent, DurableObjectAlarmEvent, DurableObjectEvent, DurableObjectEventContext, DurableObjectFetchEvent, DurableObjectWebSocketCloseEvent, DurableObjectWebSocketErrorEvent, DurableObjectWebSocketMessageEvent, EmailEvent, EventContext, EventInitOptions, FetchEvent, FetchEventInit, QueueEvent, RequestContext, RuntimeContextValue, RuntimeEventType, ScheduledEvent, TailEvent, WorkerEvent } from './context-types.js';
+export declare function runWithContext<T, TEnv = unknown>(env: TEnv, ctx: ExecutionContext | DurableObjectState | null, request: Request | null, fn: () => T, type?: RequestContext['type']): T;
+export declare function runWithEventContext<T, TEnv = unknown, TLocals extends Record<string, unknown> = Record<string, unknown>>(event: EventContext<TEnv, TLocals>, fn: () => T): T;
+export declare function getContext<TEnv = unknown, TLocals extends Record<string, unknown> = Record<string, unknown>>(): RequestContext<TEnv, TLocals>;
+export declare function getContextOrNull<TEnv = unknown, TLocals extends Record<string, unknown> = Record<string, unknown>>(): RequestContext<TEnv, TLocals> | null;
+export declare function getEventContext<TEnv = unknown, TLocals extends Record<string, unknown> = Record<string, unknown>>(): EventContext<TEnv, TLocals>;
+export declare function getEventContextOrNull<TEnv = unknown, TLocals extends Record<string, unknown> = Record<string, unknown>>(): EventContext<TEnv, TLocals> | null;
 export declare function hasContext(): boolean;
-/**
- * Error thrown when context is accessed outside of a request handler
- */
-export declare class ContextUnavailableError extends Error {
-    readonly code = "CONTEXT_UNAVAILABLE";
-    constructor();
-}
+export declare const getFetchEvent: EventAccessor<FetchEvent>;
+export declare const getQueueEvent: EventAccessor<QueueEvent<unknown, unknown, Record<string, unknown>>>;
+export declare const getScheduledEvent: EventAccessor<ScheduledEvent<unknown, Record<string, unknown>>>;
+export declare const getEmailEvent: EventAccessor<EmailEvent<unknown, Record<string, unknown>>>;
+export declare const getTailEvent: EventAccessor<TailEvent<unknown, Record<string, unknown>>>;
+export declare const getDurableObjectEvent: EventAccessor<DurableObjectEvent>;
+export declare const getDurableObjectFetchEvent: EventAccessor<DurableObjectFetchEvent<unknown, Record<string, unknown>>>;
+export declare const getDurableObjectAlarmEvent: EventAccessor<DurableObjectAlarmEvent<unknown, Record<string, unknown>>>;
+export declare const getDurableObjectWebSocketMessageEvent: EventAccessor<DurableObjectWebSocketMessageEvent<unknown, Record<string, unknown>>>;
+export declare const getDurableObjectWebSocketCloseEvent: EventAccessor<DurableObjectWebSocketCloseEvent<unknown, Record<string, unknown>>>;
+export declare const getDurableObjectWebSocketErrorEvent: EventAccessor<DurableObjectWebSocketErrorEvent<unknown, Record<string, unknown>>>;
 //# sourceMappingURL=context.d.ts.map

package/dist/runtime/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,IAAI,GAAG,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAChF,GAAG,EAAE,IAAI,CAAA;IACT,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC5B,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;CACxD;AAOD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,EAC/C,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,gBAAgB,GAAG,IAAI,EAC5B,OAAO,EAAE,OAAO,GAAG,IAAI,EACvB,EAAE,EAAE,MAAM,CAAC,EACX,IAAI,GAAE,cAAc,CAAC,MAAM,CAAW,GACpC,CAAC,CAUH;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,GAAG,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAM7G;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,GAAG,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,IAAI,CAG1H;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,yBAAwB;IAErC,cAUC;CACD"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"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"}

package/dist/runtime/exports.d.ts

@@ -1,87 +1,103 @@
+import { type EventContext, type RuntimeContextValue } from './context.js';
+import '../env.js';
 /**
  * Access environment bindings (KV, D1, R2, etc.) and variables
  *
  * @remarks
  * This is readonly - bindings cannot be reassigned at runtime.
- * Available only within request handlers or middleware.
+ * Available only within an active Devflare-managed handler or middleware call trail.
  *
  * @example
  * ```ts
- * import { env } from 'devflare/runtime'
- *
- * export default {
- *   async fetch(request) {
- *     const value = await env.MY_KV.get('key')
- *     const dbResult = await env.DB.prepare('SELECT * FROM users').all()
- *     return new Response(JSON.stringify({ value, dbResult }))
- *   }
+ * import { env, type FetchEvent } from 'devflare/runtime'
+ *
+ * export async function fetch(event: FetchEvent) {
+ *   const value = await env.MY_KV.get('key')
+ *   const dbResult = await env.DB.prepare('SELECT * FROM users').all()
+ *   return new Response(JSON.stringify({
+ *     path: event.url.pathname,
+ *     value,
+ *     dbResult
+ *   }))
  * }
  * ```
  *
- * @throws {ContextAccessError} When accessed outside request handler
+ * @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
  */
-export declare const env: Readonly<Record<string, unknown>>;
+export declare const env: Readonly<DevflareEnv>;
+/**
+ * Access typed runtime variables declared with `defineConfig({ vars })`.
+ *
+ * @remarks
+ * This proxy reads from the active Worker environment object, just like
+ * {@link env}, but its type is generated from the `vars` config lane. Nested
+ * values are preserved, so `vars.mongo.database` works when config declares a
+ * nested object.
+ *
+ * @example
+ * ```ts
+ * import { vars } from 'devflare/runtime'
+ *
+ * export async function fetch() {
+ *   return Response.json({
+ *     database: vars.mongo.database
+ *   })
+ * }
+ * ```
+ *
+ * @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
+ */
+export declare const vars: Readonly<DevflareVars>;
 /**
  * Access the ExecutionContext for background tasks
  *
  * @remarks
  * Provides `waitUntil()` for background processing and
- * `passThroughOnException()` for error handling.
+ * `passThroughOnException()` for error handling on worker surfaces.
+ * When running inside a Durable Object, this proxy exposes the current
+ * `DurableObjectState` instead.
  * This is readonly.
  *
  * @example
  * ```ts
- * import { ctx } from 'devflare/runtime'
- *
- * export default {
- *   async fetch(request) {
- *     // Process request quickly
- *     const response = new Response('OK')
- *
- *     // Queue background work
- *     ctx.waitUntil(analytics.track('request-processed'))
+ * import { ctx, type FetchEvent } from 'devflare/runtime'
  *
- *     return response
- *   }
+ * export async function fetch(event: FetchEvent) {
+ *   const response = new Response('OK')
+ *   ctx.waitUntil(analytics.track(event.url.pathname))
+ *   return response
  * }
  * ```
  *
- * @throws {ContextAccessError} When accessed outside request handler
+ * @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
  */
-export declare const ctx: Readonly<ExecutionContext>;
+export declare const ctx: Readonly<RuntimeContextValue>;
 /**
- * Event context shape - provides access to request and context type
- */
-export interface EventContext {
-    /** The incoming Request object */
-    request: Request | null;
-    /** Type of event trigger */
-    type: 'fetch' | 'scheduled' | 'queue' | 'email' | 'tail';
-}
-/**
- * Access event-level context (request, event type)
+ * Access the current event object.
  *
  * @remarks
- * Provides access to the current Request and the type of event
- * that triggered this handler.
+ * This is the generic event proxy for the active AsyncLocalStorage context.
+ *
+ * For strong per-surface typing, prefer `getFetchEvent()`, `getQueueEvent()`,
+ * `getScheduledEvent()`, `getEmailEvent()`, and the Durable Object getters
+ * from `devflare/runtime`.
  *
  * @example
  * ```ts
- * import { event } from 'devflare/runtime'
+ * import { event as runtimeEvent, type FetchEvent, type ScheduledEvent } from 'devflare/runtime'
  *
- * export default {
- *   async fetch(request) {
- *     console.log(event.type)       // 'fetch'
- *     console.log(event.request.url) // Request URL
- *   },
+ * export async function fetch(event: FetchEvent) {
+ *   console.log(runtimeEvent.type)
+ *   console.log(event.url.pathname)
+ * }
  *
- *   async scheduled(controller, env, ctx) {
- *     console.log(event.type) // 'scheduled'
- *   }
+ * export async function scheduled(event: ScheduledEvent) {
+ *   console.log(runtimeEvent.type)
+ *   console.log(event.cron)
  * }
  * ```
  *
- * @throws {ContextAccessError} When accessed outside request handler
+ * @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
  */
 export declare const event: Readonly<EventContext>;
 /**
@@ -96,23 +112,22 @@ export declare const event: Readonly<EventContext>;
  *
  * @example
  * ```ts
- * import { locals } from 'devflare/runtime'
+ * import { locals, type FetchEvent } from 'devflare/runtime'
  *
  * // In auth middleware
- * const authMiddleware = async (next) => {
- *   locals.user = await validateToken(request.headers.get('Authorization'))
+ * const authMiddleware = async (event: FetchEvent, next: () => Promise<Response>) => {
+ *   locals.user = await validateToken(event.request?.headers.get('Authorization'))
  *   return next()
  * }
  *
  * // In handler
- * export default {
- *   async fetch(request) {
- *     console.log(locals.user) // Access authenticated user
- *   }
+ * export async function fetch(event: FetchEvent) {
+ *   void event
+ *   console.log(locals.user)
  * }
  * ```
  *
- * @throws {ContextAccessError} When accessed outside request handler
+ * @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
  */
 export declare const locals: Record<string, unknown>;
 //# sourceMappingURL=exports.d.ts.map

package/dist/runtime/exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/runtime/exports.ts"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGjD,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAG1C,CAAA;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,kCAAkC;IAClC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAA;IACvB,4BAA4B;IAC5B,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;CACxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,YAAY,CAUxC,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAG1C,CAAA"}
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../src/runtime/exports.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAoB,MAAM,WAAW,CAAA;AAKzF,OAAO,QAAQ,CAAA;AAqBf;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,GAAG,EAAE,QAAQ,CAAC,WAAW,CAGrC,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,YAAY,CAGvC,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,GAAG,EAAE,QAAQ,CAAC,mBAAmB,CAG7C,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,YAAY,CAGxC,CAAA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAG1C,CAAA"}

package/dist/runtime/index.d.ts

@@ -1,4 +1,11 @@
-export { createContextProxy, ContextAccessError } from './validation';
-export { sequence, resolve, pipe, type Middleware, type Handler } from './middleware';
-export { durableObject, getDurableObjectOptions, type DurableObjectOptions } from '../decorators';
+export { env, vars, ctx, event, locals } from './exports.js';
+export type { EventContext } from './context.js';
+export { createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, hasContext, type RuntimeEventType, type RuntimeContextValue, type RequestContext } from './context.js';
+export type { FetchEvent, QueueEvent, ScheduledEvent, EmailEvent, TailEvent, DurableObjectEvent, DurableObjectFetchEvent, DurableObjectAlarmEvent, DurableObjectWebSocketMessageEvent, DurableObjectWebSocketCloseEvent, DurableObjectWebSocketErrorEvent, WorkerEvent, AnyEvent } from './context.js';
+export { createContextProxy, ContextAccessError } from './validation.js';
+export { sequence, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, defineFetchHandler, defineQueueHandler, defineScheduledHandler, markResolveStyle, markWorkerStyle, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, type Awaitable, type ResolveFetch, type FetchMiddleware } from './middleware.js';
+export { matchFetchRoute, invokeRouteModules, createRouteResolve } from './router/index.js';
+export type { RouteSegment, RouteModuleDefinition, RouteMatchResult } from './router/types.js';
+export { durableObject, getDurableObjectOptions, type DurableObjectOptions } from '../decorators/index.js';
+export { setLocalSendEmailBindings, clearLocalSendEmailBindings, type LocalSendEmailBindingConfig } from '../utils/send-email.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAGrE,OAAO,EACN,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,aAAa,EACb,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACN,GAAG,EACH,IAAI,EACJ,GAAG,EACH,KAAK,EACL,MAAM,EACN,MAAM,WAAW,CAAA;AAElB,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAG7C,OAAO,EACN,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,6BAA6B,EAC7B,6BAA6B,EAC7B,wCAAwC,EACxC,sCAAsC,EACtC,sCAAsC,EACtC,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,qCAAqC,EACrC,mCAAmC,EACnC,mCAAmC,EACnC,UAAU,EACV,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,MAAM,WAAW,CAAA;AAElB,YAAY,EACX,UAAU,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,kCAAkC,EAClC,gCAAgC,EAChC,gCAAgC,EAChC,WAAW,EACX,QAAQ,EACR,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAGrE,OAAO,EACN,QAAQ,EACR,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EACf,+BAA+B,EAC/B,mCAAmC,EACnC,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,MAAM,cAAc,CAAA;AAErB,OAAO,EACN,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,MAAM,UAAU,CAAA;AAEjB,YAAY,EACX,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EACN,aAAa,EACb,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,MAAM,eAAe,CAAA;AAKtB,OAAO,EACN,yBAAyB,EACzB,2BAA2B,EAC3B,KAAK,2BAA2B,EAChC,MAAM,qBAAqB,CAAA"}

package/dist/runtime/index.js

@@ -1,111 +1,5 @@
-import {
-  durableObject,
-  getDurableObjectOptions
-} from "../index-a855bdsx.js";
-import"../index-37x76zdn.js";
-
-// src/runtime/validation.ts
-class ContextAccessError extends Error {
-  contextName;
-  propertyName;
-  constructor(contextName, propertyName) {
-    super(`Cannot access ${contextName}.${propertyName} outside of request handler.
-
-` + `This typically happens when:
-` + `  1. Accessing ${contextName} at module top-level (during import)
-` + `  2. Accessing ${contextName} in a callback that runs after the request 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/middleware.ts
-function sequence(...middlewares) {
-  return (handler) => {
-    if (middlewares.length === 0) {
-      return async () => {
-        const response = await handler();
-        return response ?? new Response("Not Found", { status: 404 });
-      };
-    }
-    return async () => {
-      let index = 0;
-      const executeMiddleware = async () => {
-        if (index < middlewares.length) {
-          const middleware = middlewares[index++];
-          return middleware(executeMiddleware);
-        } else {
-          const response = await handler();
-          return response ?? new Response("Not Found", { status: 404 });
-        }
-      };
-      return executeMiddleware();
-    };
-  };
-}
-function resolve(...handlers) {
-  return async () => {
-    for (const handler of handlers) {
-      const response = await handler();
-      if (response !== null) {
-        return response;
-      }
-    }
-    return null;
-  };
-}
-function pipe(middlewares, handlers) {
-  return sequence(...middlewares)(resolve(...handlers));
-}
-export {
-  sequence,
-  resolve,
-  pipe,
-  getDurableObjectOptions,
-  durableObject,
-  createContextProxy,
-  ContextAccessError
-};
+import { n as getDurableObjectOptions, t as durableObject } from "../_chunks/decorators-QmV57ixr.js";
+import { A as createTailEvent, C as createDurableObjectWebSocketCloseEvent, D as createFetchEvent, E as createEmailEvent, O as createQueueEvent, S as createDurableObjectFetchEvent, T as createDurableObjectWebSocketMessageEvent, _ as runWithContext, a as getDurableObjectFetchEvent, b as createContextProxy, c as getDurableObjectWebSocketMessageEvent, d as getEventContextOrNull, f as getFetchEvent, g as hasContext, h as getTailEvent, i as getDurableObjectEvent, k as createScheduledEvent, l as getEmailEvent, m as getScheduledEvent, n as getContextOrNull, o as getDurableObjectWebSocketCloseEvent, p as getQueueEvent, r as getDurableObjectAlarmEvent, s as getDurableObjectWebSocketErrorEvent, t as getContext, u as getEventContext, v as runWithEventContext, w as createDurableObjectWebSocketErrorEvent, x as createDurableObjectAlarmEvent, y as ContextAccessError } from "../_chunks/context-CX50Y2Kb.js";
+import { clearLocalSendEmailBindings, setLocalSendEmailBindings } from "../utils/send-email.js";
+import { _ as env, a as assertExplicitScheduledHandlerStyle, b as vars, c as defineQueueHandler, d as invokeFetchModule, f as markResolveStyle, g as ctx, h as sequence, i as assertExplicitQueueHandlerStyle, l as defineScheduledHandler, m as resolveFetchHandler, n as invokeRouteModules, o as createResolveFetch, p as markWorkerStyle, r as matchFetchRoute, s as defineFetchHandler, t as createRouteResolve, u as invokeFetchHandler, v as event, y as locals } from "../_chunks/runtime-FvXvfuZ2.js";
+export { ContextAccessError, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, clearLocalSendEmailBindings, createContextProxy, createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, createEmailEvent, createFetchEvent, createQueueEvent, createResolveFetch, createRouteResolve, createScheduledEvent, createTailEvent, ctx, defineFetchHandler, defineQueueHandler, defineScheduledHandler, durableObject, env, event, getContext, getContextOrNull, getDurableObjectAlarmEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectOptions, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, getDurableObjectWebSocketMessageEvent, getEmailEvent, getEventContext, getEventContextOrNull, getFetchEvent, getQueueEvent, getScheduledEvent, getTailEvent, hasContext, invokeFetchHandler, invokeFetchModule, invokeRouteModules, locals, markResolveStyle, markWorkerStyle, matchFetchRoute, resolveFetchHandler, runWithContext, runWithEventContext, sequence, setLocalSendEmailBindings, vars };

package/dist/runtime/middleware.d.ts

@@ -1,82 +1,124 @@
+import { type FetchEvent } from './context.js';
+type AnyFunction = (...args: any[]) => any;
+type FetchModule = Record<string, unknown>;
 /**
- * A function that handles a request and returns a Response
- * Can return null to indicate "pass through" to next handler
+ * Promise-or-value helper used by worker-safe runtime APIs.
  */
-export type Handler = () => Promise<Response | null>;
+export type Awaitable<T> = T | Promise<T>;
 /**
- * Middleware function that wraps a handler
+ * Resolve the next request-wide middleware or module-local leaf handler.
  *
- * @param next - Call this to continue to the next middleware/handler
- * @returns Response from the middleware or the wrapped handler
+ * Passing a new event mirrors SvelteKit's `resolve(event)` pattern and lets
+ * middleware continue the chain with a modified request context.
+ */
+export type ResolveFetch<TEvent extends FetchEvent = FetchEvent> = (event?: TEvent) => Promise<Response>;
+/**
+ * Request-wide fetch middleware.
+ *
+ * These are intended for the single module-level fetch entry export such as:
+ * - `export const fetch = sequence(corsHandle, appFetch)`
+ * - `export const handle = sequence(corsHandle, appFetch)`
  *
- * @example
- * ```ts
- * const authMiddleware: Middleware = async (next) => {
- *   const token = event.request?.headers.get('Authorization')
- *   if (!token) {
- *     return new Response('Unauthorized', { status: 401 })
- *   }
- *   locals.user = await validateToken(token)
- *   return next()
- * }
- * ```
+ * `fetch` and `handle` are aliases for the same primary fetch entry, so a
+ * module should export one or the other, not both.
  */
-export type Middleware = (next: () => Promise<Response>) => Promise<Response>;
+export type FetchMiddleware<TEvent extends FetchEvent = FetchEvent> = (event: TEvent, resolve: ResolveFetch<TEvent>) => Awaitable<Response>;
+interface FetchResolveOptions<TEvent extends FetchEvent> {
+    fallbackResolve?: ResolveFetch<TEvent>;
+}
 /**
- * Composes multiple middlewares into a single function
+ * Tag a handler as resolve-style: `(event, resolve) => Response`.
  *
- * Middlewares execute in the order provided:
- * - Before next(): runs on the way "in"
- * - After next(): runs on the way "out"
+ * Attaches `FETCH_RESOLVE_STYLE_SYMBOL` so detection survives minification
+ * (which rewrites parameter names and function source output).
+ */
+export declare function markResolveStyle<T extends AnyFunction>(handler: T): T;
+/**
+ * Tag a handler as worker-style: `(request, env)` or `(request, env, ctx)`.
  *
- * @param middlewares - Array of middleware functions to compose
- * @returns A function that accepts a handler and returns a composed handler
+ * Required for 2-argument worker-style handlers because devflare can no
+ * longer disambiguate `(event, resolve)` vs `(request, env)` from arity
+ * alone — the parameter-name fallback was removed in R1-strict.
+ */
+export declare function markWorkerStyle<T extends AnyFunction>(handler: T): T;
+/**
+ * Explicit escape hatch for declaring a handler's calling convention.
+ *
+ * - `options.style === 'resolve'` marks the handler so it is dispatched as
+ *   `(event, resolve) => Response`.
+ * - `options.style === 'worker'` marks the handler so it is dispatched as
+ *   `(request, env[, ctx]) => Response`.
  *
- * @example
- * ```ts
- * const handler = sequence(
- *   corsMiddleware,
- *   authMiddleware,
- *   loggingMiddleware
- * )(myHandler)
- * ```
+ * The marker is required for 2-argument handlers; 1-arg `(event)` and
+ * 3-arg `(request, env, ctx)` handlers do not need to be wrapped.
  */
-export declare function sequence(...middlewares: Middleware[]): (handler: Handler) => Handler;
+export declare function defineFetchHandler<T extends AnyFunction>(handler: T, options?: {
+    style?: 'resolve' | 'worker';
+}): T;
 /**
- * Chains multiple handlers, trying each until one returns a Response
+ * Tag a queue handler as worker-style: `(batch, env)` or `(batch, env, ctx)`.
  *
- * Handlers are tried in order. The first handler to return a non-null
- * Response wins. If all handlers return null, resolve() returns null.
+ * Required for 2-argument worker-style queue handlers because devflare can
+ * no longer disambiguate `(event)` vs `(batch, env)` from arity alone in
+ * R1-strict.
+ */
+export declare function defineQueueHandler<T extends AnyFunction>(handler: T): T;
+/**
+ * Tag a scheduled handler as worker-style: `(controller, env)` or
+ * `(controller, env, ctx)`.
+ */
+export declare function defineScheduledHandler<T extends AnyFunction>(handler: T): T;
+/**
+ * Throw a clear error for ambiguous unmarked 2-argument queue handlers.
  *
- * @param handlers - Array of handler functions to try
- * @returns A combined handler
+ * Mirrors `assertExplicit2ArgStyle` for the queue surface. 2-arg handlers
+ * must be wrapped with `defineQueueHandler(fn)` so dispatch is unambiguous
+ * and minification-safe; 1-arg `(event)` and 3-arg `(batch, env, ctx)` do
+ * not require wrapping.
+ */
+export declare function assertExplicitQueueHandlerStyle(handler: AnyFunction): void;
+/**
+ * Throw a clear error for ambiguous unmarked 2-argument scheduled handlers.
+ */
+export declare function assertExplicitScheduledHandlerStyle(handler: AnyFunction): void;
+/**
+ * Compose request-wide middleware into a single fetch surface.
+ */
+export declare function sequence<TEvent extends FetchEvent = FetchEvent>(...middlewares: FetchMiddleware<TEvent>[]): FetchMiddleware<TEvent>;
+/**
+ * Resolve the primary fetch surface for a module.
  *
- * @example
- * ```ts
- * const handler = resolve(
- *   staticFileHandler,   // Returns null if not a static file
- *   apiHandler,          // Returns null if not an API route
- *   notFoundHandler      // Fallback - always returns Response
- * )
- * ```
+ * `fetch` and `handle` are treated as aliases for the same primary fetch
+ * entry. Exporting more than one primary entry from the same module is
+ * rejected as ambiguous.
  */
-export declare function resolve(...handlers: Handler[]): Handler;
+export declare function resolveFetchHandler(module: FetchModule): AnyFunction | null;
 /**
- * Creates a handler that applies middleware before running resolve
+ * Invoke a fetch entry handler with the supported calling conventions.
  *
- * Convenience function combining sequence() and resolve()
+ * This supports:
+ * - `fetch(request)`
+ * - `fetch(request, env)`
+ * - `fetch(request, env, ctx)`
+ * - `fetch(event)`
+ * - `fetch(event, resolve)` / `handle(event, resolve)`
+ */
+export declare function invokeFetchHandler<TEvent extends FetchEvent>(handler: unknown, event: TEvent, resolve?: ResolveFetch<TEvent>): Promise<Response>;
+/**
+ * Create a SvelteKit-style `resolve(event)` callback for a fetch module.
  *
- * @param middlewares - Middlewares to apply
- * @param handlers - Handlers to resolve
- * @returns A composed handler
+ * Resolution order is:
+ * - matching HTTP method export such as `GET()` / `POST()` / `ALL()`
+ * - 404 response
+ */
+export declare function createResolveFetch<TEvent extends FetchEvent>(module: FetchModule, _currentEntry: unknown, initialEvent: TEvent, options?: FetchResolveOptions<TEvent>): ResolveFetch<TEvent>;
+/**
+ * Invoke the resolved fetch surface for a module.
  *
- * @example
- * ```ts
- * const handler = pipe(
- *   [authMiddleware, loggingMiddleware],
- *   [apiHandler, staticHandler, fallbackHandler]
- * )
- * ```
+ * This lets runtime wrappers support a single request-wide `handle` or
+ * `fetch` export, default exports, and same-module method handlers such as
+ * `GET()`.
  */
-export declare function pipe(middlewares: Middleware[], handlers: Handler[]): Handler;
+export declare function invokeFetchModule<TEvent extends FetchEvent>(module: FetchModule, event: TEvent, fallbackResolve?: ResolveFetch<TEvent>): Promise<Response>;
+export {};
 //# sourceMappingURL=middleware.d.ts.map

package/dist/runtime/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/runtime/middleware.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAE7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,GAAG,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CA+BpF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAUvD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CACnB,WAAW,EAAE,UAAU,EAAE,EACzB,QAAQ,EAAE,OAAO,EAAE,GACjB,OAAO,CAET"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/runtime/middleware.ts"],"names":[],"mappings":"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"}

package/dist/runtime/router/index.d.ts

@@ -0,0 +1,7 @@
+import { type FetchEvent } from '../context.js';
+import { type ResolveFetch } from '../middleware.js';
+import type { RouteMatchResult, RouteModuleDefinition } from './types.js';
+export declare function matchFetchRoute(routes: readonly RouteModuleDefinition[], input: Request | URL | string): RouteMatchResult | null;
+export declare function invokeRouteModules<TEvent extends FetchEvent>(routes: readonly RouteModuleDefinition[], event: TEvent): Promise<Response>;
+export declare function createRouteResolve<TEvent extends FetchEvent>(routes: readonly RouteModuleDefinition[], initialEvent: TEvent): ResolveFetch<TEvent>;
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/router/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAyC,MAAM,YAAY,CAAA;AACnF,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,eAAe,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAgB,MAAM,SAAS,CAAA;AAsGpF,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,qBAAqB,EAAE,EACxC,KAAK,EAAE,OAAO,GAAG,GAAG,GAAG,MAAM,GAC3B,gBAAgB,GAAG,IAAI,CAczB;AAED,wBAAsB,kBAAkB,CAAC,MAAM,SAAS,UAAU,EACjE,MAAM,EAAE,SAAS,qBAAqB,EAAE,EACxC,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,QAAQ,CAAC,CAYnB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,UAAU,EAC3D,MAAM,EAAE,SAAS,qBAAqB,EAAE,EACxC,YAAY,EAAE,MAAM,GAClB,YAAY,CAAC,MAAM,CAAC,CAItB"}