void 0.10.12 → 0.20.0

package/dist/runtime/isr-cache.mjs

@@ -1,523 +0,0 @@
-//#region src/runtime/isr-cache.ts
-/**
-* Build the normalized path segment for an ISR-cached page.
-* Root path `/` maps to `__index__` to avoid trailing-slash ambiguity.
-*/
-function normalizeIsrPath(pathname) {
-	let normalized = pathname;
-	if (normalized === "/") normalized = "__index__";
-	else {
-		normalized = normalized.startsWith("/") ? normalized.slice(1) : normalized;
-		if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
-	}
-	return normalized;
-}
-/**
-* Inverse of `normalizeIsrPath`: turn a normalized segment back into a
-* pathname starting with `/`.
-*/
-function denormalizeIsrPath(normalized) {
-	return normalized === "__index__" ? "/" : `/${normalized}`;
-}
-/**
-* Canonicalize an inbound pathname to the form used inside edge cache URLs.
-* Equivalent to `denormalizeIsrPath(normalizeIsrPath(pathname))` — strips any
-* trailing slash except for root.
-*/
-function canonicalIsrPathname(pathname) {
-	return denormalizeIsrPath(normalizeIsrPath(pathname));
-}
-/**
-* KV cache key for an ISR-cached page. Deployment- AND host-scoped: cached HTML
-* cannot outlive the hashed assets of the deployment that produced it (a fresh
-* `wrangler deploy` mints a new deployment id → cold cache), and one host's
-* cached content never bleeds into another host served by the same worker
-* (custom domain + workers.dev, apex + www, etc.).
-*/
-function isrKey(deploymentId, host, pathname) {
-	return `void-isr/${deploymentId}/${host}/${normalizeIsrPath(pathname)}`;
-}
-/**
-* Host-registry key. Every host that has written cached content registers itself
-* under `void-isr-hosts/<id>/<host>` (value `''`) so a purge with no request host
-* (cron / queue `revalidate({ paths })`) can enumerate the hosts to purge.
-* Scoped by deployment id so registrations from an old deploy do not leak.
-*/
-function hostRegistryKey(deploymentId, host) {
-	return `void-isr-hosts/${deploymentId}/${host}`;
-}
-/**
-* Edge-cache (`caches.default`) key for the HTML variant. The public URL stays
-* clean; this internal key carries the deployment id so a new deploy never
-* reads HTML produced by an older deploy.
-*/
-function htmlEdgeKey(host, pathname, id) {
-	return `https://${host}${canonicalIsrPathname(pathname)}?__void_isr=${id}`;
-}
-/**
-* Edge-cache key for the JSON (pages-protocol) variant. Separated from HTML by
-* the `&__void=json` marker.
-*/
-function jsonEdgeKey(host, pathname, id) {
-	return `${htmlEdgeKey(host, pathname, id)}&__void=json`;
-}
-const MAX_CACHE = 256;
-const literalRegexCache = /* @__PURE__ */ new Map();
-/**
-* Match a pattern against a pathname using LITERAL semantics — no named
-* captures. Two wildcards are special: `*` matches any characters INCLUDING `/`
-* (a splat), and a WHOLE-segment `:name` (preceded by `/` or start, followed by
-* `/` or end) matches exactly ONE path segment (`[^/]+`). A mid-segment literal
-* `:` (e.g. `/api/v1:health`) is left alone. This is a strict SUPERSET of the
-* old `*`-only matcher (old `*`-only manifests match identically). Malformed
-* patterns yield `false` rather than throwing.
-*/
-function matchLiteralPattern(pattern, pathname) {
-	let regex = literalRegexCache.get(pattern);
-	if (regex) {
-		literalRegexCache.delete(pattern);
-		literalRegexCache.set(pattern, regex);
-	} else {
-		try {
-			const escaped = pattern.replace(/(^|\/):[A-Za-z0-9_]+(?=\/|$)/g, "$1").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("", "[^/]+");
-			regex = new RegExp(`^${escaped}$`);
-		} catch {
-			return false;
-		}
-		if (literalRegexCache.size >= MAX_CACHE) {
-			const first = literalRegexCache.keys().next();
-			if (!first.done) literalRegexCache.delete(first.value);
-		}
-		literalRegexCache.set(pattern, regex);
-	}
-	try {
-		return regex.test(pathname);
-	} catch {
-		return false;
-	}
-}
-/**
-* Pack response headers + body into a single ArrayBuffer.
-* Format: [4 bytes uint32 LE header length][UTF-8 header JSON][raw body]
-*/
-function packIsrValue(headers, body) {
-	const headerJson = new TextEncoder().encode(JSON.stringify(headers));
-	const buffer = new ArrayBuffer(4 + headerJson.byteLength + body.byteLength);
-	new DataView(buffer).setUint32(0, headerJson.byteLength, true);
-	new Uint8Array(buffer, 4, headerJson.byteLength).set(headerJson);
-	new Uint8Array(buffer, 4 + headerJson.byteLength).set(new Uint8Array(body));
-	return buffer;
-}
-/**
-* Unpack headers + body from a packed ArrayBuffer.
-* Returns null if the buffer is too small or malformed.
-*/
-function unpackIsrValue(buffer) {
-	if (buffer.byteLength < 4) return null;
-	const headerLen = new DataView(buffer).getUint32(0, true);
-	if (buffer.byteLength < 4 + headerLen) return null;
-	try {
-		const headerBytes = new Uint8Array(buffer, 4, headerLen);
-		return {
-			headers: JSON.parse(new TextDecoder().decode(headerBytes)),
-			body: buffer.slice(4 + headerLen)
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* Read an ISR cache entry from KV. Returns null on cache miss, malformed
-* metadata, or ANY KV error (fail-open → caller renders live). The KV key is
-* deployment-scoped via `env.__VOID_ISR_DEPLOYMENT_ID` (see module header) and
-* host-scoped via `host` so one host never reads another host's cached bytes.
-*/
-async function readIsrCache(env, host, pathname) {
-	const kv = env.ISR_CACHE;
-	if (!kv) return null;
-	const key = isrKey(env.__VOID_ISR_DEPLOYMENT_ID ?? "", host, pathname);
-	let value;
-	let metadata;
-	try {
-		const result = await kv.getWithMetadata(key, "arrayBuffer");
-		value = result.value;
-		metadata = result.metadata;
-	} catch {
-		return null;
-	}
-	if (!value || !metadata) return null;
-	const unpacked = unpackIsrValue(value);
-	if (!unpacked) return null;
-	if (!Number.isInteger(metadata.s) || metadata.s < 200 || metadata.s > 599) return null;
-	if (!Number.isFinite(metadata.c) || metadata.c <= 0 || !Number.isFinite(metadata.t) || metadata.t <= 0) return null;
-	try {
-		new Headers(unpacked.headers);
-	} catch {
-		return null;
-	}
-	return {
-		body: new ReadableStream({ start(controller) {
-			controller.enqueue(new Uint8Array(unpacked.body));
-			controller.close();
-		} }),
-		status: metadata.s,
-		headers: unpacked.headers,
-		createdAt: metadata.c,
-		ttl: metadata.t
-	};
-}
-/**
-* Write an ISR cache entry to KV. The `response.clone()` is taken SYNCHRONOUSLY
-* before any `await` so a caller that consumes `response.body` for the client
-* response (after kicking us off via `ctx.waitUntil`) cannot race the body
-* away. Any KV error is swallowed (fail-open on the write path).
-*/
-async function writeIsrCache(env, host, pathname, response, ttl) {
-	const kv = env.ISR_CACHE;
-	if (!kv) return;
-	const responseClone = response.clone();
-	const headers = serializeHeaders(responseClone);
-	const status = responseClone.status;
-	const id = env.__VOID_ISR_DEPLOYMENT_ID ?? "";
-	try {
-		const packed = packIsrValue(headers, await responseClone.arrayBuffer());
-		await kv.put(isrKey(id, host, pathname), packed, { metadata: {
-			s: status,
-			c: Date.now(),
-			t: ttl
-		} });
-	} catch {}
-	await registerIsrHost(kv, id, host);
-}
-/**
-* In-isolate guard: `${id}/${host}` values whose host-registry key this isolate
-* has already written (or attempted). Bounds host registration to ~one KV write
-* per (isolate, deployment, host) instead of one per page write.
-*/
-const registeredHosts = /* @__PURE__ */ new Set();
-async function registerIsrHost(kv, deploymentId, host) {
-	const guardKey = `${deploymentId}/${host}`;
-	if (registeredHosts.has(guardKey)) return;
-	registeredHosts.add(guardKey);
-	try {
-		await kv.put(hostRegistryKey(deploymentId, host), "");
-	} catch {
-		registeredHosts.delete(guardKey);
-	}
-}
-/**
-* List every host that has registered cached content for a deployment. Used by
-* the on-demand `revalidate({ paths })` purge when there is no request host
-* (cron / queue). Fail-open: a registry read error yields the hosts collected so
-* far (or none) rather than throwing — degraded purge coverage, never a 500.
-*/
-async function listIsrHosts(kv, deploymentId) {
-	const prefix = `void-isr-hosts/${deploymentId}/`;
-	const hosts = [];
-	try {
-		let cursor;
-		do {
-			const list = await kv.list({
-				prefix,
-				cursor
-			});
-			for (const key of list.keys) hosts.push(key.name.slice(prefix.length));
-			cursor = list.list_complete ? void 0 : list.cursor;
-		} while (cursor);
-	} catch {}
-	return hosts;
-}
-/**
-* Delete an ISR cache entry from KV. Used when a worker permanently opts out
-* via `x-revalidate: 0`. Any KV error is swallowed (fail-open).
-*/
-async function deleteIsrCache(env, host, pathname) {
-	const kv = env.ISR_CACHE;
-	if (!kv) return;
-	try {
-		await kv.delete(isrKey(env.__VOID_ISR_DEPLOYMENT_ID ?? "", host, pathname));
-	} catch {}
-}
-/** Check if a cached entry is stale. */
-function isStale(entry) {
-	return Date.now() - entry.createdAt > entry.ttl * 1e3;
-}
-/** Build a Response from an ISR cache entry. */
-function isrCacheResponse(entry, stale) {
-	const headers = new Headers(entry.headers);
-	headers.set("x-isr-cache", stale ? "STALE" : "HIT");
-	if (stale) {
-		const staleTtl = Math.min(10, entry.ttl);
-		headers.set("Cache-Control", `public, s-maxage=${staleTtl}, max-age=0, must-revalidate`);
-	} else {
-		const remainingSeconds = Math.max(0, Math.floor((entry.createdAt + entry.ttl * 1e3 - Date.now()) / 1e3));
-		headers.set("Cache-Control", `public, s-maxage=${remainingSeconds}, max-age=0, must-revalidate`);
-	}
-	return new Response(entry.body, {
-		status: entry.status,
-		headers
-	});
-}
-/**
-* Read the `x-revalidate` header from a worker response.
-* Returns the override TTL, or the default. A value of 0 means "do not cache".
-*/
-function resolveRevalidateTtl(response, defaultTtl) {
-	const header = response.headers.get("x-revalidate");
-	if (header === null) return defaultTtl;
-	const value = parseInt(header, 10);
-	if (isNaN(value) || value < 0) return defaultTtl;
-	return value;
-}
-function acceptsEventStream(request) {
-	return request.headers.get("Accept")?.toLowerCase().split(",").some((part) => part.split(";", 1)[0]?.trim() === "text/event-stream") ?? false;
-}
-/**
-* ISR should be bypassed for requests with credentials and EventSource
-* requests. Pages protocol navigation (X-VoidPages) uses a separate JSON edge
-* cache.
-*/
-function shouldBypassIsr(request) {
-	return request.headers.has("Cookie") || request.headers.has("Authorization") || acceptsEventStream(request);
-}
-/**
-* Resolve the ISR TTL for a given pathname.
-* Accepts the `revalidate` config (number, object, or undefined). For the
-* object form, the first matching pattern wins.
-*/
-function resolvePathTtl(revalidate, pathname) {
-	if (revalidate == null) return 0;
-	if (typeof revalidate === "number") return revalidate;
-	for (const [pattern, ttl] of Object.entries(revalidate)) if (matchLiteralPattern(pattern, pathname)) return ttl;
-	return 0;
-}
-/** Extract response headers as a plain object, skipping ISR-managed headers. */
-const SKIP_HEADERS = /* @__PURE__ */ new Set([
-	"cache-control",
-	"x-isr-cache",
-	"x-void-page-data",
-	"set-cookie"
-]);
-function serializeHeaders(response) {
-	const result = {};
-	response.headers.forEach((value, key) => {
-		if (!SKIP_HEADERS.has(key.toLowerCase())) result[key] = value;
-	});
-	return result;
-}
-const PAGE_DATA_SCRIPT_RE = /<script\b[^>]*\bid=(["'])__VOID_PAGE_DATA__\1[^>]*>([\s\S]*?)<\/script>/i;
-function normalizePageDataForJsonCache(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (parsed.deferred !== void 0 || parsed.deferredKeys !== void 0) return null;
-		return raw;
-	} catch {
-		return null;
-	}
-}
-function extractPageDataFromHtml(html) {
-	const match = html.match(PAGE_DATA_SCRIPT_RE);
-	if (!match) return null;
-	return normalizePageDataForJsonCache(match[2]);
-}
-const CLIENT_REVALIDATE_CACHE_CONTROL = "public, max-age=0, must-revalidate";
-function clientRevalidateResponse(response) {
-	const res = new Response(response.body, response);
-	res.headers.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
-	return res;
-}
-function isEventStreamResponse(response) {
-	return response.headers.get("content-type")?.toLowerCase().split(";", 1)[0]?.trim() === "text/event-stream";
-}
-function jsonCacheResponse(pageData, ttl, state) {
-	return new Response(pageData, { headers: {
-		"content-type": "application/json",
-		"X-VoidPages": "true",
-		Vary: "X-VoidPages",
-		"Cache-Control": `public, s-maxage=${ttl}, max-age=0, must-revalidate`,
-		"x-isr-cache": state
-	} });
-}
-/**
-* Populate the JSON edge cache from a response's embedded page data (the
-* `x-void-page-data` header or the `__VOID_PAGE_DATA__` inline script). No-ops
-* when there is no extractable page data. Any cache error is swallowed
-* (fail-open) so this is always safe to fire inside `ctx.waitUntil`.
-*/
-async function populateJsonEdgeCache(cache, cacheKey, response, ttl, state) {
-	if (!cache) return;
-	try {
-		const fromHeader = response.headers.get("x-void-page-data");
-		const pageData = fromHeader ? normalizePageDataForJsonCache(fromHeader) : extractPageDataFromHtml(await response.clone().text());
-		if (!pageData) return;
-		await cache.put(cacheKey, jsonCacheResponse(pageData, ttl, state));
-	} catch {}
-}
-/**
-* The per-colo edge cache (`caches.default`), or `undefined` when the Cache API
-* is absent/degraded. Accessed through a cast because this package has both
-* `@types/node` and `@cloudflare/workers-types` in scope, and Node's ambient
-* `CacheStorage` (which lacks `.default`) otherwise shadows the Workers one on
-* the `caches` global.
-*
-* Non-throwing by contract: dereferencing `caches.default` can throw if the
-* Cache API is missing (e.g. a non-worker runtime) or degraded. We swallow that
-* here and return `undefined` so `handleIsr` never rejects before its fail-open
-* guards run — the serving invariant is a degraded cache must render live, never
-* 500. Every call site guards `undefined` (via `if (!cache)` or `cache?.`).
-*/
-function edgeCache() {
-	try {
-		return caches.default;
-	} catch {
-		return;
-	}
-}
-async function safeCachePut(cache, key, response) {
-	if (!cache) return;
-	try {
-		await cache.put(key, response);
-	} catch {}
-}
-async function safeCacheDelete(cache, key) {
-	if (!cache) return;
-	try {
-		await cache.delete(key);
-	} catch {}
-}
-/**
-* Build a new Request with the `X-VoidPages` header removed. Headers on an
-* existing Request are immutable, so we must clone into a fresh Request. ISR
-* only runs for GET, so there is no body to preserve.
-*/
-function cloneWithoutVoidPages(request) {
-	const headers = new Headers(request.headers);
-	headers.delete("X-VoidPages");
-	return new Request(request, { headers });
-}
-/**
-* Revalidate an ISR page in the background. Re-renders as HTML (X-VoidPages
-* stripped), writes fresh HTML to KV + HTML edge cache, and populates the JSON
-* edge cache from embedded page data. Errors are caught and logged — serve
-* stale, don't retry. `ttl === 0` means the worker permanently opted out:
-* delete the KV entry and both edge variants.
-*/
-async function revalidateInBackground(env, request, host, pathname, defaultTtl, keys, render) {
-	try {
-		const response = await render(cloneWithoutVoidPages(request));
-		if (isEventStreamResponse(response)) return;
-		const ttl = resolveRevalidateTtl(response, defaultTtl);
-		const cache = edgeCache();
-		if (ttl > 0 && response.status === 200) {
-			await writeIsrCache(env, host, pathname, response, ttl);
-			const headers = new Headers(response.headers);
-			headers.set("x-isr-cache", "HIT");
-			headers.set("Cache-Control", `public, s-maxage=${ttl}, max-age=0, must-revalidate`);
-			headers.delete("set-cookie");
-			headers.delete("x-void-page-data");
-			await safeCachePut(cache, keys.htmlKey, new Response(response.clone().body, {
-				status: response.status,
-				headers
-			}));
-			await populateJsonEdgeCache(cache, keys.jsonKey, response, ttl, "HIT");
-		} else if (ttl === 0) {
-			await deleteIsrCache(env, host, pathname);
-			await safeCacheDelete(cache, keys.htmlKey);
-			await safeCacheDelete(cache, keys.jsonKey);
-		}
-	} catch (err) {
-		console.error("ISR revalidation failed:", err);
-	}
-}
-/**
-* Run the ISR caching ladder for a request.
-*
-* Returns a cached/rendered `Response` when ISR applies, or `null` when the
-* caller should render live itself (request not ISR-eligible, or a read/hit
-* cache op failed open).
-*
-* Ladder:
-*   - Bail (`null`) if not GET, a Range request, `shouldBypassIsr`, or the path
-*     has no ISR TTL. Range requests bail BEFORE any cache read/write so they
-*     render live (correct 206) and never touch the shared full-response entry.
-*   - JSON (X-VoidPages) path: edge match → hit serves `clientRevalidateResponse`;
-*     miss renders live JSON and returns it — the JSON path never writes the edge
-*     cache. The JSON edge variant is warmed only as a side-effect of the HTML
-*     render path (cold colo re-renders JSON).
-*   - HTML path: L1 edge match → L2 KV. Hit serves `isrCacheResponse`
-*     (stale hits also queue a background revalidation). Miss renders live and,
-*     when cacheable, writes KV + JSON edge + HTML edge in the background.
-*/
-async function handleIsr(request, env, ctx, options, render) {
-	const { revalidate, deploymentId } = options;
-	if (request.method !== "GET") return null;
-	if (request.headers.has("range")) return null;
-	if (shouldBypassIsr(request)) return null;
-	const url = new URL(request.url);
-	const pathname = url.pathname;
-	const isrTtl = resolvePathTtl(revalidate, pathname);
-	if (isrTtl <= 0) return null;
-	env.__VOID_ISR_DEPLOYMENT_ID ??= deploymentId;
-	const host = url.hostname;
-	const cache = edgeCache();
-	if (request.headers.has("X-VoidPages")) {
-		const jsonKey = jsonEdgeKey(host, pathname, deploymentId);
-		let jsonCached;
-		try {
-			jsonCached = await cache?.match(jsonKey);
-		} catch {
-			return null;
-		}
-		if (jsonCached) return clientRevalidateResponse(jsonCached);
-		return render(request);
-	}
-	const htmlKey = htmlEdgeKey(host, pathname, deploymentId);
-	const jsonKey = jsonEdgeKey(host, pathname, deploymentId);
-	let edgeCached;
-	try {
-		edgeCached = await cache?.match(htmlKey);
-	} catch {
-		return null;
-	}
-	if (edgeCached) return clientRevalidateResponse(edgeCached);
-	const cached = await readIsrCache(env, host, pathname);
-	if (cached) try {
-		const stale = isStale(cached);
-		if (stale) ctx.waitUntil(revalidateInBackground(env, request, host, pathname, isrTtl, {
-			htmlKey,
-			jsonKey
-		}, render));
-		const cacheResponse = isrCacheResponse(cached, stale);
-		ctx.waitUntil(safeCachePut(cache, htmlKey, cacheResponse.clone()));
-		return clientRevalidateResponse(cacheResponse);
-	} catch {
-		return null;
-	}
-	const response = await render(request);
-	if (isEventStreamResponse(response)) return response;
-	const ttl = resolveRevalidateTtl(response, isrTtl);
-	if (ttl > 0 && response.status === 200) {
-		ctx.waitUntil(writeIsrCache(env, host, pathname, response, ttl));
-		ctx.waitUntil(populateJsonEdgeCache(cache, jsonKey, response, ttl, "MISS"));
-		const cacheHeaders = new Headers(response.headers);
-		cacheHeaders.set("Cache-Control", `public, s-maxage=${ttl}, max-age=0, must-revalidate`);
-		cacheHeaders.set("x-isr-cache", "MISS");
-		cacheHeaders.delete("x-void-page-data");
-		cacheHeaders.delete("set-cookie");
-		const cacheResponse = new Response(response.clone().body, {
-			status: response.status,
-			headers: cacheHeaders
-		});
-		ctx.waitUntil(safeCachePut(cache, htmlKey, cacheResponse));
-		const clientHeaders = new Headers(cacheHeaders);
-		clientHeaders.set("Cache-Control", CLIENT_REVALIDATE_CACHE_CONTROL);
-		for (const cookie of response.headers.getSetCookie()) clientHeaders.append("set-cookie", cookie);
-		return new Response(response.body, {
-			status: response.status,
-			headers: clientHeaders
-		});
-	}
-	return response;
-}
-//#endregion
-export { canonicalIsrPathname, clientRevalidateResponse, cloneWithoutVoidPages, deleteIsrCache, denormalizeIsrPath, extractPageDataFromHtml, handleIsr, hostRegistryKey, htmlEdgeKey, isEventStreamResponse, isStale, isrCacheResponse, isrKey, jsonEdgeKey, listIsrHosts, matchLiteralPattern, normalizeIsrPath, normalizePageDataForJsonCache, packIsrValue, populateJsonEdgeCache, readIsrCache, resolvePathTtl, resolveRevalidateTtl, serializeHeaders, shouldBypassIsr, unpackIsrValue, writeIsrCache };

package/dist/types-lLjNE9Qp.d.mts

@@ -1,51 +0,0 @@
-//#region src/pages/types.d.ts
-type ExplicitBoolean = true | false | undefined;
-type SsrMode = "auto" | "server" | "client";
-type PrerenderMode = "auto" | "force" | "disabled";
-type PageRenderMode = "server" | "client" | "island";
-type PageDefinition = {
-  /** URL pattern, e.g. "/users/:id" */pattern: string; /** Route params, e.g. ["id"] */
-  params: Array<string>; /** Whether this is a catch-all route */
-  catchAll: boolean; /** Component file relative path, e.g. "users/[id].vue" */
-  componentPath: string; /** Server handler file relative path, e.g. "users/[id].server.ts" */
-  serverPath: string | null; /** HTTP methods exported by server handler */
-  methods: Array<string>; /** Component ID used in page object, e.g. "users/[id]" */
-  componentId: string; /** Edge caching revalidate TTL in seconds, from .server.ts export */
-  revalidate?: number; /** Whether `export const prerender = true/false` is set in server handler */
-  prerender?: ExplicitBoolean; /** Whether `export const ssr = true/false` is set in server handler */
-  ssr?: ExplicitBoolean; /** Normalized SSR mode from the public `ssr` export */
-  ssrMode: SsrMode; /** Normalized prerender mode from the public `prerender` export */
-  prerenderMode: PrerenderMode; /** Normalized page render mode */
-  renderMode: PageRenderMode; /** Whether this page should participate in prerender collection */
-  shouldPrerender: boolean; /** Whether `export function getPrerenderPaths` is defined in server handler */
-  hasGetPrerenderPaths?: boolean; /** Whether this is an island page (.island.tsx/.island.vue) */
-  island?: boolean; /** Frontmatter metadata extracted from .md files (title, description) */
-  metadata?: {
-    title?: string;
-    description?: string;
-  }; /** Named layout selection: "name", "!name", false, or relative path */
-  layout?: string | false;
-};
-type LayoutDefinition = {
-  /** Directory path relative to pages/, e.g. "" (root) or "users" */directory: string; /** Layout file relative path, e.g. "layout.vue" or "users/layout.vue" */
-  filePath: string; /** Whether this is an island layout (layout.island.tsx/.island.vue) */
-  island?: boolean;
-};
-type NamedLayoutDefinition = {
-  /** Layout name, e.g. "home", "post" */name: string; /** Directory containing _layouts/, e.g. "" (root) or "guide" */
-  directory: string; /** File path relative to pages/, e.g. "_layouts/home.vue" */
-  filePath: string; /** Whether this is an island layout */
-  island?: boolean;
-};
-type PageScanResult = {
-  pages: Array<PageDefinition>;
-  layouts: Array<LayoutDefinition>;
-  namedLayouts: Array<NamedLayoutDefinition>;
-};
-type DevCssAsset = {
-  /** Vite client URL used to request the CSS module. */url: string; /** Vite dev style id used by the client to adopt/update SSR-inlined styles. */
-  id?: string; /** CSS bytes returned by Vite's client environment transform with ?inline. */
-  css: string;
-};
-//#endregion
-export { PageRenderMode as a, PageDefinition as i, LayoutDefinition as n, PageScanResult as o, NamedLayoutDefinition as r, DevCssAsset as t };

package/getting-started-prompt.txt

@@ -1,28 +0,0 @@
-Void is a fullstack Vite framework and deployment platform for Cloudflare.
-In an empty directory, set up a new app like this:
-
-npm install -D void
-
-Then run:
-
-npx void init
-
-In an empty directory, `void init` will add the matching Pages adapter and starter dependencies after you choose a scaffold toolchain and framework. Vite+ is the default toolchain. In an existing app, it configures Void in place by adding missing Vite scripts and creating or patching `vite.config.*` with `voidPlugin()`.
-
-During `void init`, choose Vite+ unless you specifically want plain Vite scripts, then choose a Pages framework (React, Vue, Svelte, or Solid). Choose D1 for a zero-config, fully managed default or PostgreSQL if you already have Postgres infrastructure or expect heavier writes and more complex queries.
-
-At the end of the interactive flow, `void init` can also log you in and link or create your Void project so your first deploy is just:
-
-void deploy
-
-To deploy to your OWN Cloudflare account instead of the Void platform, use `void deploy --backend cloudflare` (add `--provision` on the first deploy to create the D1/KV/R2/Queues/Hyperdrive resources your app needs). Pin an account first (`account_id` in `wrangler.jsonc` or `CLOUDFLARE_ACCOUNT_ID`) and keep real secrets in `wrangler secret put` — `.env` values ship as plaintext worker vars. v1 deploys full Void apps on the Cloudflare Workers target only (D1/KV/R2/Queues/Hyperdrive; auth and ISR on D1/SQLite); framework SSR of every kind (TanStack Start, React Router, vinext, SvelteKit, Nuxt, Analog, Astro), static/SPA/SSG apps (including output: "static"), WebSocket/Durable Object apps (*.ws.ts), a custom migrations_pattern, node/bun/deno targets, and PostgreSQL apps with auth all fail closed with guidance, and auth apps need checked-in migrations that produce the Better Auth schema. `--provision` is a single-operator, dev-machine step and is disabled in CI.
-
-Database workflow: define Drizzle tables in `db/schema.ts`, import `db` from `void/db` and tables from `@schema`. Use `void db push` to prototype (applies schema directly, no migration files). Use `void db generate` when ready to create production migration files in `db/migrations/`. `drizzle-orm` and `drizzle-kit` ship with void — no extra install needed. Scaffold new tables with `void gen model <name> [columns...]`.
-
-Routing extras: declare static redirects/rewrites/fallbacks in `void.json` under `routing.*`, or in a `public/_redirects` file. For dynamic rewrites, call `c.rewrite(path)` in a `defineMiddleware`.
-
-Logs: surface app-level errors via `import { logger } from "void/log"` and `logger.error(msg, fields?)` (also `.warn` / `.info`) so they appear under `void project logs --level error`. Errors only persisted to your own DB are invisible to Cloudflare Tail. Logs only exist where a worker ran — for 5xx generated by the edge router or on static/SPA projects, use `void project requests --status 5xx` instead.
-
-CI / fresh clones: run `void prepare` after install to generate `.void/routes.d.ts`, `.void/db.d.ts`, `.void/queues.d.ts`, `.void/env.d.ts`, and `.void/tsconfig.json` without booting Vite. `vite dev` / `vite build` populate these during normal app workflows.
-
-Now ask me what I want to build.

package/skills/void/command/void.md

@@ -1,7 +0,0 @@
-# `/void` Command Flow
-
-1. Open `SKILL.md`.
-2. If no task/arguments are provided, run the brief app status check from `SKILL.md`.
-3. If a task is provided, route to the smallest relevant set of `docs/*.md` files.
-4. For CLI syntax and flags, always use `docs/cli.md`.
-5. Execute, verify, and report concise next actions.