devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/_chunks/runtime-BlKTWIgD.js

@@ -0,0 +1,874 @@
+import { D as createFetchEvent, b as createContextProxy, n as getContextOrNull, v as runWithEventContext } from "./context-DGMev2AF.js";
+import { AwsV4Signer } from "aws4fetch";
+//#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
+//#region src/runtime/r2-presign.ts
+/** URL path prefix of the local presign endpoint served by devflare gateways. */
+const R2_PRESIGN_LOCAL_PATH_PREFIX = "/_devflare/r2/presigned/";
+/** Version tag prepended to the local canonical string (breaks old URLs on format changes). */
+const LOCAL_CANONICAL_VERSION = "devflare:r2-presign:v1";
+/** Env/var names devflare injects in local dev + tests to enable local presigning. */
+const R2_PRESIGN_SECRET_VAR = "DEVFLARE_R2_PRESIGN_SECRET";
+const R2_PRESIGN_ORIGIN_VAR = "DEVFLARE_R2_PRESIGN_ORIGIN";
+/** Var (injected at deploy compile time) mapping R2 binding names to bucket metadata. */
+const R2_BUCKETS_VAR = "DEVFLARE_R2_BUCKETS";
+/** Default env/secret names for R2 S3 API credentials in production. */
+const R2_ACCOUNT_ID_VAR = "R2_ACCOUNT_ID";
+const R2_ACCESS_KEY_ID_VAR = "R2_ACCESS_KEY_ID";
+const R2_SECRET_ACCESS_KEY_VAR = "R2_SECRET_ACCESS_KEY";
+/** Maximum expiry accepted by S3-style presigned URLs (7 days, in seconds). */
+const MAX_EXPIRES_IN_SECONDS = 10080 * 60;
+/** Default presigned URL lifetime (15 minutes, in seconds). */
+const DEFAULT_EXPIRES_IN_SECONDS = 900;
+/**
+* Read a string value by name from the platform `env`, falling back to
+* `process.env`. Handles dev-mode env proxies gracefully: any non-string
+* (e.g. a bridge binding proxy) is treated as absent.
+*/
+function readEnvString(env, name) {
+	let own;
+	try {
+		own = env?.[name];
+	} catch {
+		own = void 0;
+	}
+	if (typeof own === "string" && own.length > 0) return own;
+	const fromProcess = (globalThis.process?.env)?.[name];
+	return typeof fromProcess === "string" && fromProcess.length > 0 ? fromProcess : void 0;
+}
+/**
+* Resolve the local presign context (origin + secret) injected by devflare in
+* dev/test. Returns `null` outside devflare-managed local environments.
+*/
+function resolveLocalContext(env) {
+	const secret = readEnvString(env, R2_PRESIGN_SECRET_VAR);
+	const origin = readEnvString(env, R2_PRESIGN_ORIGIN_VAR);
+	if (!secret || !origin) return null;
+	return {
+		origin: origin.replace(/\/$/, ""),
+		secret
+	};
+}
+/**
+* Parse the injected `DEVFLARE_R2_BUCKETS` mapping from `env`. Accepts either
+* a JSON string var or an already-parsed object (wrangler JSON vars).
+*/
+function readBucketsVar(env) {
+	let raw;
+	try {
+		raw = env?.[R2_BUCKETS_VAR];
+	} catch {
+		return null;
+	}
+	if (raw === void 0 || raw === null) raw = (globalThis.process?.env)?.[R2_BUCKETS_VAR];
+	if (typeof raw === "string") try {
+		raw = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!raw || typeof raw !== "object") return null;
+	const entries = {};
+	for (const [binding, value] of Object.entries(raw)) {
+		if (!value || typeof value !== "object") continue;
+		const bucketName = value.bucketName;
+		if (typeof bucketName !== "string" || bucketName.length === 0) continue;
+		const jurisdiction = value.jurisdiction;
+		entries[binding] = {
+			bucketName,
+			...typeof jurisdiction === "string" && jurisdiction.length > 0 && { jurisdiction }
+		};
+	}
+	return entries;
+}
+/**
+* Validate the binding/key/options tuple shared by PUT and GET presigning.
+* Returns the effective expiry in seconds.
+*
+* @throws {RangeError} on out-of-range `expiresIn`, `contentLength` or `maxSizeBytes`.
+* @throws {TypeError} on an empty binding or key.
+*/
+function validateCommonInputs(binding, key, options) {
+	if (typeof binding !== "string" || binding.length === 0) throw new TypeError("[devflare] presignR2*: `binding` must be a non-empty R2 binding name.");
+	if (typeof key !== "string" || key.length === 0) throw new TypeError("[devflare] presignR2*: `key` must be a non-empty object key.");
+	if (key.startsWith("/")) throw new TypeError("[devflare] presignR2*: `key` must not start with \"/\".");
+	const controlChars = /[\u0000-\u001f\u007f]/;
+	if (controlChars.test(key) || controlChars.test(binding)) throw new TypeError("[devflare] presignR2*: `binding`/`key` must not contain control characters.");
+	const expiresIn = options.expiresIn ?? DEFAULT_EXPIRES_IN_SECONDS;
+	if (!Number.isInteger(expiresIn) || expiresIn < 1 || expiresIn > MAX_EXPIRES_IN_SECONDS) throw new RangeError(`[devflare] presignR2*: \`expiresIn\` must be an integer between 1 and ${MAX_EXPIRES_IN_SECONDS} seconds (got ${expiresIn}).`);
+	if (options.contentLength !== void 0) {
+		if (!Number.isInteger(options.contentLength) || options.contentLength < 0) throw new RangeError("[devflare] presignR2Put: `contentLength` must be a non-negative integer byte count.");
+	}
+	if (options.maxSizeBytes !== void 0) {
+		if (!Number.isInteger(options.maxSizeBytes) || options.maxSizeBytes < 1) throw new RangeError("[devflare] presignR2Put: `maxSizeBytes` must be a positive integer byte count.");
+	}
+	if (options.contentLength !== void 0 && options.maxSizeBytes !== void 0 && options.contentLength > options.maxSizeBytes) throw new RangeError(`[devflare] presignR2Put: \`contentLength\` (${options.contentLength}) exceeds \`maxSizeBytes\` (${options.maxSizeBytes}).`);
+	return expiresIn;
+}
+/**
+* Percent-encode an object key for use in a URL path, RFC 3986-strict
+* (S3 canonical-URI compatible), preserving `/` as the segment separator.
+*/
+function encodeKeyPath(key) {
+	return key.split("/").map((segment) => encodeURIComponent(segment).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)).join("/");
+}
+/** Compute a lowercase hex HMAC-SHA256 of `message` with `secret` via WebCrypto. */
+async function hmacSha256Hex(secret, message) {
+	const encoder = new TextEncoder();
+	const cryptoKey = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", cryptoKey, encoder.encode(message));
+	return [...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Build the canonical string covered by the local signature. MUST match
+* `buildCanonicalString` in `src/bridge/r2-presign-runtime.ts` byte-for-byte.
+*/
+function buildLocalCanonicalString(input) {
+	return [
+		LOCAL_CANONICAL_VERSION,
+		input.method,
+		input.binding,
+		input.key,
+		String(input.expires),
+		input.contentType ?? "",
+		input.contentLength !== void 0 ? String(input.contentLength) : "",
+		input.maxSizeBytes !== void 0 ? String(input.maxSizeBytes) : ""
+	].join("\n");
+}
+/** Mint a signed URL against the devflare gateway's local presign endpoint. */
+async function presignLocal(input) {
+	const expires = Math.floor(Date.now() / 1e3) + input.expiresIn;
+	const signature = await hmacSha256Hex(input.secret, buildLocalCanonicalString({
+		method: input.method,
+		binding: input.binding,
+		key: input.key,
+		expires,
+		contentType: input.contentType,
+		contentLength: input.contentLength,
+		maxSizeBytes: input.maxSizeBytes
+	}));
+	const url = new URL(`${input.origin}${R2_PRESIGN_LOCAL_PATH_PREFIX}${encodeURIComponent(input.binding)}/${encodeKeyPath(input.key)}`);
+	url.searchParams.set("X-Devflare-Method", input.method);
+	url.searchParams.set("X-Devflare-Expires", String(expires));
+	if (input.contentType !== void 0) url.searchParams.set("X-Devflare-Content-Type", input.contentType);
+	if (input.contentLength !== void 0) url.searchParams.set("X-Devflare-Content-Length", String(input.contentLength));
+	if (input.maxSizeBytes !== void 0) url.searchParams.set("X-Devflare-Max-Size", String(input.maxSizeBytes));
+	url.searchParams.set("X-Devflare-Signature", signature);
+	return {
+		url: url.toString(),
+		method: input.method,
+		headers: input.contentType !== void 0 ? { "content-type": input.contentType } : {},
+		expiresAt: /* @__PURE__ */ new Date(expires * 1e3),
+		key: input.key,
+		mode: "local"
+	};
+}
+/**
+* Resolve production credentials from options or env.
+*
+* @throws {Error} naming exactly which credential values are missing.
+*/
+function resolveCredentials(env, options) {
+	if (options.credentials) return options.credentials;
+	const accountId = readEnvString(env, R2_ACCOUNT_ID_VAR);
+	const accessKeyId = readEnvString(env, R2_ACCESS_KEY_ID_VAR);
+	const secretAccessKey = readEnvString(env, R2_SECRET_ACCESS_KEY_VAR);
+	if (accountId && accessKeyId && secretAccessKey) return {
+		accountId,
+		accessKeyId,
+		secretAccessKey
+	};
+	const missing = [
+		!accountId && "R2_ACCOUNT_ID",
+		!accessKeyId && "R2_ACCESS_KEY_ID",
+		!secretAccessKey && "R2_SECRET_ACCESS_KEY"
+	].filter(Boolean);
+	throw new Error(`[devflare] presignR2*: missing R2 S3 credentials (${missing.join(", ")}). Provide them as Worker secrets (\`wrangler secret put <NAME>\`) or pass \`options.credentials\`. Create R2 S3 credentials under Cloudflare Dashboard → R2 → Manage R2 API Tokens. In devflare local dev no credentials are needed — this error usually means the code runs in production without the secrets set.`);
+}
+/**
+* Resolve the production bucket for a binding from options or the injected
+* `DEVFLARE_R2_BUCKETS` mapping.
+*
+* @throws {Error} when the bucket cannot be resolved.
+*/
+function resolveBucket(env, binding, options) {
+	if (options.bucketName) return {
+		bucketName: options.bucketName,
+		...options.jurisdiction && { jurisdiction: options.jurisdiction }
+	};
+	const entry = readBucketsVar(env)?.[binding];
+	if (entry) return {
+		bucketName: entry.bucketName,
+		...(options.jurisdiction ?? entry.jurisdiction) && { jurisdiction: options.jurisdiction ?? entry.jurisdiction }
+	};
+	throw new Error(`[devflare] presignR2*: cannot resolve the bucket name for binding '${binding}'. Deploy through devflare (which injects the ${R2_BUCKETS_VAR} var from \`bindings.r2\`) or pass \`options.bucketName\` explicitly.`);
+}
+/** Mint a real S3 SigV4 presigned URL against the R2 S3 endpoint. */
+async function presignRemote(input) {
+	const jurisdictionHost = input.bucket.jurisdiction ? `.${input.bucket.jurisdiction}` : "";
+	const endpoint = new URL(`https://${input.credentials.accountId}${jurisdictionHost}.r2.cloudflarestorage.com/${input.bucket.bucketName}/${encodeKeyPath(input.key)}`);
+	endpoint.searchParams.set("X-Amz-Expires", String(input.expiresIn));
+	const signedHeaders = {};
+	if (input.contentType !== void 0) signedHeaders["content-type"] = input.contentType;
+	if (input.contentLength !== void 0) signedHeaders["content-length"] = String(input.contentLength);
+	return {
+		url: (await new AwsV4Signer({
+			url: endpoint.toString(),
+			method: input.method,
+			accessKeyId: input.credentials.accessKeyId,
+			secretAccessKey: input.credentials.secretAccessKey,
+			region: "auto",
+			service: "s3",
+			signQuery: true,
+			allHeaders: true,
+			headers: signedHeaders
+		}).sign()).url.toString(),
+		method: input.method,
+		headers: input.contentType !== void 0 ? { "content-type": input.contentType } : {},
+		expiresAt: new Date(Date.now() + input.expiresIn * 1e3),
+		key: input.key,
+		mode: "remote"
+	};
+}
+/**
+* Presign a direct-to-R2 `PUT` URL for a browser (or any HTTP client) upload.
+*
+* Resolves to a real R2 S3 presigned URL in production and to a signed
+* devflare-gateway URL in local dev and the test harness — same call, same
+* guarantees (signature, expiry, method, content type, size), so upload and
+* quota logic can be exercised identically in every environment.
+*
+* @param env - The platform env (`platform.env` in SvelteKit, `env` in a
+* Worker handler). Used to detect the local dev context and to read
+* production credentials/bucket mapping.
+* @param binding - The R2 binding name from `bindings.r2` (e.g. `'BUCKET'`).
+* @param key - Object key to upload to. Percent-encoding is handled internally.
+* @param options - Expiry, enforcement (content type / length / max size) and
+* production credential overrides.
+* @returns The presigned request: `url` to PUT to, `headers` the client must
+* send, and `expiresAt`.
+* @throws {Error} in production when credentials or the bucket mapping are missing.
+* @throws {TypeError | RangeError} on invalid inputs.
+*
+* @example
+* ```ts
+* // Server (SvelteKit endpoint) — reserve quota first, then presign:
+* const { url, headers } = await presignR2Put(platform.env, 'BUCKET', `media/${id}.png`, {
+*   expiresIn: 600,
+*   contentType: file.type,
+*   contentLength: file.size
+* })
+*
+* // Browser — upload directly to storage:
+* await fetch(url, { method: 'PUT', body: file, headers })
+*
+* // Server — finalize: confirm the object before committing quota:
+* const head = await platform.env.BUCKET.head(`media/${id}.png`)
+* ```
+*/
+async function presignR2Put(env, binding, key, options = {}) {
+	const expiresIn = validateCommonInputs(binding, key, options);
+	const local = resolveLocalContext(env);
+	if (local) return presignLocal({
+		...local,
+		method: "PUT",
+		binding,
+		key,
+		expiresIn,
+		contentType: options.contentType,
+		contentLength: options.contentLength,
+		maxSizeBytes: options.maxSizeBytes
+	});
+	return presignRemote({
+		credentials: resolveCredentials(env, options),
+		bucket: resolveBucket(env, binding, options),
+		method: "PUT",
+		key,
+		expiresIn,
+		contentType: options.contentType,
+		contentLength: options.contentLength
+	});
+}
+/**
+* Presign a direct-from-R2 `GET` URL (also valid for `HEAD`) so a browser can
+* download an object without routing the bytes through the Worker.
+*
+* Same dev/prod symmetry as {@link presignR2Put}. Note that browser reads
+* from real R2 additionally require CORS rules on the bucket itself.
+*
+* @param env - The platform env (see {@link presignR2Put}).
+* @param binding - The R2 binding name from `bindings.r2`.
+* @param key - Object key to read.
+* @param options - Expiry and production credential overrides.
+* @returns The presigned request; `headers` is always empty for GET.
+* @throws {Error} in production when credentials or the bucket mapping are missing.
+* @throws {TypeError | RangeError} on invalid inputs.
+*/
+async function presignR2Get(env, binding, key, options = {}) {
+	const expiresIn = validateCommonInputs(binding, key, options);
+	const local = resolveLocalContext(env);
+	if (local) return presignLocal({
+		...local,
+		method: "GET",
+		binding,
+		key,
+		expiresIn
+	});
+	return presignRemote({
+		credentials: resolveCredentials(env, options),
+		bucket: resolveBucket(env, binding, options),
+		method: "GET",
+		key,
+		expiresIn
+	});
+}
+//#endregion
+export { vars as C, locals as S, resolveFetchHandler as _, matchFetchRoute as a, env as b, assertExplicitScheduledHandlerStyle as c, defineQueueHandler as d, defineScheduledHandler as f, markWorkerStyle as g, markResolveStyle as h, invokeRouteModules as i, createResolveFetch as l, invokeFetchModule as m, presignR2Put as n, assertExplicit2ArgStyle as o, invokeFetchHandler as p, createRouteResolve as r, assertExplicitQueueHandlerStyle as s, presignR2Get as t, defineFetchHandler as u, sequence as v, event as x, ctx as y };