emdash 0.40.1 → 0.42.0

package/src/schema/registry.ts

@@ -11,6 +11,7 @@ import { ulid } from "ulidx";
 
 import { refreshDevTypes } from "../astro/dev-typegen.js";
 import {
+	columnExists,
 	currentTimestamp,
 	isPostgres,
 	listTablesLike,
@@ -21,6 +22,7 @@ import type { CollectionTable, Database, FieldTable } from "../database/types.js
 import { validateIdentifier } from "../database/validate.js";
 import {
 	canResumeMediaUsageCollectionCapture,
+	findResumableMediaUsageCollectionCaptureId,
 	finalizeMediaUsageCollectionCapture,
 	installPreparedMediaUsageCollectionCapture,
 	markMediaUsageCollectionCaptureReady,
@@ -65,10 +67,12 @@ import {
 	FIELD_TYPE_TO_COLUMN,
 	REPEATER_SUB_FIELD_TYPES,
 	isIndexableFieldType,
+	isStoragelessField,
 	RESERVED_FIELD_SLUGS,
 	RESERVED_COLLECTION_SLUGS,
 	MAX_BLOCKS_ITEMS,
 } from "./types.js";
+import { compileUrlPattern } from "./url-pattern.js";
 
 // Regex patterns for schema registry
 const SLUG_VALIDATION_PATTERN = /^[a-z][a-z0-9_]*$/;
@@ -152,15 +156,32 @@ const UNORDERED_COLLECTION_RANK = 2147483647;
  */
 const collectionOrder = sql<number>`coalesce(sort_order, ${sql.lit(UNORDERED_COLLECTION_RANK)})`;
 
-function assertIndexableField(type: FieldType, indexed: boolean | undefined, slug: string): void {
-	if (indexed && !isIndexableFieldType(type)) {
+function assertIndexableField(
+	field: { type: FieldType; validation?: FieldValidation | null },
+	indexed: boolean | undefined,
+	slug: string,
+): void {
+	if (!indexed) return;
+	if (!isIndexableFieldType(field.type)) {
 		throw new SchemaError(
-			`Field "${slug}" cannot be indexed because type "${type}" is not a scalar query type`,
+			`Field "${slug}" cannot be indexed because type "${field.type}" is not a scalar query type`,
+			"FIELD_NOT_INDEXABLE",
+		);
+	}
+	if (isStoragelessField(field)) {
+		throw new SchemaError(
+			`Field "${slug}" cannot be indexed because it stores no column to index`,
 			"FIELD_NOT_INDEXABLE",
 		);
 	}
 }
 
+/** A field record's `validation`, which the package carries as any JSON value. */
+function importFieldValidation(value: unknown): FieldValidation | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	return value;
+}
+
 function isCollectionSupport(value: unknown): value is CollectionSupport {
 	return typeof value === "string" && VALID_COLLECTION_SUPPORTS.has(value);
 }
@@ -193,6 +214,7 @@ function parseCollectionAdmin(raw: string | null | undefined): CollectionAdminCo
 		listColumns: Array.isArray(listColumns)
 			? listColumns.filter((value): value is string => typeof value === "string")
 			: undefined,
+		quickCreate: typeof parsed.quickCreate === "boolean" ? parsed.quickCreate : undefined,
 	};
 }
 
@@ -310,7 +332,7 @@ export class SchemaRegistry {
 	 * Notify the dev typegen hook that the schema has changed.
 	 */
 	private notifyTypegen(): void {
-		refreshDevTypes(this.db);
+		refreshDevTypes();
 	}
 
 	// ============================================
@@ -473,6 +495,7 @@ export class SchemaRegistry {
 	async createCollection(input: CreateCollectionInput): Promise<Collection> {
 		// Validate slug
 		this.validateSlug(input.slug, "collection");
+		this.validateUrlPattern(input.urlPattern);
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
 			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		}
@@ -496,6 +519,19 @@ export class SchemaRegistry {
 		}
 
 		const proposedId = existing?.id ?? ulid();
+		const tableName = this.getTableName(input.slug);
+		if (
+			!existing &&
+			(await tableExists(this.db, tableName)) &&
+			!(await findResumableMediaUsageCollectionCaptureId(this.db, {
+				collectionSlug: input.slug,
+			}))
+		) {
+			throw new SchemaError(
+				`Collection table "${tableName}" exists but is not registered`,
+				"COLLECTION_TABLE_ORPHANED",
+			);
+		}
 
 		// Default `supports` to drafts + revisions when the caller didn't
 		// specify it. Explicit empty array (`[]`) is preserved as an opt-out
@@ -587,6 +623,7 @@ export class SchemaRegistry {
 		fields: readonly CreateFieldInput[],
 	): Promise<void> {
 		this.validateSlug(input.slug, "collection");
+		this.validateUrlPattern(input.urlPattern);
 		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) {
 			throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
 		}
@@ -598,7 +635,7 @@ export class SchemaRegistry {
 		const normalizedFields: CreateFieldInput[] = [];
 		for (const field of fields) {
 			this.validateSlug(field.slug, "field");
-			assertIndexableField(field.type, field.indexed, field.slug);
+			assertIndexableField(field, field.indexed, field.slug);
 			if (RESERVED_FIELD_SLUGS.includes(field.slug)) {
 				throw new SchemaError(`Field slug "${field.slug}" is reserved`, "RESERVED_SLUG");
 			}
@@ -961,7 +998,8 @@ export class SchemaRegistry {
 					"INVALID_FIELD_TYPE",
 				);
 			}
-			assertIndexableField(field.type, field.indexed, field.slug);
+			const validation = importFieldValidation(field.validation);
+			assertIndexableField({ type: field.type, validation }, field.indexed, field.slug);
 			if (field.indexed) this.getFieldIndexName(field.id);
 			return {
 				slug: field.slug,
@@ -969,6 +1007,7 @@ export class SchemaRegistry {
 				type: field.type,
 				required: field.required,
 				defaultValue: field.defaultValue,
+				validation,
 			};
 		});
 	}
@@ -1028,6 +1067,7 @@ export class SchemaRegistry {
 			if (!existingRow) {
 				throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
 			}
+			if (input.urlPattern !== existingRow.url_pattern) this.validateUrlPattern(input.urlPattern);
 			const existing = this.mapCollectionRow(existingRow);
 			await this.validateTitleDateFields(
 				existing.id,
@@ -1043,7 +1083,7 @@ export class SchemaRegistry {
 			if (input.label !== undefined) updates.label = input.label;
 			if (input.labelSingular !== undefined) updates.label_singular = input.labelSingular;
 			if (input.description !== undefined) updates.description = input.description;
-			if (input.icon !== undefined) updates.icon = input.icon;
+			if (input.icon !== undefined) updates.icon = input.icon || null;
 			if (input.admin !== undefined) updates.admin_config = JSON.stringify(input.admin);
 			if (input.supports !== undefined) updates.supports = JSON.stringify(input.supports);
 			if (input.urlPattern !== undefined) updates.url_pattern = input.urlPattern;
@@ -1105,16 +1145,29 @@ export class SchemaRegistry {
 	}
 
 	/**
-	 * Delete a collection
+	 * The content guard {@link deleteCollection} refuses on, on its own.
+	 *
+	 * A caller that has to cascade before deleting — relations, whose edges point
+	 * at rows the drop is about to take — needs to know the delete is acceptable
+	 * before it changes anything, since the cascade cannot be rolled back on D1.
 	 */
-	async deleteCollection(slug: string, options?: { force?: boolean }): Promise<void> {
+	async assertCollectionDeletable(slug: string, options?: { force?: boolean }): Promise<void> {
+		if (options?.force) return;
 		const existing = await this.getCollection(slug);
-		if (existing && !options?.force && (await this.collectionHasContent(slug))) {
+		if (existing && (await this.collectionHasContent(slug))) {
 			throw new SchemaError(
 				`Collection "${slug}" has content. Use force: true to delete.`,
 				"COLLECTION_HAS_CONTENT",
 			);
 		}
+	}
+
+	/**
+	 * Delete a collection
+	 */
+	async deleteCollection(slug: string, options?: { force?: boolean }): Promise<void> {
+		await this.assertCollectionDeletable(slug, options);
+		const existing = await this.getCollection(slug);
 		const activated = await deleteActivatedMediaUsageCollection(this.db, {
 			collectionId: existing?.id,
 			collectionSlug: slug,
@@ -1230,7 +1283,7 @@ export class SchemaRegistry {
 				? await this.normalizeBlocksFieldValidation(collectionSlug, input, undefined, this.db)
 				: input.validation;
 		const columnType = FIELD_TYPE_TO_COLUMN[input.type];
-		assertIndexableField(input.type, input.indexed, input.slug);
+		assertIndexableField(input, input.indexed, input.slug);
 
 		// Get max sort order
 		const maxSort = await this.db
@@ -1273,17 +1326,21 @@ export class SchemaRegistry {
 					.execute();
 				schemaMutated = true;
 
-				// Add column to content table — pass trx to stay on the same connection
-				await this.addColumn(
-					collectionSlug,
-					input.slug,
-					input.type,
-					{
-						required: input.required,
-						defaultValue: input.defaultValue,
-					},
-					trx,
-				);
+				// Add column to content table — pass trx to stay on the same connection.
+				// A storage-less field persists no column; its values live in a side
+				// table (see `isStoragelessField`). Insert the field row only.
+				if (!isStoragelessField(input)) {
+					await this.addColumn(
+						collectionSlug,
+						input.slug,
+						input.type,
+						{
+							required: input.required,
+							defaultValue: input.defaultValue,
+						},
+						trx,
+					);
+				}
 
 				if (input.indexed) {
 					await this.createFieldIndex(collectionSlug, id, input.slug, trx);
@@ -1390,9 +1447,29 @@ export class SchemaRegistry {
 								field,
 								trx,
 							)
-						: input.validation;
+						: input.validation !== undefined
+							? input.validation
+							: field.validation;
 
 				if (input.type !== undefined && input.type !== field.type) {
+					// A change into or out of storage-less is never a no-op column change:
+					// string -> reference both map to TEXT and would slip past the affinity
+					// check below, yet one has a column and the other does not. An unwired
+					// reference field is column-backed, so its refusal comes from the
+					// text-alias check instead.
+					const storagelessBefore = isStoragelessField(field);
+					const storagelessAfter = isStoragelessField({
+						type: input.type,
+						validation: nextValidation,
+					});
+					if (storagelessBefore !== storagelessAfter) {
+						throw new SchemaError(
+							`Cannot change field "${fieldSlug}" in collection "${collectionSlug}" between ` +
+								`storage-less and column-backed types ("${field.type}" -> "${input.type}").`,
+							"FIELD_TYPE_COLUMN_CHANGE",
+						);
+					}
+
 					const newColumnType = FIELD_TYPE_TO_COLUMN[input.type];
 					if (newColumnType !== field.columnType) {
 						throw new SchemaError(
@@ -1464,7 +1541,11 @@ export class SchemaRegistry {
 				if (input.options !== undefined) updates.options = JSON.stringify(input.options);
 				if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
 
-				assertIndexableField(nextType, input.indexed ?? field.indexed, fieldSlug);
+				assertIndexableField(
+					{ type: nextType, validation: nextValidation },
+					input.indexed ?? field.indexed,
+					fieldSlug,
+				);
 				if (Object.keys(updates).length === 0) return field;
 
 				activeCoverageInvalidated = await invalidateContentMediaUsageSchemaChange(
@@ -1636,8 +1717,19 @@ export class SchemaRegistry {
 					await this.dropFieldIndex(field.id, trx);
 				}
 
-				// Drop column from content table — safe now because FTS triggers are gone
-				await this.dropColumn(collectionSlug, fieldSlug, trx);
+				// Drop column from content table — safe now because FTS triggers are gone.
+				// Whether a field is storage-less is a property of the row rather than of
+				// its type: reference fields created before they became storage-less
+				// still carry a column, and skipping the DDL would strand it and block
+				// the slug from ever being reused.
+				const hasColumn = await columnExists(
+					trx,
+					this.getTableName(collectionSlug),
+					this.getColumnName(fieldSlug),
+				);
+				if (hasColumn) {
+					await this.dropColumn(collectionSlug, fieldSlug, trx);
+				}
 			});
 			if (activeCoverageInvalidated) {
 				await invalidateContentMediaUsageSchemaChange(this.db, collectionSlug);
@@ -1777,6 +1869,8 @@ export class SchemaRegistry {
 		if (options.ifNotExists) table = table.ifNotExists();
 
 		for (const field of fields) {
+			if (isStoragelessField(field)) continue;
+
 			const columnName = this.getColumnName(field.slug);
 			const columnType = COLUMN_TYPE_TO_DATA_TYPE[FIELD_TYPE_TO_COLUMN[field.type]];
 			table = table.addColumn(columnName, columnType, (column) => {
@@ -2232,6 +2326,18 @@ export class SchemaRegistry {
 		}
 	}
 
+	private validateUrlPattern(urlPattern: string | null | undefined): void {
+		if (!urlPattern) return;
+		try {
+			compileUrlPattern(urlPattern);
+		} catch (error) {
+			throw new SchemaError(
+				error instanceof Error ? error.message : "Invalid URL pattern",
+				"INVALID_URL_PATTERN",
+			);
+		}
+	}
+
 	/**
 	 * Format a default value for SQL.
 	 *

package/src/schema/types.ts

@@ -99,6 +99,48 @@ export const FIELD_TYPE_TO_COLUMN: Record<FieldType, ColumnType> = {
 
 export const MAX_BLOCKS_ITEMS = 100;
 
+/**
+ * Field types that *can* persist no `ec_*` column — see `isStoragelessField`
+ * for whether a given row actually does. The `FIELD_TYPE_TO_COLUMN` entry above
+ * is retained deliberately: it doubles as the `isFieldType` guard.
+ */
+export const STORAGELESS_FIELD_TYPES: ReadonlySet<string> = new Set<FieldType>(["reference"]);
+
+/**
+ * Whether a field row keeps its values outside the content table.
+ *
+ * Storage-less is a property of the row, not of the type. A `reference` field
+ * is storage-less once it is bound to a relation: the selection lives as edges
+ * in `_emdash_content_references`. A reference field created before relations
+ * existed — or one whose target collection could not be resolved — still owns a
+ * TEXT column holding an entry id, and behaves like a string field until
+ * something wires it.
+ */
+export function isStoragelessField(field: {
+	type: string;
+	validation?: FieldValidation | null;
+}): boolean {
+	if (!STORAGELESS_FIELD_TYPES.has(field.type)) return false;
+	return typeof field.validation?.relation === "string" && field.validation.relation.length > 0;
+}
+
+/**
+ * `isStoragelessField` for a raw `_emdash_fields` row, whose `validation` is
+ * unparsed JSON. Malformed JSON reads as unwired: a field nothing can resolve a
+ * relation for keeps its column.
+ */
+export function isStoragelessFieldRow(row: { type: string; validation: string | null }): boolean {
+	if (!STORAGELESS_FIELD_TYPES.has(row.type) || !row.validation) return false;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(row.validation);
+	} catch {
+		return false;
+	}
+	if (typeof parsed !== "object" || parsed === null) return false;
+	return isStoragelessField({ type: row.type, validation: parsed });
+}
+
 /**
  * Features a collection can support
  */
@@ -166,6 +208,19 @@ export interface FieldValidation {
 	minItems?: number; // For repeater fields
 	maxItems?: number; // For repeater fields
 	allowedMimeTypes?: string[];
+	/** Reference fields: the relation's slug. */
+	relation?: string;
+	/**
+	 * Reference fields: which end of the relation this collection sits on.
+	 * `parent` picks children and controls their order; `child` picks parents
+	 * and is unordered, since `sort_order` is scoped to a parent.
+	 */
+	relationSide?: "parent" | "child";
+	/** Reference fields: the collection on the *other* end (derived from the
+	 * relation and the side, denormalized here). */
+	targetCollection?: string;
+	/** Reference fields: allow selecting more than one entry (UI constraint). */
+	multiple?: boolean;
 	allowedTypes?: string[]; // For blocks fields
 	retiredTypes?: string[]; // Server-owned retained types for blocks fields
 }
@@ -192,10 +247,15 @@ export const MAX_COLLECTION_LIST_COLUMNS = 4;
 /** Longest admin sidebar folder label a collection may declare. */
 export const MAX_COLLECTION_GROUP_LENGTH = 100;
 
+/** Longest Phosphor icon name a collection may declare. */
+export const MAX_COLLECTION_ICON_LENGTH = 64;
+
 /** Collection-level admin presentation options. */
 export interface CollectionAdminConfig {
 	/** Custom field slugs to show in the content list. */
 	listColumns?: string[];
+	/** Show a "new entry" quick action on the dashboard. Defaults to true. */
+	quickCreate?: boolean;
 }
 
 /**
@@ -435,6 +495,9 @@ export const RESERVED_COLLECTION_SLUGS = [
 	// Shadowed by the static POST /schema/collections/reorder route: a
 	// collection with this slug could never be addressed at its own URL.
 	"reorder",
+	// Shadowed by the static /content-types/relations admin route, for the same
+	// reason: a collection with this slug would be unreachable in the admin.
+	"relations",
 ];
 
 /**

package/src/schema/url-pattern.ts

@@ -6,6 +6,13 @@ function escapeRegex(literal: string): string {
 	return literal.replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
 }
 
+/**
+ * Compile a collection URL pattern to an anchored regex.
+ *
+ * Each placeholder must sit in its own path segment. Two `[^/]+` groups in one
+ * segment can split the segment many ways, so a crafted request path makes the
+ * regex backtrack polynomially (exponentially in the placeholder count).
+ */
 export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames: string[] } {
 	const paramNames: string[] = [];
 	let regexSource = "";
@@ -15,6 +22,9 @@ export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames:
 		const matchIndex = match.index;
 		const literal = pattern.slice(previousIndex, matchIndex);
 		if (INVALID_LITERAL_PATTERN.test(literal)) throw new Error("Invalid URL pattern placeholder");
+		if (paramNames.length > 0 && !literal.includes("/")) {
+			throw new Error("URL patterns allow only one placeholder per path segment");
+		}
 		regexSource += escapeRegex(literal);
 
 		const name = match[1];

package/src/schema/zod-generator.ts

@@ -1,8 +1,15 @@
 import { z, type ZodType } from "zod";
 
 import { hashString } from "../utils/hash.js";
+import { isSafeUrlFieldValue } from "../utils/url.js";
 import type { BlockFieldDefinition } from "./block-types.js";
-import type { CollectionWithFields, Field, FieldType, RepeaterSubField } from "./types.js";
+import {
+	isStoragelessField,
+	type CollectionWithFields,
+	type Field,
+	type FieldType,
+	type RepeaterSubField,
+} from "./types.js";
 
 /** Pattern to split on underscores, hyphens, and spaces for PascalCase conversion */
 const PASCAL_CASE_SPLIT_PATTERN = /[_\-\s]+/;
@@ -19,6 +26,7 @@ export function generateZodSchema(
 	const shape: Record<string, ZodType> = {};
 
 	for (const field of collection.fields) {
+		if (isStoragelessField(field)) continue;
 		shape[field.slug] = generateFieldSchema(field);
 	}
 
@@ -73,7 +81,16 @@ export function generateBlockFieldSchema(field: BlockFieldDefinition): ZodType {
 function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodType {
 	switch (type) {
 		case "url":
-			return z.string().check(z.url());
+			// The admin localizes `invalid_format` issues with `format: "url"`.
+			return z.string().check((ctx) => {
+				if (isSafeUrlFieldValue(ctx.value)) return;
+				ctx.issues.push({
+					code: "invalid_format",
+					format: "url",
+					input: ctx.value,
+					message: "URL must use http, https, mailto, or tel, or be a site-relative path",
+				});
+			});
 
 		case "string":
 		case "text":
@@ -349,6 +366,10 @@ export function generateTypeScript(
 	lines.push(`  status: string;`);
 
 	for (const field of collection.fields) {
+		// A storage-less field holds no value in `data`; a reference field bound to
+		// a relation resolves through `references` instead. One that predates
+		// relations still owns its column, so it stays an entry id string.
+		if (isStoragelessField(field)) continue;
 		const tsType = blockFieldTypes.get(field.slug) ?? fieldTypeToTypeScript(field);
 		const optional = field.required ? "" : "?";
 		lines.push(`  ${field.slug}${optional}: ${tsType};`);
@@ -443,12 +464,17 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		),
 	);
 
+	const withReferences = collections.filter((c) => c.fields.some(isStoragelessField));
+
 	// Build imports - BylineSummary, ContentBylineCredit and TaxonomyTerm are always needed
 	// for the hydrated bylines/terms fields
 	const imports = ["BylineSummary", "ContentBylineCredit", "TaxonomyTerm"];
 	if (needsPortableText) {
 		imports.push("PortableTextBlock");
 	}
+	if (withReferences.length > 0) {
+		imports.push("ReferencePage");
+	}
 	lines.push(`import type { ${imports.join(", ")} } from "emdash";`);
 	lines.push(``);
 
@@ -456,6 +482,14 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 	// (e.g. `book` and `books` both -> `Book`), so resolve collisions up front
 	// to keep every interface identifier unique within the file.
 	const interfaceNames = uniqueInterfaceNames(collections);
+	// `{Collection}References`, built on an already-unique name. No slug can
+	// produce a data interface name ending in `References` -- `singularize`
+	// always strips the trailing `s` of a final `references` segment -- so the
+	// suffix cannot collide with one.
+	const referenceInterfaces: [CollectionWithFields, string][] = withReferences.map((c) => [
+		c,
+		`${interfaceNames.get(c.slug)}References`,
+	]);
 
 	// Generate individual interfaces
 	for (const collection of collections) {
@@ -466,6 +500,11 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		lines.push(``);
 	}
 
+	for (const [collection, name] of referenceInterfaces) {
+		lines.push(generateReferencesTypeScript(collection, name, interfaceNames));
+		lines.push(``);
+	}
+
 	// Generate the Collections interface for module augmentation
 	lines.push(`declare module "emdash" {`);
 	lines.push(`  interface EmDashCollections {`);
@@ -473,11 +512,48 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		lines.push(`    ${collection.slug}: ${interfaceNames.get(collection.slug)};`);
 	}
 	lines.push(`  }`);
+	if (referenceInterfaces.length > 0) {
+		lines.push(`  interface EmDashCollectionReferences {`);
+		for (const [collection, name] of referenceInterfaces) {
+			lines.push(`    ${collection.slug}: ${name};`);
+		}
+		lines.push(`  }`);
+	}
 	lines.push(`}`);
 
 	return lines.join("\n");
 }
 
+/**
+ * Generate the references interface for one collection: a page per reference
+ * field bound to a relation, keyed by field slug, which is how
+ * `getEmDashEntry({ references })` both asks for and returns them.
+ *
+ * A field is always present on the interface, not optional -- a selection that
+ * names it always yields a page, empty when nothing is linked. The narrowing in
+ * `getEmDashEntry` picks out the fields the caller asked for.
+ */
+function generateReferencesTypeScript(
+	collection: CollectionWithFields,
+	interfaceName: string,
+	interfaceNames: Map<string, string>,
+): string {
+	const lines: string[] = [`export interface ${interfaceName} {`];
+
+	for (const field of collection.fields) {
+		if (!isStoragelessField(field)) continue;
+		// A target outside this file (dropped collection, or a relation whose
+		// other end has not been created) leaves the page's data un-narrowed
+		// rather than referring to an identifier that does not exist.
+		const target = field.validation?.targetCollection;
+		const targetName = target ? interfaceNames.get(target) : undefined;
+		lines.push(`  ${field.slug}: ReferencePage${targetName ? `<${targetName}>` : ""};`);
+	}
+
+	lines.push(`}`);
+	return lines.join("\n");
+}
+
 /**
  * Generate schema hash for cache invalidation
  */