emdash 0.40.0 → 0.41.0

package/src/seed/types.ts

@@ -45,6 +45,9 @@ export interface SeedFile {
 	/** Database-owned block types, applied before collections that reference them. */
 	blockTypes?: SeedBlockType[];
 
+	/** Relations joining two collections, which reference fields bind to */
+	relations?: SeedRelation[];
+
 	/** Taxonomy definitions */
 	taxonomies?: SeedTaxonomy[];
 
@@ -118,6 +121,34 @@ export interface SeedCollection {
 	fields: SeedField[];
 }
 
+/**
+ * Relation definition in seed.
+ *
+ * A relation joins two collections and owns the link set a reference field
+ * views. Declaring it here names it — the slug is how a field addresses it — and
+ * lets a field on either collection bind to it. A reference field that names
+ * only a `targetCollection` gets a relation created for it instead, which stays
+ * the shorter path for a one-sided link.
+ *
+ * Labels are single-valued: a relation is schema, like a collection or a field,
+ * and carries no locale.
+ */
+export interface SeedRelation {
+	slug: string;
+	parentCollection: string;
+	childCollection: string;
+	/** Names the parent's role, as seen from the child. */
+	parentLabel: string;
+	parentLabelSingular?: string;
+	/** Names the child's role, as seen from the parent. */
+	childLabel: string;
+	childLabelSingular?: string;
+	/** How many children one parent may link. Omitted or `null` is unlimited. */
+	maxChildrenPerParent?: number | null;
+	/** How many parents one child may link. Omitted or `null` is unlimited. */
+	maxParentsPerChild?: number | null;
+}
+
 /**
  * Field definition in seed
  */
@@ -129,6 +160,8 @@ export interface SeedField {
 	unique?: boolean;
 	searchable?: boolean;
 	indexed?: boolean;
+	/** Whether the value is stored per locale (default true). `false` shares one value across translations. */
+	translatable?: boolean;
 	defaultValue?: unknown;
 	validation?: Record<string, unknown>;
 	widget?: string;
@@ -250,8 +283,8 @@ export interface SeedSection {
 	keywords?: string[];
 	/** Portable Text content */
 	content: Array<{ _type: string; _key?: string; [key: string]: unknown }>;
-	/** Source: "theme" for seed-provided, "import" for WP imports */
-	source?: "theme" | "import";
+	/** Source: "theme" for seed-provided (the default), "user" for editor-created, "import" for WP imports */
+	source?: "theme" | "user" | "import";
 }
 
 /**
@@ -375,6 +408,7 @@ export interface SeedApplyResult {
 	blockTypes: { created: number; skipped: number; updated: number };
 	collections: { created: number; skipped: number; updated: number };
 	fields: { created: number; skipped: number; updated: number };
+	relations: { created: number; skipped: number; updated: number };
 	taxonomies: { created: number; skipped: number; terms: number };
 	bylines: { created: number; skipped: number; updated: number };
 	menus: { created: number; items: number };

package/src/seed/validate.ts

@@ -15,6 +15,8 @@ import {
 import type { SeedFile, SeedMenuItem, SeedTaxonomy, ValidationResult } from "./types.js";
 
 const COLLECTION_FIELD_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
+/** Matches `SchemaRegistry.validateSlug`, which collection and field slugs go through. */
+const MAX_SLUG_LENGTH = 63;
 const SLUG_PATTERN = /^[a-z0-9-]+$/;
 const REDIRECT_TYPES = new Set([301, 302, 307, 308]);
 const CRLF_PATTERN = /[\r\n]/;
@@ -278,12 +280,27 @@ export function validateSeed(data: unknown): ValidationResult {
 							errors.push(`${fieldPrefix}.indexed: must be a boolean`);
 						}
 
+						if (field.translatable !== undefined && typeof field.translatable !== "boolean") {
+							errors.push(`${fieldPrefix}.translatable: must be a boolean`);
+						}
+
 						if (!field.type) {
 							errors.push(`${fieldPrefix}: type is required`);
 						} else if (!(FIELD_TYPES as readonly string[]).includes(field.type)) {
 							errors.push(`${fieldPrefix}.type: unsupported field type "${field.type}"`);
 						} else if (field.indexed === true && !isIndexableFieldType(field.type)) {
 							errors.push(`${fieldPrefix}.indexed: type "${field.type}" cannot be indexed`);
+						} else if (
+							field.indexed === true &&
+							field.type === "reference" &&
+							typeof field.validation?.targetCollection === "string"
+						) {
+							// A targetCollection makes this field storage-less on apply: its
+							// selection becomes relation edges, leaving no column to index.
+							// Without one it stays a plain entry-id column, which can be.
+							errors.push(
+								`${fieldPrefix}.indexed: a reference field with a targetCollection stores no column to index`,
+							);
 						}
 					}
 				}
@@ -291,6 +308,65 @@ export function validateSeed(data: unknown): ValidationResult {
 		}
 	}
 
+	// Validate relations
+	if (seed.relations) {
+		if (!Array.isArray(seed.relations)) {
+			errors.push("relations must be an array");
+		} else {
+			const relationSlugs = new Set<string>();
+
+			for (let i = 0; i < seed.relations.length; i++) {
+				const relation = seed.relations[i];
+				const prefix = `relations[${i}]`;
+				if (!relation) continue;
+
+				if (!relation.slug) {
+					errors.push(`${prefix}: slug is required`);
+				} else {
+					if (!COLLECTION_FIELD_SLUG_PATTERN.test(relation.slug)) {
+						errors.push(
+							`${prefix}.slug: must start with a letter and contain only lowercase letters, numbers, and underscores`,
+						);
+					}
+					if (relation.slug.length > MAX_SLUG_LENGTH) {
+						errors.push(`${prefix}.slug: must be ${MAX_SLUG_LENGTH} characters or fewer`);
+					}
+					if (relationSlugs.has(relation.slug)) {
+						errors.push(`${prefix}.slug: duplicate relation slug "${relation.slug}"`);
+					}
+					relationSlugs.add(relation.slug);
+				}
+
+				for (const end of ["parentCollection", "childCollection"] as const) {
+					const value = relation[end];
+					if (!value) {
+						errors.push(`${prefix}: ${end} is required`);
+					} else if (!COLLECTION_FIELD_SLUG_PATTERN.test(value)) {
+						errors.push(`${prefix}.${end}: "${value}" is not a valid collection slug`);
+					}
+				}
+
+				for (const label of ["parentLabel", "childLabel"] as const) {
+					if (!relation[label]) errors.push(`${prefix}: ${label} is required`);
+				}
+				for (const label of ["parentLabelSingular", "childLabelSingular"] as const) {
+					const value = relation[label];
+					if (value !== undefined && typeof value !== "string") {
+						errors.push(`${prefix}.${label}: must be a string`);
+					}
+				}
+
+				for (const limit of ["maxChildrenPerParent", "maxParentsPerChild"] as const) {
+					const value = relation[limit];
+					if (value === undefined || value === null) continue;
+					if (!Number.isInteger(value) || value < 1) {
+						errors.push(`${prefix}.${limit}: must be a positive integer, or null for unlimited`);
+					}
+				}
+			}
+		}
+	}
+
 	// Validate taxonomies
 	if (seed.taxonomies) {
 		if (!Array.isArray(seed.taxonomies)) {
@@ -637,8 +713,8 @@ export function validateSeed(data: unknown): ValidationResult {
 				}
 
 				// Validate source
-				if (section.source && !["theme", "import"].includes(section.source)) {
-					errors.push(`${prefix}.source: must be "theme" or "import"`);
+				if (section.source && !["theme", "user", "import"].includes(section.source)) {
+					errors.push(`${prefix}.source: must be "theme", "user", or "import"`);
 				}
 			}
 		}

package/src/transfer/analyze/unique-keys.ts

@@ -32,8 +32,7 @@ export const UNIQUE_CONSTRAINTS = [
 	"byline_principal_locale",
 	"byline_field_slug",
 	"menu_name_locale",
-	"relation_name_locale",
-	"relation_group_locale",
+	"relation_slug",
 	"widget_area_name",
 	"section_slug",
 	"content_reference_groups",
@@ -111,22 +110,14 @@ export function uniqueKeysOf(record: SitePackageRecord): UniqueKey[] {
 		case "menu":
 			return [key("menu_name_locale", record.name, record.locale)];
 		case "relation":
-			return [
-				key("relation_name_locale", record.name, record.locale),
-				key("relation_group_locale", record.translationGroup, record.locale),
-			];
+			return [key("relation_slug", record.slug)];
 		case "widget_area":
 			return [key("widget_area_name", record.name)];
 		case "section":
 			return [key("section_slug", record.slug)];
 		case "content_reference":
 			return [
-				key(
-					"content_reference_groups",
-					record.relationGroup,
-					record.parentGroup,
-					record.childGroup,
-				),
+				key("content_reference_groups", record.relationId, record.parentGroup, record.childGroup),
 			];
 		case "content_byline":
 			return [

package/src/transfer/analyze/validate.ts

@@ -37,6 +37,7 @@ import { SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isTransferError, TransferError } from "../errors.js";
 import {
 	blocksFieldTypeSlugs,
+	referenceFieldRelationSlugs,
 	blockTypeVersionKey,
 	compareIds,
 	compareStreamOrder,
@@ -122,6 +123,7 @@ export const validationStateSchema = z.strictObject({
 					z.strictObject({
 						columnType: z.enum(["TEXT", "REAL", "INTEGER", "JSON"]),
 						required: z.boolean(),
+						storageless: z.boolean().optional(),
 					}),
 				]),
 			),
@@ -722,7 +724,9 @@ function groupIdOf(record: SitePackageRecord): string {
 }
 
 function nameKeyOf(record: SitePackageRecord): string | null {
-	if (record.kind === "collection" || record.kind === "block_type") return record.slug;
+	if (record.kind === "collection" || record.kind === "block_type" || record.kind === "relation") {
+		return record.slug;
+	}
 	if (record.kind === "menu") return record.name;
 	if (record.kind === "block_type_version") {
 		return blockTypeVersionKey(record.blockTypeId, record.version);
@@ -1015,6 +1019,7 @@ function collectRecordFacts(
 			fields.set(record.slug, {
 				columnType: record.columnType,
 				required: record.required === true,
+				storageless: referenceFieldRelationSlugs(record).length > 0,
 			});
 			state.fields.set(collectionSlug, fields);
 			return;
@@ -1172,27 +1177,44 @@ interface NestedReference {
 	targets: readonly RecordKind[];
 	by: ReferenceKey;
 	values: (record: SitePackageRecord) => string[];
+	/** A dangling value is a warning, not a blocker (see `KindReference.soft`). */
+	soft?: boolean;
 }
 
 /**
  * References that live inside a property rather than being one: the block
- * types a `blocks` field names in `validation`, and the version a block type
- * names as current.
+ * types a `blocks` field names in `validation`, the relation a bound
+ * `reference` field names there, and the version a block type names as
+ * current.
+ *
+ * A bound field's relation is soft because the origin does not keep it
+ * resolvable: deleting a relation leaves the fields bound to it in place.
  */
-const NESTED_REFERENCES: Partial<Record<RecordKind, NestedReference>> = {
-	field: {
-		property: "validation",
-		targets: ["block_type"],
-		by: "slug",
-		values: (record) => (record.kind === "field" ? blocksFieldTypeSlugs(record) : []),
-	},
-	block_type: {
-		property: "currentVersion",
-		targets: ["block_type_version"],
-		by: "name",
-		values: (record) =>
-			record.kind === "block_type" ? [blockTypeVersionKey(record.id, record.currentVersion)] : [],
-	},
+const NESTED_REFERENCES: Partial<Record<RecordKind, readonly NestedReference[]>> = {
+	field: [
+		{
+			property: "validation",
+			targets: ["block_type"],
+			by: "slug",
+			values: (record) => (record.kind === "field" ? blocksFieldTypeSlugs(record) : []),
+		},
+		{
+			property: "validation",
+			targets: ["relation"],
+			by: "slug",
+			values: (record) => (record.kind === "field" ? referenceFieldRelationSlugs(record) : []),
+			soft: true,
+		},
+	],
+	block_type: [
+		{
+			property: "currentVersion",
+			targets: ["block_type_version"],
+			by: "name",
+			values: (record) =>
+				record.kind === "block_type" ? [blockTypeVersionKey(record.id, record.currentVersion)] : [],
+		},
+	],
 };
 
 async function checkNestedReferences(
@@ -1201,29 +1223,33 @@ async function checkNestedReferences(
 	records: readonly ChunkRecord[],
 	path: string,
 ): Promise<void> {
-	const reference = NESTED_REFERENCES[kind];
-	if (!reference) return;
-	const owners = new Map<string, ChunkRecord[]>();
-	for (const item of records) {
-		for (const value of reference.values(item.record)) {
-			const list = owners.get(value) ?? [];
-			list.push(item);
-			owners.set(value, list);
+	for (const reference of NESTED_REFERENCES[kind] ?? []) {
+		const owners = new Map<string, ChunkRecord[]>();
+		for (const item of records) {
+			for (const value of reference.values(item.record)) {
+				const list = owners.get(value) ?? [];
+				list.push(item);
+				owners.set(value, list);
+			}
 		}
-	}
-	if (owners.size === 0) return;
-	const missing = await context.index.findMissing(reference.targets, reference.by, [
-		...owners.keys(),
-	]);
-	for (const value of missing) {
-		for (const item of owners.get(value) ?? []) {
-			addBlocker(context.state.issues, {
-				code: "dangling_reference",
-				message: "Reference does not resolve to a record in the package",
-				kind,
-				id: item.record.id,
-				detail: { property: reference.property, path, line: item.line },
-			});
+		if (owners.size === 0) continue;
+		const missing = await context.index.findMissing(reference.targets, reference.by, [
+			...owners.keys(),
+		]);
+		for (const value of missing) {
+			for (const item of owners.get(value) ?? []) {
+				const issue = {
+					message: "Reference does not resolve to a record in the package",
+					kind,
+					id: item.record.id,
+					detail: { property: reference.property, path, line: item.line },
+				};
+				if (reference.soft) {
+					addWarning(context.state.issues, { code: "soft_reference_dangling", ...issue });
+				} else {
+					addBlocker(context.state.issues, { code: "dangling_reference", ...issue });
+				}
+			}
 		}
 	}
 }

package/src/transfer/analyze/values.ts

@@ -19,6 +19,8 @@ export type TargetDialect = "sqlite" | "postgres";
 export interface FieldInfo {
 	columnType: FieldColumnType;
 	required: boolean;
+	/** Values live as content references; the target has no column for them. */
+	storageless?: boolean;
 }
 
 const PROVIDER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -184,6 +186,10 @@ export function checkEntryFields(
 			result.issues.push(mismatch(slug, "Entry has a value for a field its collection lacks"));
 			continue;
 		}
+		if (info.storageless) {
+			result.issues.push(mismatch(slug, "Entry has a value for a field that stores no column"));
+			continue;
+		}
 		try {
 			encodeColumn(dialect, codecForColumnType(info.columnType), value);
 		} catch (error) {
@@ -204,7 +210,12 @@ export function checkEntryFields(
 		}
 	}
 	for (const [slug, info] of fields) {
-		if (info.required && info.columnType !== "JSON" && !Object.hasOwn(entry.fields, slug)) {
+		if (
+			info.required &&
+			!info.storageless &&
+			info.columnType !== "JSON" &&
+			!Object.hasOwn(entry.fields, slug)
+		) {
 			result.issues.push(mismatch(slug, "Required field has no value"));
 		}
 	}

package/src/transfer/export/readers.ts

@@ -769,10 +769,7 @@ function configFor(kind: RecordKind): TableReaderConfig {
 					const references = "_emdash_content_references";
 					return sql<boolean>`EXISTS (
 						SELECT 1 FROM _emdash_relations AS __relation
-						WHERE (
-							__relation.translation_group = ${col(references, "relation_group")}
-							OR (__relation.translation_group IS NULL AND __relation.id = ${col(references, "relation_group")})
-						)
+						WHERE __relation.id = ${col(references, "relation_id")}
 						AND ${entryGroupExists(context, sql`__relation.parent_collection`, col(references, "parent_group"))}
 						AND ${entryGroupExists(context, sql`__relation.child_collection`, col(references, "child_group"))}
 					)`;
@@ -818,7 +815,7 @@ interface ContentCollection {
 	columns: Readonly<Record<string, ColumnSpec>>;
 }
 
-type FieldColumns = ReadonlyArray<{ slug: string; column_type: string }>;
+type FieldColumns = Parameters<typeof contentColumnSpecs>[0];
 
 class EntryReader implements KindReader<"entry"> {
 	readonly kind = "entry";
@@ -839,14 +836,21 @@ class EntryReader implements KindReader<"entry"> {
 				"_emdash_collections.slug as collection",
 				"_emdash_fields.slug as slug",
 				"_emdash_fields.column_type as column_type",
+				"_emdash_fields.type as type",
+				"_emdash_fields.validation as validation",
 			])
 			.execute()
 			.then((rows) => {
-				const fields = new Map<string, Array<{ slug: string; column_type: string }>>();
+				const fields = new Map<string, Array<FieldColumns[number]>>();
 				for (const row of rows) {
 					const list = fields.get(row.collection) ?? [];
-					if (row.slug !== null && row.column_type !== null) {
-						list.push({ slug: row.slug, column_type: row.column_type });
+					if (row.slug !== null && row.column_type !== null && row.type !== null) {
+						list.push({
+							slug: row.slug,
+							column_type: row.column_type,
+							type: row.type,
+							validation: row.validation,
+						});
 					}
 					fields.set(row.collection, list);
 				}

package/src/transfer/format/columns.ts

@@ -24,6 +24,7 @@ import type { Kysely } from "kysely";
 import { listTableColumns, type TableColumnInfo } from "../../database/dialect-helpers.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
+import { isStoragelessFieldRow } from "../../schema/types.js";
 import { TransferError } from "../errors.js";
 import type { RecordKind } from "./kinds.js";
 
@@ -175,13 +176,15 @@ const PORTABLE_TABLE_LIST: PortableTableSpec[] = [
 		kind: "relation",
 		columns: {
 			id: f("id"),
-			name: f("name"),
+			slug: f("slug"),
 			parent_collection: f("parentCollection"),
 			child_collection: f("childCollection"),
 			parent_label: f("parentLabel"),
 			child_label: f("childLabel"),
-			locale: f("locale"),
-			translation_group: f("translationGroup"),
+			parent_label_singular: f("parentLabelSingular"),
+			child_label_singular: f("childLabelSingular"),
+			max_children_per_parent: f("maxChildrenPerParent", "integer"),
+			max_parents_per_child: f("maxParentsPerChild", "integer"),
 			created_at: f("createdAt"),
 			updated_at: f("updatedAt"),
 		},
@@ -335,7 +338,7 @@ const PORTABLE_TABLE_LIST: PortableTableSpec[] = [
 		kind: "content_reference",
 		columns: {
 			id: f("id"),
-			relation_group: f("relationGroup"),
+			relation_id: f("relationId"),
 			parent_group: f("parentGroup"),
 			child_group: f("childGroup"),
 			sort_order: f("sortOrder", "integer"),
@@ -623,7 +626,12 @@ export async function getColumnSpecs(
 	const fields = await db
 		.selectFrom("_emdash_fields")
 		.innerJoin("_emdash_collections", "_emdash_collections.id", "_emdash_fields.collection_id")
-		.select(["_emdash_fields.slug as slug", "_emdash_fields.column_type as column_type"])
+		.select([
+			"_emdash_fields.slug as slug",
+			"_emdash_fields.column_type as column_type",
+			"_emdash_fields.type as type",
+			"_emdash_fields.validation as validation",
+		])
 		.where("_emdash_collections.slug", "=", slug)
 		.execute();
 	return contentColumnSpecs(fields, await listTableColumns(db, table));
@@ -632,15 +640,27 @@ export async function getColumnSpecs(
 /**
  * Column classification of an `ec_*` table from its collection's registered
  * fields and the table's declared columns (see {@link getColumnSpecs}).
+ *
+ * A storage-less field's values are content references, not a column. A
+ * column left under its slug from before the field was bound is excluded.
  */
 export function contentColumnSpecs(
-	fields: ReadonlyArray<{ slug: string; column_type: string }>,
+	fields: ReadonlyArray<{
+		slug: string;
+		column_type: string;
+		type: string;
+		validation: string | null;
+	}>,
 	tableColumns: readonly TableColumnInfo[],
 ): Readonly<Record<string, ColumnSpec>> {
 	const declared = new Map(tableColumns.map((column) => [column.name, column.type.toLowerCase()]));
 	const columns: Record<string, ColumnSpec> = { ...CONTENT_TABLE_COLUMNS };
 	for (const field of fields) {
 		if (Object.hasOwn(columns, field.slug)) continue;
+		if (isStoragelessFieldRow(field)) {
+			columns[field.slug] = EXCLUDED;
+			continue;
+		}
 		let codec = codecForColumnType(field.column_type);
 		if (codec === "nativeJson" && !JSON_COLUMN_TYPES.has(declared.get(field.slug) ?? "")) {
 			codec = "json";

package/src/transfer/format/kinds.ts

@@ -234,13 +234,15 @@ export const taxonomyDefRecordSchema = z.strictObject({
 export const relationRecordSchema = z.strictObject({
 	kind: z.literal("relation"),
 	id: portableIdSchema,
-	name: shortString.min(1),
+	slug: shortString.min(1),
 	parentCollection: identifierSchema,
 	childCollection: identifierSchema,
 	parentLabel: shortString,
 	childLabel: shortString,
-	locale: localeSchema,
-	translationGroup: portableIdSchema,
+	parentLabelSingular: shortString.optional(),
+	childLabelSingular: shortString.optional(),
+	maxChildrenPerParent: integer.optional(),
+	maxParentsPerChild: integer.optional(),
 	createdAt: timestamp.optional(),
 	updatedAt: timestamp.optional(),
 });
@@ -394,7 +396,7 @@ export const contentBylineRecordSchema = z.strictObject({
 export const contentReferenceRecordSchema = z.strictObject({
 	kind: z.literal("content_reference"),
 	id: portableIdSchema,
-	relationGroup: portableIdSchema,
+	relationId: portableIdSchema,
 	parentGroup: portableIdSchema,
 	childGroup: portableIdSchema,
 	sortOrder: integer,
@@ -715,7 +717,7 @@ export const KIND_REFERENCES: Readonly<Record<RecordKind, readonly KindReference
 			{ property: "bylineGroup", targets: ["byline"], by: "group" },
 		],
 		content_reference: [
-			{ property: "relationGroup", targets: ["relation"], by: "group", soft: true },
+			{ property: "relationId", targets: ["relation"], by: "id", soft: true },
 			{ property: "parentGroup", targets: ["entry"], by: "group", soft: true },
 			{ property: "childGroup", targets: ["entry"], by: "group", soft: true },
 		],
@@ -763,6 +765,20 @@ export function blocksFieldTypeSlugs(record: FieldRecord): string[] {
 	return [...slugs];
 }
 
+/**
+ * The relation slug a bound `reference` field names in `validation.relation`.
+ * An unbound reference field keeps a column and names no relation.
+ */
+export function referenceFieldRelationSlugs(record: FieldRecord): string[] {
+	const validation = record.validation;
+	if (record.type !== "reference" || typeof validation !== "object" || validation === null) {
+		return [];
+	}
+	if (Array.isArray(validation)) return [];
+	const relation = validation.relation;
+	return typeof relation === "string" && relation.length > 0 ? [relation] : [];
+}
+
 /**
  * Key of a block type's version: a `block_type`'s `currentVersion` must name
  * the `block_type_version` record with the same key.

package/src/transfer/import/context.ts

@@ -6,6 +6,7 @@ import type { Kysely } from "kysely";
 
 import { isPostgres } from "../../database/dialect-helpers.js";
 import type { Database } from "../../database/types.js";
+import { isStoragelessFieldRow } from "../../schema/types.js";
 import type { Storage } from "../../storage/types.js";
 import { TransferError } from "../errors.js";
 import {
@@ -90,7 +91,10 @@ export class ImportContext {
 		return records;
 	}
 
-	/** Target column type of each field of a collection, from the imported schema. */
+	/**
+	 * Target column type of each field of a collection that has a column, from
+	 * the imported schema.
+	 */
 	async fieldColumns(collection: string): Promise<ReadonlyMap<string, FieldColumnType>> {
 		return (await this.fields(collection)).columns;
 	}
@@ -110,9 +114,12 @@ export class ImportContext {
 					"_emdash_fields.slug as slug",
 					"_emdash_fields.column_type as column_type",
 					"_emdash_fields.required as required",
+					"_emdash_fields.type as type",
+					"_emdash_fields.validation as validation",
 				])
 				.where("_emdash_collections.slug", "=", collection)
 				.execute()
+				.then((all) => all.filter((row) => !isStoragelessFieldRow(row)))
 				.then((rows) => ({
 					columns: new Map(
 						rows.map((row) => [row.slug, toFieldColumnType(row.column_type)] as const),

package/src/transfer/ops/package-index.ts

@@ -6,7 +6,7 @@
  * Conventions for what analysis stores:
  * - `group_id`: the record's `translationGroup`, or its `id` when it has none
  *   (what `by: "group"` references resolve against);
- * - `name_key`: the collection or block type `slug`, the menu `name`, or the
+ * - `name_key`: the collection, block type or relation `slug`, the menu `name`, or the
  *   block type version's `blockTypeVersionKey` (what `by: "slug"` and
  *   `by: "name"` references resolve against);
  * - `parent_id` and `depth` for topological kinds.

package/dist/action-token-DYwe4Pk0.mjs

@@ -1,26 +0,0 @@
-import { r as verifyPreviewToken, t as generatePreviewToken } from "./tokens-u78jETkX.mjs";
-
-//#region src/visual-editing/action-token.ts
-const VISUAL_ACTION_SECRET_DOMAIN = "emdash:visual-editing-action:v1:";
-const VISUAL_ACTION_TOKEN_INVALID = "VISUAL_ACTION_TOKEN_INVALID";
-function visualActionSecret(previewSecret) {
-	return `${VISUAL_ACTION_SECRET_DOMAIN}${previewSecret}`;
-}
-function generateVisualEditingActionToken(previewSecret, userId) {
-	return generatePreviewToken({
-		contentId: `visual-editing:${userId}`,
-		expiresIn: "5m",
-		secret: visualActionSecret(previewSecret)
-	});
-}
-async function verifyVisualEditingActionToken(token, previewSecret, userId) {
-	const verification = await verifyPreviewToken({
-		token,
-		secret: visualActionSecret(previewSecret)
-	});
-	return verification.valid && verification.payload.cid === `visual-editing:${userId}`;
-}
-
-//#endregion
-export { generateVisualEditingActionToken as n, verifyVisualEditingActionToken as r, VISUAL_ACTION_TOKEN_INVALID as t };
-//# sourceMappingURL=action-token-DYwe4Pk0.mjs.map

package/dist/action-token-DYwe4Pk0.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-token-DYwe4Pk0.mjs","names":[],"sources":["../src/visual-editing/action-token.ts"],"sourcesContent":["import { generatePreviewToken, verifyPreviewToken } from \"../preview/tokens.js\";\n\nconst VISUAL_ACTION_SECRET_DOMAIN = \"emdash:visual-editing-action:v1:\";\nexport const VISUAL_ACTION_TOKEN_INVALID = \"VISUAL_ACTION_TOKEN_INVALID\";\n\nfunction visualActionSecret(previewSecret: string): string {\n\treturn `${VISUAL_ACTION_SECRET_DOMAIN}${previewSecret}`;\n}\n\nexport function generateVisualEditingActionToken(\n\tpreviewSecret: string,\n\tuserId: string,\n): Promise<string> {\n\treturn generatePreviewToken({\n\t\tcontentId: `visual-editing:${userId}`,\n\t\texpiresIn: \"5m\",\n\t\tsecret: visualActionSecret(previewSecret),\n\t});\n}\n\nexport async function verifyVisualEditingActionToken(\n\ttoken: string,\n\tpreviewSecret: string,\n\tuserId: string,\n): Promise<boolean> {\n\tconst verification = await verifyPreviewToken({\n\t\ttoken,\n\t\tsecret: visualActionSecret(previewSecret),\n\t});\n\treturn verification.valid && verification.payload.cid === `visual-editing:${userId}`;\n}\n"],"mappings":";;;AAEA,MAAM,8BAA8B;AACpC,MAAa,8BAA8B;AAE3C,SAAS,mBAAmB,eAA+B;AAC1D,QAAO,GAAG,8BAA8B;;AAGzC,SAAgB,iCACf,eACA,QACkB;AAClB,QAAO,qBAAqB;EAC3B,WAAW,kBAAkB;EAC7B,WAAW;EACX,QAAQ,mBAAmB,cAAc;EACzC,CAAC;;AAGH,eAAsB,+BACrB,OACA,eACA,QACmB;CACnB,MAAM,eAAe,MAAM,mBAAmB;EAC7C;EACA,QAAQ,mBAAmB,cAAc;EACzC,CAAC;AACF,QAAO,aAAa,SAAS,aAAa,QAAQ,QAAQ,kBAAkB"}