devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/runtime-DL-Nz3k8.js

@@ -0,0 +1,550 @@
+import { D as createFetchEvent, b as createContextProxy, n as getContextOrNull, v as runWithEventContext } from "./context-CX50Y2Kb.js";
+//#region src/runtime/exports.ts
+/**
+* Creates a readonly proxy that throws on mutation attempts. Thin wrapper
+* over {@link createContextProxy} with `mutable: false`.
+*/
+function createReadonlyProxy(getter, name) {
+	return createContextProxy(getter, name, { mutable: false });
+}
+/**
+* Access environment bindings (KV, D1, R2, etc.) and variables
+*
+* @remarks
+* This is readonly - bindings cannot be reassigned at runtime.
+* Available only within an active Devflare-managed handler or middleware call trail.
+*
+* @example
+* ```ts
+* 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 an active Devflare-managed handler trail
+*/
+const env = createReadonlyProxy(() => getContextOrNull()?.env, "env");
+/**
+* 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
+*/
+const vars = createReadonlyProxy(() => getContextOrNull()?.env, "vars");
+/**
+* Access the ExecutionContext for background tasks
+*
+* @remarks
+* Provides `waitUntil()` for background processing and
+* `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, type FetchEvent } from 'devflare/runtime'
+*
+* 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 an active Devflare-managed handler trail
+*/
+const ctx = createReadonlyProxy(() => getContextOrNull()?.ctx, "ctx");
+/**
+* Access the current event object.
+*
+* @remarks
+* 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 as runtimeEvent, type FetchEvent, type ScheduledEvent } from 'devflare/runtime'
+*
+* export async function fetch(event: FetchEvent) {
+*   console.log(runtimeEvent.type)
+*   console.log(event.url.pathname)
+* }
+*
+* export async function scheduled(event: ScheduledEvent) {
+*   console.log(runtimeEvent.type)
+*   console.log(event.cron)
+* }
+* ```
+*
+* @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
+*/
+const event = createReadonlyProxy(() => getContextOrNull()?.event, "event");
+/**
+* Mutable request-scoped storage for sharing data between middleware
+*
+* @remarks
+* Unlike `env` and `ctx`, locals can be mutated. Each request gets
+* a fresh locals object. Use this for:
+* - Authentication state
+* - Parsed request data
+* - Computed values shared across middleware
+*
+* @example
+* ```ts
+* import { locals, type FetchEvent } from 'devflare/runtime'
+*
+* // In auth middleware
+* const authMiddleware = async (event: FetchEvent, next: () => Promise<Response>) => {
+*   locals.user = await validateToken(event.request?.headers.get('Authorization'))
+*   return next()
+* }
+*
+* // In handler
+* export async function fetch(event: FetchEvent) {
+*   void event
+*   console.log(locals.user)
+* }
+* ```
+*
+* @throws {ContextAccessError} When accessed outside an active Devflare-managed handler trail
+*/
+const locals = createContextProxy(() => getContextOrNull()?.locals, "locals");
+//#endregion
+//#region src/runtime/middleware.ts
+const FETCH_SEQUENCE_SYMBOL = Symbol.for("devflare.fetch-sequence");
+const FETCH_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-style");
+const FETCH_WORKER_STYLE_SYMBOL = Symbol.for("devflare.fetch-worker-style");
+const QUEUE_WORKER_STYLE_SYMBOL = Symbol.for("devflare.queue-worker-style");
+const SCHEDULED_WORKER_STYLE_SYMBOL = Symbol.for("devflare.scheduled-worker-style");
+function createNotFoundResponse() {
+	return new Response("Not Found", { status: 404 });
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+/**
+* Tag a handler as resolve-style: `(event, resolve) => Response`.
+*
+* Attaches `FETCH_RESOLVE_STYLE_SYMBOL` so detection survives minification
+* (which rewrites parameter names and function source output).
+*/
+function markResolveStyle(handler) {
+	Object.defineProperty(handler, FETCH_RESOLVE_STYLE_SYMBOL, {
+		value: true,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	return handler;
+}
+/**
+* Tag a handler as worker-style: `(request, env)` or `(request, env, ctx)`.
+*
+* 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.
+*/
+function markWorkerStyle(handler) {
+	Object.defineProperty(handler, FETCH_WORKER_STYLE_SYMBOL, {
+		value: true,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	return handler;
+}
+/**
+* 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`.
+*
+* The marker is required for 2-argument handlers; 1-arg `(event)` and
+* 3-arg `(request, env, ctx)` handlers do not need to be wrapped.
+*/
+function defineFetchHandler(handler, options) {
+	if (options?.style === "resolve") return markResolveStyle(handler);
+	if (options?.style === "worker") return markWorkerStyle(handler);
+	return handler;
+}
+function hasResolveStyleMarker(handler) {
+	const record = handler;
+	return Boolean(record[FETCH_RESOLVE_STYLE_SYMBOL] || record[FETCH_SEQUENCE_SYMBOL]);
+}
+function hasWorkerStyleMarker(handler) {
+	return Boolean(handler[FETCH_WORKER_STYLE_SYMBOL]);
+}
+/**
+* Detect resolve-style `(event, resolve) => Response` handlers.
+*
+* Symbol-based only — the previous parameter-name fallback was removed in
+* R1-strict. Callers that rely on a 2-argument resolve-style handler must
+* wrap it with `markResolveStyle`, `defineFetchHandler({ style: 'resolve' })`,
+* or compose it via `sequence(...)`.
+*/
+function isResolveStyleFunction(handler) {
+	return hasResolveStyleMarker(handler);
+}
+/**
+* Throw a clear error for ambiguous unmarked 2-argument fetch handlers.
+*
+* In R1-strict, devflare no longer guesses the calling convention from
+* parameter names. 2-arg handlers must be marked with
+* `defineFetchHandler(fn, { style: 'resolve' | 'worker' })` (or wrapped via
+* `markResolveStyle` / `markWorkerStyle` / `sequence(...)`) so dispatch is
+* unambiguous and minification-safe.
+*/
+function assertExplicit2ArgStyle(handler) {
+	if (handler.length !== 2) return;
+	if (hasResolveStyleMarker(handler) || hasWorkerStyleMarker(handler)) return;
+	throw new Error("[devflare] Ambiguous 2-argument fetch handler. The calling convention must be declared explicitly via `defineFetchHandler(fn, { style: 'resolve' })` (for `(event, resolve) => Response`) or `defineFetchHandler(fn, { style: 'worker' })` (for `(request, env) => Response`). Single-arg `(event) => Response` and 3-arg worker-style `(request, env, ctx) => Response` handlers do not require wrapping.");
+}
+/**
+* Tag a queue handler as worker-style: `(batch, env)` or `(batch, env, ctx)`.
+*
+* Required for 2-argument worker-style queue handlers because devflare can
+* no longer disambiguate `(event)` vs `(batch, env)` from arity alone in
+* R1-strict.
+*/
+function defineQueueHandler(handler) {
+	Object.defineProperty(handler, QUEUE_WORKER_STYLE_SYMBOL, {
+		value: true,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	return handler;
+}
+/**
+* Tag a scheduled handler as worker-style: `(controller, env)` or
+* `(controller, env, ctx)`.
+*/
+function defineScheduledHandler(handler) {
+	Object.defineProperty(handler, SCHEDULED_WORKER_STYLE_SYMBOL, {
+		value: true,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	return handler;
+}
+function hasQueueWorkerStyleMarker(handler) {
+	return Boolean(handler[QUEUE_WORKER_STYLE_SYMBOL]);
+}
+function hasScheduledWorkerStyleMarker(handler) {
+	return Boolean(handler[SCHEDULED_WORKER_STYLE_SYMBOL]);
+}
+/**
+* Throw a clear error for ambiguous unmarked 2-argument queue handlers.
+*
+* 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.
+*/
+function assertExplicitQueueHandlerStyle(handler) {
+	if (handler.length !== 2) return;
+	if (hasQueueWorkerStyleMarker(handler)) return;
+	throw new Error("[devflare] Ambiguous 2-argument queue handler. The calling convention must be declared explicitly via `defineQueueHandler(fn)` for `(batch, env) => void` worker-style handlers. Single-arg `(event) => void` and 3-arg `(batch, env, ctx) => void` handlers do not require wrapping.");
+}
+/**
+* Throw a clear error for ambiguous unmarked 2-argument scheduled handlers.
+*/
+function assertExplicitScheduledHandlerStyle(handler) {
+	if (handler.length !== 2) return;
+	if (hasScheduledWorkerStyleMarker(handler)) return;
+	throw new Error("[devflare] Ambiguous 2-argument scheduled handler. The calling convention must be declared explicitly via `defineScheduledHandler(fn)` for `(controller, env) => void` worker-style handlers. Single-arg `(event) => void` and 3-arg `(controller, env, ctx) => void` handlers do not require wrapping.");
+}
+/**
+* Detect Cloudflare Worker-style `fetch(request, env[, ctx])` handlers.
+*
+* Returns true when:
+* - arity is `>= 3` (unambiguous worker signature), or
+* - the handler is explicitly marked worker-style via `markWorkerStyle` or
+*   `defineFetchHandler({ style: 'worker' })`.
+*
+* In R1-strict, 2-argument worker-style handlers must be marked — there is
+* no parameter-name fallback. Unmarked 2-arg handlers throw via
+* `assertExplicit2ArgStyle` when invoked.
+*/
+function isWorkerStyleFetchFunction(handler) {
+	if (isResolveStyleFunction(handler)) return false;
+	if (handler.length >= 3) return true;
+	return hasWorkerStyleMarker(handler);
+}
+function invokeWorkerStyleFetchFunction(handler, event) {
+	return handler(event.request, event.env, event.ctx);
+}
+function bindMethod(target, key) {
+	if (!target || typeof target !== "object") return null;
+	const value = target[key];
+	if (!isFunction(value)) return null;
+	const boundHandler = value.bind(target);
+	if (isResolveStyleFunction(value)) markResolveStyle(boundHandler);
+	if (hasWorkerStyleMarker(value)) markWorkerStyle(boundHandler);
+	return boundHandler;
+}
+function createFetchSequence(middlewares) {
+	return async (event, resolve = async () => createNotFoundResponse()) => {
+		const executeMiddleware = async (index, activeEvent) => {
+			if (index >= middlewares.length) return resolve(activeEvent);
+			const middleware = middlewares[index];
+			return middleware(activeEvent, async (nextEvent = activeEvent) => {
+				return executeMiddleware(index + 1, nextEvent);
+			});
+		};
+		return executeMiddleware(0, event);
+	};
+}
+/**
+* Compose request-wide middleware into a single fetch surface.
+*/
+function sequence(...middlewares) {
+	const composed = createFetchSequence(middlewares);
+	Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return markResolveStyle(composed);
+}
+function getDefaultHandleHandler(module) {
+	return bindMethod(module.default, "handle");
+}
+function getDefaultFetchHandler(module) {
+	const defaultExport = module.default;
+	if (isFunction(defaultExport)) return defaultExport;
+	return bindMethod(defaultExport, "fetch");
+}
+function getPrimaryFetchEntryCandidates(module) {
+	const candidates = [];
+	const namedHandle = isFunction(module.handle) ? module.handle : null;
+	if (namedHandle) candidates.push({
+		name: "handle",
+		handler: namedHandle
+	});
+	const namedFetch = isFunction(module.fetch) ? module.fetch : null;
+	if (namedFetch) candidates.push({
+		name: "fetch",
+		handler: namedFetch
+	});
+	const defaultHandle = getDefaultHandleHandler(module);
+	if (defaultHandle) candidates.push({
+		name: "default.handle",
+		handler: defaultHandle
+	});
+	const defaultFetch = getDefaultFetchHandler(module);
+	if (defaultFetch) candidates.push({
+		name: isFunction(module.default) ? "default" : "default.fetch",
+		handler: defaultFetch
+	});
+	return candidates;
+}
+function assertSinglePrimaryFetchEntry(candidates) {
+	if (candidates.length <= 1) return;
+	const foundEntries = candidates.map(({ name }) => `"${name}"`).join(", ");
+	throw new Error(`Ambiguous fetch entry module. Export exactly one primary fetch entry per module. Use either "fetch" or "handle" (or one default equivalent), not both. Found: ${foundEntries}`);
+}
+function resolveMethodHandler(module, method) {
+	const normalizedMethod = method.toUpperCase();
+	const directHandler = isFunction(module[normalizedMethod]) ? module[normalizedMethod] : bindMethod(module.default, normalizedMethod);
+	if (directHandler) return {
+		handler: directHandler,
+		stripBody: false
+	};
+	if (normalizedMethod === "HEAD") {
+		const getHandler = isFunction(module.GET) ? module.GET : bindMethod(module.default, "GET");
+		if (getHandler) return {
+			handler: getHandler,
+			stripBody: true
+		};
+	}
+	const allHandler = isFunction(module.ALL) ? module.ALL : bindMethod(module.default, "ALL");
+	if (allHandler) return {
+		handler: allHandler,
+		stripBody: false
+	};
+	return null;
+}
+async function invokeResolvedFetchHandler(handler, event) {
+	if (isResolveStyleFunction(handler)) return handler(event, async () => createNotFoundResponse());
+	if (isWorkerStyleFetchFunction(handler)) return invokeWorkerStyleFetchFunction(handler, event);
+	assertExplicit2ArgStyle(handler);
+	return handler(event);
+}
+/**
+* Resolve the primary fetch surface for a module.
+*
+* `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.
+*/
+function resolveFetchHandler(module) {
+	const candidates = getPrimaryFetchEntryCandidates(module);
+	assertSinglePrimaryFetchEntry(candidates);
+	return candidates[0]?.handler ?? null;
+}
+/**
+* Invoke a fetch entry handler with the supported calling conventions.
+*
+* This supports:
+* - `fetch(request)`
+* - `fetch(request, env)`
+* - `fetch(request, env, ctx)`
+* - `fetch(event)`
+* - `fetch(event, resolve)` / `handle(event, resolve)`
+*/
+async function invokeFetchHandler(handler, event, resolve = async () => createNotFoundResponse()) {
+	if (!isFunction(handler)) return resolve(event);
+	if (isResolveStyleFunction(handler)) return await handler(event, resolve) ?? createNotFoundResponse();
+	if (isWorkerStyleFetchFunction(handler)) return await invokeWorkerStyleFetchFunction(handler, event) ?? createNotFoundResponse();
+	assertExplicit2ArgStyle(handler);
+	return await handler(event) ?? createNotFoundResponse();
+}
+/**
+* Create a SvelteKit-style `resolve(event)` callback for a fetch module.
+*
+* Resolution order is:
+* - matching HTTP method export such as `GET()` / `POST()` / `ALL()`
+* - 404 response
+*/
+function createResolveFetch(module, _currentEntry, initialEvent, options = {}) {
+	return async (nextEvent = initialEvent) => {
+		return runWithEventContext(nextEvent, async () => {
+			const methodResolution = resolveMethodHandler(module, nextEvent.request.method);
+			if (methodResolution) {
+				const finalResponse = await invokeResolvedFetchHandler(methodResolution.handler, nextEvent) ?? createNotFoundResponse();
+				if (methodResolution.stripBody) return new Response(null, finalResponse);
+				return finalResponse;
+			}
+			if (options.fallbackResolve) return options.fallbackResolve(nextEvent);
+			return createNotFoundResponse();
+		});
+	};
+}
+/**
+* Invoke the resolved fetch surface for a module.
+*
+* This lets runtime wrappers support a single request-wide `handle` or
+* `fetch` export, default exports, and same-module method handlers such as
+* `GET()`.
+*/
+async function invokeFetchModule(module, event, fallbackResolve) {
+	const handler = resolveFetchHandler(module);
+	if (!handler) return createResolveFetch(module, null, event, { fallbackResolve })(event);
+	return invokeFetchHandler(handler, event, createResolveFetch(module, handler, event, { fallbackResolve }));
+}
+//#endregion
+//#region src/runtime/router/index.ts
+function normalizePathname(pathname) {
+	if (!pathname || pathname === "/") return "/";
+	const trimmed = (pathname.startsWith("/") ? pathname : `/${pathname}`).replace(/\/+$|\/+$/g, "");
+	return trimmed === "" ? "/" : trimmed;
+}
+function decodePathSegment(segment) {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+}
+function getPathSegments(pathname) {
+	const normalizedPathname = normalizePathname(pathname);
+	if (normalizedPathname === "/") return [];
+	return normalizedPathname.slice(1).split("/").filter(Boolean).map(decodePathSegment);
+}
+function getMatchPathname(input) {
+	if (input instanceof Request) return new URL(input.url).pathname;
+	if (input instanceof URL) return input.pathname;
+	if (input.includes("://")) return new URL(input).pathname;
+	return input;
+}
+function matchRouteSegments(routeSegments, pathnameSegments) {
+	if (routeSegments.length === 0) return pathnameSegments.length === 0 ? {} : null;
+	const params = {};
+	let routeIndex = 0;
+	let pathIndex = 0;
+	while (routeIndex < routeSegments.length) {
+		const routeSegment = routeSegments[routeIndex];
+		if (routeSegment.type === "optional-rest") {
+			params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+			pathIndex = pathnameSegments.length;
+			routeIndex += 1;
+			continue;
+		}
+		if (routeSegment.type === "rest") {
+			if (pathIndex >= pathnameSegments.length) return null;
+			params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+			pathIndex = pathnameSegments.length;
+			routeIndex += 1;
+			continue;
+		}
+		const pathnameSegment = pathnameSegments[pathIndex];
+		if (pathnameSegment === void 0) return null;
+		if (routeSegment.type === "static") {
+			if (pathnameSegment !== routeSegment.value) return null;
+		} else params[routeSegment.name] = pathnameSegment;
+		pathIndex += 1;
+		routeIndex += 1;
+	}
+	if (pathIndex !== pathnameSegments.length) return null;
+	return params;
+}
+function matchFetchRoute(routes, input) {
+	const pathnameSegments = getPathSegments(getMatchPathname(input));
+	for (const route of routes) {
+		const params = matchRouteSegments(route.segments, pathnameSegments);
+		if (params) return {
+			route,
+			params
+		};
+	}
+	return null;
+}
+async function invokeRouteModules(routes, event) {
+	const match = matchFetchRoute(routes, event.request);
+	if (!match) return new Response("Not Found", { status: 404 });
+	const routeEvent = createFetchEvent(event.request, event.env, event.ctx, {
+		params: match.params,
+		locals: event.locals
+	});
+	return runWithEventContext(routeEvent, () => invokeFetchModule(match.route.module, routeEvent));
+}
+function createRouteResolve(routes, initialEvent) {
+	return async (nextEvent = initialEvent) => {
+		return invokeRouteModules(routes, nextEvent);
+	};
+}
+//#endregion
+export { ctx as _, assertExplicitQueueHandlerStyle as a, locals as b, defineFetchHandler as c, invokeFetchHandler as d, invokeFetchModule as f, sequence as g, resolveFetchHandler as h, assertExplicit2ArgStyle as i, defineQueueHandler as l, markWorkerStyle as m, invokeRouteModules as n, assertExplicitScheduledHandlerStyle as o, markResolveStyle as p, matchFetchRoute as r, createResolveFetch as s, createRouteResolve as t, defineScheduledHandler as u, env as v, vars as x, event as y };