void 0.1.6 → 0.7.0

package/dist/handler-B0ds0OHJ.d.mts

@@ -0,0 +1,269 @@
+import { n as HeadDescriptor } from "./head-P-egrtFE.mjs";
+import { r as AuthUser, t as AuthSession } from "./auth-BdsJ0Aff.mjs";
+import { t as StandardSchemaV1 } from "./standard-schema-9CRjx-uR.mjs";
+import * as _$_cloudflare_sandbox0 from "@cloudflare/sandbox";
+import { Context, Env, MiddlewareHandler } from "hono";
+import { RewriteDestination } from "void/routes";
+
+//#region src/runtime/validator.d.ts
+interface ValidatorSlots {
+  body?: StandardSchemaV1;
+  query?: StandardSchemaV1;
+  params?: StandardSchemaV1;
+}
+interface ValidationSuccess<V extends ValidatorSlots> {
+  ok: true;
+  input: HandlerInput<V>;
+}
+interface ValidationFailure {
+  ok: false;
+  response: Response;
+}
+type HandlerInput<V extends ValidatorSlots> = { [K in keyof V as V[K] extends StandardSchemaV1 ? K : never]: V[K] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<V[K]> : never };
+declare function runValidation<V extends ValidatorSlots>(validators: V, c: CloudContext): Promise<ValidationSuccess<V> | ValidationFailure>;
+//#endregion
+//#region src/pages/validation-error.d.ts
+declare class ValidationError extends Error {
+  readonly errors: Record<string, string>;
+  constructor(errors: Record<string, string>);
+}
+//#endregion
+//#region src/pages/defer.d.ts
+/** Reactive wrapper for a deferred prop on non-React clients. */
+type DeferredState<T> = {
+  readonly loading: true;
+  readonly value: null;
+  readonly error: null;
+} | {
+  readonly loading: false;
+  readonly value: T;
+  readonly error: null;
+} | {
+  readonly loading: false;
+  readonly value: null;
+  readonly error: Error;
+};
+/**
+* Deferred props are represented as framework-native resources on the client.
+* React treats them as promises consumed with `use()`, while the other adapters
+* expose the historical `{ loading, value, error }` state object.
+*/
+type Deferred<T> = DeferredState<T> & Promise<T>;
+/** Extract the props type from a typed handler (loader). */
+type InferProps<T> = T extends {
+  __output: infer R;
+} ? R : never;
+declare function defer<T>(resolver: (c: CloudContext) => Promise<T>): Deferred<T>;
+declare function defer<T>(group: string, resolver: (c: CloudContext) => Promise<T>): Deferred<T>;
+//#endregion
+//#region src/runtime/handler.d.ts
+/**
+* Thrown when `c.rewrite()` is called with a destination whose final path
+* segment ends in a known static-asset extension (e.g. `/hero.png`,
+* `/app.css`). Runtime rewrites only reach routes and SSR entries inside
+* the worker — static asset handlers run in front of the worker, so a
+* `c.rewrite()` into an asset path re-enters the Hono router, matches
+* nothing, and returns a 404. Fail at the call site so users reach for
+* static `routing.rewrites` instead of debugging a mystery 404.
+*/
+declare class VoidAssetRewriteError extends Error {
+  override name: string;
+  constructor(destination: string);
+}
+/**
+* Hono environment type for Void workers.
+*
+* Includes standard Cloudflare bindings plus request-scoped auth
+* variables populated by Better Auth middleware.
+*/
+interface CloudContextVariables {
+  user: AuthUser | null;
+  session: AuthSession | null;
+  headDefaults?: HeadDescriptor;
+  [key: string]: unknown;
+}
+/**
+* Hono `Bindings` shape for Void workers.
+*
+* Augmented by the generated `.void/env.d.ts` so user-declared env keys
+* become typed on `c.env`. The index signature keeps untyped access
+* working for bindings that aren't in the schema (queues, custom
+* bindings, etc.).
+*/
+interface CloudBindings {
+  DB: D1Database;
+  KV: KVNamespace;
+  STORAGE: R2Bucket;
+  AI: Ai;
+  SANDBOX: DurableObjectNamespace<_$_cloudflare_sandbox0.Sandbox>;
+  [key: string]: unknown;
+}
+interface CloudEnv extends Env {
+  Bindings: CloudBindings;
+  Variables: CloudContextVariables;
+}
+declare module "hono" {
+  interface Context {
+    /**
+    * Rewrite the request to a different internal path without changing the browser URL.
+    *
+    * Must be called inside a `defineMiddleware` handler and the result must be returned:
+    *
+    * ```ts
+    * export default defineMiddleware(async (c, next) => {
+    *   if (!hasLocalePrefix(c.req.path)) {
+    *     return c.rewrite(`/en${c.req.path}`);
+    *   }
+    *   return next();
+    * });
+    * ```
+    *
+    * The request is re-dispatched through the Hono router with the new pathname.
+    * The re-dispatched request is tracked internally so that static routing rules
+    * do not re-evaluate on it. Your middleware is responsible for its own loop
+    * prevention (e.g., checking if the path already has a prefix).
+    *
+    * The `path` type is `RewriteDestination`, which is `keyof RouteMap | (string & {})`.
+    * Known routes autocomplete, but any string is still accepted so dynamic paths
+    * (e.g. `` `/users/${id}` ``) continue to work. When `.void/routes.d.ts` has not
+    * been generated yet, `RouteMap` is empty and this is equivalent to `string`.
+    */
+    rewrite: (path: RewriteDestination) => Promise<Response>;
+    /**
+    * Returns the URL the client actually requested — the pre-rewrite URL as
+    * a `URL` object — or `null` when the current request was not rewritten.
+    *
+    * Set on every Void-managed request, whether the rewrite came from a
+    * static rule (`routing.rewrites`, `routing.fallbacks`, `_redirects`
+    * `200`/`200!`) or `c.rewrite()` in middleware. Useful for canonical
+    * link generation and locale negotiation that must reference the URL
+    * the user actually requested.
+    */
+    originalUrl: () => URL | null;
+    /**
+    * Returns `true` when the current request was re-dispatched by a rewrite,
+    * `false` otherwise. Equivalent to `c.originalUrl() !== null`.
+    *
+    * Use this to skip side-effectful work that would otherwise double-fire
+    * on the second pass of middleware (request logging, rate-limit
+    * increments, auth audit trails). Static rewrites (edge dispatch,
+    * `routing.rewrites`, `routing.fallbacks`, `_redirects` `200`/`200!`)
+    * and `c.rewrite()` in middleware both set the flag.
+    */
+    isRewritten: () => boolean;
+  }
+}
+/**
+* Hono {@link Context} pre-typed with {@link CloudEnv}.
+*
+* This is the type of the `c` parameter in route handlers and middleware
+* created with {@link defineHandler} and {@link defineMiddleware}.
+*/
+type CloudContext = Context<CloudEnv>;
+type HandlerFn = (c: CloudContext) => unknown | Promise<unknown>;
+type MiddlewareFn = MiddlewareHandler<CloudEnv>;
+/** Pre-rendered asset tags injected by the SSR build. */
+interface RenderAssetTags {
+  /** CSS stylesheet links for `<head>`. */
+  css: string;
+  /** JS modulepreload links for `<head>` (only when page needs JS). */
+  preloads: string;
+  /** Script tags for `</body>` (only when page needs JS). */
+  body: string;
+}
+type RenderFn = (c: CloudContext, assetTags: RenderAssetTags) => Response | Promise<Response>;
+type JobController = ScheduledController;
+type JobExecutionContext = ExecutionContext;
+type ScheduledFn = (controller: JobController, env: CloudEnv["Bindings"], ctx: JobExecutionContext) => unknown | Promise<unknown>;
+type QueueRetryOptions = {
+  delaySeconds?: number;
+};
+/** A single message in a queue batch. */
+type QueueMessage<T = unknown> = {
+  readonly id: string;
+  readonly timestamp: Date;
+  readonly body: T;
+  readonly attempts: number;
+  ack(): void;
+  retry(options?: QueueRetryOptions): void;
+};
+/** A batch of queue messages delivered to a consumer handler. */
+type QueueBatch<T = unknown> = {
+  readonly queue: string;
+  readonly messages: Array<QueueMessage<T>>;
+  ackAll(): void;
+  retryAll(options?: QueueRetryOptions): void;
+};
+type QueueFn<T = unknown> = (batch: QueueBatch<T>, env: CloudEnv["Bindings"]) => void | Promise<void>;
+/**
+* A typed queue handler with a phantom type carrier for the payload type.
+* `__payload` exists at the type level only —
+* TypeScript's `typeof import(...)` reads it for codegen.
+*/
+interface TypedQueueHandler<T = unknown> {
+  (batch: QueueBatch<T>, env: CloudEnv["Bindings"]): void | Promise<void>;
+  readonly __payload: T;
+}
+/**
+* A typed handler with phantom type carriers for validators and return type.
+* `__validators` and `__output` exist at the type level only —
+* TypeScript's `typeof import(...)` reads them for codegen.
+*/
+interface TypedHandler<V extends ValidatorSlots = {}, R = unknown> {
+  (c: CloudContext): Promise<Response> | Response | unknown | Promise<unknown>;
+  readonly __validators: V;
+  readonly __output: R;
+}
+/**
+* Define a route handler, optionally composed with per-route middleware.
+*
+* Single argument: identity wrapper (backwards compatible).
+* Multiple arguments: middleware chain + final handler, composed at runtime.
+*/
+declare function defineHandler<R>(handler: (c: CloudContext) => R | Response | Promise<R | Response>): TypedHandler<{}, Exclude<Awaited<R>, Response>>;
+declare function defineHandler(m1: MiddlewareFn, handler: HandlerFn): TypedHandler;
+declare function defineHandler(m1: MiddlewareFn, m2: MiddlewareFn, handler: HandlerFn): TypedHandler;
+declare function defineHandler(m1: MiddlewareFn, m2: MiddlewareFn, m3: MiddlewareFn, handler: HandlerFn): TypedHandler;
+declare function defineHandler(m1: MiddlewareFn, m2: MiddlewareFn, m3: MiddlewareFn, m4: MiddlewareFn, handler: HandlerFn): TypedHandler;
+declare function defineHandler(m1: MiddlewareFn, m2: MiddlewareFn, m3: MiddlewareFn, m4: MiddlewareFn, m5: MiddlewareFn, handler: HandlerFn): TypedHandler;
+/**
+* Create a handler with input validation using Standard Schema validators.
+*
+* ```ts
+* export const POST = defineHandler.withValidator({
+*   body: mySchema,
+* })((c, { body }) => {
+*   return { received: body };
+* });
+* ```
+*/
+declare namespace defineHandler {
+  function withValidator<V extends ValidatorSlots>(validators: V): <R>(handler: (c: CloudContext, input: HandlerInput<V>) => R) => TypedHandler<V, R>;
+}
+/**
+* Identity function that provides type inference for middleware.
+* At runtime it simply returns the function passed to it.
+*/
+declare function defineMiddleware(handler: MiddlewareHandler<CloudEnv>): MiddlewareHandler<CloudEnv>;
+/**
+* Identity function that provides type inference for scheduled jobs.
+* At runtime it simply returns the function passed to it.
+*/
+declare function defineScheduled(handler: ScheduledFn): ScheduledFn;
+/**
+* Identity function that provides type inference for SSR render entry.
+* The second argument includes asset tags for client scripts/styles.
+*/
+declare function defineRender(handler: RenderFn): RenderFn;
+/**
+* Identity function that provides type inference for page `head()` exports.
+* At runtime it simply returns the function passed to it.
+*/
+declare function defineHead<P = Record<string, unknown>>(handler: (c: CloudContext, props: P) => HeadDescriptor | undefined): (c: CloudContext, props: P) => HeadDescriptor | undefined;
+/**
+* Identity function that provides type inference for queue consumers.
+* At runtime it simply returns the function passed to it.
+*/
+declare function defineQueue<T = unknown>(handler: QueueFn<T>): TypedQueueHandler<T>;
+//#endregion
+export { HandlerInput as C, ValidationError as S, runValidation as T, defineScheduled as _, QueueBatch as a, InferProps as b, RenderAssetTags as c, VoidAssetRewriteError as d, defineHandler as f, defineRender as g, defineQueue as h, CloudEnv as i, TypedHandler as l, defineMiddleware as m, CloudContext as n, QueueMessage as o, defineHead as p, CloudContextVariables as r, QueueRetryOptions as s, CloudBindings as t, TypedQueueHandler as u, Deferred as v, ValidatorSlots as w, defer as x, DeferredState as y };

package/dist/head-P-egrtFE.d.mts

@@ -0,0 +1,45 @@
+//#region src/pages/head.d.ts
+/** Shape of a single page's head metadata. */
+interface HeadDescriptor {
+  title?: string;
+  meta?: Array<{
+    name?: string;
+    property?: string;
+    content?: string;
+    charset?: string;
+  }>;
+  link?: Array<{
+    rel: string;
+    href: string;
+    [key: string]: string | undefined;
+  }>;
+  script?: Array<{
+    src?: string;
+    innerHTML?: string;
+    [key: string]: string | undefined;
+  }>;
+  htmlAttrs?: Record<string, string>;
+  bodyAttrs?: Record<string, string>;
+}
+/** Extended head config with template support (used in void.json). */
+interface HeadConfig extends HeadDescriptor {
+  /** Title template — `%s` is replaced with the page title. */
+  titleTemplate?: string;
+}
+/**
+* Merge head descriptors with precedence: page > middleware > config.
+*
+* - `title`: page wins; `titleTemplate` from config wraps it (`%s` replaced)
+* - `meta`: page overrides entries with same `name`/`property`; others appended
+* - `link`/`script`: concatenated (config first, then middleware, then page)
+* - `htmlAttrs`/`bodyAttrs`: shallow merge, page wins conflicts
+*/
+declare function resolveHead(configHead: HeadConfig | undefined, middlewareHead: HeadDescriptor | undefined, pageHead: HeadDescriptor | undefined): HeadDescriptor | undefined;
+/** Serialize a HeadDescriptor to HTML tags for injection into `<head>`. */
+declare function renderHeadToString(head: HeadDescriptor): string;
+/** Serialize htmlAttrs to an attribute string (includes leading space). */
+declare function renderHtmlAttrs(head: HeadDescriptor): string;
+/** Serialize bodyAttrs to an attribute string (includes leading space). */
+declare function renderBodyAttrs(head: HeadDescriptor): string;
+//#endregion
+export { renderHtmlAttrs as a, renderHeadToString as i, HeadDescriptor as n, resolveHead as o, renderBodyAttrs as r, HeadConfig as t };

package/dist/headers-DCXc7mDs.mjs

@@ -0,0 +1,279 @@
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { a as convertRedirectsConfig, d as parseHostPrefixedSource, i as convertHeadersConfig, o as convertRewritesConfig, r as convertFallbacksConfig, s as countSplats, t as VALID_REDIRECT_STATUSES, u as isProtocolRelative } from "./config-BIa9HwVX.mjs";
+import { i as voidWarn } from "./log-DXdqnmhF.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/cli/headers.ts
+/**
+* Parse a Cloudflare/Netlify `_headers` file into HeaderRule[].
+*
+* Format:
+*   - Non-indented lines = path pattern (starts a new block)
+*   - Indented lines = `Header-Name: value` (split on first `:`)
+*   - Lines starting with `#` are comments
+*   - `! Header-Name` unset directives are skipped (last-match-wins handles this)
+*
+* Output is sorted by pattern length ascending (shortest first) so that
+* more-specific patterns come last — matching dispatch's last-match-wins semantics.
+*
+* Returns `undefined` if the file doesn't exist or yields no valid rules.
+*/
+function parseHeadersFile(dir) {
+	const filePath = join(dir, "_headers");
+	if (!existsSync(filePath)) return;
+	const content = readFileSync(filePath, "utf-8");
+	const rules = [];
+	let current = null;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trimEnd();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		if (line[0] === " " || line[0] === "	") {
+			if (!current) continue;
+			const stripped = trimmed.trimStart();
+			if (stripped.startsWith("!")) continue;
+			const colonIdx = stripped.indexOf(":");
+			if (colonIdx === -1) continue;
+			const name = stripped.slice(0, colonIdx).trim();
+			const value = stripped.slice(colonIdx + 1).trim();
+			if (name) current.headers.push([name, value]);
+		} else {
+			if (current && current.headers.length > 0) rules.push(current);
+			current = {
+				pattern: trimmed,
+				headers: []
+			};
+		}
+	}
+	if (current && current.headers.length > 0) rules.push(current);
+	if (rules.length === 0) return;
+	rules.sort((a, b) => a.pattern.length - b.pattern.length);
+	return rules;
+}
+/**
+* Parse a `_redirects` file.
+*
+* Format: `source destination [status]` per line (status defaults to 302).
+* Lines starting with # are comments. Includes 3xx redirects and 200 rewrites.
+*
+* Force suffix (`!`) semantics:
+*   - On status 200: toggles `force: true` (Netlify-compat). The plain form
+*     fires only when the static asset would 404; the force form fires
+*     unconditionally, overriding any matching static asset.
+*   - On 3xx (301/302/307/308): silently stripped. A redirect always changes
+*     the URL, so `!` is redundant. We count these in `redundantForceOn3xx`
+*     so the deploy command can surface a single aggregated lint warning
+*     rather than one per line — Netlify users pasting their `_redirects`
+*     file shouldn't be punished for harmless cruft.
+*
+* Returns `undefined` when the file doesn't exist or yields no valid rules.
+* Otherwise returns `{rules, redundantForceOn3xx}`.
+*/
+function parseRedirectsFile(dir) {
+	const filePath = join(dir, "_redirects");
+	if (!existsSync(filePath)) return;
+	const content = readFileSync(filePath, "utf-8");
+	const rules = [];
+	let redundantForceOn3xx = 0;
+	const rawLines = content.split("\n");
+	for (let i = 0; i < rawLines.length; i++) {
+		const lineNumber = i + 1;
+		const trimmed = rawLines[i].trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const parts = trimmed.split(/\s+/);
+		if (parts.length < 2) continue;
+		const origin = `_redirects:${lineNumber}`;
+		const [rawSource, destination, statusStr] = parts;
+		const parsedSource = parseHostPrefixedSource(rawSource);
+		if ("error" in parsedSource) {
+			voidWarn(`Skipping _redirects entry "${rawSource} ${destination}${statusStr ? ` ${statusStr}` : ""}" (line ${lineNumber}): source ${parsedSource.error}.`);
+			continue;
+		}
+		const { host, path: source } = parsedSource;
+		if (countSplats(source) > 1) {
+			voidWarn(`Skipping _redirects entry "${rawSource} ${destination}${statusStr ? ` ${statusStr}` : ""}" (line ${lineNumber}): source must contain at most one "*" wildcard (captured as :splat).`);
+			continue;
+		}
+		let status;
+		let force = false;
+		if (statusStr) if (statusStr.endsWith("!")) {
+			const numericPart = statusStr.slice(0, -1);
+			status = parseInt(numericPart, 10);
+			if (status === 200) force = true;
+			else if (status >= 300 && status < 400) redundantForceOn3xx++;
+		} else status = parseInt(statusStr, 10);
+		else status = 302;
+		if (status === 200) {
+			if (!destination.startsWith("/")) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must start with "/" (only internal paths are supported).`);
+				continue;
+			}
+			if (isProtocolRelative(destination)) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must not start with "//" (protocol-relative URLs parse as cross-origin; only internal paths are supported).`);
+				continue;
+			}
+			if (destination.includes("?")) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must not contain "?" (query strings are not supported in rewrite destinations; the incoming request's query is preserved automatically).`);
+				continue;
+			}
+			rules.push({
+				source,
+				destination,
+				status,
+				force,
+				origin,
+				...host && { host }
+			});
+		} else if (status >= 300 && status < 400) {
+			if (!VALID_REDIRECT_STATUSES.has(status)) {
+				voidWarn(`Skipping _redirects entry "${rawSource} ${destination} ${statusStr}" (line ${lineNumber}): redirect status must be 301, 302, 303, 307, or 308.`);
+				continue;
+			}
+			rules.push({
+				source,
+				destination,
+				status,
+				origin,
+				...host && { host }
+			});
+		}
+	}
+	if (rules.length === 0 && redundantForceOn3xx === 0) return;
+	return {
+		rules,
+		redundantForceOn3xx
+	};
+}
+/**
+* Split parsed `_redirects` rules into "always-apply" and "asset-miss only"
+* buckets. Rules with `status: 200` and `force === false` are fallbacks — they
+* should only fire when the static asset resolver would 404. All other rules
+* (3xx redirects and forced `200!` rewrites) stay in the "always" bucket and
+* are merged with `routing.rewrites` / `routing.redirects` from void.json.
+*/
+function splitRedirectRulesByForce(rules) {
+	const always = [];
+	const fallbacks = [];
+	if (!rules) return {
+		always,
+		fallbacks
+	};
+	for (const rule of rules) if (rule.status === 200 && rule.force !== true) fallbacks.push(rule);
+	else always.push(rule);
+	return {
+		always,
+		fallbacks
+	};
+}
+/**
+* Merge file-based rules (`_redirects`, `_headers`) in `dir` with routing
+* rules from `void.json`. Shared between the deploy pipeline and the dev
+* plugin so both surfaces produce identical rule tables.
+*
+* Ordering for routing rules (redirects/rewrites/fallbacks): `void.json`
+* rules first, then `_redirects` file rules. Because the router evaluates
+* routing rules with first-match-wins semantics, `void.json` entries
+* override `_redirects` entries for the same source — matching the
+* documented precedence (`docs/guide/edge/rewrites.md`). This holds even
+* though `_redirects` is conceptually "closer to the build output".
+*
+* Header rules use the inverse order — `_redirects`/`_headers` last —
+* because header rules are last-match-wins (`_headers` is Netlify-style
+* last-wins). The asymmetry is intentional and matches dispatch.
+*
+* Phase split:
+*   - `_redirects` `200!` (force) + 3xx entries → `redirectRules` (always-fire)
+*   - `_redirects` plain `200`           entries → `fallbackRules` (asset-miss)
+*   - `routing.redirects` + `routing.rewrites`    → `redirectRules`
+*   - `routing.fallbacks`                         → `fallbackRules`
+*
+* Returns `fallbackRules === undefined` when empty so callers that default to
+* "no post-asset phase" behave identically to the old deploy code.
+*
+* Duplicate linting is NOT called here (callers decide which warning surface
+* to use — CLI vs. Vite logger). `redundantForceOn3xx` is returned raw for
+* the same reason.
+*/
+function mergeRoutingRules(opts) {
+	const { dir, routing } = opts;
+	const fileDir = dir !== null && existsSync(dir) ? dir : null;
+	const fileHeaders = fileDir !== null ? parseHeadersFile(fileDir) : void 0;
+	const fileParsed = fileDir !== null ? parseRedirectsFile(fileDir) : void 0;
+	const { always: fileAlways, fallbacks: fileFallbacks } = splitRedirectRulesByForce(fileParsed?.rules);
+	const cfgHeaders = convertHeadersConfig(routing?.headers);
+	const cfgRedirects = convertRedirectsConfig(routing?.redirects);
+	const cfgRewrites = convertRewritesConfig(routing?.rewrites);
+	const cfgFallbacks = convertFallbacksConfig(routing?.fallbacks);
+	const headerRules = [...fileHeaders ?? [], ...cfgHeaders ?? []];
+	const redirectRules = [
+		...cfgRedirects ?? [],
+		...cfgRewrites ?? [],
+		...fileAlways
+	];
+	const mergedFallbacks = [...cfgFallbacks ?? [], ...fileFallbacks];
+	return {
+		headerRules,
+		redirectRules,
+		fallbackRules: mergedFallbacks.length > 0 ? mergedFallbacks : void 0,
+		redundantForceOn3xx: fileParsed?.redundantForceOn3xx ?? 0
+	};
+}
+/**
+* Warn when a rule's `destination` contains a literal `*`. The platform's
+* `substituteParams` only replaces `:name` tokens (e.g. `:splat`, `:id`) —
+* bare `*` in destinations is a literal character, not a capture reference,
+* and will silently pass through to the rewritten/redirected URL.
+*
+* Users who write `/old/*` → `/new/*` almost always intended `:splat` to
+* reflect the captured portion of the source wildcard. Surface the mistake
+* with a single aggregated warning at the same surface as
+* `lintDuplicateSources` — per-phase, near the merge site — rather than
+* failing the deploy: a `*` in a destination is well-formed output, just
+* probably not what was meant.
+*
+* Only reported once per rule — the count of `*` in the destination is
+* irrelevant, a single occurrence is already suspicious.
+*/
+function lintDestinationSplats(rules, phaseName) {
+	if (!rules || rules.length === 0) return;
+	const affected = rules.filter((r) => r.destination.includes("*"));
+	if (affected.length === 0) return;
+	voidWarn(`destinations in ${phaseName} contain a literal "*" — splat tokens are not substituted in destinations; use ":splat" (or other named params) or rewrite the destination:\n${affected.map((r) => `  ${r.source} → ${r.destination}  (${r.origin ?? "<unknown>"})`).join("\n")}`);
+}
+/**
+* Warn when the same `source` pattern appears more than once within a single
+* merged phase (pre-asset `redirectRules` or post-asset `fallbackRules`).
+*
+* Sources are scoped to the phase: a pattern appearing once in redirects and
+* once in fallbacks is *not* a collision, because those lists run in separate
+* phases and don't shadow each other. Within a single phase the dispatcher
+* uses first-match-wins semantics, so a duplicate silently hides the later
+* entry. This lint never fails the deploy; it surfaces the collision so the
+* user can decide whether to fix it.
+*
+* Only exact string duplicates are reported. Subset-shadow cases (e.g. `/*`
+* overshadowing `/docs`) are out of scope — pattern-aware analysis would be
+* both harder and noisier.
+*
+* Emits a single aggregated warning summarizing every duplicated source, each
+* annotated with the `origin` of every occurrence (e.g. `_redirects:12` vs
+* `void.json#routing.rewrites`). Aggregation avoids a wall of per-pair
+* warnings on configs with many collisions.
+*/
+function lintDuplicateSources(rules, phaseName) {
+	if (!rules || rules.length < 2) return;
+	const bySource = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const existing = bySource.get(rule.source);
+		if (existing) existing.push(rule);
+		else bySource.set(rule.source, [rule]);
+	}
+	const lines = [];
+	for (const [source, occurrences] of bySource) {
+		if (occurrences.length < 2) continue;
+		const origins = occurrences.map((r) => r.origin ?? "<unknown>").join(", ");
+		lines.push(`  ${source}  — ${origins}`);
+	}
+	if (lines.length === 0) return;
+	voidWarn(`duplicate rule sources detected in ${phaseName} (first match wins — the earlier entry takes effect):\n${lines.join("\n")}`);
+}
+//#endregion
+export { parseRedirectsFile as i, lintDuplicateSources as n, mergeRoutingRules as r, lintDestinationSplats as t };

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import { n as HeadDescriptor } from "./head-P-egrtFE.mjs";
+import { r as AuthUser } from "./auth-BdsJ0Aff.mjs";
+import { C as HandlerInput, _ as defineScheduled, a as QueueBatch, b as InferProps, c as RenderAssetTags, d as VoidAssetRewriteError, f as defineHandler, g as defineRender, h as defineQueue, i as CloudEnv, l as TypedHandler, m as defineMiddleware, n as CloudContext, o as QueueMessage, p as defineHead, r as CloudContextVariables, s as QueueRetryOptions, u as TypedQueueHandler, v as Deferred, w as ValidatorSlots, x as defer, y as DeferredState } from "./handler-B0ds0OHJ.mjs";
+import { QueueMap } from "./runtime/queues.mjs";
+import { PluginConfig } from "@cloudflare/vite-plugin";
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+/**
+* Void plugin — the main entry point.
+*
+* Composes:
+* 1. Routing plugin (file-based routing from routes/ and middleware/)
+* 2. Migration plugin (auto-apply .sql migrations on dev startup)
+* 3. @cloudflare/vite-plugin (workerd runtime, HMR, builds)
+*
+* Binding inference runs synchronously here so results are available
+* before the Cloudflare plugin initializes.
+*
+* If the user has a `wrangler.jsonc` / `wrangler.json` in their project root,
+* the Cloudflare plugin reads it and provides the resolved config to our
+* config function. Bindings already defined there (with real IDs for
+* production deployment) are preserved — we only add inferred bindings
+* that are missing. This allows `vite build && wrangler deploy` to work
+* for deploying directly to Cloudflare without the Void platform.
+*/
+declare function voidPlugin(options?: {
+  persistTo?: string;
+  auxiliaryWorkers?: PluginConfig["auxiliaryWorkers"];
+}): Array<Plugin>;
+//#endregion
+export { type AuthUser, type CloudContext, type CloudContextVariables, type CloudEnv, type Deferred, type DeferredState, type HandlerInput, type HeadDescriptor, type InferProps, type QueueBatch, type QueueMap, type QueueMessage, type QueueRetryOptions, type RenderAssetTags, type TypedHandler, type TypedQueueHandler, type ValidatorSlots, VoidAssetRewriteError, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled, voidPlugin };