void 0.21.9 → 0.23.0

package/dist/runtime/migration-handler.mjs

@@ -1,4 +1,4 @@
-import { t as canonicalJson } from "../canonical-json-DuDiiUsQ.mjs";
+import { canonicalJson } from "@void/deploy-core";
 //#region src/runtime/migration-handler.ts
 const SUPPORTED_CLASSIFIER_VERSION = 1;
 function createMigrationHandler(env, migrations, _dialect, runAuthMigrations, planBundle) {
@@ -85,7 +85,8 @@ async function createTrackingTable(db) {
     )`).run();
 }
 async function createAttemptTables(db) {
-	await db.batch([db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_attempts (
+	await db.batch([
+		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_attempts (
         attempt_id TEXT PRIMARY KEY,
         deployment_id TEXT,
         migration_list_hash TEXT NOT NULL,
@@ -95,16 +96,23 @@ async function createAttemptTables(db) {
         started_at TEXT NOT NULL,
         completed_at TEXT,
         error TEXT
-      )`), db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_lock (
+      )`),
+		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_lock (
         name TEXT PRIMARY KEY,
         attempt_id TEXT NOT NULL,
         acquired_at TEXT NOT NULL
-      )`)]);
+      )`),
+		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migration_fences (
+        attempt_id TEXT PRIMARY KEY,
+        owned INTEGER NOT NULL CHECK (owned = 1)
+      )`)
+	]);
 }
-async function upgradeTrackingTable(db) {
+async function upgradeTrackingTable(db, fencedAttemptId) {
 	const { results } = await db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_migrations'").all();
 	if (!results || results.length === 0) return;
 	await db.batch([
+		...ownershipFence(db, fencedAttemptId),
 		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migrations (
         name TEXT PRIMARY KEY,
         applied_at TEXT NOT NULL
@@ -121,18 +129,13 @@ async function runD1AppMigrations(db, migrations, planBundle, attempt) {
 	const verified = await verifyPlanBundle(migrations, planBundle);
 	await createAttemptTables(db);
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const lock = await acquireAttemptLock(db, attempt.attemptId, now);
-	if (lock !== "acquired") return lock;
 	const plannedNames = migrations.map((migration) => migration.name);
 	const planHashes = verified.plans.map((plan) => plan.planHash);
-	try {
-		await db.prepare(`INSERT INTO _void_migration_attempts
+	const fenced = verified.plans.every((plan) => plan.kind !== "legacy-unsplit-multi-statement");
+	const lock = await acquireAttemptLock(db, attempt.attemptId, now, [db.prepare(`INSERT INTO _void_migration_attempts
           (attempt_id, deployment_id, migration_list_hash, planned_names_json, plan_hashes_json, status, started_at)
-         VALUES (?, ?, ?, ?, ?, 'running', ?)`).bind(attempt.attemptId, attempt.deploymentId ?? null, verified.migrationListHash, JSON.stringify(plannedNames), JSON.stringify(planHashes), now).run();
-	} catch {
-		await releaseAttemptLock(db, attempt.attemptId);
-		return reconcileAttempt(db, attempt.attemptId);
-	}
+         VALUES (?, ?, ?, ?, ?, 'running', ?)`).bind(attempt.attemptId, attempt.deploymentId ?? null, verified.migrationListHash, JSON.stringify(plannedNames), JSON.stringify(planHashes), now), ...fenced ? [db.prepare("INSERT INTO _void_migration_fences (attempt_id, owned) VALUES (?, 1)").bind(attempt.attemptId)] : []]);
+	if (lock !== "acquired") return lock;
 	const migrationResults = [];
 	const confirmedApplied = [];
 	const confirmedSkipped = [];
@@ -140,7 +143,7 @@ async function runD1AppMigrations(db, migrations, planBundle, attempt) {
 	let stability = "stable";
 	try {
 		await createTrackingTable(db);
-		await upgradeTrackingTable(db);
+		await upgradeTrackingTable(db, fenced ? attempt.attemptId : void 0);
 		const applied = await readAppliedSet(db);
 		for (let index = 0; index < migrations.length; index++) {
 			const migration = migrations[index];
@@ -159,7 +162,7 @@ async function runD1AppMigrations(db, migrations, planBundle, attempt) {
 			}
 			const start = Date.now();
 			try {
-				await executeMigrationPlan(db, migration, plan);
+				await executeMigrationPlan(db, migration, plan, fenced ? attempt.attemptId : void 0);
 				applied.add(migration.name);
 				confirmedApplied.push(migration.name);
 				migrationResults.push({
@@ -223,16 +226,16 @@ async function runD1AppMigrations(db, migrations, planBundle, attempt) {
 		};
 	}
 }
-async function acquireAttemptLock(db, attemptId, acquiredAt) {
+async function acquireAttemptLock(db, attemptId, acquiredAt, initialize) {
 	for (let tries = 0; tries < 2; tries++) try {
-		await db.prepare("INSERT INTO _void_migration_lock (name, attempt_id, acquired_at) VALUES (?, ?, ?)").bind("app", attemptId, acquiredAt).run();
+		await db.batch([db.prepare("INSERT INTO _void_migration_lock (name, attempt_id, acquired_at) VALUES (?, ?, ?)").bind("app", attemptId, acquiredAt), ...initialize]);
 		return "acquired";
 	} catch {
 		const existing = await db.prepare("SELECT attempt_id FROM _void_migration_lock WHERE name = ?").bind("app").first();
-		if (existing?.attempt_id === attemptId) return reconcileAttempt(db, attemptId);
+		if (!existing && await readAttempt(db, attemptId)) return reconcileAttempt(db, attemptId, false);
 		if (existing?.attempt_id) {
 			const row = await readAttempt(db, existing.attempt_id);
-			if (!row || row.status === "completed" || row.status === "failed" || row.status === "unknown") {
+			if (row?.status === "completed" || row?.status === "failed") {
 				await releaseAttemptLock(db, existing.attempt_id).catch(() => {});
 				continue;
 			}
@@ -253,23 +256,41 @@ async function acquireAttemptLock(db, attemptId, acquiredAt) {
 		error: "migration lock could not be acquired"
 	};
 }
-async function executeMigrationPlan(db, migration, plan) {
+async function executeMigrationPlan(db, migration, plan, fencedAttemptId) {
 	const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
 	if (plan.kind === "single-statement") {
-		await db.batch([db.prepare(migration.sql), db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)]);
+		await db.batch([
+			...ownershipFence(db, fencedAttemptId),
+			db.prepare(migration.sql),
+			db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)
+		]);
 		return;
 	}
 	if (plan.kind === "breakpoint-framed") {
-		await db.batch([...plan.statements.map((statement) => db.prepare(statement)), db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)]);
+		await db.batch([
+			...ownershipFence(db, fencedAttemptId),
+			...plan.statements.map((statement) => db.prepare(statement)),
+			db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt)
+		]);
 		return;
 	}
 	await db.exec(migration.sql);
 	await db.prepare("INSERT OR IGNORE INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(migration.name, appliedAt).run();
 }
-async function markAttempt(db, attemptId, status, error) {
-	await db.prepare(`UPDATE _void_migration_attempts
+/** Fail the whole D1 batch if recovery has revoked this executor's ownership. */
+function ownershipFence(db, attemptId) {
+	if (!attemptId) return [];
+	return [db.prepare(`INSERT INTO _void_migration_fences (attempt_id, owned)
+     VALUES (?, EXISTS(SELECT 1 FROM _void_migration_lock WHERE name = 'app' AND attempt_id = ?))
+     ON CONFLICT(attempt_id) DO UPDATE SET owned = excluded.owned`).bind(attemptId, attemptId)];
+}
+function attemptUpdate(db, attemptId, status, error) {
+	return db.prepare(`UPDATE _void_migration_attempts
        SET status = ?, completed_at = ?, error = ?
-       WHERE attempt_id = ?`).bind(status, (/* @__PURE__ */ new Date()).toISOString(), error ?? null, attemptId).run();
+       WHERE attempt_id = ? AND status ${status === "completed" ? "IN ('running', 'unknown')" : "= 'running'"}`).bind(status, (/* @__PURE__ */ new Date()).toISOString(), error ?? null, attemptId);
+}
+async function markAttempt(db, attemptId, status, error) {
+	await attemptUpdate(db, attemptId, status, error).run();
 }
 async function releaseAttemptLock(db, attemptId) {
 	await db.prepare("DELETE FROM _void_migration_lock WHERE name = ? AND attempt_id = ?").bind("app", attemptId).run();
@@ -277,27 +298,26 @@ async function releaseAttemptLock(db, attemptId) {
 async function readAttempt(db, attemptId) {
 	return db.prepare("SELECT * FROM _void_migration_attempts WHERE attempt_id = ?").bind(attemptId).first();
 }
-async function reconcileAttempt(db, attemptId) {
+async function reconcileAttempt(db, attemptId, recover = true) {
 	await createAttemptTables(db);
 	await createTrackingTable(db);
 	const row = await readAttempt(db, attemptId);
-	if (!row) {
-		await releaseAttemptLock(db, attemptId).catch(() => {});
-		return {
-			ok: false,
-			protocolVersion: 2,
-			attemptId,
-			migrations: [],
-			error: "migration attempt not found"
-		};
-	}
+	if (!row) return {
+		ok: false,
+		protocolVersion: 2,
+		attemptId,
+		migrations: [],
+		error: "migration attempt not found"
+	};
+	const fenced = await db.prepare("SELECT attempt_id FROM _void_migration_fences WHERE attempt_id = ?").bind(attemptId).first();
+	if (recover && fenced) await db.batch([attemptUpdate(db, attemptId, "unknown", "migration outcome unknown"), db.prepare("DELETE FROM _void_migration_lock WHERE name = ? AND attempt_id = ?").bind("app", attemptId)]);
 	const plannedNames = JSON.parse(row.planned_names_json);
 	const applied = await readAppliedSet(db);
 	const confirmed = plannedNames.filter((name) => applied.has(name));
 	const complete = confirmed.length === plannedNames.length;
 	if (complete && row.status !== "completed") await markAttempt(db, attemptId, "completed").catch(() => {});
-	if (!complete && row.status === "running") await markAttempt(db, attemptId, "unknown", row.error ?? "migration outcome unknown").catch(() => {});
-	await releaseAttemptLock(db, attemptId).catch(() => {});
+	const inProgress = !fenced && !complete && (row.status === "running" || row.status === "unknown");
+	if (complete || row.status === "completed" || row.status === "failed") await releaseAttemptLock(db, attemptId);
 	return {
 		ok: complete,
 		protocolVersion: 2,
@@ -310,7 +330,7 @@ async function reconcileAttempt(db, attemptId) {
 			name,
 			status: applied.has(name) ? "skipped" : "failed"
 		})),
-		error: complete ? void 0 : row.error ?? "migration outcome unknown",
+		error: complete ? void 0 : inProgress ? `migration already in progress for attempt ${attemptId}; wait for this migration to finish before retrying recovery` : row.error ?? "migration outcome unknown",
 		stability: "stable"
 	};
 }
@@ -322,7 +342,7 @@ async function verifyPlanBundle(migrations, planBundle) {
 		const migration = migrations[index];
 		const plan = planBundle.plans[index];
 		if (plan.name !== migration.name || plan.dialect !== "sqlite" || plan.classifierVersion !== SUPPORTED_CLASSIFIER_VERSION) throw new Error(`invalid migration execution plan for ${migration.name}`);
-		const sqlHash = await sha256Hex(canonicalSql(migration.sql));
+		const sqlHash = await sha256Hex(canonicalSql$1(migration.sql));
 		if (plan.sqlHash !== sqlHash) throw new Error(`migration SQL hash mismatch for ${migration.name}`);
 		const planHash = await hashPlan(plan);
 		if (plan.planHash !== planHash) throw new Error(`migration plan hash mismatch for ${migration.name}`);
@@ -335,7 +355,7 @@ async function verifyPlanBundle(migrations, planBundle) {
 	if (planBundle.migrationListHash !== migrationListHash) throw new Error("migration list hash mismatch");
 	return planBundle;
 }
-function canonicalSql(sql) {
+function canonicalSql$1(sql) {
 	return (sql.charCodeAt(0) === 65279 ? sql.slice(1) : sql).replace(/\r\n?/g, "\n");
 }
 async function sha256Hex(value) {

package/dist/runtime/route-url.d.mts

@@ -0,0 +1,4 @@
+//#region src/runtime/route-url.d.ts
+/** Expand complete route tokens without changing query strings or fragments. */
+export declare function interpolateRouteParams(path: string, params?: Record<string, string>): string;
+//#endregion

package/dist/runtime/route-url.mjs

@@ -0,0 +1,2 @@
+import { t as interpolateRouteParams } from "../route-url-CG7U-cRN.mjs";
+export { interpolateRouteParams };

package/dist/runtime/routing.d.mts

@@ -0,0 +1,180 @@
+import { t as DevCssAsset } from "../types-BAp5AEBU.mjs";
+import { a as handlePageMutation, i as handlePageGet } from "../protocol-CjF_iI9X.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Context, ExecutionContext, Hono, MiddlewareHandler } from "hono";
+//#region src/runtime/routing-errors.d.ts
+type ErrorRendererOptions = {
+  dev?: boolean;
+  projectRoot: string;
+  homeDir: string;
+};
+type ErrorRenderer = {
+  createResponse: (request: Request, status: number, title: string, error?: unknown) => Response;
+  serveCustomPage: (context: Context, status: number, title: string, error?: unknown) => Promise<Response>;
+  onError: (error: Error, context: Context) => Promise<Response> | Response;
+};
+/** Error rendering is shared by generated Pages apps; production never includes exception details. */
+export declare function createErrorRenderer(options: ErrorRendererOptions): ErrorRenderer;
+//#endregion
+//#region src/runtime/routing-worker.d.ts
+type AssetBinding = {
+  fetch: (request: Request) => Promise<Response>;
+};
+type RuntimeEnvironment = Record<string, unknown> & {
+  ASSETS?: AssetBinding;
+};
+type AssetFallbackOptions = {
+  assetsDir?: string;
+  serveSpaFallback?: boolean;
+  notFound?: "none" | "404-page" | "single-page-application";
+};
+export declare function createAssetFallback(options?: AssetFallbackOptions): (request: Request, env: RuntimeEnvironment, response: Response) => Promise<Response>;
+/** Hide platform capabilities without copying bindings or changing application bindings. */
+export declare function filterInternalBindings<E extends Record<string, unknown>>(env: E, prefixes: Array<string>, exactNames?: Array<string>): E;
+type WorkerFetchOptions = {
+  app: {
+    fetch: (request: Request, env: RuntimeEnvironment, context: ExecutionContext) => Response | Promise<Response>;
+  };
+  assets: ReturnType<typeof createAssetFallback>;
+  withRawEnv: (env: RuntimeEnvironment, fn: () => Promise<Response>) => Promise<Response>;
+  withRuntimeEnv: (env: RuntimeEnvironment, fn: () => Promise<Response>) => Promise<Response>;
+  filterBindings: (env: RuntimeEnvironment) => RuntimeEnvironment;
+  validateEnv?: (env: RuntimeEnvironment) => Promise<void>;
+  /** Authored/generated version metadata binding used to prove the served native version. */
+  versionMetadataBinding?: string;
+  remoteEnv?: (env: RuntimeEnvironment) => RuntimeEnvironment;
+  internalRoute: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response | null>;
+  collectPrerenderPaths: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Array<string>>;
+  emailReceipt?: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response>;
+  isr?: {
+    deploymentId: string;
+    handle: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext, render: (request: Request) => Promise<Response>) => Promise<Response | null>;
+  };
+};
+export declare function createWorkerFetch(options: WorkerFetchOptions): (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response>;
+//#endregion
+//#region src/runtime/routing-assets.d.ts
+type ClientAssetTags = {
+  css: string;
+  preloads: string;
+  body: string;
+  devCss?: Array<DevCssAsset>;
+};
+type ClientManifest = Record<string, {
+  file?: string;
+  imports?: Array<string>;
+  css?: Array<string>;
+  /** Build-proven fingerprinted outputs; absent in older/third-party manifests. */
+  immutableFiles?: Array<string>;
+}>;
+type ManifestLoader = (request: Request, env: RuntimeEnvironment) => Promise<ClientManifest | null>;
+export declare function createManifestLoader(): ManifestLoader;
+type ClientAssetOptions = {
+  entryId: string;
+  entryUrl: string;
+  extraEntryId?: string;
+  extraEntryUrl?: string;
+  pageCssKeys?: Record<string, Array<string>>;
+  devRootPhases?: Record<string, Array<Array<string>>>;
+  kind: "ssr" | "pages" | "islands";
+  dev?: boolean;
+  reactRefresh?: boolean;
+  devCss?: (request: Request, env: RuntimeEnvironment, options: {
+    kind: "pages" | "islands";
+    componentId: string;
+    rootPhases: Array<Array<string>>;
+  }) => Promise<unknown>;
+};
+/** Frameworks supply only client entry IDs and active layout/page roots. */
+export declare function createClientAssetTags(options: ClientAssetOptions, loadManifest?: ManifestLoader): (request: Request, env: RuntimeEnvironment, componentId?: string) => Promise<ClientAssetTags>;
+//#endregion
+//#region src/runtime/routing-pages.d.ts
+type PageGetArguments = Parameters<typeof handlePageGet>;
+type PageModule = {
+  loader?: PageGetArguments[0];
+  head?: PageGetArguments[1];
+  action?: Parameters<typeof handlePageMutation>[0];
+  actions?: Record<string, Parameters<typeof handlePageMutation>[0]>;
+};
+type PageRouteOptions = {
+  load?: () => Promise<PageModule>;
+  head?: PageGetArguments[1];
+  componentId: string;
+  render: PageGetArguments[4];
+  assets: PageGetArguments[5];
+  headConfig: PageGetArguments[6] | null;
+  renderOptions: PageGetArguments[7];
+  namedActions?: boolean;
+};
+export declare function createPageGetHandler(options: PageRouteOptions): (c: Context) => Promise<Response>;
+export declare function createPageMutationHandler(options: PageRouteOptions): (c: Context) => Promise<Response>;
+export declare function createPagesFallback(options: {
+  routing: RoutingRuntime;
+  errors: ErrorRenderer;
+  fallbackRules?: Array<RoutingRule>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+type SsrModule = {
+  render?: (c: Context, assets: ClientAssetTags) => Response | Promise<Response>;
+  default?: (c: Context, assets: unknown) => Promise<Response>;
+};
+export declare function createSsrFallback(options: {
+  routing: RoutingRuntime;
+  nodeTarget?: boolean;
+  fallbackRules?: Array<RoutingRule>;
+  load: () => Promise<SsrModule>;
+  assets: (request: Request, env: Context["env"]) => Promise<ClientAssetTags>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+export declare function createAssetNotFound(options: {
+  routing: RoutingRuntime;
+  nodeTarget?: boolean;
+  fallbackRules?: Array<RoutingRule>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+//#endregion
+//#region src/runtime/routing.d.ts
+export type RoutingRule = {
+  source: string;
+  destination: string;
+  status: number;
+  host?: string;
+  force?: boolean;
+  origin?: string;
+};
+export type RoutingHeaderRule = {
+  pattern: string;
+  headers: Array<[string, string]>;
+};
+export type RequestContextStore = {
+  request: Request;
+  executionCtx?: Context["executionCtx"];
+};
+export type RoutingContext = Context & {
+  rewrite: (path: string) => Promise<Response>;
+  originalUrl: () => URL | null;
+  isRewritten: () => boolean;
+};
+export type RoutingRuntime = {
+  requestContext: AsyncLocalStorage<RequestContextStore>;
+  originalUrls: WeakMap<Request, URL>;
+  contextMiddleware: MiddlewareHandler;
+  requestMiddleware: MiddlewareHandler;
+  routingMiddleware: (rules: Array<RoutingRule>) => MiddlewareHandler;
+  headerMiddleware: (rules: Array<RoutingHeaderRule>) => MiddlewareHandler;
+  applyFallback: (context: Context, rules: Array<RoutingRule>) => Promise<Response | undefined>;
+  markNoMatch: (request: Request, response: Response) => Response;
+};
+/** One state owner per generated app: recursive dispatch shares rewrite and fallback guards. */
+export declare function createRoutingRuntime(app: Hono, options?: {
+  dev?: boolean;
+  nodeTarget?: boolean;
+  managedDispatch?: boolean;
+  blockedAssetExtensions?: Array<string>;
+  originalUrls?: WeakMap<Request, URL>;
+}): RoutingRuntime;
+export declare const DEFAULT_ASSET_EXTENSIONS: Array<string>;
+export declare function markNoMatch(request: Request, response: Response): Response;
+export declare function createHttpRouteHandler(load: () => Promise<Record<string, (c: Context) => unknown>>, method: string): (c: Context) => Promise<Response>;
+export declare function createModuleLoader<T>(load: () => Promise<T>, cache?: boolean): () => Promise<T>;
+//#endregion