@shapio/local 0.5.8 → 0.5.10

package/dist/index.js

@@ -1,9 +1,9 @@
-import { c as assertNotNested, d as toDatetimeText, f as AppError, i as createMysqlDb, l as withConnectionScope, n as createSqliteDb, o as DEFAULT_POOL_ACQUIRE_TIMEOUT_MS, s as pgAcquireError, t as lockKeyFromId, u as toStoredTimestamp } from "./advisoryLocks-ajVNBhfa.js";
+import { c as assertNotNested, d as toDatetimeText, f as AppError, i as createMysqlDb, l as withConnectionScope, n as createSqliteDb, o as DEFAULT_POOL_ACQUIRE_TIMEOUT_MS, s as pgAcquireError, t as lockKeyFromId, u as toStoredTimestamp } from "./advisoryLocks-DGbxw3_E.js";
 import { a as visibilityOfKey, i as isValidStorageKey, n as ObjectNotFoundError, o as withVisibility, r as encodeKeyPath, t as InvalidStorageKeyError } from "./errors-nQvt9bs7.js";
 import { t as assertNodeRuntime } from "./nodeRuntime-DzuiHUhY.js";
 import { ShapioApiError, createClient, createDeliveryClient } from "@shapio/client";
 import { Value } from "typebox/value";
-import { BIGINTEGER_PATTERN, DATE_PATTERN, DECIMAL_PATTERN, EMPTY_SEO_DEFAULTS, SCALAR_DATA_TYPES, SEO_COMPONENT_ID, SEO_FIELD_IDS, SeoDefaultsSchema, TEXT_TITLE_FIELD_TYPES, TIME_PATTERN, effectiveLayout, effectiveTitleField, embeddedComponentIds, findDependentModels, hashDefinition, isComponentDefinition, isModelDefinition, isSeoField, isStableId, renderRichTextHtml, resolveSeo, richTextMediaIds, routeKeyOf, seoDefaultsForLocale, withDerivedPlural } from "@shapio/schema";
+import { BIGINTEGER_PATTERN, DATE_PATTERN, DECIMAL_PATTERN, EMPTY_SEO_DEFAULTS, MAX_INHERITANCE_DEPTH, MAX_ROUTE_KEY_LENGTH, SCALAR_DATA_TYPES, SEO_COMPONENT_ID, SEO_FIELD_IDS, SeoDefaultsSchema, TEXT_TITLE_FIELD_TYPES, TIME_PATTERN, createDefinitionIndex, effectiveLayout, effectiveTitleField, embeddedComponentIds, findDependentModels, hashDefinition, isComponentDefinition, isModelDefinition, isSeoField, isStableId, renderRichTextHtml, resolveSeo, richTextMediaIds, routePathOf, seoDefaultsForLocale, splitRoutePath, withDerivedPlural } from "@shapio/schema";
 import { Type } from "typebox";
 import { Kysely, PostgresDialect, sql } from "kysely";
 import { createHash, createHmac, randomBytes } from "node:crypto";
@@ -15,7 +15,7 @@ import { mkdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 //#endregion
 //#region ../../apps/api/src/constants/version.ts
-const SHAPIO_VERSION$1 = "0.5.8";
+const SHAPIO_VERSION$1 = "0.5.10";
 //#endregion
 //#region ../../apps/api/src/helpers/errorResponse.ts
 const STATUS_CODES = {
@@ -127,6 +127,14 @@ const toShapioApiError = (error, log) => {
 const SITE_QUERY_PARAMETER = "site";
 //#endregion
 //#region ../../apps/api/src/content/model.ts
+/** Where a model is served: its nested route key and its ancestors' API IDs, root first. */
+const modelRouteOf = (snapshot, definition) => {
+	const ancestors = snapshot.ancestors(definition.id).map((id) => snapshot.byId.get(id)?.definition).filter((ancestor) => ancestor !== void 0 && isModelDefinition(ancestor));
+	return {
+		key: routePathOf(definition, ancestors),
+		ancestors: ancestors.map((ancestor) => ancestor.apiKey)
+	};
+};
 const modelNotFound = (key) => new AppError(404, "MODEL_NOT_FOUND", `No content model "${key}"`, { modelKey: key });
 const collectComponents = (snapshot, model) => {
 	const found = /* @__PURE__ */ new Map();
@@ -143,12 +151,24 @@ const collectComponents = (snapshot, model) => {
 	}
 	return found;
 };
-const toContentModel = (snapshot, active) => ({
-	definition: active.definition,
-	version: active.version,
-	revisionId: active.revisionId,
-	components: collectComponents(snapshot, active.definition)
-});
+const ancestorsOf = (snapshot, definition) => new Map(definition.ancestorIds.flatMap((id) => {
+	const ancestor = snapshot.byId.get(id);
+	return ancestor ? [[id, {
+		version: ancestor.version,
+		revisionId: ancestor.revisionId
+	}]] : [];
+}));
+const toContentModel = (snapshot, active) => {
+	const definition = snapshot.resolve(active.definition.id);
+	return {
+		definition,
+		version: active.version,
+		revisionId: active.revisionId,
+		ancestors: ancestorsOf(snapshot, definition),
+		components: collectComponents(snapshot, definition),
+		route: modelRouteOf(snapshot, definition)
+	};
+};
 const isModel = (active) => active !== void 0 && !isComponentDefinition(active.definition);
 /**
 * Resolves `/api/…/content/:modelKey` through the registry at request time (CONTRIBUTING.md rule 2). Only a
@@ -176,6 +196,27 @@ const resolveModelById = (snapshot, modelId) => {
 	return isModel(active) ? toContentModel(snapshot, active) : void 0;
 };
 const findFieldByApiKey = (fields, apiKey) => fields.find((field) => field.apiKey === apiKey && !field.deprecated);
+Math.max(100, MAX_ROUTE_KEY_LENGTH + 2 * (MAX_INHERITANCE_DEPTH - 1));
+const decodeSegment = (segment) => {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return;
+	}
+};
+/**
+* Splits the decoded segments after a content prefix into the route key and the rest (`splitRoutePath`),
+* with how many segments the key took. Undefined when a segment does not decode or none is a key.
+*/
+const splitContentPath = (rawSegments) => {
+	const decoded = rawSegments.map(decodeSegment);
+	if (decoded.some((segment) => segment === void 0)) return;
+	const split = splitRoutePath(decoded);
+	return split ? {
+		...split,
+		consumed: decoded.length - split.rest.length
+	} : void 0;
+};
 //#endregion
 //#region ../../apps/api/src/helpers/siteQuery.ts
 const isSiteSegment = (segment) => {
@@ -500,25 +541,70 @@ const snapshotInvalid = (requested, current) => new AppError(400, "SNAPSHOT_INVA
 	current
 });
 //#endregion
-//#region ../../apps/api/src/usage/keys.ts
+//#region ../../apps/api/src/content/family.ts
 /**
-* How delivery reads are attributed (plan developer-face §5). Delivery tokens are consumers, one key per
-* token; app users are counted together, and so are anonymous callers. Admin reads (admin users and
-* admin-scope API tokens), system work and previews are not consumers and are never counted.
+* Families (plan polymorphic-types): a model and every model that extends it, directly or not. Reading a
+* route reads its model's family; relations to a model accept any member; an entry may change kind within
+* its family. Members share their inherited fields' IDs, their localization and their publishing flags.
 */
-const APP_USERS_PRINCIPAL_KEY = "app_users";
-const ANONYMOUS_PRINCIPAL_KEY = "anonymous";
-/** `token:<id>`, `app_users`, `anonymous`, or null for principals whose reads are not counted. */
-const usagePrincipalKey = (principal) => {
-	switch (principal.kind) {
-		case "token": return principal.scope === "delivery" ? `token:${principal.tokenId}` : null;
-		case "appUser": return APP_USERS_PRINCIPAL_KEY;
-		case "anonymous": return ANONYMOUS_PRINCIPAL_KEY;
-		default: return null;
+/** The members of a model's family that are in the schema view: the model first, then its descendants. */
+const familyModels = (snapshot, model) => snapshot.family(model.definition.id).flatMap((id) => id === model.definition.id ? [model] : resolveModelById(snapshot, id) ?? []);
+/** The family's model IDs (the model first). */
+const familyIdsOf = (snapshot, modelId) => {
+	const family = snapshot.family(modelId);
+	return family.length > 0 ? family : [modelId];
+};
+/**
+* The members of the model's family the caller may read, each with its own policy, the model first when it is
+* readable. A member the caller may not read is left out (never a 403: the caller asked for the family).
+*/
+const readableMembers = async (snapshot, model, policyFor) => {
+	const models = familyModels(snapshot, model);
+	const policies = await Promise.all(models.map((member) => policyFor(member.definition.id)));
+	return models.flatMap((member, index) => {
+		const policy = policies[index];
+		return policy.allowed ? [{
+			model: member,
+			policy
+		}] : [];
+	});
+};
+/** The member a row belongs to, by its `model_id`. */
+const memberOf = (members, modelId) => members.find((member) => member.model.definition.id === modelId);
+/** Rows grouped by their member, in first-seen order; rows of a model not among the members are dropped. */
+const groupByMember = (members, rows) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		let group = groups.get(row.model_id);
+		if (!group) {
+			const member = memberOf(members, row.model_id);
+			if (!member) continue;
+			group = {
+				member,
+				rows: []
+			};
+			groups.set(row.model_id, group);
+		}
+		group.rows.push(row);
 	}
+	return [...groups.values()];
+};
+/**
+* The kinds a family list covers, in tree order (the route's model, then each kind before its own kinds):
+* the members the caller may read. Undefined for a model without kinds, so its responses do not change.
+*/
+const kindsMetaOf = (snapshot, route, members) => {
+	if (snapshot.childrenOf(route.definition.id).length === 0) return;
+	return members.map(({ model }) => {
+		const parentId = model.definition.extends;
+		return {
+			apiKey: model.definition.apiKey,
+			label: model.definition.label,
+			parent: parentId === void 0 ? null : snapshot.byId.get(parentId)?.definition.apiKey ?? null,
+			routeKey: model.route?.key ?? modelRouteOf(snapshot, model.definition).key
+		};
+	});
 };
-/** A populated relation's target field: `<relation field ID>.<target field ID>`. */
-const relationFieldPath = (relationFieldId, targetFieldId) => `${relationFieldId}.${targetFieldId}`;
 //#endregion
 //#region ../../apps/api/src/content/validator/scalars.ts
 const INPUT_DATETIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/;
@@ -570,6 +656,36 @@ const canonicalBigInteger = (value) => {
 * keeps values until an explicit cleanup); deprecated fields' values are kept but not validated.
 */
 const COMPONENT_KEY = "__component";
+/**
+* The API ID of an entry's own model on every delivered entry (plan polymorphic-types). A system attribute:
+* never a field (API IDs may not start with `__`), so a write naming it fails as an unknown field.
+*/
+const MODEL_KEY = "__model";
+/**
+* The singular API IDs of an entry's kind lineage on every delivered entry, root first and its own kind last
+* (plan polymorphic-types). A system attribute like `MODEL_KEY`: never a field, never written.
+*/
+const KINDS_KEY = "__kinds";
+//#endregion
+//#region ../../apps/api/src/usage/keys.ts
+/**
+* How delivery reads are attributed (plan developer-face §5). Delivery tokens are consumers, one key per
+* token; app users are counted together, and so are anonymous callers. Admin reads (admin users and
+* admin-scope API tokens), system work and previews are not consumers and are never counted.
+*/
+const APP_USERS_PRINCIPAL_KEY = "app_users";
+const ANONYMOUS_PRINCIPAL_KEY = "anonymous";
+/** `token:<id>`, `app_users`, `anonymous`, or null for principals whose reads are not counted. */
+const usagePrincipalKey = (principal) => {
+	switch (principal.kind) {
+		case "token": return principal.scope === "delivery" ? `token:${principal.tokenId}` : null;
+		case "appUser": return APP_USERS_PRINCIPAL_KEY;
+		case "anonymous": return ANONYMOUS_PRINCIPAL_KEY;
+		default: return null;
+	}
+};
+/** A populated relation's target field: `<relation field ID>.<target field ID>`. */
+const relationFieldPath = (relationFieldId, targetFieldId) => `${relationFieldId}.${targetFieldId}`;
 //#endregion
 //#region ../../apps/api/src/permissions/policy.ts
 const EMPTY_MASK = {
@@ -586,7 +702,11 @@ const ALLOW_ALL_POLICY = Object.freeze({
 	rowWriteMasks: null
 });
 const WRITE_ACTIONS = /* @__PURE__ */ new Set(["create", "update"]);
-const grantsFor = (grants, action, modelId) => grants.filter((grant) => grant.action === action && (grant.modelId === null || grant.modelId === modelId));
+/**
+* Grants of `action` that apply to a model: on every model, on the model itself, or on one of the models it
+* extends (`ancestors`), so a grant on Products covers Digital products (plan polymorphic-types D8).
+*/
+const grantsFor = (grants, action, modelId, ancestors) => grants.filter((grant) => grant.action === action && (grant.modelId === null || grant.modelId === modelId || ancestors.includes(grant.modelId)));
 /** Rows: the union of what each grant allows. Any unconditional grant means no restriction. */
 const combineRowFilters = (grants) => {
 	if (grants.some((grant) => grant.condition === null)) return null;
@@ -664,11 +784,11 @@ const combineRowFieldMasks = (grants, audience, fields) => {
 * The policy for one (action, model) request from a principal's grants. Pure: no I/O, so it is unit- and
 * property-tested directly. Deny by default: no matching grant, no access.
 */
-const buildPolicy = (grants, request, audience, fields) => {
+const buildPolicy = (grants, request, audience, fields, ancestors = []) => {
 	if (audience === "delivery" && fields === void 0) return DENIED_POLICY;
-	const matching = grantsFor(grants, request.action, request.modelId);
+	const matching = grantsFor(grants, request.action, request.modelId, ancestors);
 	if (matching.length === 0) return DENIED_POLICY;
-	const readGrants = request.action === "read" ? matching : grantsFor(grants, "read", request.modelId);
+	const readGrants = request.action === "read" ? matching : grantsFor(grants, "read", request.modelId, ancestors);
 	const writes = WRITE_ACTIONS.has(request.action);
 	return {
 		allowed: true,
@@ -752,6 +872,13 @@ const CONTENT_HEADS_COLUMNS = {
 	state: "state"
 };
 //#endregion
+//#region ../../apps/api/src/content/compiler/dialect/modelMatch.ts
+/**
+* `column` names one of the models: `= <literal>` for one model (the form partial indexes match), `in (…)`
+* for a family (plan polymorphic-types). Model IDs arrive as literals already checked by `expressions.ts`.
+*/
+const modelIdMatches = (column, modelIds) => modelIds.length === 1 ? sql`${column} = ${modelIds[0]}` : sql`${column} in (${sql.join([...modelIds])})`;
+//#endregion
 //#region ../../apps/api/src/content/compiler/dialect/mysql.ts
 /**
 * MySQL content SQL (ADR 0001, "MySQL"). `data` is a JSON column; there is no containment index and no
@@ -815,15 +942,15 @@ const COLUMN_TYPES = {
 };
 const addIndexColumn = ({ name, table, expression, cast, numericString }) => sql`alter table ${sql.table(table)} add column ${sql.id(fieldIndexColumnName(name))} ${numericString ? DECIMAL : COLUMN_TYPES[cast]}
     generated always as (${expression}) virtual invisible, algorithm=inplace, lock=none`;
-/** Published revisions of a model as of a publication sequence (`snapshotCte`, relation targets). */
-const snapshotRows$2 = ({ siteId, modelId, seq }) => sql`
+/** Published revisions of a model (or a family) as of a publication sequence (`snapshotCte`, relation targets). */
+const snapshotRows$2 = ({ siteId, modelIds, seq }) => sql`
     select pl.entry_id, pl.site_id, pl.model_id, pl.locale, 'published' as state, r.data, 0 as version,
       r.id as revision_id, pl.published_at as updated_at, null as autosaved_at,
       en.created_at as entry_created_at
     from publication_log pl
     join content_revisions r on r.id = pl.revision_id
     join entries en on en.id = pl.entry_id
-    where pl.site_id = ${siteId} and pl.model_id = ${modelId}
+    where pl.site_id = ${siteId} and ${modelIdMatches(sql`pl.model_id`, modelIds)}
       and pl.from_seq <= ${seq}
       and (pl.to_seq is null or pl.to_seq > ${seq})`;
 /**
@@ -949,15 +1076,15 @@ const castParameter$2 = (value, cast) => {
 * so nothing from the request is ever spliced into the SQL text.
 */
 const containment = (document) => sql`(${DATA$1} @> ${JSON.stringify(document)}::jsonb)`;
-/** Published revisions of a model as of a publication sequence (`snapshotCte`, relation targets). */
-const snapshotRows$1 = ({ siteId, modelId, seq }) => sql`
+/** Published revisions of a model (or a family) as of a publication sequence (`snapshotCte`, relation targets). */
+const snapshotRows$1 = ({ siteId, modelIds, seq }) => sql`
     select pl.entry_id, pl.site_id, pl.model_id, pl.locale, 'published'::text as state, r.data, 0 as version,
       r.id as revision_id, pl.published_at as updated_at, null::timestamptz as autosaved_at,
       en.created_at as entry_created_at
     from publication_log pl
     join content_revisions r on r.id = pl.revision_id
     join entries en on en.id = pl.entry_id
-    where pl.site_id = ${siteId}::uuid and pl.model_id = ${modelId}
+    where pl.site_id = ${siteId}::uuid and ${modelIdMatches(sql`pl.model_id`, modelIds)}
       and pl.from_seq <= ${seq}::bigint
       and (pl.to_seq is null or pl.to_seq > ${seq}::bigint)`;
 /** A UUID-shaped text cast to uuid; anything else is no ID (a cast would fail the whole statement). */
@@ -1043,15 +1170,15 @@ const castParameter$1 = (value, cast) => {
 		default: return sql`${value}`;
 	}
 };
-/** Published revisions of a model as of a publication sequence (`snapshotCte`, relation targets). */
-const snapshotRows = ({ siteId, modelId, seq }) => sql`
+/** Published revisions of a model (or a family) as of a publication sequence (`snapshotCte`, relation targets). */
+const snapshotRows = ({ siteId, modelIds, seq }) => sql`
     select pl.entry_id, pl.site_id, pl.model_id, pl.locale, 'published' as state, r.data, 0 as version,
       r.id as revision_id, pl.published_at as updated_at, null as autosaved_at,
       en.created_at as entry_created_at
     from publication_log pl
     join content_revisions r on r.id = pl.revision_id
     join entries en on en.id = pl.entry_id
-    where pl.site_id = ${siteId} and pl.model_id = ${modelId}
+    where pl.site_id = ${siteId} and ${modelIdMatches(sql`pl.model_id`, modelIds)}
       and pl.from_seq <= ${seq}
       and (pl.to_seq is null or pl.to_seq > ${seq})`;
 /** One row per stored ID: `json_each` for a list, a one-row select for a single ID (UUIDs are text). */
@@ -1624,17 +1751,30 @@ const showsReference = ({ field }, shown, dialect) => {
       where ${ids.matches(sql`m.id`)} and m.site_id = ${dialect.uuid(shown.siteId)} and m.deleted_at is null))`;
 	const table = shown.source.kind === "heads" ? sql.table("entry_heads") : sql`(${dialect.snapshotRows({
 		siteId: shown.siteId,
-		modelId: modelIdLiteral(shown.modelId),
+		modelIds: shown.members.map((member) => modelIdLiteral(member.modelId)),
 		seq: shown.source.seq
 	})})`;
-	const rowFilter = compileRowFilter(shown.rowFilter, shown.actor, dialect);
-	const where = whereOf({
+	const members = shown.members.map((member) => {
+		const rowFilter = compileRowFilter(member.rowFilter, shown.actor, dialect);
+		return {
+			modelId: member.modelId,
+			conditions: rowFilter ? [rowFilter] : []
+		};
+	});
+	const [single] = members;
+	const matches = ids.matches(sql`h.entry_id`);
+	const where = whereOf(members.length === 1 && single ? {
 		siteId: shown.siteId,
-		modelId: shown.modelId,
+		model: modelIs(single.modelId),
 		source: shown.source,
 		locales: shown.locales,
-		conditions: [ids.matches(sql`h.entry_id`), ...rowFilter ? [rowFilter] : []],
-		orderBy: []
+		conditions: [matches, ...single.conditions]
+	} : {
+		siteId: shown.siteId,
+		model: anyMember(members),
+		source: shown.source,
+		locales: shown.locales,
+		conditions: [matches]
 	}, table, dialect);
 	return sql`exists (select 1 from ${ids.from} where exists (select 1 from ${table} h
       join entries e on e.id = h.entry_id and e.deleted_at is null where ${where}))`;
@@ -1697,7 +1837,7 @@ const compileAuthorCondition = (adminUserId, dialect = contentDialect()) => sql`
 const compileSearch = (fieldId, text, dialect = contentDialect()) => containsInsensitiveExpression(fieldId, text, dialect);
 const SNAPSHOT_CTE = "content_snapshot";
 /** The FROM item for a source, aliased `alias`, and the CTE it needs (snapshots only). */
-const sourceOf$1 = (source, modelId, siteId, dialect) => {
+const sourceOf$1 = (source, modelIds, siteId, dialect) => {
 	if (source.kind === "heads") return {
 		cte: null,
 		table: sql.table("entry_heads")
@@ -1706,7 +1846,7 @@ const sourceOf$1 = (source, modelId, siteId, dialect) => {
 		cte: dialect.snapshotCte({
 			name: SNAPSHOT_CTE,
 			siteId,
-			modelId: modelIdLiteral(modelId),
+			modelIds: modelIds.map(modelIdLiteral),
 			seq: source.seq
 		}),
 		table: sql.id(SNAPSHOT_CTE)
@@ -1721,13 +1861,16 @@ const localeConditions = (scope, table, source, dialect) => {
       and ${dialect.oneOf(sql`h2.locale`, chain, "text")}
       and ${dialect.localeRank(chain, sql`h2.locale`)} < ${dialect.localeRank(chain, sql`h.locale`)})`];
 };
-const whereOf = (plan, table, dialect) => {
+const modelIs = (modelId) => sql`h.model_id = ${modelIdLiteral(modelId)}`;
+/** Heads of any of the members, each under its own conditions (a relation's target family). */
+const anyMember = (members) => sql`(${sql.join(members.map((member) => member.conditions.length === 0 ? modelIs(member.modelId) : sql`(${modelIs(member.modelId)} and ${sql.join([...member.conditions], sql` and `)})`), sql` or `)})`;
+const whereOf = (scope, table, dialect) => {
 	const conditions = [
-		sql`h.site_id = ${dialect.uuid(plan.siteId)}`,
-		sql`h.model_id = ${modelIdLiteral(plan.modelId)}`,
-		...plan.source.kind === "heads" ? [sql`h.state = ${plan.source.state}`] : [],
-		...localeConditions(plan.locales, table, plan.source, dialect),
-		...plan.conditions
+		sql`h.site_id = ${dialect.uuid(scope.siteId)}`,
+		scope.model,
+		...scope.source.kind === "heads" ? [sql`h.state = ${scope.source.state}`] : [],
+		...localeConditions(scope.locales, table, scope.source, dialect),
+		...scope.conditions
 	];
 	return sql.join(conditions, sql` and `);
 };
@@ -1738,30 +1881,94 @@ const whereOf = (plan, table, dialect) => {
 * (the model index, or a field index for an indexed filter). A snapshot keeps the join: the publication log
 * still lists entries deleted since.
 */
-const countFrom = (plan, table, where, joined) => plan.source.kind === "heads" && !(plan.conditionsReadEntries ?? plan.conditions.length > 0) ? sql`from ${table} h where ${where}` : joined;
-const HEAD_COLUMNS = sql`h.entry_id, h.locale, h.data, h.version, h.revision_id, h.updated_at,
+const countFrom = (plan, member, table, where, joined) => plan.source.kind === "heads" && !(plan.conditionsReadEntries ?? plan.conditions.length > 0) && (member.conditions?.length ?? 0) === 0 ? sql`from ${table} h where ${where}` : joined;
+const HEAD_COLUMNS = sql`h.entry_id, h.model_id, h.locale, h.data, h.version, h.revision_id, h.updated_at,
       h.autosaved_at, e.created_at, e.updated_at as entry_updated_at, e.created_by_admin_id, e.owner_app_user_id`;
-/** The parts every statement over a plan's heads shares. */
-const headQueryParts = (plan, dialect) => {
-	const { cte, table } = sourceOf$1(plan.source, plan.modelId, plan.siteId, dialect);
-	const where = whereOf(plan, table, dialect);
+/** The same columns read back from the union of a family read's arms (aliased `u`). */
+const UNION_COLUMNS = sql`u.entry_id, u.model_id, u.locale, u.data, u.version, u.revision_id, u.updated_at,
+      u.autosaved_at, u.created_at, u.entry_updated_at, u.created_by_admin_id, u.owner_app_user_id`;
+const renderTerm = (expression, term, dialect) => dialect.sortTerm ? dialect.sortTerm(expression, term.direction, term.nullable) : sql`${expression} ${dialect.sortDirection(term.direction, term.nullable)}`;
+const orderByOf = (terms) => terms.length > 0 ? sql` order by ${sql.join([...terms])}` : sql``;
+/** The FROM, WHERE and COUNT FROM of one member's heads. */
+const memberParts = (plan, member, table, dialect) => {
+	const where = whereOf({
+		siteId: plan.siteId,
+		model: modelIs(member.modelId),
+		source: plan.source,
+		locales: plan.locales,
+		conditions: [...plan.conditions, ...member.conditions ?? []]
+	}, table, dialect);
 	const from = sql`from ${table} h join entries e on e.id = h.entry_id and e.deleted_at is null where ${where}`;
-	const orderBy = plan.orderBy.length > 0 ? sql` order by ${sql.join([...plan.orderBy])}` : sql``;
+	return {
+		from,
+		counted: countFrom(plan, member, table, where, from)
+	};
+};
+/** One model: the statement as it has always been. */
+const singleParts = (plan, member, table, dialect) => {
+	const { from, counted } = memberParts(plan, member, table, dialect);
+	const orderBy = orderByOf(plan.orderBy.map((term) => renderTerm(term.expression, term, dialect)));
 	const limit = plan.limit !== void 0 ? sql` limit ${plan.limit}` : sql``;
 	const offset = plan.offset ? sql` offset ${plan.offset}` : sql``;
 	return {
-		prefix: cte ?? sql``,
+		columns: HEAD_COLUMNS,
 		rows: sql`${from}${orderBy}${limit}${offset}`,
-		countFrom: countFrom(plan, table, where, from)
+		total: sql`(select count(*) ${counted})`,
+		count: sql`select count(*) as total ${counted}`
+	};
+};
+/**
+* A family read (plan polymorphic-types): one arm per member, each `h.model_id = '<literal>'` with that
+* member's conditions, so each keeps its partial expression indexes and entry-order index. Each arm is a
+* derived table that projects the sort expressions as `s0…sn`, sorts and stops at `offset + limit` itself
+* (SQLite allows ORDER BY and LIMIT in a compound member only inside a derived table); the union is ordered
+* by the aliases and paged on the outside. The total is the sum of the arms' counts.
+*/
+const unionParts = (plan, table, dialect) => {
+	const pageEnd = plan.limit !== void 0 ? plan.limit + (plan.offset ?? 0) : void 0;
+	const aliases = plan.orderBy.map((_term, index) => `s${index}`);
+	const projected = plan.orderBy.map((term, index) => sql`${term.expression} as ${sql.id(aliases[index])}`);
+	const arms = plan.members.map((member, index) => {
+		const { from, counted } = memberParts(plan, member, table, dialect);
+		const columns = projected.length > 0 ? sql`${HEAD_COLUMNS}, ${sql.join(projected)}` : HEAD_COLUMNS;
+		const orderBy = pageEnd !== void 0 ? orderByOf(plan.orderBy.map((term) => renderTerm(term.expression, term, dialect))) : sql``;
+		const limit = pageEnd !== void 0 ? sql` limit ${pageEnd}` : sql``;
+		return {
+			rows: sql`select * from (select ${columns}
+      ${from}${orderBy}${limit}) ${sql.id(`a${index}`)}`,
+			total: sql`(select count(*) ${counted})`
+		};
+	});
+	const orderBy = orderByOf(plan.orderBy.map((term, index) => renderTerm(sql.ref(`u.${aliases[index]}`), term, dialect)));
+	const limit = plan.limit !== void 0 ? sql` limit ${plan.limit}` : sql``;
+	const offset = plan.offset ? sql` offset ${plan.offset}` : sql``;
+	const total = sql`(${sql.join(arms.map((arm) => arm.total), sql` + `)})`;
+	return {
+		columns: UNION_COLUMNS,
+		rows: sql`from (${sql.join(arms.map((arm) => arm.rows), sql`
+      union all `)}) u${orderBy}${limit}${offset}`,
+		total,
+		count: sql`select ${total} as total`
+	};
+};
+/** The parts every statement over a plan's heads shares. */
+const headQueryParts = (plan, dialect) => {
+	const [first] = plan.members;
+	if (!first) throw new Error("A head query reads at least one model");
+	const { cte, table } = sourceOf$1(plan.source, plan.members.map((member) => member.modelId), plan.siteId, dialect);
+	const parts = plan.members.length === 1 ? singleParts(plan, first, table, dialect) : unionParts(plan, table, dialect);
+	return {
+		prefix: cte ?? sql``,
+		...parts
 	};
 };
 /** The SELECT for a plan: rows, plus the matching COUNT for pagination. */
 const compileHeadQuery = (plan, dialect = contentDialect()) => {
-	const { prefix, rows, countFrom: counted } = headQueryParts(plan, dialect);
+	const { prefix, columns, rows, count } = headQueryParts(plan, dialect);
 	return {
-		rows: sql`${prefix}select ${HEAD_COLUMNS}
+		rows: sql`${prefix}select ${columns}
       ${rows}`,
-		count: sql`${prefix}select count(*) as total ${counted}`
+		count: sql`${prefix}${count}`
 	};
 };
 /**
@@ -1772,11 +1979,11 @@ const compileHeadQuery = (plan, dialect = contentDialect()) => {
 * sequence alone, for callers that read it in the same transaction as `rows`.
 */
 const compileHeadPage = (plan, options, dialect = contentDialect()) => {
-	const { prefix, rows, countFrom: counted } = headQueryParts(plan, dialect);
-	const total = options.total ? sql`(select count(*) ${counted})` : sql`null`;
+	const { prefix, columns, rows, total: counted } = headQueryParts(plan, dialect);
+	const total = options.total ? counted : sql`null`;
 	const seq = sql`(select ps.last_seq from publication_state ps where ps.site_id = ${dialect.uuid(plan.siteId)})`;
 	return {
-		rows: sql`${prefix}select ${HEAD_COLUMNS}, ${total} as page_total, ${seq} as page_seq
+		rows: sql`${prefix}select ${columns}, ${total} as page_total, ${seq} as page_seq
       ${rows}`,
 		meta: sql`${prefix}select ${total} as page_total, ${seq} as page_seq`
 	};
@@ -1791,6 +1998,8 @@ const compileHeadPage = (plan, options, dialect = contentDialect()) => {
 const entryIdIs = (id, dialect = contentDialect()) => sql`h.entry_id = ${dialect.uuid(id)}`;
 /** The head belongs to one of `ids` (one bound parameter, whatever its length). */
 const entryIdIn = (ids, dialect = contentDialect()) => dialect.oneOf(sql`h.entry_id`, ids, "uuid");
+/** No head: a read narrowed to kinds the caller may not read (`filters[__model]`). */
+const matchesNothing = (dialect = contentDialect()) => dialect.bool(false);
 //#endregion
 //#region ../../apps/api/src/content/compiler/sort.ts
 /**
@@ -1807,12 +2016,11 @@ const SYSTEM_SORT_COLUMNS = {
 	createdAt: "h.entry_created_at",
 	updatedAt: "h.updated_at"
 };
-const termSql = (term, dialect) => {
-	const nullable = term.target.kind === "field";
-	const expression = term.target.kind === "system" ? sql.ref(SYSTEM_SORT_COLUMNS[term.target.name]) : fieldValueExpression(term.target.field.id, term.target.field.type, dialect);
-	if (dialect.sortTerm) return dialect.sortTerm(expression, term.direction, nullable);
-	return sql`${expression} ${dialect.sortDirection(term.direction, nullable)}`;
-};
+const termOf = (term, dialect) => ({
+	expression: term.target.kind === "system" ? sql.ref(SYSTEM_SORT_COLUMNS[term.target.name]) : fieldValueExpression(term.target.field.id, term.target.field.type, dialect),
+	direction: term.direction,
+	nullable: term.target.kind === "field"
+});
 const defaultSortTerms = (model, isReadable) => {
 	const preferred = model.display.defaultSort;
 	const field = preferred ? model.fields.find((candidate) => candidate.id === preferred.fieldId) : void 0;
@@ -1831,7 +2039,15 @@ const defaultSortTerms = (model, isReadable) => {
 		direction: "desc"
 	}];
 };
-const compileOrderBy = (terms, dialect = contentDialect()) => [...terms.map((term) => termSql(term, dialect)), sql`h.entry_id asc`];
+/**
+* The ORDER BY of a head query, as terms the compiler renders (`compile.ts`): a family read orders each arm by
+* them and the union by their projected aliases.
+*/
+const compileOrderBy = (terms, dialect = contentDialect()) => [...terms.map((term) => termOf(term, dialect)), {
+	expression: sql`h.entry_id`,
+	direction: "asc",
+	nullable: false
+}];
 //#endregion
 //#region ../../apps/api/src/content/locales.ts
 /**
@@ -2118,15 +2334,17 @@ const populateRelations = async (env, rows, fields, tree) => {
 		populated.set(fieldId, byId);
 		const target = resolveModelById(env.snapshot, field.settings.target);
 		if (!target) continue;
-		const policy = await env.policyFor(env, target.definition.id);
-		const targetRows = await env.fetch(env, target, policy, idsOf$1(rows, fieldId));
-		for (const { row, data } of await env.project(env, target, policy, targetRows, {
-			fields: null,
-			populate: subtree
-		})) byId.set(row.entry_id, {
-			...env.system(env, row),
-			...data
-		});
+		const heads = await env.fetch(env, target, idsOf$1(rows, fieldId));
+		for (const group of groupByMember(heads.members, heads.rows)) {
+			const { model, policy } = group.member;
+			for (const { row, data } of await env.project(env, model, policy, group.rows, {
+				fields: null,
+				populate: subtree
+			})) byId.set(row.entry_id, {
+				...env.system(env, row),
+				...data
+			});
+		}
 	}
 	return populated;
 };
@@ -2248,26 +2466,58 @@ const readPolicy = (env, modelId) => env.permissions.evaluate(env.actor, {
 	modelId
 }, env.executor);
 /**
-* Heads of the given entries that the policy lets the caller read, served per the locale chain (or per
-* `locales` when given: GraphQL's `fallback: false` and `localizations`).
+* The plan members and shared conditions of a read over these members. A lone member's row filter stays a
+* plan condition, so a read of a model without kinds compiles exactly as it always has; with several, each
+* member carries its own.
 */
-const fetchHeadsByIds = async (env, model, policy, ids, locales) => {
-	if (ids.length === 0 || !policy.allowed) return [];
-	const rowFilter = compileRowFilter(policy.rowFilter, env.actor);
+const planMembers = (members, actor) => {
+	const compiled = members.map((member) => ({
+		modelId: member.model.definition.id,
+		rowFilter: compileRowFilter(member.policy.rowFilter, actor)
+	}));
+	const [single] = compiled;
+	if (compiled.length === 1 && single) return {
+		members: [{ modelId: single.modelId }],
+		conditions: single.rowFilter ? [single.rowFilter] : []
+	};
+	return {
+		members: compiled.map(({ modelId, rowFilter }) => ({
+			modelId,
+			...rowFilter ? { conditions: [rowFilter] } : {}
+		})),
+		conditions: []
+	};
+};
+/**
+* Heads of the given entries over the model's family (a relation to a model accepts any of its kinds, plan
+* polymorphic-types), each member under its own read policy, served per the locale chain (or `locales`).
+* Members the caller may not read are left out.
+*/
+const fetchFamilyHeadsByIds = async (env, model, ids, locales) => {
+	const members = await readableMembers(env.snapshot, model, (modelId) => readPolicy(env, modelId));
+	if (ids.length === 0 || members.length === 0) return {
+		members,
+		rows: []
+	};
+	const plan = planMembers(members, env.actor);
 	const { rows } = compileHeadQuery({
 		siteId: env.siteId,
-		modelId: model.definition.id,
+		members: plan.members,
 		source: env.source,
 		locales: locales ?? readScopeFor(env.snapshot, model.definition, env.locale, { fallback: true }),
-		conditions: [entryIdIn(ids), ...rowFilter ? [rowFilter] : []],
+		conditions: [entryIdIn(ids), ...plan.conditions],
 		orderBy: []
 	});
-	return runHeadQuery(rows, env.executor);
+	return {
+		members,
+		rows: await runHeadQuery(rows, env.executor)
+	};
 };
 /**
 * Relation targets the caller may see in these rows: for delivery, only targets that are published (at the
 * same snapshot) and readable under their model's policy, so a published entry never leaks the ID of a
-* draft (brief §10). Admin reads see every ID (null). The heads read are returned for populate.
+* draft (brief §10). A relation to a model with kinds shows targets of any kind the caller may read. Admin
+* reads see every ID (null). The heads read are returned for populate.
 */
 const relationTargets = async (env, model, rows, fields) => {
 	const fetched = /* @__PURE__ */ new Map();
@@ -2280,12 +2530,11 @@ const relationTargets = async (env, model, rows, fields) => {
 	for (const [targetModelId, ids] of targets) {
 		const target = resolveModelById(env.snapshot, targetModelId);
 		if (!target) continue;
-		const policy = await readPolicy(env, targetModelId);
-		const found = await fetchHeadsByIds(env, target, policy, [...ids]);
-		found.forEach((row) => visible.add(row.entry_id));
+		const heads = await fetchFamilyHeadsByIds(env, target, [...ids]);
+		heads.rows.forEach((row) => visible.add(row.entry_id));
 		fetched.set(targetModelId, {
 			ids,
-			rows: found
+			heads
 		});
 	}
 	return {
@@ -2294,16 +2543,20 @@ const relationTargets = async (env, model, rows, fields) => {
 	};
 };
 /**
-* `fetchHeadsByIds` for populate, answered from the heads relation visibility already read when it asked for
-* every one of these IDs under the same policy and locale scope (populate's default), else from the database.
+* `fetchFamilyHeadsByIds` for populate, answered from the heads relation visibility already read when it
+* asked for every one of these IDs under the same policies and locale scope (populate's default), else from
+* the database.
 */
-const fetchReusing = (fetched) => async (env, model, policy, ids) => {
+const fetchReusing = (fetched) => async (env, model, ids) => {
 	const known = fetched.get(model.definition.id);
 	if (known && ids.every((id) => known.ids.has(id))) {
 		const wanted = new Set(ids);
-		return known.rows.filter((row) => wanted.has(row.entry_id));
+		return {
+			members: known.heads.members,
+			rows: known.heads.rows.filter((row) => wanted.has(row.entry_id))
+		};
 	}
-	return fetchHeadsByIds(env, model, policy, ids);
+	return fetchFamilyHeadsByIds(env, model, ids);
 };
 /**
 * Whether projecting these rows reads anything more (relation targets, populated entries, asset views). When
@@ -2369,9 +2622,21 @@ const toDeliveryAsset = (view) => ({
 		url
 	}))
 });
-/** System attributes first, then the readable, selected fields by API key. */
+/** The singular API IDs of a model's lineage, root first, the model last. */
+const kindLineage = (snapshot, modelId) => [...snapshot.ancestors(modelId), modelId].flatMap((id) => {
+	const apiKey = snapshot.byId.get(id)?.definition.apiKey;
+	return apiKey === void 0 ? [] : [apiKey];
+});
+/**
+* System attributes first, then the readable, selected fields by API key. `__model` is the API ID of the
+* entry's own model, on every entry (plan polymorphic-types): a family read mixes kinds, and a client can rely
+* on it everywhere, as it does on `__component` in dynamic zones. `__kinds` is the kind's lineage, root first,
+* so a client can tell a Physical row from its Apparel kind without knowing the schema.
+*/
 const systemAttributes = (env, row) => ({
 	id: row.entry_id,
+	[MODEL_KEY]: env.snapshot.byId.get(row.model_id)?.definition.apiKey ?? null,
+	[KINDS_KEY]: kindLineage(env.snapshot, row.model_id),
 	locale: row.locale,
 	createdAt: row.created_at.toISOString(),
 	updatedAt: row.updated_at.toISOString(),
@@ -2393,7 +2658,6 @@ const projectRows = async (env, model, policy, rows, query) => {
 		...env,
 		project: projectRows,
 		fetch: fetchReusing(fetched),
-		policyFor: readPolicy,
 		system: systemAttributes
 	};
 	const populated = await populateRelations(populateEnv, rows, fields, query.populate);
@@ -2418,6 +2682,23 @@ const projectRows = async (env, model, policy, rows, query) => {
 		};
 	});
 };
+/**
+* Rows of a family read projected each through its own member (plan polymorphic-types): the member's
+* effective fields, read mask, components and SEO fields. Without `fields=` a row carries every field its kind
+* has and the caller may read; with it, the named (shared) fields. Rows keep their order; a row of a model
+* that is not a member is left out.
+*/
+const projectMemberRows = async (env, members, rows, query) => {
+	const projected = /* @__PURE__ */ new Map();
+	for (const group of groupByMember(members, rows)) for (const { row, data } of await projectRows(env, group.member.model, group.member.policy, group.rows, query)) projected.set(row, data);
+	return rows.flatMap((row) => {
+		const data = projected.get(row);
+		return data ? [{
+			row,
+			data
+		}] : [];
+	});
+};
 //#endregion
 //#region ../../apps/api/src/content/visibleReferences.ts
 const ID_OPERATORS = /* @__PURE__ */ new Set([
@@ -2457,8 +2738,7 @@ const visibleIds = async (env, conditions) => {
 			continue;
 		}
 		if (env.audience === "admin") continue;
-		const policy = await readPolicy(env, field.settings.target);
-		if (!policy.allowed) throw queryForbidden(`You may not filter on "${field.apiKey}": you may not read the entries it links to`, { field: field.apiKey });
+		if (!(await readPolicy(env, field.settings.target)).allowed) throw queryForbidden(`You may not filter on "${field.apiKey}": you may not read the entries it links to`, { field: field.apiKey });
 		const target = resolveModelById(env.snapshot, field.settings.target);
 		if (!target) {
 			visible.set(field.id, {
@@ -2467,16 +2747,18 @@ const visibleIds = async (env, conditions) => {
 			});
 			continue;
 		}
-		const rows = await fetchHeadsByIds(env, target, policy, ids);
+		const heads = await fetchFamilyHeadsByIds(env, target, ids);
 		visible.set(field.id, {
-			ids: new Set(rows.map((row) => row.entry_id)),
+			ids: new Set(heads.rows.map((row) => row.entry_id)),
 			shown: {
 				kind: "relation",
 				siteId: env.siteId,
-				modelId: target.definition.id,
+				members: heads.members.map((member) => ({
+					modelId: member.model.definition.id,
+					rowFilter: member.policy.rowFilter
+				})),
 				source: env.source,
 				locales: readScopeFor(env.snapshot, target.definition, env.locale, { fallback: true }),
-				rowFilter: policy.rowFilter,
 				actor: env.actor
 			}
 		});
@@ -2589,6 +2871,8 @@ const toList = (value, { commas = true } = {}) => {
 };
 //#endregion
 //#region ../../apps/api/src/content/compiler/parse.ts
+/** The system attribute naming an entry's kind; it filters by kind, never as a field. */
+const KIND_KEY = "__model";
 const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
 	"filters",
 	"sort",
@@ -2625,7 +2909,7 @@ const resolveTarget = (context, key, use = "query") => {
 	};
 	const field = findFieldByApiKey(context.model.fields, key);
 	if (!field) throw queryInvalid(`Unknown field "${key}"`, { field: key });
-	if (use === "select" ? !context.isReadable(field) : !context.isQueryable(field)) throw queryForbidden(use === "select" ? `You may not read the field "${key}"` : `You may not filter, sort or search on "${key}"`, { field: key });
+	if (!(use === "select" ? (context.isSelectable ?? context.isReadable)(field) : context.isQueryable(field))) throw queryForbidden(use === "select" ? `You may not read the field "${key}"` : `You may not filter, sort or search on "${key}"`, { field: key });
 	return {
 		kind: "field",
 		field
@@ -2792,10 +3076,37 @@ const parsePublicationState = (tree, context) => {
 	if (!PUBLICATION_STATE_SET.has(value)) throw queryInvalid(`"publicationState" must be one of ${PUBLICATION_STATES.join(", ")}`);
 	return { publicationState: value };
 };
+/**
+* `filters[__model][$eq]=guide` or `[$in]=guide,opinion` (a bare value is `$eq`): the kinds of the route's
+* family to read, by singular API ID. A top-level filter only; it narrows which kinds are read rather than
+* becoming a condition.
+*/
+const parseKinds = (value, context) => {
+	const kinds = context.kinds;
+	if (!kinds) throw queryInvalid(`Unknown field "${KIND_KEY}"`, { field: KIND_KEY });
+	const [entry, ...extra] = isTree(value) ? Object.entries(value) : [["$eq", value]];
+	if (!entry || extra.length > 0 || entry[0] !== "$eq" && entry[0] !== "$in") throw queryInvalid(`"${KIND_KEY}" takes one $eq or $in of kinds`, { field: KIND_KEY });
+	const [operator, operand] = entry;
+	const values = operator === "$in" ? toList(operand) : [operand];
+	if (operator === "$eq" && typeof operand !== "string") throw queryInvalid(`"${KIND_KEY}" $eq needs a single value`, { field: KIND_KEY });
+	return values.map((item) => {
+		const modelId = typeof item === "string" ? kinds.get(item) : void 0;
+		if (modelId === void 0) throw queryInvalid(`"${typeof item === "string" ? item : JSON.stringify(item)}" is not a kind of this model`, { field: KIND_KEY });
+		return modelId;
+	});
+};
+/** The filter tree without its `__model` key, and the kinds that key names. */
+const splitKindFilter = (filters, context) => {
+	const { [KIND_KEY]: kindFilter, ...rest } = filters;
+	return {
+		filters: Object.keys(rest).length > 0 ? rest : null,
+		kinds: kindFilter !== void 0 ? parseKinds(kindFilter, context) : void 0
+	};
+};
 const parseContentQuery = (tree, context) => {
 	for (const key of Object.keys(tree)) if (!TOP_LEVEL_KEYS.has(key)) throw queryInvalid(`Unknown query parameter "${key}"`);
-	const filters = tree.filters;
-	if (filters !== void 0 && !isTree(filters)) throw queryInvalid("filters needs field conditions, e.g. filters[title][$eq]=Hello");
+	if (tree.filters !== void 0 && !isTree(tree.filters)) throw queryInvalid("filters needs field conditions, e.g. filters[title][$eq]=Hello");
+	const { filters, kinds } = tree.filters ? splitKindFilter(tree.filters, context) : { filters: null };
 	const locale = single(tree.locale, "locale");
 	if (locale !== void 0 && !context.locales.includes(locale)) throw queryInvalid(`Unknown locale "${locale}"`);
 	const snapshot = positiveInteger(tree.snapshot, "snapshot", Number.MAX_SAFE_INTEGER);
@@ -2816,7 +3127,8 @@ const parseContentQuery = (tree, context) => {
 		...parseRichText(tree, context),
 		...parseSeo(tree, context),
 		...parsePublicationState(tree, context),
-		...parseAdminFilters(tree, context)
+		...parseAdminFilters(tree, context),
+		...kinds ? { kinds } : {}
 	};
 };
 //#endregion
@@ -2841,31 +3153,78 @@ sql``, sql` desc`;
 sql` nulls first`, sql` nulls last`;
 //#endregion
 //#region ../../apps/api/src/services/contentReads.ts
-/** Filters, search and row filter of a parsed query as SQL conditions. */
-/** Whether `queryConditions` names an `entries` column (`HeadQueryPlan.conditionsReadEntries`). */
-const queryReadsEntries = (query, policy) => query.filter !== null && filterReadsEntries(query.filter) || query.author !== void 0 || policy.rowFilter !== null;
-const queryConditions = (context, query, policy) => {
-	const rowFilter = compileRowFilter(policy.rowFilter, context.actor);
-	return [
-		...query.filter ? [compileFilter(query.filter)] : [],
-		...query.search ? [compileSearch(query.search.field.id, query.search.text)] : [],
-		...query.status ? [compileStatusCondition(query.status)] : [],
-		...query.author ? [compileAuthorCondition(query.author)] : [],
-		...rowFilter ? [rowFilter] : []
-	];
+/** Whether the filter, search and admin filters of a query name an `entries` column. */
+const queryFilterReadsEntries = (query) => query.filter !== null && filterReadsEntries(query.filter) || query.author !== void 0;
+/** Filters, search and admin filters of a parsed query as SQL conditions. */
+const queryFilterConditions = (query) => [
+	...query.filter ? [compileFilter(query.filter)] : [],
+	...query.search ? [compileSearch(query.search.field.id, query.search.text)] : [],
+	...query.status ? [compileStatusCondition(query.status)] : [],
+	...query.author ? [compileAuthorCondition(query.author)] : []
+];
+/**
+* The plan of a read over a family's readable members (plan polymorphic-types): the members, and the query's
+* conditions shared by every arm. A lone member's row filter is a shared condition, so a model without kinds
+* compiles as it always has.
+*/
+const familyQueryPlan = (context, query, members) => {
+	const [route] = members;
+	const kinds = query.kinds ? new Set(query.kinds) : null;
+	const narrowed = kinds ? members.filter((member) => kinds.has(member.model.definition.id)) : members;
+	if (narrowed.length === 0 && route) return {
+		members: [{ modelId: route.model.definition.id }],
+		conditions: [matchesNothing()],
+		conditionsReadEntries: false
+	};
+	const plan = planMembers(narrowed, context.actor);
+	return {
+		members: plan.members,
+		conditions: [...queryFilterConditions(query), ...plan.conditions],
+		conditionsReadEntries: queryFilterReadsEntries(query) || plan.conditions.length > 0
+	};
 };
-const parseQueryFor = (context, model, policy, rawQuery, options) => parseContentQuery(parseQueryTree(rawQuery), {
-	model: model.definition,
-	locales: context.snapshot.locales.map((locale) => locale.code),
-	isReadable: (field) => maskAllows(policy.readMask, field),
-	isQueryable: (field) => maskAllows(everyRowReadMask(policy), field),
-	allowSnapshot: options.allowSnapshot,
-	allowAdminFilters: options.allowAdminFilters ?? false,
-	allowRichText: options.allowRichText ?? false,
-	allowSeo: options.allowSeo ?? false,
-	allowPublicationState: options.allowPublicationState ?? false,
-	resolveModel: (modelId) => resolveModelById(context.snapshot, modelId)?.definition
-});
+/** The route model's family by API ID, for `filters[__model]`. */
+const kindsOf$1 = (context, model) => new Map(familyIdsOf(context.snapshot, model.definition.id).flatMap((id) => {
+	const apiKey = context.snapshot.byId.get(id)?.definition.apiKey;
+	return apiKey ? [[apiKey, id]] : [];
+}));
+/**
+* The readable members of the route model's family (the route model first, under the policy already
+* evaluated for it). A kind the caller may not read is left out of the read, never a 403.
+*/
+const familyMembersFor = (context, model, policy) => readableMembers(context.snapshot, model, (modelId) => modelId === model.definition.id ? Promise.resolve(policy) : context.permissions.evaluate(context.actor, {
+	action: "read",
+	modelId
+}));
+/**
+* A field the query may filter, sort or search on (and, in a family read, select): readable on every row of
+* every kind read, so a query never reveals a value one kind's grant hides (plan polymorphic-types, decision
+* 11).
+*/
+const readableOnEveryRow = (members) => (field) => members.every((member) => maskAllows(everyRowReadMask(member.policy), field));
+const parseQueryFor = (context, model, policy, rawQuery, options) => {
+	const members = options.members ?? [{
+		model,
+		policy
+	}];
+	const family = members.length > 1;
+	return parseContentQuery(parseQueryTree(rawQuery), {
+		model: model.definition,
+		locales: context.snapshot.locales.map((locale) => locale.code),
+		isReadable: (field) => maskAllows(policy.readMask, field),
+		...family ? { isSelectable: readableOnEveryRow(members) } : {},
+		isQueryable: readableOnEveryRow(members),
+		allowSnapshot: options.allowSnapshot,
+		allowAdminFilters: options.allowAdminFilters ?? false,
+		allowRichText: options.allowRichText ?? false,
+		allowSeo: options.allowSeo ?? false,
+		allowPublicationState: options.allowPublicationState ?? false,
+		resolveModel: (modelId) => resolveModelById(context.snapshot, modelId)?.definition,
+		kinds: kindsOf$1(context, model)
+	});
+};
+/** The sort of a read: the query's, else the route model's default when every kind read shows that field. */
+const sortOf = (query, model, members) => query.sort.length > 0 ? query.sort : defaultSortTerms(model.definition, readableOnEveryRow(members));
 //#endregion
 //#region ../../apps/api/src/repositories/sites.ts
 const findById = (id, trx = db) => trx.selectFrom("sites").selectAll().where("id", "=", id).executeTakeFirst();
@@ -2941,12 +3300,21 @@ const deliveryEnvironment = (context, executor, source, locale, richText, seo) =
 	...richText ? { richText } : {},
 	...seo ? { seo } : {}
 });
+/** The kinds a read covers: its members, or the model alone. */
+const membersOf = (read) => read.members ?? [{
+	model: read.model,
+	policy: read.policy
+}];
 const environmentOf = (read, executor) => deliveryEnvironment(read.context, executor, read.source, read.query.locale, read.query.richText, read.seo);
 /**
 * Selected top-level relation or media fields, populate, or a default SEO image to show: the read will need a
 * follow-up statement.
 */
-const followsUp = (read) => read.query.populate.size > 0 || selectFields(read.model, read.policy.readMask, read.query.fields).some((field) => field.type === "relation" || field.type === "media" || Boolean(read.seo?.imageId) && isSeoField(field));
+const followsUp = (read) => read.query.populate.size > 0 || membersOf(read).some(({ model, policy }) => selectFields(model, policy.readMask, read.query.fields).some((field) => field.type === "relation" || field.type === "media" || Boolean(read.seo?.imageId) && isSeoField(field)));
+/** `needsFollowUpReads` over every kind among the rows. */
+const rowsNeedFollowUp = (env, read, rows) => groupByMember(membersOf(read), rows).some(({ member, rows: memberRows }) => needsFollowUpReads(env, member.model, memberRows, read.query, member.policy));
+/** `needsMediaReads` over every kind among the rows. */
+const rowsNeedMedia = (env, read, rows) => groupByMember(membersOf(read), rows).some(({ member, rows: memberRows }) => needsMediaReads(env, member.model, memberRows, selectFields(member.model, member.policy.readMask, read.query.fields)));
 /**
 * A live read of published heads (no `?snapshot`, not a preview or draft read, no extra conditions) without
 * populate: its only possible follow-up is relation visibility (asset views are checked on the rows).
@@ -2977,14 +3345,13 @@ const readConsistently = async (read, plan, options, finish) => {
 	if (!followsUp(read) || live) {
 		const env = environmentOf(read, db);
 		const { rows, meta } = await runHeadPage(compiled.rows, db);
-		const fields = selectFields(read.model, read.policy.readMask, read.query.fields);
-		if (meta && !needsFollowUpReads(env, read.model, rows, read.query, read.policy)) return finish({
+		if (meta && !rowsNeedFollowUp(env, read, rows)) return finish({
 			env,
 			rows,
 			total: meta.total,
 			seq: seqOf(meta.seq)
 		});
-		if (meta && live && !needsMediaReads(env, read.model, rows, fields)) return finish({
+		if (meta && live && !rowsNeedMedia(env, read, rows)) return finish({
 			env,
 			rows,
 			total: meta.total,
@@ -3004,7 +3371,7 @@ const readConsistently = async (read, plan, options, finish) => {
 	}, db);
 };
 const localesOf = (read) => readScopeFor(read.context.snapshot, read.model.definition, read.query.locale, { fallback: read.fallback });
-const toEntries = async (read, env, rows) => (await projectRows(env, read.model, read.policy, rows, read.query)).map(({ row, data }) => ({
+const toEntries = async (read, env, rows) => (await projectMemberRows(env, membersOf(read), rows, read.query)).map(({ row, data }) => ({
 	...systemAttributes(env, row),
 	...data
 }));
@@ -3014,21 +3381,22 @@ const toEntries = async (read, env, rows) => (await projectRows(env, read.model,
 */
 const readEntryPage = async (unloaded, options = { total: true }) => {
 	const read = await withSeoDefaults(unloaded);
-	const { context, model, policy } = read;
+	const { context, model } = read;
 	const query = {
 		...read.query,
 		filter: await visibleReferenceFilter(environmentOf(read, context.db), read.query.filter)
 	};
 	const { limit, offset } = toLimitOffset(query.page, query.pageSize);
-	const sort = query.sort.length > 0 ? query.sort : defaultSortTerms(model.definition, (field) => maskAllows(everyRowReadMask(policy), field));
+	const members = membersOf(read);
+	const family = familyQueryPlan(context, query, members);
 	const plan = {
 		siteId: context.site.id,
-		modelId: model.definition.id,
+		members: family.members,
 		source: read.source,
 		locales: localesOf(read),
-		conditions: [...queryConditions(context, query, policy), ...read.conditions ?? []],
-		conditionsReadEntries: queryReadsEntries(query, policy) || (read.conditions?.length ?? 0) > 0,
-		orderBy: compileOrderBy(sort),
+		conditions: [...family.conditions, ...read.conditions ?? []],
+		conditionsReadEntries: Boolean(family.conditionsReadEntries) || (read.conditions?.length ?? 0) > 0,
+		orderBy: compileOrderBy(sortOf(query, model, members)),
 		limit,
 		offset
 	};
@@ -3045,18 +3413,20 @@ const readEntryPage = async (unloaded, options = { total: true }) => {
 /** One entry by ID in the delivery shape (undefined when it is not there for this read), and the sequence. */
 const readOneEntry = async (unloaded, id, options = {}) => {
 	const read = await withSeoDefaults(unloaded);
-	const { context, model, policy, query } = read;
+	const { context } = read;
+	const { kinds: _kinds, ...query } = read.query;
+	const family = familyQueryPlan(context, {
+		...query,
+		filter: null,
+		search: null
+	}, membersOf(read));
 	const plan = {
 		siteId: context.site.id,
-		modelId: model.definition.id,
+		members: family.members,
 		source: read.source,
 		locales: localesOf(read),
 		conditions: [
-			...queryConditions(context, {
-				...query,
-				filter: null,
-				search: null
-			}, policy),
+			...family.conditions,
 			...read.conditions ?? [],
 			entryIdIs(id)
 		],
@@ -3094,6 +3464,10 @@ const assertMayReadDrafts = async (context, modelId, modelKey) => {
 };
 //#endregion
 //#region ../../apps/api/src/services/contentDelivery.ts
+/**
+* The route's model and the caller's read policy (401/403 when it may not read it), and the kinds a read of
+* the route covers: every member of the model's family the caller may read (plan polymorphic-types).
+*/
 const readableModel = async (context, modelKey) => {
 	const model = resolveModel(context.snapshot, modelKey);
 	const policy = await context.permissions.evaluate(context.actor, {
@@ -3103,7 +3477,8 @@ const readableModel = async (context, modelKey) => {
 	if (!policy.allowed) throw context.actor.kind === "anonymous" ? new AppError(401, "UNAUTHENTICATED", "This content needs a delivery token") : new AppError(403, "FORBIDDEN", `Your token may not read "${modelKey}"`);
 	return {
 		model,
-		policy
+		policy,
+		members: await familyMembersFor(context, model, policy)
 	};
 };
 /** Whether a read asks for drafts: GraphQL's option, or `?publicationState=draft`. */
@@ -3135,24 +3510,31 @@ const snapshotCheck = (query) => (current) => {
 };
 /**
 * Counts a successful REST read for field usage (plan developer-face §5): once per request, after the
-* projection, by principal. Admin users and draft reads are never counted.
+* projection, by principal. Admin users and draft reads are never counted. A family read counts each kind's
+* fields under that kind, for the kinds the response carried (`shown`, by API ID); a read of one model
+* counts under it as always.
 */
-const recordUsage = async (context, options, model, policy, query) => {
+const recordUsage = async (context, options, members, query, shown) => {
 	const principalKey = usagePrincipalKey(context.actor);
 	if (!options.usage || readsDrafts(query, options) || principalKey === null) return;
-	const reads = await restFieldReads({
-		snapshot: context.snapshot,
-		model,
-		policy,
-		query,
-		policyFor: (modelId) => context.permissions.evaluate(context.actor, {
-			action: "read",
-			modelId
-		})
-	});
 	options.usage.recordRequest(context.site.id, principalKey, query.snapshot ?? null);
-	options.usage.recordFieldReads(context.site.id, principalKey, model.definition.id, reads);
+	const counted = members.length === 1 ? members : members.filter((member) => shown.has(member.model.definition.apiKey));
+	for (const { model, policy } of counted) {
+		const reads = await restFieldReads({
+			snapshot: context.snapshot,
+			model,
+			policy,
+			query,
+			policyFor: (modelId) => context.permissions.evaluate(context.actor, {
+				action: "read",
+				modelId
+			})
+		});
+		options.usage.recordFieldReads(context.site.id, principalKey, model.definition.id, reads);
+	}
 };
+/** The kinds (API IDs) among delivered entries. */
+const kindsOf = (entries) => new Set(entries.map((entry) => entry[MODEL_KEY]));
 /** Records usage after the response when the caller can defer it (REST), else before returning. */
 const afterRead = async (options, task) => {
 	if (options.defer) {
@@ -3195,8 +3577,11 @@ const assertItemParameters = (rawQuery, allowed) => {
 };
 /** `GET /api/content/:modelKey`: a page of a collection, or a singleton's one entry. */
 const listDelivery = async (context, modelKey, rawQuery, options = {}) => {
-	const { model, policy } = await readableModel(context, modelKey);
-	const query = parseQueryFor(context, model, policy, rawQuery, DELIVERY_PARSE);
+	const { model, policy, members } = await readableModel(context, modelKey);
+	const query = parseQueryFor(context, model, policy, rawQuery, {
+		...DELIVERY_PARSE,
+		members
+	});
 	const drafts = readsDrafts(query, options);
 	const source = sourceOf(query, drafts);
 	await authorizeDrafts(context, model, modelKey, drafts);
@@ -3207,6 +3592,7 @@ const listDelivery = async (context, modelKey, rawQuery, options = {}) => {
 		source,
 		model,
 		policy,
+		members,
 		query,
 		fallback: options.fallback ?? true
 	}, {
@@ -3222,14 +3608,18 @@ const listDelivery = async (context, modelKey, rawQuery, options = {}) => {
 			data: entry,
 			meta: metaOf(locale, snapshot, drafts)
 		};
-	} else result = {
-		data: entries,
-		meta: {
-			...metaOf(locale, snapshot, drafts),
-			pagination: paginationMeta(query.page, limit, total)
-		}
-	};
-	await afterRead(options, () => recordUsage(context, options, model, policy, query));
+	} else {
+		const kinds = kindsMetaOf(context.snapshot, model, members);
+		result = {
+			data: entries,
+			meta: {
+				...metaOf(locale, snapshot, drafts),
+				pagination: paginationMeta(query.page, limit, total),
+				...kinds ? { kinds } : {}
+			}
+		};
+	}
+	await afterRead(options, () => recordUsage(context, options, members, query, kindsOf(entries)));
 	return result;
 };
 /**
@@ -3238,8 +3628,11 @@ const listDelivery = async (context, modelKey, rawQuery, options = {}) => {
 */
 const getDelivery = async (context, modelKey, id, rawQuery, options = {}) => {
 	assertItemParameters(rawQuery, ITEM_PARAMETERS);
-	const { model, policy } = await readableModel(context, modelKey);
-	const query = parseQueryFor(context, model, policy, rawQuery, DELIVERY_PARSE);
+	const { model, policy, members } = await readableModel(context, modelKey);
+	const query = parseQueryFor(context, model, policy, rawQuery, {
+		...DELIVERY_PARSE,
+		members
+	});
 	const drafts = readsDrafts(query, options);
 	const source = sourceOf(query, drafts);
 	await authorizeDrafts(context, model, modelKey, drafts);
@@ -3248,11 +3641,12 @@ const getDelivery = async (context, modelKey, id, rawQuery, options = {}) => {
 		source,
 		model,
 		policy,
+		members,
 		query,
 		fallback: options.fallback ?? true
 	}, id, { check: snapshotCheck(query) });
 	if (!entry) throw entryNotFound(id);
-	await afterRead(options, () => recordUsage(context, options, model, policy, query));
+	await afterRead(options, () => recordUsage(context, options, members, query, kindsOf([entry])));
 	return {
 		data: entry,
 		meta: metaOf(query.locale ?? context.snapshot.defaultLocale, query.snapshot ?? seq, drafts)
@@ -3310,6 +3704,17 @@ const liveAt = (dialect, siteId, seq) => sql`(
   order by p.from_seq desc
   limit 1
 )`;
+/**
+* The model the entry had in the publication log as of `seq` (its latest period starting by then): an entry
+* that changed kind (plan polymorphic-types) is reported under the kind it was published as, not under
+* `entries.model_id`, its kind now.
+*/
+const modelAt = (dialect, siteId, seq) => sql`(
+  select p.model_id from publication_log p
+  where p.site_id = ${dialect.uuid(siteId)} and p.entry_id = g.entry_id and p.from_seq <= ${dialect.seq(seq)}
+  order by p.from_seq desc
+  limit 1
+)`;
 const selectSnapshotDiffRows = async (params, executor) => {
 	const dialect = isMysql() ? MYSQL : isSqlite() ? SQLITE : POSTGRES;
 	const { from, to } = params;
@@ -3338,19 +3743,23 @@ const selectSnapshotDiffRows = async (params, executor) => {
       from states s
       where ${dialect.distinct(sql`s.from_revision_id`, sql`s.to_revision_id`)}
     )
-    select ch.entry_id, e.model_id,
-      ${dialect.aggregate(sql`${dialect.object}(
-          'locale', ch.locale,
-          'change', ch.${dialect.change},
-          'fromRevisionId', ch.from_revision_id,
-          'toRevisionId', ch.to_revision_id
-        )`)} as locales
-    from changes ch
-    join entries e on e.id = ch.entry_id
-    where ${params.rowFilter ?? sql`true`}
-    group by ch.entry_id, e.model_id
-    order by ch.entry_id
-    limit ${params.maxRows}
+    select g.entry_id, ${modelAt(dialect, params.siteId, to)} as model_id, g.locales
+    from (
+      select ch.entry_id,
+        ${dialect.aggregate(sql`${dialect.object}(
+            'locale', ch.locale,
+            'change', ch.${dialect.change},
+            'fromRevisionId', ch.from_revision_id,
+            'toRevisionId', ch.to_revision_id
+          )`)} as locales
+      from changes ch
+      join entries e on e.id = ch.entry_id
+      where ${params.rowFilter ?? sql`true`}
+      group by ch.entry_id
+      order by ch.entry_id
+      limit ${params.maxRows}
+    ) g
+    order by g.entry_id
   `.execute(executor)).rows.map((row) => typeof row.locales === "string" ? {
 		...row,
 		locales: JSON.parse(row.locales)
@@ -3422,7 +3831,7 @@ const readableModels = async (context) => {
 			modelId: definition.id
 		});
 		if (policy.allowed) readable.push({
-			definition,
+			definition: context.snapshot.resolve(definition.id) ?? definition,
 			rowFilter: policy.rowFilter,
 			readMask: everyRowReadMask(policy)
 		});
@@ -3509,7 +3918,7 @@ const listSnapshotChanges = async (context, query) => {
 					id: item.entryId,
 					modelId: item.modelId,
 					modelKey: model.apiKey,
-					routeKey: routeKeyOf(model),
+					routeKey: modelRouteOf(context.snapshot, model).key,
 					...describe(item),
 					locales: item.locales.map(({ locale, change, fromRevisionId, toRevisionId }) => ({
 						locale,
@@ -3901,7 +4310,7 @@ const guardingSkew = async (runtime, statement) => {
 		return await statement();
 	} catch (error) {
 		if (error instanceof AppError) throw error;
-		const { getPendingMigrations } = await import("./migrator-CO5sXosL.js");
+		const { getPendingMigrations } = await import("./migrator-BfVtncOo.js");
 		if ((await getPendingMigrations(runtime.db)).length > 0) throw new ShapioVersionSkewError$1(null, SHAPIO_VERSION$1, { cause: error });
 		throw error;
 	}
@@ -3979,30 +4388,29 @@ const openCallScope = async (runtime, { token, site: requestedKey }) => {
 };
 //#endregion
 //#region ../../apps/api/src/delivery/request.ts
-const decodeSegment = (segment) => {
-	try {
-		return decodeURIComponent(segment);
-	} catch {
-		return;
-	}
+/**
+* `content/<routeKey>[/<id>]`: the route key may be nested (`products/digital`, or one encoded segment), split
+* the way the server's URL rewrite splits it (helpers/contentRoutes.ts).
+*/
+const contentRouteOf = (segments) => {
+	const split = splitContentPath(segments);
+	if (!split || split.rest.length > 1) return;
+	const [id] = split.rest;
+	if (id === void 0) return {
+		kind: "list",
+		routeKey: split.routeKey
+	};
+	return id ? {
+		kind: "item",
+		routeKey: split.routeKey,
+		id
+	} : void 0;
 };
 const routeOf = (segments) => {
 	const [api, group, first, second, ...rest] = segments;
-	if (api !== "api" || rest.length > 0) return;
-	if (group === "content" && first) {
-		const routeKey = decodeSegment(first);
-		if (routeKey === void 0) return;
-		if (second === void 0) return {
-			kind: "list",
-			routeKey
-		};
-		const id = decodeSegment(second);
-		return id ? {
-			kind: "item",
-			routeKey,
-			id
-		} : void 0;
-	}
+	if (api !== "api") return;
+	if (group === "content" && first) return contentRouteOf(segments.slice(2));
+	if (rest.length > 0) return;
 	if (group === "site" && first === void 0) return { kind: "site" };
 	if (group === "snapshots" && second === void 0) {
 		if (first === "current") return { kind: "snapshotCurrent" };
@@ -4336,7 +4744,7 @@ const groupByRole = (grants) => {
 * Every role's grants, held in memory and reloaded when `system_versions.permissions_version` moves.
 * The version is checked on every lookup: read here, or read once by the request (`versions`, see
 * `KnownVersions`). That durable check is what makes a permission change visible to every instance from the
-* next request (NOTIFY would only be an optimisation). Lookups on the pool share one reload; a
+* next request (NOTIFY would only be an optimization). Lookups on the pool share one reload; a
 * lookup inside a transaction reads (and, when stale, reloads) through that transaction alone, never
 * through a reload running on another request's transaction.
 */
@@ -4470,7 +4878,8 @@ const createPermissionEvaluator = ({ grants, fields }) => {
 			const held = await grants.getGrants(roleIds, executor, versions);
 			if (held.length === 0) return DENIED_POLICY;
 			const modelFields = roles.audience === "delivery" ? await fields.getModelFields(request.modelId, executor, versions) : void 0;
-			return buildPolicy(held, request, roles.audience, modelFields);
+			const ancestors = await fields.getAncestors(request.modelId, executor, versions);
+			return buildPolicy(held, request, roles.audience, modelFields, ancestors);
 		},
 		canPerform: async (principal, action, executor) => {
 			const roles = await rolesOf(principal, grants, executor, versions);
@@ -4500,20 +4909,18 @@ const findValue = async (key, trx = db) => (await trx.selectFrom("system_setting
 * Uses the durable version check on every call (or the version the request read once, `versions`), so a
 * field made non-public is hidden on every instance from the next request, whether or not it got the
 * notification. Deprecated fields are reported as non-public: they are hidden from the API unless a role
-* names them explicitly. Components are not delivery models.
+* names them explicitly. Components are not delivery models. Fields are the effective ones (inherited first).
 */
 const createSchemaFieldVisibility = (registry) => {
-	const activeModel = async (modelId, executor, versions) => {
-		const active = (await registry.getSnapshot(executor, versions)).byId.get(modelId);
-		return active && active.definition.kind !== "component" ? active.definition : void 0;
-	};
+	const activeModel = async (modelId, executor, versions) => (await registry.getSnapshot(executor, versions)).resolve(modelId);
 	return {
 		getModelFields: async (modelId, executor, versions) => (await activeModel(modelId, executor, versions))?.fields.map((field) => ({
 			id: field.id,
 			public: field.public && !field.deprecated
 		})),
 		hasModel: async (modelId, executor, versions) => await activeModel(modelId, executor, versions) !== void 0,
-		getModelSite: async (modelId, executor, versions) => (await registry.getSnapshot(executor, versions)).scopeOf(modelId) ?? null
+		getModelSite: async (modelId, executor, versions) => (await registry.getSnapshot(executor, versions)).scopeOf(modelId) ?? null,
+		getAncestors: async (modelId, executor, versions) => (await registry.getSnapshot(executor, versions)).ancestors(modelId)
 	};
 };
 //#endregion
@@ -4533,12 +4940,14 @@ const list = (executor = db) => executor.selectFrom("locales").select(COLUMNS).o
 * On a collision the model whose API ID is the route key keeps it (a singleton keeps the URL it always
 * had); otherwise the first definition does. Deterministic, so every instance serves the same model.
 */
-const indexByRouteKey = (definitions) => {
+const indexByRouteKey = (definitions, inheritance) => {
 	const modelsByRouteKey = /* @__PURE__ */ new Map();
 	const routeKeyCollisions = [];
+	const byId = new Map(definitions.map((active) => [active.definition.id, active.definition]));
 	for (const active of definitions) {
-		if (isComponentDefinition(active.definition)) continue;
-		const routeKey = routeKeyOf(active.definition);
+		if (!isModelDefinition(active.definition)) continue;
+		const ancestors = inheritance.ancestors(active.definition.id).map((id) => byId.get(id)).filter((ancestor) => ancestor !== void 0 && isModelDefinition(ancestor));
+		const routeKey = routePathOf(active.definition, ancestors);
 		const existing = modelsByRouteKey.get(routeKey);
 		if (!existing) {
 			modelsByRouteKey.set(routeKey, active);
@@ -4561,7 +4970,14 @@ const byIdPart = (version, definitions, locales) => {
 	const byId = new Map(definitions.map((active) => [active.definition.id, active]));
 	const all = definitions.map((active) => active.definition);
 	const dependents = /* @__PURE__ */ new Map();
+	const index = createDefinitionIndex(all);
 	return {
+		resolve: index.resolve,
+		ancestors: index.ancestors,
+		childrenOf: index.childrenOf,
+		descendants: index.descendants,
+		family: index.family,
+		rootOf: index.rootOf,
 		version,
 		definitions,
 		byId,
@@ -4582,9 +4998,10 @@ const buildView = (network, siteId, definitions) => {
 	const modelsByApiKey = /* @__PURE__ */ new Map();
 	const componentsByApiKey = /* @__PURE__ */ new Map();
 	for (const active of definitions) (isComponentDefinition(active.definition) ? componentsByApiKey : modelsByApiKey).set(active.definition.apiKey, active);
-	const { modelsByRouteKey, routeKeyCollisions } = indexByRouteKey(definitions);
+	const part = byIdPart(network.version, definitions, network.locales);
+	const { modelsByRouteKey, routeKeyCollisions } = indexByRouteKey(definitions, part);
 	return Object.freeze({
-		...byIdPart(network.version, definitions, network.locales),
+		...part,
 		siteId,
 		modelsByApiKey,
 		modelsByRouteKey,