emdash 0.41.0 → 0.42.0

package/src/plugins/marketplace.ts

@@ -200,6 +200,50 @@ export class MarketplaceUnavailableError extends MarketplaceError {
 	}
 }
 
+const MAX_REDIRECTS = 5;
+
+/**
+ * Fetches a marketplace URL, following redirects only while they stay on
+ * that URL's origin. Throws a `MarketplaceError` coded
+ * `${codePrefix}_REDIRECT_UNTRUSTED` or `${codePrefix}_TOO_MANY_REDIRECTS`.
+ */
+export async function fetchWithinOrigin(
+	url: string,
+	label: string,
+	codePrefix: string,
+): Promise<Response> {
+	const origin = new URL(url).origin;
+	let currentUrl = url;
+	let response = await fetch(currentUrl, { redirect: "manual" });
+
+	for (let i = 0; i < MAX_REDIRECTS; i++) {
+		if (response.status < 300 || response.status >= 400) break;
+
+		const location = response.headers.get("location");
+		if (!location) break;
+
+		const target = new URL(location, currentUrl);
+		if (target.origin !== origin) {
+			throw new MarketplaceError(
+				`${label} redirected to untrusted host: ${target.origin}`,
+				response.status,
+				`${codePrefix}_REDIRECT_UNTRUSTED`,
+			);
+		}
+		currentUrl = target.href;
+		response = await fetch(currentUrl, { redirect: "manual" });
+	}
+
+	if (response.status >= 300 && response.status < 400) {
+		throw new MarketplaceError(
+			`${label} exceeded maximum redirects (${MAX_REDIRECTS})`,
+			response.status,
+			`${codePrefix}_TOO_MANY_REDIRECTS`,
+		);
+	}
+	return response;
+}
+
 // ── Implementation ─────────────────────────────────────────────────
 
 class MarketplaceClientImpl implements MarketplaceClient {
@@ -241,40 +285,9 @@ class MarketplaceClientImpl implements MarketplaceClient {
 	async downloadBundle(id: string, version: string): Promise<PluginBundle> {
 		const bundleUrl = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/bundle`;
 
-		const marketplaceOrigin = new URL(this.baseUrl).origin;
-		const MAX_REDIRECTS = 5;
 		let response: Response;
 		try {
-			let currentUrl = bundleUrl;
-			response = await fetch(currentUrl, { redirect: "manual" });
-
-			// Follow redirects manually, validating each target stays on the marketplace host
-			for (let i = 0; i < MAX_REDIRECTS; i++) {
-				if (response.status < 300 || response.status >= 400) break;
-
-				const location = response.headers.get("location");
-				if (!location) break;
-
-				const target = new URL(location, currentUrl);
-				if (target.origin !== marketplaceOrigin) {
-					throw new MarketplaceError(
-						`Bundle download redirected to untrusted host: ${target.origin}`,
-						response.status,
-						"BUNDLE_REDIRECT_UNTRUSTED",
-					);
-				}
-				currentUrl = target.href;
-				response = await fetch(currentUrl, { redirect: "manual" });
-			}
-
-			// If still a redirect after MAX_REDIRECTS, fail explicitly
-			if (response.status >= 300 && response.status < 400) {
-				throw new MarketplaceError(
-					`Bundle download exceeded maximum redirects (${MAX_REDIRECTS})`,
-					response.status,
-					"BUNDLE_TOO_MANY_REDIRECTS",
-				);
-			}
+			response = await fetchWithinOrigin(bundleUrl, "Bundle download", "BUNDLE");
 		} catch (err) {
 			if (err instanceof MarketplaceError) throw err;
 			throw new MarketplaceUnavailableError(err);
@@ -383,10 +396,9 @@ class MarketplaceClientImpl implements MarketplaceClient {
  * over plugin bundle tarballs regardless of distribution channel.
  */
 // Aligns with RFC 0001 §"Bundle size limits" (256 KiB decompressed,
-// 20 files). Matches `MAX_BUNDLE_SIZE` in cli/commands/bundle-utils.ts
-// (the publish-side cap). We don't import that constant to keep this
-// runtime module independent of the CLI; the two values are
-// load-bearing identical and must stay in sync.
+// 20 files). Matches `MAX_BUNDLE_SIZE` in @emdash-cms/plugin-cli. We
+// don't import that constant to keep this runtime module independent
+// of the authoring CLI; the two values must stay in sync.
 //
 // Tar adds per-file headers (~512 bytes each) plus directory entries,
 // so the entry count cap is set comfortably above RFC's 20-file limit.

package/src/plugins/sandbox/proxy.ts

@@ -124,6 +124,7 @@ export function createSandboxedPluginProxy(
 			settingsSchema: manifest.admin.settingsSchema,
 			portableTextBlocks: manifest.admin.portableTextBlocks,
 			fieldWidgets: manifest.admin.fieldWidgets,
+			mcp: manifest.mcp,
 		},
 	);
 }

package/src/plugins/types.ts

@@ -674,6 +674,66 @@ export interface TaxonomyAccessWithWrite extends TaxonomyAccess {
 	): Promise<TaxonomyTermInfo[]>;
 }
 
+/**
+ * Public byline profile returned from the byline API. Omits the linked user
+ * account, guest flag, and custom field values.
+ */
+export interface BylineInfo {
+	id: string;
+	slug: string;
+	displayName: string;
+	bio: string | null;
+	websiteUrl: string | null;
+	/** Media ID of the avatar image. Resolve it with `ctx.media.get()`. */
+	avatarMediaId: string | null;
+	locale: string;
+	/** Locale-agnostic identity shared by every translation of the byline. */
+	translationGroup: string;
+}
+
+/** A byline credited on a content entry. */
+export interface BylineCreditInfo {
+	byline: BylineInfo;
+	sortOrder: number;
+	roleLabel: string | null;
+	/**
+	 * `explicit` for a credit assigned in the editor; `inferred` when the entry
+	 * has no credits and the byline linked to the entry's author is used.
+	 */
+	source: "explicit" | "inferred";
+}
+
+export interface BylineListOptions {
+	/** Match one locale. Omit to list every locale. */
+	locale?: string;
+	/** Page size, clamped to 1–100. Defaults to 50. */
+	limit?: number;
+	cursor?: string;
+}
+
+/** Byline credits for one entry in a batched lookup. */
+export interface EntryBylineCredits {
+	entryId: string;
+	bylines: BylineCreditInfo[];
+}
+
+/**
+ * Byline access interface — capability-gated on `bylines:read`.
+ */
+export interface BylineAccess {
+	/** Get a byline by its row ID. */
+	get(id: string): Promise<BylineInfo | null>;
+	/** List bylines, newest first. */
+	list(options?: BylineListOptions): Promise<PaginatedResult<BylineInfo>>;
+	/**
+	 * Bylines credited on up to 100 entries of one collection, in the order the
+	 * IDs were given. Duplicate IDs are returned once. Credits resolve at each
+	 * entry's own locale, matching what the site renders. Trashed and missing
+	 * entries have no credits.
+	 */
+	getEntriesBylines(collection: string, entryIds: string[]): Promise<EntryBylineCredits[]>;
+}
+
 export type RedirectStatus = 301 | 302 | 307 | 308 | 410 | 451;
 
 export interface RedirectInfo {
@@ -988,6 +1048,9 @@ export interface PluginContext<TStorage extends PluginStorageConfig = PluginStor
 	/** Taxonomy access - only if a taxonomy capability is declared. */
 	taxonomies?: TaxonomyAccess | TaxonomyAccessWithWrite;
 
+	/** Byline access - only if bylines:read capability */
+	bylines?: BylineAccess;
+
 	/** Redirect access - only if redirects:read or redirects:write capability */
 	redirects?: RedirectAccess | RedirectAccessWithWrite;
 
@@ -1463,6 +1526,34 @@ export type ContentAfterUnscheduleHandler = (
 	ctx: PluginContext,
 ) => Promise<void>;
 
+/**
+ * Event for `byline:afterSave`, fired after a byline profile or one of its
+ * locale translations is created or updated.
+ */
+export interface BylineAfterSaveEvent {
+	byline: BylineInfo;
+	isNew: boolean;
+}
+
+/**
+ * Event for `byline:afterDelete`, fired after a byline row is deleted. When it
+ * was the last locale of its translation group, its credits have already been
+ * removed from every entry.
+ */
+export interface BylineAfterDeleteEvent {
+	byline: BylineInfo;
+}
+
+export type BylineAfterSaveHandler = (
+	event: BylineAfterSaveEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
+export type BylineAfterDeleteHandler = (
+	event: BylineAfterDeleteEvent,
+	ctx: PluginContext,
+) => Promise<void>;
+
 export type MediaBeforeUploadHandler = (
 	event: MediaUploadEvent,
 	ctx: PluginContext,
@@ -1678,6 +1769,8 @@ export interface PluginHooks {
 	"comment:moderate"?: HookConfig<CommentModerateHandler> | CommentModerateHandler;
 	"comment:afterCreate"?: HookConfig<CommentAfterCreateHandler> | CommentAfterCreateHandler;
 	"comment:afterModerate"?: HookConfig<CommentAfterModerateHandler> | CommentAfterModerateHandler;
+	"byline:afterSave"?: HookConfig<BylineAfterSaveHandler> | BylineAfterSaveHandler;
+	"byline:afterDelete"?: HookConfig<BylineAfterDeleteHandler> | BylineAfterDeleteHandler;
 
 	// Public page hooks
 	"page:metadata"?: HookConfig<PageMetadataHandler> | PageMetadataHandler;
@@ -2077,6 +2170,8 @@ export interface ResolvedPluginHooks {
 	"comment:moderate"?: ResolvedHook<CommentModerateHandler>;
 	"comment:afterCreate"?: ResolvedHook<CommentAfterCreateHandler>;
 	"comment:afterModerate"?: ResolvedHook<CommentAfterModerateHandler>;
+	"byline:afterSave"?: ResolvedHook<BylineAfterSaveHandler>;
+	"byline:afterDelete"?: ResolvedHook<BylineAfterDeleteHandler>;
 	"page:metadata"?: ResolvedHook<PageMetadataHandler>;
 	"page:fragments"?: ResolvedHook<PageFragmentHandler>;
 }

package/src/query.ts

@@ -1878,8 +1878,15 @@ export async function resolveEmDashPath<T = Record<string, unknown>>(
 		cachedUrlPatterns = [];
 		for (const collection of collections) {
 			if (!collection.urlPattern) continue;
-			const { regex, paramNames } = compileUrlPattern(collection.urlPattern);
-			cachedUrlPatterns.push({ slug: collection.slug, regex, paramNames });
+			try {
+				const { regex, paramNames } = compileUrlPattern(collection.urlPattern);
+				cachedUrlPatterns.push({ slug: collection.slug, regex, paramNames });
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				console.warn(
+					`[emdash] Skipping URL pattern "${collection.urlPattern}" for collection "${collection.slug}": ${reason}. Update the collection's URL pattern to route its entries.`,
+				);
+			}
 		}
 		urlPatternCache.patterns = cachedUrlPatterns;
 	}

package/src/redirects/cache.ts

@@ -23,7 +23,12 @@ import {
 	singleFlightCached,
 } from "../utils/single-flight-cache.js";
 import type { CompiledPattern } from "./patterns.js";
-import { compilePattern, interpolateDestination, matchPattern } from "./patterns.js";
+import {
+	compilePattern,
+	interpolateDestination,
+	matchPattern,
+	validatePattern,
+} from "./patterns.js";
 
 export interface CachedRedirectRule {
 	redirect: Redirect;
@@ -89,6 +94,11 @@ function compileRedirects(redirects: Redirect[]): CachedRedirects {
 	const patterns: CachedRedirectRule[] = [];
 	for (const r of redirects) {
 		if (r.isPattern) {
+			const patternError = validatePattern(r.source);
+			if (patternError) {
+				console.warn(`[emdash:redirects] Skipping redirect ${r.id}: ${patternError}`);
+				continue;
+			}
 			patterns.push({ redirect: r, compiled: compilePattern(r.source) });
 		} else {
 			exact.set(r.source, r);

package/src/redirects/destination.ts

@@ -0,0 +1,20 @@
+/**
+ * Browsers strip tab/CR/LF anywhere in a URL, so `/\t/evil.example` resolves
+ * as `//evil.example`. Reject every C0 control and DEL rather than just those.
+ */
+// eslint-disable-next-line no-control-regex -- matching control characters is the purpose of this regex
+const CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+
+/**
+ * Returns true if `destination` is a single-slash site-relative path, i.e. a
+ * browser resolves it on the current origin: no scheme, no `//` or `/\`
+ * prefix, and no control characters.
+ */
+export function isSiteRelativeDestination(destination: string): boolean {
+	return (
+		destination.startsWith("/") &&
+		destination[1] !== "/" &&
+		destination[1] !== "\\" &&
+		!CONTROL_CHARS.test(destination)
+	);
+}

package/src/redirects/loops.ts

@@ -14,6 +14,7 @@ import {
 	compilePattern,
 	matchPattern,
 	interpolateDestination,
+	validatePattern,
 	type CompiledPattern,
 } from "./patterns.js";
 
@@ -37,7 +38,7 @@ interface CompiledPatternRedirect {
 function compilePatterns(edges: RedirectEdge[]): CompiledPatternRedirect[] {
 	const result: CompiledPatternRedirect[] = [];
 	for (const edge of edges) {
-		if (edge.enabled && edge.isPattern) {
+		if (edge.enabled && edge.isPattern && validatePattern(edge.source) === null) {
 			result.push({
 				id: edge.id,
 				compiled: compilePattern(edge.source),
@@ -256,7 +257,8 @@ export function wouldCreateLoop(
 	// If the proposed source is a pattern, compile it so we can check
 	// whether resolved paths would match it (not just string equality)
 	const sourceIsPattern = source.includes("[");
-	const compiledSource = sourceIsPattern ? compilePattern(source) : null;
+	const compiledSource =
+		sourceIsPattern && validatePattern(source) === null ? compilePattern(source) : null;
 
 	// Determine starting points for the walk. If the destination is a
 	// template, generate representative concrete paths AND find existing
@@ -265,10 +267,12 @@ export function wouldCreateLoop(
 	if (destination.includes("[")) {
 		const reps = generateRepresentatives(destination, filtered);
 		// Also find existing exact graph keys that match this template
-		const compiled = compilePattern(destination);
-		for (const [key] of graph) {
-			if (!key.includes("[") && matchPattern(compiled, key) !== null) {
-				reps.push(key);
+		if (validatePattern(destination) === null) {
+			const compiled = compilePattern(destination);
+			for (const [key] of graph) {
+				if (!key.includes("[") && matchPattern(compiled, key) !== null) {
+					reps.push(key);
+				}
 			}
 		}
 		// Always include the destination itself — it may be an exact graph key

package/src/redirects/patterns.ts

@@ -36,11 +36,8 @@ const OPEN_BRACKET = /\[/g;
 /** Count close brackets */
 const CLOSE_BRACKET = /\]/g;
 
-/** Split on capture groups in compiled regex string */
-const CAPTURE_GROUP_SPLIT = /(\([^)]+\))/;
-
 /** Escape regex-special characters in literal parts */
-const REGEX_SPECIAL_CHARS = /[.*+?^${}|\\]/g;
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
 
 export interface CompiledPattern {
 	regex: RegExp;
@@ -145,34 +142,19 @@ export function validateDestinationParams(source: string, destination: string):
  */
 export function compilePattern(source: string): CompiledPattern {
 	const paramNames: string[] = [];
-
-	// Replace [...splat] first (before [param]) since [...x] contains [x]
-	let regexStr = source.replace(SPLAT_PATTERN, (_match, name: string) => {
-		paramNames.push(name);
-		return "(.+)";
-	});
-
-	// Then replace [param]
-	regexStr = regexStr.replace(PARAM_PATTERN, (_match, name: string) => {
-		paramNames.push(name);
-		return "([^/]+)";
-	});
-
-	// Escape any regex-special characters in the literal parts
-	// We need to be careful: the replacement groups are already valid regex
-	// Split on capture groups, escape literals, rejoin
-	const parts = regexStr.split(CAPTURE_GROUP_SPLIT);
-	const escaped = parts
-		.map((part, i) => {
-			// Odd indices are the capture groups -- leave them alone
-			if (i % 2 === 1) return part;
-			// Even indices are literal text -- escape special regex chars
-			return part.replace(REGEX_SPECIAL_CHARS, "\\$&");
-		})
-		.join("");
+	let regexStr = "";
+	let literalStart = 0;
+
+	for (const match of source.matchAll(ANY_PLACEHOLDER)) {
+		regexStr += source.slice(literalStart, match.index).replace(REGEX_SPECIAL_CHARS, "\\$&");
+		paramNames.push(match[1]);
+		regexStr += match[0].startsWith("[...") ? "(.+)" : "([^/]+)";
+		literalStart = match.index + match[0].length;
+	}
+	regexStr += source.slice(literalStart).replace(REGEX_SPECIAL_CHARS, "\\$&");
 
 	return {
-		regex: new RegExp(`^${escaped}$`),
+		regex: new RegExp(`^${regexStr}$`),
 		paramNames,
 		source,
 	};

package/src/references/staged.ts

@@ -24,6 +24,14 @@ import {
  */
 export const STAGED_REFERENCES_KEY = "_references";
 
+/**
+ * The live selection each staged field was saved against. Promotion computes
+ * the diff between `_references` and this baseline, so a draft only adds or
+ * removes the links it actually intended rather than replacing the live set
+ * with a stale snapshot.
+ */
+export const STAGED_REFERENCES_BASELINE_KEY = "_referencesBaseline";
+
 /**
  * A staged selection, by field slug, holding `translation_group` values rather
  * than entry ids: an edge names a thing, not one locale's row of it, so the
@@ -35,6 +43,9 @@ export const STAGED_REFERENCES_KEY = "_references";
  */
 export type StagedReferences = Record<string, string[]>;
 
+/** The live selection a staged field(s) was saved against, by field slug. */
+export type StagedReferenceBaselines = Record<string, string[]>;
+
 /** Default page size for one reference field, matching the list endpoints. */
 export const REFERENCE_PAGE_LIMIT = 50;
 /** Hard ceiling, matching the list endpoints. */
@@ -115,3 +126,32 @@ export function mergeStagedReferences(
 ): StagedReferences {
 	return { ...readStagedReferences(base), ...incoming };
 }
+
+/** The baseline selection inside a revision's data, if it carries one. */
+export function readStagedReferenceBaselines(
+	data: Record<string, unknown> | undefined,
+): StagedReferenceBaselines | undefined {
+	const baselines = data?.[STAGED_REFERENCES_BASELINE_KEY];
+	if (typeof baselines !== "object" || baselines === null || Array.isArray(baselines)) {
+		return undefined;
+	}
+
+	const result: StagedReferenceBaselines = {};
+	for (const [fieldSlug, groups] of Object.entries(baselines)) {
+		if (isGroupList(groups)) result[fieldSlug] = groups;
+	}
+	return Object.keys(result).length > 0 ? result : undefined;
+}
+
+/**
+ * Fold a save's baselines into the previous draft's baselines. The baseline for
+ * a field is captured once, on the first save that stages it, so the diff stays
+ * anchored to the live selection the user was looking at.
+ */
+export function mergeStagedReferenceBaselines(
+	base: Record<string, unknown> | undefined,
+	incoming: StagedReferenceBaselines,
+): StagedReferenceBaselines {
+	const existing = readStagedReferenceBaselines(base) ?? {};
+	return { ...incoming, ...existing };
+}

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 };
+}