emdash 0.40.1 → 0.42.0

package/src/registry/artifact-fetch.ts

@@ -4,14 +4,6 @@ import type { RequestOptions } from "node:https";
 import { resolveAndValidateExternalUrlTarget, SsrfError } from "../security/ssrf.js";
 
 const TRAILING_DOT = /\.+$/;
-const HEADER_END = new Uint8Array([13, 10, 13, 10]);
-const CRLF = new Uint8Array([13, 10]);
-const STATUS_LINE_RE = /^HTTP\/1\.[01] ([2-5][0-9]{2})(?: .*)?$/;
-const HEADER_NAME_RE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-const FOLDED_HEADER_RE = /^[ \t]/;
-const CONTENT_LENGTH_RE = /^(0|[1-9][0-9]*)$/;
-const CHUNK_SIZE_RE = /^[0-9A-Fa-f]+$/;
-const MAX_HEADER_BYTES = 32 * 1024;
 const LOCALHOST_HOSTNAMES = new Set([
 	"localhost",
 	"localhost.localdomain",
@@ -29,7 +21,8 @@ export interface RegistryArtifactTransportInput {
 export interface RegistryArtifactTransport {
 	fetch(input: RegistryArtifactTransportInput): Promise<{
 		response: Response;
-		connectedAddress: string;
+		/** Workers Fetch does not expose its connected peer; DNS validation still runs before dispatch. */
+		connectedAddress: string | null;
 	}>;
 }
 
@@ -130,7 +123,7 @@ export async function fetchRegistryArtifactUrl(
 		signal: options.signal,
 		maxResponseBytes: options.maxResponseBytes,
 	});
-	if (!target.addresses.includes(result.connectedAddress)) {
+	if (result.connectedAddress !== null && !target.addresses.includes(result.connectedAddress)) {
 		await result.response.body?.cancel().catch(() => undefined);
 		throw new Error("Registry artifact transport connected outside the validated address set");
 	}
@@ -138,86 +131,59 @@ export async function fetchRegistryArtifactUrl(
 }
 
 async function createRuntimeRegistryArtifactTransport(): Promise<RegistryArtifactTransport> {
-	try {
-		// @ts-ignore - virtual module
-		const sockets: unknown = await import("cloudflare:sockets");
-		const connect = objectProperty(sockets, "connect");
-		if (!isWorkerSocketConnect(connect)) throw new TypeError("Workers socket binding is invalid");
-		return createWorkersRegistryArtifactTransport(connect);
-	} catch {
-		return createNodeRegistryArtifactTransport();
-	}
-}
-
-export interface RegistryArtifactWorkerSocket {
-	readonly opened: Promise<unknown>;
-	readonly readable: ReadableStream<Uint8Array>;
-	readonly writable: WritableStream<Uint8Array>;
-	startTls(options: { expectedServerHostname: string }): RegistryArtifactWorkerSocket;
-	close(): Promise<void>;
+	return isCloudflareWorkersRuntime()
+		? createWorkersRegistryArtifactTransport()
+		: createNodeRegistryArtifactTransport();
 }
 
-export type RegistryArtifactWorkerSocketConnect = (
-	address: { hostname: string; port: number },
-	options: { secureTransport: "starttls"; allowHalfOpen: false },
-) => RegistryArtifactWorkerSocket;
-
 export function createWorkersRegistryArtifactTransport(
-	connect: RegistryArtifactWorkerSocketConnect,
+	workerFetch: typeof globalThis.fetch = globalThis.fetch,
 ): RegistryArtifactTransport {
 	return {
 		async fetch(input) {
-			let lastError: unknown;
-			for (const address of input.allowedAddresses) {
-				if (input.signal.aborted) throw new Error("Registry artifact request was aborted");
-				let socket: RegistryArtifactWorkerSocket | undefined;
-				let tls: RegistryArtifactWorkerSocket | undefined;
-				try {
-					socket = connect(
-						{ hostname: address, port: parseHttpsPort(input.url) },
-						{ secureTransport: "starttls", allowHalfOpen: false },
-					);
-					await abortable(socket.opened, input.signal, () => socket?.close());
-					tls = socket.startTls({
-						expectedServerHostname: stripIpv6Brackets(input.url.hostname),
-					});
-					await abortable(tls.opened, input.signal, () => tls?.close());
-					const writer = tls.writable.getWriter();
-					try {
-						await abortable(writer.write(buildHttpRequest(input.url)), input.signal, () =>
-							tls?.close(),
-						);
-					} finally {
-						writer.releaseLock();
-					}
-					const bytes = await readWorkerSocketResponse(
-						tls,
-						input.maxResponseBytes + MAX_HEADER_BYTES,
-						input.signal,
-					);
-					await tls.close().catch(() => undefined);
-					return {
-						response: parsedResponseToWebResponse(
-							parsePinnedHttpResponse(bytes, input.maxResponseBytes),
-						),
-						connectedAddress: address,
-					};
-				} catch (error) {
-					await Promise.all([
-						tls?.close().catch(() => undefined),
-						socket?.close().catch(() => undefined),
-					]);
-					if (input.signal.aborted) throw error;
-					lastError = error;
-				}
-			}
-			throw new Error("Registry artifact transport could not connect to an approved address", {
-				cause: lastError,
+			const response = await workerFetch(input.url, {
+				redirect: "manual",
+				signal: input.signal,
+				headers: { "Accept-Encoding": "identity" },
 			});
+			return {
+				response: limitResponseBody(response, input.maxResponseBytes),
+				connectedAddress: null,
+			};
 		},
 	};
 }
 
+function isCloudflareWorkersRuntime(): boolean {
+	return (
+		typeof navigator !== "undefined" &&
+		typeof navigator.userAgent === "string" &&
+		navigator.userAgent.includes("Cloudflare-Workers")
+	);
+}
+
+function limitResponseBody(response: Response, maxBytes: number): Response {
+	if (!response.body) return response;
+	let received = 0;
+	const body = response.body.pipeThrough(
+		new TransformStream<Uint8Array, Uint8Array>({
+			transform(chunk, controller) {
+				received += chunk.byteLength;
+				if (received > maxBytes) {
+					controller.error(new RangeError("Registry artifact response exceeds its byte limit"));
+					return;
+				}
+				controller.enqueue(chunk);
+			},
+		}),
+	);
+	return new Response(body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers,
+	});
+}
+
 export type RegistryArtifactNodeRequest = (
 	options: RequestOptions,
 	callback: (response: IncomingMessage) => void,
@@ -315,71 +281,6 @@ interface ParsedHttpResponse {
 	body: Uint8Array;
 }
 
-function parsePinnedHttpResponse(bytes: Uint8Array, maxResponseBytes: number): ParsedHttpResponse {
-	const headerEnd = findSequence(bytes, HEADER_END, 0);
-	if (headerEnd === -1 || headerEnd > MAX_HEADER_BYTES) {
-		throw new Error("Registry artifact response headers are invalid or too large");
-	}
-	const headerText = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, headerEnd));
-	const lines = headerText.split("\r\n");
-	const statusMatch = STATUS_LINE_RE.exec(lines.shift() ?? "");
-	if (!statusMatch) throw new Error("Registry artifact response status line is invalid");
-	const headers = new Headers();
-	const rawHeaders = new Map<string, string[]>();
-	for (const line of lines) {
-		if (FOLDED_HEADER_RE.test(line)) {
-			throw new Error("Registry artifact response uses folded headers");
-		}
-		const separator = line.indexOf(":");
-		if (separator < 1) throw new Error("Registry artifact response header is invalid");
-		const name = line.slice(0, separator);
-		const value = line.slice(separator + 1).trim();
-		if (!HEADER_NAME_RE.test(name) || containsInvalidHeaderValue(value)) {
-			throw new Error("Registry artifact response header is invalid");
-		}
-		const normalized = name.toLowerCase();
-		const values = rawHeaders.get(normalized) ?? [];
-		values.push(value);
-		rawHeaders.set(normalized, values);
-		headers.append(name, value);
-	}
-	const contentEncoding = rawHeaders.get("content-encoding");
-	if (
-		contentEncoding &&
-		(contentEncoding.length !== 1 || contentEncoding[0]?.toLowerCase() !== "identity")
-	) {
-		throw new Error("Registry artifact response content encoding is unsupported");
-	}
-	const contentLength = rawHeaders.get("content-length");
-	const transferEncoding = rawHeaders.get("transfer-encoding");
-	if (contentLength && transferEncoding) {
-		throw new Error("Registry artifact response framing is ambiguous");
-	}
-	const bodyBytes = bytes.subarray(headerEnd + HEADER_END.length);
-	let body: Uint8Array;
-	if (transferEncoding) {
-		if (transferEncoding.length !== 1 || transferEncoding[0]?.toLowerCase() !== "chunked") {
-			throw new Error("Registry artifact response transfer encoding is unsupported");
-		}
-		body = decodeChunkedBody(bodyBytes, maxResponseBytes);
-	} else if (contentLength) {
-		if (contentLength.length !== 1 || !CONTENT_LENGTH_RE.test(contentLength[0])) {
-			throw new Error("Registry artifact response content length is invalid");
-		}
-		const length = Number(contentLength[0]);
-		if (!Number.isSafeInteger(length) || length !== bodyBytes.byteLength) {
-			throw new Error("Registry artifact response body length does not match its framing");
-		}
-		body = new Uint8Array(bodyBytes);
-	} else {
-		body = new Uint8Array(bodyBytes);
-	}
-	if (body.byteLength > maxResponseBytes) {
-		throw new RangeError("Registry artifact response exceeds its byte limit");
-	}
-	return { status: Number(statusMatch[1]), headers, body };
-}
-
 function parsedResponseToWebResponse(parsed: ParsedHttpResponse): Response {
 	const bodyAllowed = ![204, 205, 304].includes(parsed.status);
 	let body: ArrayBuffer | null = null;
@@ -393,95 +294,6 @@ function parsedResponseToWebResponse(parsed: ParsedHttpResponse): Response {
 	});
 }
 
-function buildHttpRequest(url: URL): Uint8Array {
-	return new TextEncoder().encode(
-		[
-			`GET ${url.pathname}${url.search} HTTP/1.1`,
-			`Host: ${url.host}`,
-			"Connection: close",
-			"Accept-Encoding: identity",
-			"",
-			"",
-		].join("\r\n"),
-	);
-}
-
-async function readWorkerSocketResponse(
-	socket: RegistryArtifactWorkerSocket,
-	maximumBytes: number,
-	signal: AbortSignal,
-): Promise<Uint8Array> {
-	const reader = socket.readable.getReader();
-	const chunks: Uint8Array[] = [];
-	let total = 0;
-	try {
-		for (;;) {
-			const next = await abortable(reader.read(), signal, () => socket.close());
-			if (next.done) break;
-			total += next.value.byteLength;
-			if (total > maximumBytes) {
-				throw new RangeError("Registry artifact response exceeds its byte limit");
-			}
-			chunks.push(next.value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return concatBytes(chunks, total);
-}
-
-function decodeChunkedBody(bytes: Uint8Array, maximumBytes: number): Uint8Array {
-	const chunks: Uint8Array[] = [];
-	let offset = 0;
-	let total = 0;
-	for (;;) {
-		const lineEnd = findSequence(bytes, CRLF, offset);
-		if (lineEnd === -1 || lineEnd - offset > 128) {
-			throw new Error("Registry artifact chunk size line is invalid");
-		}
-		const sizeText = new TextDecoder().decode(bytes.subarray(offset, lineEnd)).split(";", 1)[0];
-		if (!sizeText || !CHUNK_SIZE_RE.test(sizeText)) {
-			throw new Error("Registry artifact chunk size is invalid");
-		}
-		const size = Number.parseInt(sizeText, 16);
-		if (!Number.isSafeInteger(size)) throw new Error("Registry artifact chunk size is invalid");
-		offset = lineEnd + CRLF.length;
-		if (size === 0) {
-			if (
-				offset + CRLF.length !== bytes.length ||
-				bytes[offset] !== 13 ||
-				bytes[offset + 1] !== 10
-			) {
-				throw new Error("Registry artifact chunk trailer is invalid");
-			}
-			break;
-		}
-		if (offset + size + CRLF.length > bytes.length) {
-			throw new Error("Registry artifact chunk body is truncated");
-		}
-		if (bytes[offset + size] !== 13 || bytes[offset + size + 1] !== 10) {
-			throw new Error("Registry artifact chunk delimiter is invalid");
-		}
-		total += size;
-		if (total > maximumBytes) {
-			throw new RangeError("Registry artifact response exceeds its byte limit");
-		}
-		chunks.push(new Uint8Array(bytes.subarray(offset, offset + size)));
-		offset += size + CRLF.length;
-	}
-	return concatBytes(chunks, total);
-}
-
-function findSequence(bytes: Uint8Array, sequence: Uint8Array, start: number): number {
-	outer: for (let offset = start; offset <= bytes.length - sequence.length; offset += 1) {
-		for (let index = 0; index < sequence.length; index += 1) {
-			if (bytes[offset + index] !== sequence[index]) continue outer;
-		}
-		return offset;
-	}
-	return -1;
-}
-
 function concatBytes(chunks: readonly Uint8Array[], total: number): Uint8Array {
 	const bytes = new Uint8Array(total);
 	let offset = 0;
@@ -492,14 +304,6 @@ function concatBytes(chunks: readonly Uint8Array[], total: number): Uint8Array {
 	return bytes;
 }
 
-function containsInvalidHeaderValue(value: string): boolean {
-	for (const character of value) {
-		const code = character.codePointAt(0)!;
-		if (code === 0 || code === 10 || code === 13) return true;
-	}
-	return false;
-}
-
 function parseHttpsPort(url: URL): number {
 	const port = url.port === "" ? 443 : Number(url.port);
 	if (!Number.isSafeInteger(port) || port < 1 || port > 65_535) {
@@ -511,33 +315,3 @@ function parseHttpsPort(url: URL): number {
 function stripIpv6Brackets(hostname: string): string {
 	return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
 }
-
-function objectProperty(value: unknown, key: string): unknown {
-	if (typeof value !== "object" || value === null) return undefined;
-	return Object.getOwnPropertyDescriptor(value, key)?.value;
-}
-
-function isWorkerSocketConnect(value: unknown): value is RegistryArtifactWorkerSocketConnect {
-	return typeof value === "function";
-}
-
-async function abortable<T>(
-	operation: Promise<T>,
-	signal: AbortSignal,
-	onAbort: () => void | Promise<void>,
-): Promise<T> {
-	if (signal.aborted) throw new Error("Registry artifact request was aborted");
-	let abort: (() => void) | undefined;
-	const aborted = new Promise<never>((_resolve, reject) => {
-		abort = () => {
-			void onAbort();
-			reject(new Error("Registry artifact request was aborted"));
-		};
-		signal.addEventListener("abort", abort, { once: true });
-	});
-	try {
-		return await Promise.race([operation, aborted]);
-	} finally {
-		if (abort) signal.removeEventListener("abort", abort);
-	}
-}

package/src/registry/testing.ts

@@ -5,14 +5,26 @@ import {
 	type AuthoritativeRecordReader,
 } from "./authoritative-records.js";
 
-export interface RegistryAuthoritativeFixture {
+interface RegistryAuthoritativeFixtureBase {
 	publisherDid: string;
 	packageSlug: string;
-	version: string;
 	profileCid: string;
-	releaseCid: string;
 	profile: unknown;
-	release: unknown;
+}
+
+export type RegistryAuthoritativeFixture = RegistryAuthoritativeFixtureBase &
+	(
+		| { version: string; releaseCid: string; release: unknown; releases?: never }
+		| {
+				releases: Array<{ version: string; releaseCid: string; release: unknown }>;
+				version?: never;
+				releaseCid?: never;
+				release?: never;
+		  }
+	);
+
+interface NormalizedRegistryAuthoritativeFixture extends RegistryAuthoritativeFixtureBase {
+	releases: Array<{ version: string; releaseCid: string; release: unknown }>;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -24,28 +36,61 @@ export function installRegistryAuthoritativeFixture(input: unknown): void {
 		!isRecord(input) ||
 		typeof input.publisherDid !== "string" ||
 		typeof input.packageSlug !== "string" ||
-		typeof input.version !== "string" ||
 		typeof input.profileCid !== "string" ||
-		typeof input.releaseCid !== "string" ||
 		!("profile" in input) ||
-		!("release" in input)
+		(!("releases" in input) &&
+			!(
+				typeof input.version === "string" &&
+				typeof input.releaseCid === "string" &&
+				"release" in input
+			))
 	) {
 		throw new TypeError("Registry authoritative fixture is invalid");
 	}
-	const fixture: RegistryAuthoritativeFixture = {
+	let releases: Array<{ version: string; releaseCid: string; release: unknown }>;
+	if (Array.isArray(input.releases)) {
+		releases = input.releases.filter(
+			(value): value is { version: string; releaseCid: string; release: unknown } =>
+				isRecord(value) &&
+				typeof value.version === "string" &&
+				typeof value.releaseCid === "string" &&
+				"release" in value,
+		);
+	} else {
+		if (
+			typeof input.version !== "string" ||
+			typeof input.releaseCid !== "string" ||
+			!("release" in input)
+		) {
+			throw new TypeError("Registry authoritative fixture release is invalid");
+		}
+		releases = [
+			{
+				version: input.version,
+				releaseCid: input.releaseCid,
+				release: input.release,
+			},
+		];
+	}
+	if (
+		releases.length === 0 ||
+		(Array.isArray(input.releases) && releases.length !== input.releases.length)
+	) {
+		throw new TypeError("Registry authoritative fixture releases are invalid");
+	}
+	const fixture: NormalizedRegistryAuthoritativeFixture = {
 		publisherDid: input.publisherDid,
 		packageSlug: input.packageSlug,
-		version: input.version,
 		profileCid: input.profileCid,
-		releaseCid: input.releaseCid,
 		profile: input.profile,
-		release: input.release,
+		releases,
 	};
 	const reader: AuthoritativeRecordReader = async (publisherDid, packageSlug, version) => {
+		const fixtureRelease = fixture.releases.find((release) => release.version === version);
 		if (
 			publisherDid !== fixture.publisherDid ||
 			packageSlug !== fixture.packageSlug ||
-			version !== fixture.version
+			!fixtureRelease
 		) {
 			return {
 				success: false,
@@ -63,7 +108,7 @@ export function installRegistryAuthoritativeFixture(input: unknown): void {
 			rkey,
 			profileCid: fixture.profileCid,
 			profile: fixture.profile,
-			release: fixture.release,
+			release: fixtureRelease.release,
 		});
 		if (!inspection.success) {
 			return {
@@ -88,7 +133,7 @@ export function installRegistryAuthoritativeFixture(input: unknown): void {
 				},
 				release: {
 					uri: `at://${publisherDid}/com.emdashcms.experimental.package.release/${rkey}`,
-					cid: fixture.releaseCid,
+					cid: fixtureRelease.releaseCid,
 					rkey,
 					value: inspection.value.release,
 				},

package/src/request-context.ts

@@ -65,6 +65,14 @@ export function createRequestMetrics(start: number): RequestMetrics {
 export interface EmDashRequestContext {
 	/** Whether the current request is in visual editing mode */
 	editMode: boolean;
+	/**
+	 * The response may be stored by Astro's route cache.
+	 *
+	 * Cache hits never execute the Worker. A request that reaches rendering is
+	 * therefore a fill candidate and must not rebuild a purged response from an
+	 * eventually-consistent object-cache snapshot.
+	 */
+	routeCacheFill?: boolean;
 	/** Preview token info, if this is a preview request */
 	preview?: {
 		collection: string;

package/src/schema/block-type-registry.ts

@@ -284,7 +284,7 @@ export class BlockTypeRegistry {
 				);
 			}
 		}
-		refreshDevTypes(this.db);
+		refreshDevTypes();
 	}
 
 	async createBlockType(input: CreateBlockTypeInput): Promise<BlockType> {

package/src/schema/env-types.ts

@@ -0,0 +1,37 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+import { expandCollectionBlockFields } from "./block-values.js";
+import { SchemaRegistry } from "./registry.js";
+import { generateSchemaHash, generateTypesFile } from "./zod-generator.js";
+
+async function safeListCollections(registry: SchemaRegistry) {
+	try {
+		return await registry.listCollections();
+	} catch (error) {
+		// Handle missing tables for new sites that haven't run setup yet
+		if (error instanceof Error && error.message.includes("no such table")) {
+			return [];
+		}
+		throw error;
+	}
+}
+
+/**
+ * Generate the `emdash-env.d.ts` content for the schema stored in `db`.
+ */
+export async function generateEnvTypes(db: Kysely<Database>) {
+	const registry = new SchemaRegistry(db);
+	const collections = await safeListCollections(registry);
+	const collectionsWithFields = await Promise.all(
+		collections.map(async (c) => {
+			const fields = await registry.listFields(c.id);
+			return expandCollectionBlockFields(db, { ...c, fields });
+		}),
+	);
+
+	const types = generateTypesFile(collectionsWithFields);
+	const hash: string = await generateSchemaHash(collectionsWithFields);
+
+	return { types, hash, collections: collections.length };
+}

package/src/schema/project-env-types.ts

@@ -0,0 +1,41 @@
+/**
+ * Offline `emdash-env.d.ts` generation for a project directory.
+ *
+ * Reproduces what a fresh `astro dev` run writes: migrate an empty database,
+ * apply the project's seed, and generate types from the resulting schema.
+ * Used by `scripts/env-types.mjs` to keep committed files in the repo current.
+ */
+
+import { generateSeedModule } from "../astro/integration/virtual-modules.js";
+import { createDatabase } from "../database/connection.js";
+import { runMigrations } from "../database/migrations/runner.js";
+import { applySeed } from "../seed/apply.js";
+import type { SeedFile } from "../seed/types.js";
+import { validateSeed } from "../seed/validate.js";
+import { generateEnvTypes } from "./env-types.js";
+
+async function loadProjectSeed(projectRoot: string): Promise<SeedFile> {
+	const source = generateSeedModule(projectRoot);
+	const mod: { seed: SeedFile } = await import(
+		/* @vite-ignore */ `data:text/javascript,${encodeURIComponent(source)}`
+	);
+	return mod.seed;
+}
+
+export async function generateProjectEnvTypes(projectRoot: string): Promise<string> {
+	const seed = await loadProjectSeed(projectRoot);
+	const { errors } = validateSeed(seed);
+	if (errors.length > 0) {
+		throw new Error(`Invalid seed in ${projectRoot}:\n  ${errors.join("\n  ")}`);
+	}
+
+	const db = createDatabase({ url: ":memory:" });
+	try {
+		await runMigrations(db);
+		await applySeed(db, seed, { includeContent: false, onConflict: "skip" });
+		const { types } = await generateEnvTypes(db);
+		return types;
+	} finally {
+		await db.destroy();
+	}
+}