@bettercms-ai/kit 0.1.1 → 2.0.0

package/dist/core/core.d.ts

@@ -0,0 +1,63 @@
+/**
+ * THE CORE SCHEMA `C` (P2 C1): one canonical, versioned form of a V2 schema that both directions meet in.
+ *
+ *   normV2:  V2 → C      canonical JSON (sorted keys, no undefined) of the V2 schema, with V2's own equivalences folded
+ *   embedV2: C → V2      the schema C holds
+ *   embedProd: C → prod  the prod adapter (fromTypeSchema, the façade) on embedV2(c)
+ *   normProd: prod → C   normV2 of what the prod schema reads back as (toTypeSchema / propsToTypeSchema, the façades)
+ *
+ * Laws (PBT, src/core/__tests__): norm∘embed = id on C (P1); normProd(embedProd(c)) equals c except under the paths
+ * the adapter names (P2); prod zod accepts embedProd(c) (P3); every named loss is excluded, pending or out of its bound
+ * (P4); both normalisers are idempotent (P5); the hash is byte-stable (P6); one prod key per facet (P7); out-of-domain
+ * prod keys survive a write (P8).
+ *
+ * V2's equivalences folded by normV2 (what the V2 engine draws the same, so C cannot tell apart):
+ *   - a list's itemNoun equal to the engine's fallback (lib/schema.ts itemNoun) is the absent one
+ *   - a fieldset a field names but the schema does not declare is the declared { name, title: name } (engine/field-list
+ *     arrange), appended after the declared ones in first-use order
+ */
+import { type AdapterTarget, type FromTypeSchemaResult, type ToTypeSchemaOptions } from "../adapters/schema";
+import type { ProdComponent, ProdContentModel } from "../adapters/prod-types";
+import type { TypeSchema } from "../schema/types";
+import { type FacetRow } from "./facets";
+export declare const CORE_VERSION: 1;
+export interface CoreSchema {
+    v: typeof CORE_VERSION;
+    schema: TypeSchema;
+}
+/** Canonical JSON value: object keys sorted, undefined dropped, arrays in their order (order is meaning). */
+export declare function canonical<T>(v: T): T;
+export declare function normV2(v2: TypeSchema): CoreSchema;
+export declare const embedV2: (c: CoreSchema) => TypeSchema;
+export declare function embedProd(c: CoreSchema, lane: "fields"): FromTypeSchemaResult<ProdContentModel>;
+export declare function embedProd(c: CoreSchema, lane: "props"): FromTypeSchemaResult<ProdComponent>;
+export declare function embedProd(c: CoreSchema, lane: AdapterTarget): FromTypeSchemaResult<ProdContentModel | ProdComponent>;
+export declare function normProd(prod: ProdContentModel | ProdComponent, lane: AdapterTarget, opts?: ToTypeSchemaOptions): CoreSchema;
+/** Byte-stable serialisation of C: the hash input, and the form fixtures are frozen in. */
+export declare const coreJson: (c: CoreSchema) => string;
+/** `schema_hash`: "v1:" + sha256 of coreJson (Web Crypto: the same in the browser, Node and Bun). */
+export declare function coreHash(c: CoreSchema): Promise<string>;
+/** The leaf paths where two JSON values differ ("/fields/0/title"); a missing object or list compares as an empty one. */
+export declare function leafDiff(a: unknown, b: unknown, path?: string, out?: string[]): string[];
+export interface CoreLossItem {
+    path: string;
+    feature: string;
+    facet: FacetRow | undefined;
+}
+export interface CoreRoundTrip {
+    prod: ProdContentModel | ProdComponent;
+    back: CoreSchema;
+    /** the paths where C and normProd(embedProd(C)) differ */
+    diffs: string[];
+    /** loss(c): each item the adapter names that has a difference under it (an item C's equivalences absorb is no loss) */
+    loss: CoreLossItem[];
+    /** a difference no named item covers: a silent drop (P2 fails on any) */
+    unreported: string[];
+}
+/** C through prod and back, against the lane's read: the oracle P2 and P4 assert on. */
+export declare function roundTripCore(c: CoreSchema, lane: AdapterTarget): CoreRoundTrip;
+/**
+ * A prod definition written from C, with every out-of-domain key (facets.ts OUT_OF_DOMAIN: a prop's binding, host and
+ * server config) the stored definition held carried over by key. What write_schema stores (C6).
+ */
+export declare function preserveOutOfDomain<T extends ProdContentModel | ProdComponent>(written: T, stored: T | undefined, lane: AdapterTarget): T;

package/dist/core/core.js

@@ -0,0 +1,171 @@
+import { SERVER_CONFIG_KEYS, isHostConfigKey } from "../adapters/lossy.js";
+import { fromTypeSchema, propsToTypeSchema, toTypeSchema } from "../adapters/schema.js";
+import { itemNoun } from "../lib/schema.js";
+import { facetOf } from "./facets.js";
+//#region src/core/core.ts
+/**
+* THE CORE SCHEMA `C` (P2 C1): one canonical, versioned form of a V2 schema that both directions meet in.
+*
+*   normV2:  V2 → C      canonical JSON (sorted keys, no undefined) of the V2 schema, with V2's own equivalences folded
+*   embedV2: C → V2      the schema C holds
+*   embedProd: C → prod  the prod adapter (fromTypeSchema, the façade) on embedV2(c)
+*   normProd: prod → C   normV2 of what the prod schema reads back as (toTypeSchema / propsToTypeSchema, the façades)
+*
+* Laws (PBT, src/core/__tests__): norm∘embed = id on C (P1); normProd(embedProd(c)) equals c except under the paths
+* the adapter names (P2); prod zod accepts embedProd(c) (P3); every named loss is excluded, pending or out of its bound
+* (P4); both normalisers are idempotent (P5); the hash is byte-stable (P6); one prod key per facet (P7); out-of-domain
+* prod keys survive a write (P8).
+*
+* V2's equivalences folded by normV2 (what the V2 engine draws the same, so C cannot tell apart):
+*   - a list's itemNoun equal to the engine's fallback (lib/schema.ts itemNoun) is the absent one
+*   - a fieldset a field names but the schema does not declare is the declared { name, title: name } (engine/field-list
+*     arrange), appended after the declared ones in first-use order
+*/
+var CORE_VERSION = 1;
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/** Canonical JSON value: object keys sorted, undefined dropped, arrays in their order (order is meaning). */
+function canonical(v) {
+	if (Array.isArray(v)) return v.map(canonical);
+	if (!isObj(v)) return v;
+	const out = {};
+	for (const k of Object.keys(v).sort()) if (v[k] !== void 0) out[k] = canonical(v[k]);
+	return out;
+}
+function foldField(f) {
+	const out = { ...f };
+	if (out.fields) out.fields = out.fields.map(foldField);
+	if (Array.isArray(out.of)) out.of = out.of.map(foldField);
+	if (out.slotSettings) out.slotSettings = out.slotSettings.map(foldField);
+	if (out.itemNoun !== void 0 && out.itemNoun === itemNoun({
+		...out,
+		itemNoun: void 0
+	})) delete out.itemNoun;
+	return out;
+}
+/** The fieldsets fields name, depth first, the way the adapter visits them (fromTypeSchema propSetsFor / fieldsetsFor). */
+function namedSets(fields, out = []) {
+	for (const f of fields) {
+		if (f.fieldset !== void 0 && !out.includes(f.fieldset)) out.push(f.fieldset);
+		if (f.fields) namedSets(f.fields, out);
+		if (Array.isArray(f.of)) {
+			for (const i of f.of) if (i.fields) namedSets(i.fields, out);
+		}
+	}
+	return out;
+}
+function normV2(v2) {
+	const schema = {
+		...v2,
+		fields: v2.fields.map(foldField)
+	};
+	const declared = new Set((v2.fieldsets ?? []).map((s) => s.name));
+	const undeclared = namedSets(v2.fields).filter((n) => !declared.has(n));
+	if (undeclared.length) schema.fieldsets = [...v2.fieldsets ?? [], ...undeclared.map((name) => ({
+		name,
+		title: name
+	}))];
+	return {
+		v: 1,
+		schema: canonical(schema)
+	};
+}
+var embedV2 = (c) => structuredClone(c.schema);
+function embedProd(c, lane) {
+	return lane === "fields" ? fromTypeSchema(embedV2(c), "fields") : fromTypeSchema(embedV2(c), "props");
+}
+function normProd(prod, lane, opts = {}) {
+	return normV2(lane === "fields" ? toTypeSchema(prod, opts) : propsToTypeSchema(prod, opts));
+}
+/** Byte-stable serialisation of C: the hash input, and the form fixtures are frozen in. */
+var coreJson = (c) => JSON.stringify(canonical(c));
+/** `schema_hash`: "v1:" + sha256 of coreJson (Web Crypto: the same in the browser, Node and Bun). */
+async function coreHash(c) {
+	return `v1:${[...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(coreJson(c))))].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+/** The leaf paths where two JSON values differ ("/fields/0/title"); a missing object or list compares as an empty one. */
+function leafDiff(a, b, path = "", out = []) {
+	const obj = (x) => x === void 0 || isObj(x);
+	const arr = (x) => x === void 0 || Array.isArray(x);
+	if ((isObj(a) || isObj(b)) && obj(a) && obj(b)) {
+		const A = a ?? {};
+		const B = b ?? {};
+		for (const k of /* @__PURE__ */ new Set([...Object.keys(A), ...Object.keys(B)])) leafDiff(A[k], B[k], `${path}/${k}`, out);
+	} else if ((Array.isArray(a) || Array.isArray(b)) && arr(a) && arr(b)) {
+		const A = a ?? [];
+		const B = b ?? [];
+		for (let i = 0; i < Math.max(A.length, B.length); i++) leafDiff(A[i], B[i], `${path}/${i}`, out);
+	} else if (JSON.stringify(a) !== JSON.stringify(b)) out.push(path);
+	return out;
+}
+var under = (path, root) => path === root || path.startsWith(`${root}/`);
+/** C through prod and back, against the lane's read: the oracle P2 and P4 assert on. */
+function roundTripCore(c, lane) {
+	const r = embedProd(c, lane);
+	const back = normProd(r.schema, lane, { blockModels: r.blockModels });
+	const diffs = leafDiff(lane === "props" ? normV2(withDefaultGroups(c.schema)).schema : c.schema, back.schema);
+	const named = [...r.lossy, ...r.catalog];
+	return {
+		prod: r.schema,
+		back,
+		diffs,
+		loss: named.filter((l) => diffs.some((d) => under(d, l.path))).map((l) => ({
+			path: l.path,
+			feature: l.feature,
+			facet: facetOf(l.feature)
+		})),
+		unreported: diffs.filter((d) => !named.some((l) => under(d, l.path)))
+	};
+}
+function withDefaultGroups(s) {
+	const d = (s.groups?.find((g) => g.default) ?? s.groups?.[0])?.name;
+	return d === void 0 ? s : {
+		...s,
+		fields: s.fields.map((f) => f.group === void 0 ? {
+			...f,
+			group: d
+		} : f)
+	};
+}
+var OUT_OF_DOMAIN_KEYS = [
+	"target",
+	"stale",
+	"origin"
+];
+/** One written definition with the out-of-domain keys of the stored one it replaces (same key) carried over. */
+function carryDef(written, stored) {
+	if (!stored) return written;
+	const out = { ...written };
+	for (const k of OUT_OF_DOMAIN_KEYS) if (stored[k] !== void 0 && out[k] === void 0) out[k] = stored[k];
+	const type = String(written.type ?? "");
+	const host = Object.entries(stored.config ?? {}).filter(([k, v]) => v !== void 0 && (isHostConfigKey(type, k) || SERVER_CONFIG_KEYS.has(k)) && out.config?.[k] === void 0);
+	if (host.length || out.config) out.config = {
+		...out.config ?? {},
+		...Object.fromEntries(host)
+	};
+	if (Array.isArray(written.fields)) out.fields = carryList(written.fields, stored.fields);
+	const cf = out.config?.fields;
+	if (Array.isArray(cf)) out.config = {
+		...out.config,
+		fields: carryList(cf, stored.config?.fields)
+	};
+	return out;
+}
+var carryList = (written, stored) => written.map((w) => carryDef(w, stored?.find((s) => s.key === w.key)));
+/**
+* A prod definition written from C, with every out-of-domain key (facets.ts OUT_OF_DOMAIN: a prop's binding, host and
+* server config) the stored definition held carried over by key. What write_schema stores (C6).
+*/
+function preserveOutOfDomain(written, stored, lane) {
+	if (!stored) return written;
+	const list = lane === "fields" ? "fields" : "props";
+	const w = written;
+	const s = stored;
+	return {
+		...w,
+		[list]: carryList(w[list] ?? [], s[list])
+	};
+}
+//#endregion
+export { CORE_VERSION, canonical, coreHash, coreJson, embedProd, embedV2, leafDiff, normProd, normV2, preserveOutOfDomain, roundTripCore };
+
+//# sourceMappingURL=core.js.map

package/dist/core/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":[],"sources":["../../src/core/core.ts"],"sourcesContent":["/**\n * THE CORE SCHEMA `C` (P2 C1): one canonical, versioned form of a V2 schema that both directions meet in.\n *\n *   normV2:  V2 → C      canonical JSON (sorted keys, no undefined) of the V2 schema, with V2's own equivalences folded\n *   embedV2: C → V2      the schema C holds\n *   embedProd: C → prod  the prod adapter (fromTypeSchema, the façade) on embedV2(c)\n *   normProd: prod → C   normV2 of what the prod schema reads back as (toTypeSchema / propsToTypeSchema, the façades)\n *\n * Laws (PBT, src/core/__tests__): norm∘embed = id on C (P1); normProd(embedProd(c)) equals c except under the paths\n * the adapter names (P2); prod zod accepts embedProd(c) (P3); every named loss is excluded, pending or out of its bound\n * (P4); both normalisers are idempotent (P5); the hash is byte-stable (P6); one prod key per facet (P7); out-of-domain\n * prod keys survive a write (P8).\n *\n * V2's equivalences folded by normV2 (what the V2 engine draws the same, so C cannot tell apart):\n *   - a list's itemNoun equal to the engine's fallback (lib/schema.ts itemNoun) is the absent one\n *   - a fieldset a field names but the schema does not declare is the declared { name, title: name } (engine/field-list\n *     arrange), appended after the declared ones in first-use order\n */\nimport { fromTypeSchema, propsToTypeSchema, toTypeSchema, type AdapterTarget, type FromTypeSchemaResult, type ToTypeSchemaOptions } from \"../adapters/schema\";\nimport { isHostConfigKey, SERVER_CONFIG_KEYS, type CatalogItem, type LossyItem } from \"../adapters/lossy\";\nimport type { ProdComponent, ProdContentModel } from \"../adapters/prod-types\";\nimport { itemNoun } from \"../lib/schema\";\nimport type { FieldSchema, TypeSchema } from \"../schema/types\";\nimport { facetOf, type FacetRow } from \"./facets\";\n\nexport const CORE_VERSION = 1 as const;\n\nexport interface CoreSchema {\n  v: typeof CORE_VERSION;\n  schema: TypeSchema;\n}\n\ntype Obj = Record<string, unknown>;\nconst isObj = (v: unknown): v is Obj => !!v && typeof v === \"object\" && !Array.isArray(v);\n\n/** Canonical JSON value: object keys sorted, undefined dropped, arrays in their order (order is meaning). */\nexport function canonical<T>(v: T): T {\n  if (Array.isArray(v)) return v.map(canonical) as T;\n  if (!isObj(v)) return v;\n  const out: Obj = {};\n  for (const k of Object.keys(v).sort()) if (v[k] !== undefined) out[k] = canonical(v[k]);\n  return out as T;\n}\n\nfunction foldField(f: FieldSchema): FieldSchema {\n  const out: FieldSchema = { ...f };\n  if (out.fields) out.fields = out.fields.map(foldField);\n  if (Array.isArray(out.of)) out.of = out.of.map(foldField);\n  if (out.slotSettings) out.slotSettings = out.slotSettings.map(foldField);\n  if (out.itemNoun !== undefined && out.itemNoun === itemNoun({ ...out, itemNoun: undefined })) delete out.itemNoun;\n  return out;\n}\n\n/** The fieldsets fields name, depth first, the way the adapter visits them (fromTypeSchema propSetsFor / fieldsetsFor). */\nfunction namedSets(fields: FieldSchema[], out: string[] = []): string[] {\n  for (const f of fields) {\n    if (f.fieldset !== undefined && !out.includes(f.fieldset)) out.push(f.fieldset);\n    if (f.fields) namedSets(f.fields, out);\n    if (Array.isArray(f.of)) for (const i of f.of) if (i.fields) namedSets(i.fields, out);\n  }\n  return out;\n}\n\nexport function normV2(v2: TypeSchema): CoreSchema {\n  const schema: TypeSchema = { ...v2, fields: v2.fields.map(foldField) };\n  const declared = new Set((v2.fieldsets ?? []).map((s) => s.name));\n  const undeclared = namedSets(v2.fields).filter((n) => !declared.has(n));\n  if (undeclared.length) schema.fieldsets = [...(v2.fieldsets ?? []), ...undeclared.map((name) => ({ name, title: name }))];\n  return { v: CORE_VERSION, schema: canonical(schema) };\n}\n\nexport const embedV2 = (c: CoreSchema): TypeSchema => structuredClone(c.schema);\n\nexport function embedProd(c: CoreSchema, lane: \"fields\"): FromTypeSchemaResult<ProdContentModel>;\nexport function embedProd(c: CoreSchema, lane: \"props\"): FromTypeSchemaResult<ProdComponent>;\nexport function embedProd(c: CoreSchema, lane: AdapterTarget): FromTypeSchemaResult<ProdContentModel | ProdComponent>;\nexport function embedProd(c: CoreSchema, lane: AdapterTarget) {\n  return lane === \"fields\" ? fromTypeSchema(embedV2(c), \"fields\") : fromTypeSchema(embedV2(c), \"props\");\n}\n\nexport function normProd(prod: ProdContentModel | ProdComponent, lane: AdapterTarget, opts: ToTypeSchemaOptions = {}): CoreSchema {\n  return normV2(lane === \"fields\" ? toTypeSchema(prod as ProdContentModel, opts) : propsToTypeSchema(prod as ProdComponent, opts));\n}\n\n/** Byte-stable serialisation of C: the hash input, and the form fixtures are frozen in. */\nexport const coreJson = (c: CoreSchema): string => JSON.stringify(canonical(c));\n\n/** `schema_hash`: \"v1:\" + sha256 of coreJson (Web Crypto: the same in the browser, Node and Bun). */\nexport async function coreHash(c: CoreSchema): Promise<string> {\n  const bytes = new Uint8Array(await crypto.subtle.digest(\"SHA-256\", new TextEncoder().encode(coreJson(c))));\n  return `v${CORE_VERSION}:${[...bytes].map((b) => b.toString(16).padStart(2, \"0\")).join(\"\")}`;\n}\n\n/** The leaf paths where two JSON values differ (\"/fields/0/title\"); a missing object or list compares as an empty one. */\nexport function leafDiff(a: unknown, b: unknown, path = \"\", out: string[] = []): string[] {\n  const obj = (x: unknown) => x === undefined || isObj(x);\n  const arr = (x: unknown) => x === undefined || Array.isArray(x);\n  if ((isObj(a) || isObj(b)) && obj(a) && obj(b)) {\n    const A = (a ?? {}) as Obj;\n    const B = (b ?? {}) as Obj;\n    for (const k of new Set([...Object.keys(A), ...Object.keys(B)])) leafDiff(A[k], B[k], `${path}/${k}`, out);\n  } else if ((Array.isArray(a) || Array.isArray(b)) && arr(a) && arr(b)) {\n    const A = (a ?? []) as unknown[];\n    const B = (b ?? []) as unknown[];\n    for (let i = 0; i < Math.max(A.length, B.length); i++) leafDiff(A[i], B[i], `${path}/${i}`, out);\n  } else if (JSON.stringify(a) !== JSON.stringify(b)) out.push(path);\n  return out;\n}\n\nconst under = (path: string, root: string) => path === root || path.startsWith(`${root}/`);\n\nexport interface CoreLossItem {\n  path: string;\n  feature: string;\n  facet: FacetRow | undefined;\n}\n\nexport interface CoreRoundTrip {\n  prod: ProdContentModel | ProdComponent;\n  back: CoreSchema;\n  /** the paths where C and normProd(embedProd(C)) differ */\n  diffs: string[];\n  /** loss(c): each item the adapter names that has a difference under it (an item C's equivalences absorb is no loss) */\n  loss: CoreLossItem[];\n  /** a difference no named item covers: a silent drop (P2 fails on any) */\n  unreported: string[];\n}\n\n/** C through prod and back, against the lane's read: the oracle P2 and P4 assert on. */\nexport function roundTripCore(c: CoreSchema, lane: AdapterTarget): CoreRoundTrip {\n  const r = embedProd(c, lane);\n  const back = normProd(r.schema, lane, { blockModels: r.blockModels });\n  // the props lane reads each top-level field's default-group placement back explicitly: compare it as such\n  const want = lane === \"props\" ? normV2(withDefaultGroups(c.schema)).schema : c.schema;\n  const diffs = leafDiff(want, back.schema);\n  const named: (LossyItem | CatalogItem)[] = [...r.lossy, ...r.catalog];\n  return {\n    prod: r.schema,\n    back,\n    diffs,\n    loss: named.filter((l) => diffs.some((d) => under(d, l.path))).map((l) => ({ path: l.path, feature: l.feature, facet: facetOf(l.feature) })),\n    unreported: diffs.filter((d) => !named.some((l) => under(d, l.path))),\n  };\n}\n\nfunction withDefaultGroups(s: TypeSchema): TypeSchema {\n  const d = (s.groups?.find((g) => g.default) ?? s.groups?.[0])?.name;\n  return d === undefined ? s : { ...s, fields: s.fields.map((f) => (f.group === undefined ? { ...f, group: d } : f)) };\n}\n\n/* ── P8: out-of-domain prod keys survive a write ── */\n\ntype ProdDef = Obj & { key?: string; type?: string; config?: Obj; fields?: ProdDef[] };\nconst OUT_OF_DOMAIN_KEYS = [\"target\", \"stale\", \"origin\"] as const;\n\n/** One written definition with the out-of-domain keys of the stored one it replaces (same key) carried over. */\nfunction carryDef(written: ProdDef, stored: ProdDef | undefined): ProdDef {\n  if (!stored) return written;\n  const out: ProdDef = { ...written };\n  for (const k of OUT_OF_DOMAIN_KEYS) if (stored[k] !== undefined && out[k] === undefined) out[k] = stored[k];\n  const type = String(written.type ?? \"\");\n  const host = Object.entries(stored.config ?? {}).filter(([k, v]) => v !== undefined && (isHostConfigKey(type, k) || SERVER_CONFIG_KEYS.has(k)) && out.config?.[k] === undefined);\n  if (host.length || out.config) out.config = { ...(out.config ?? {}), ...Object.fromEntries(host) };\n  // nested definitions: a model field's fields, a prop's config.fields\n  if (Array.isArray(written.fields)) out.fields = carryList(written.fields, stored.fields);\n  const cf = out.config?.fields;\n  if (Array.isArray(cf)) out.config = { ...out.config, fields: carryList(cf as ProdDef[], stored.config?.fields as ProdDef[] | undefined) };\n  return out;\n}\n\nconst carryList = (written: ProdDef[], stored: ProdDef[] | undefined) => written.map((w) => carryDef(w, stored?.find((s) => s.key === w.key)));\n\n/**\n * A prod definition written from C, with every out-of-domain key (facets.ts OUT_OF_DOMAIN: a prop's binding, host and\n * server config) the stored definition held carried over by key. What write_schema stores (C6).\n */\nexport function preserveOutOfDomain<T extends ProdContentModel | ProdComponent>(written: T, stored: T | undefined, lane: AdapterTarget): T {\n  if (!stored) return written;\n  const list = lane === \"fields\" ? \"fields\" : \"props\";\n  const w = written as unknown as Obj;\n  const s = stored as unknown as Obj;\n  return { ...w, [list]: carryList((w[list] as ProdDef[]) ?? [], s[list] as ProdDef[] | undefined) } as unknown as T;\n}\n"],"mappings":"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"}

package/dist/core/facets.d.ts

@@ -0,0 +1,347 @@
+/**
+ * THE FACET TABLE (kit-facet-table.v3.md, G0b closed 2026-10-23): every V2 schema facet the adapter can name, with the
+ * ONE prod key per lane that stores it. `satisfies Record<V2Facet, FacetRow>` makes it total: a feature added to
+ * FEATURES or CATALOG (adapters/lossy.ts) without a row here fails tsc.
+ *
+ * Carriers are `value` (an explicit stored key) and `excluded` (owner-signed). A `bound` names the one shared constant
+ * the V2 authoring rule and the prod zod rule both read: a value inside it is carried, one outside it is refused with
+ * the facet's name. `status` is "landed" when the adapter carries the facet today, else the step that lands it.
+ * Prod-only keys V2 has no concept of are not facets: OUT_OF_DOMAIN, preserved on every write (PBT P8).
+ */
+import type { CatalogFeature, LossyFeature } from "../adapters/lossy";
+/** Prod keys with no V2 concept (facet table §B.1): never written from V2, carried through a write from the stored definition. */
+export declare const OUT_OF_DOMAIN: {
+    readonly "prop target": "a prop's binding: props[].target (+ stale, origin)";
+    readonly "host config": "HOST_CONFIG_KEYS + SERVER_CONFIG_KEYS in a field's or prop's config (adapters/lossy.ts)";
+};
+export type OutOfDomainFeature = keyof typeof OUT_OF_DOMAIN;
+export type V2Facet = Exclude<LossyFeature | CatalogFeature, OutOfDomainFeature>;
+export interface FacetRow {
+    /** facet table v3: an A row number, or the B group */
+    row: string;
+    carrier: "value" | "excluded";
+    /** the prod key(s) per lane, one per shape the facet takes; [] = the facet does not arise in that lane */
+    props: readonly string[];
+    fields: readonly string[];
+    /** the shared constant: inside it the facet is carried, outside it the facet is refused by name */
+    bound?: string;
+    status: "landed" | `pending:${string}`;
+    /** a facet stored at another facet's key (kind:page is the shape facet's value "page") */
+    foldedInto?: V2Facet;
+}
+export declare const FACETS: {
+    readonly ai: {
+        readonly row: "A1";
+        readonly carrier: "value";
+        readonly props: readonly ["props[].ai"];
+        readonly fields: readonly ["fields[].ai"];
+        readonly status: "pending:C3";
+    };
+    readonly category: {
+        readonly row: "A2";
+        readonly carrier: "value";
+        readonly props: readonly ["components.category"];
+        readonly fields: readonly ["content_models.v2.category"];
+        readonly bound: "CATEGORY_ORDER";
+        readonly status: "pending:C3+C5";
+    };
+    readonly variants: {
+        readonly row: "A3";
+        readonly carrier: "value";
+        readonly props: readonly ["component_variant_groups (+ components.variant_group_id, variant_input_mappings; order/icon/description → component_variant_groups.v2.variants)"];
+        readonly fields: readonly ["fields[_variant] select + showIf {field:_variant}; content_models.v2.variants{slug → {icon, description}}"];
+        readonly status: "pending:C4";
+    };
+    readonly "block icon": {
+        readonly row: "A4";
+        readonly carrier: "value";
+        readonly props: readonly ["components.icon"];
+        readonly fields: readonly ["content_models.icon"];
+        readonly bound: "DOCK_ICON_NAMES";
+        readonly status: "pending:C1-model-settings";
+    };
+    readonly "document preview": {
+        readonly row: "A5";
+        readonly carrier: "value";
+        readonly props: readonly ["components.preview"];
+        readonly fields: readonly ["content_models.list_preview"];
+        readonly status: "pending:C3";
+    };
+    readonly "document preview path": {
+        readonly row: "B catalog";
+        readonly carrier: "value";
+        readonly props: readonly ["components.preview (path rule widened)"];
+        readonly fields: readonly [];
+        readonly status: "pending:C3";
+    };
+    readonly "kind:global": {
+        readonly row: "A6";
+        readonly carrier: "value";
+        readonly props: readonly ["components.v2.shape"];
+        readonly fields: readonly ["content_models.v2.shape"];
+        readonly status: "pending:C5";
+    };
+    readonly "kind:entry (props)": {
+        readonly row: "A6";
+        readonly carrier: "value";
+        readonly props: readonly ["components.v2.shape"];
+        readonly fields: readonly [];
+        readonly status: "pending:C5";
+        readonly foldedInto: "kind:global";
+    };
+    readonly "kind:block (fields)": {
+        readonly row: "A6";
+        readonly carrier: "value";
+        readonly props: readonly [];
+        readonly fields: readonly ["content_models.v2.shape"];
+        readonly status: "pending:C5";
+        readonly foldedInto: "kind:global";
+    };
+    readonly "kind:page": {
+        readonly row: "A22";
+        readonly carrier: "value";
+        readonly props: readonly [];
+        readonly fields: readonly ["content_models.v2.shape"];
+        readonly status: "pending:C5";
+        readonly foldedInto: "kind:global";
+    };
+    readonly "kind:object": {
+        readonly row: "A6";
+        readonly carrier: "value";
+        readonly props: readonly [];
+        readonly fields: readonly ["content_models.v2.shape"];
+        readonly status: "pending:C5";
+        readonly foldedInto: "kind:global";
+    };
+    readonly "groups>3": {
+        readonly row: "A7";
+        readonly carrier: "value";
+        readonly props: readonly ["components.tabs"];
+        readonly fields: readonly ["content_models.fieldsets[kind:tab]"];
+        readonly bound: "TAB_MAX";
+        readonly status: "pending:C3+C8";
+    };
+    readonly "item openMode": {
+        readonly row: "A8";
+        readonly carrier: "value";
+        readonly props: readonly ["config.item.openMode (object item)", "config.itemTypes[i].openMode (polymorphic)"];
+        readonly fields: readonly ["ui.blocks[slug].openMode (modular)"];
+        readonly status: "pending:C3";
+    };
+    readonly "reference target": {
+        readonly row: "A9";
+        readonly carrier: "value";
+        readonly props: readonly ["config.targets"];
+        readonly fields: readonly ["config.targets"];
+        readonly bound: "REF_TARGET_KINDS";
+        readonly status: "landed";
+    };
+    readonly "type:slot": {
+        readonly row: "A10";
+        readonly carrier: "value";
+        readonly props: readonly ["props[] type slot (config.allow)"];
+        readonly fields: readonly ["fields[] type slot (config.blockSlugs)"];
+        readonly bound: "SLOT_BLOCK_SLUGS_REQUIRED";
+        readonly status: "landed";
+    };
+    readonly "block model field": {
+        readonly row: "A11";
+        readonly carrier: "value";
+        readonly props: readonly [];
+        readonly fields: readonly ["kind:'block' model fields[]"];
+        readonly bound: "BLOCK_FIELD_TYPES";
+        readonly status: "pending:G7";
+    };
+    readonly "shopify reference": {
+        readonly row: "A12";
+        readonly carrier: "excluded";
+        readonly props: readonly [];
+        readonly fields: readonly [];
+        readonly status: "landed";
+    };
+    readonly "type:table": {
+        readonly row: "A13";
+        readonly carrier: "value";
+        readonly props: readonly ["props[] type table (config.mode data)"];
+        readonly fields: readonly ["fields[] type table"];
+        readonly status: "landed";
+    };
+    readonly "group (nested)": {
+        readonly row: "A14";
+        readonly carrier: "value";
+        readonly props: readonly ["ui.tab {id}"];
+        readonly fields: readonly ["ui.tab {id} (nested field)"];
+        readonly bound: "TAB_MAX";
+        readonly status: "landed";
+    };
+    readonly "fieldset collision": {
+        readonly row: "A15";
+        readonly carrier: "value";
+        readonly props: readonly ["ui.group {id}"];
+        readonly fields: readonly ["fieldsetId"];
+        readonly bound: "TAB_FIELDSET_ID_UNIQUE";
+        readonly status: "landed";
+    };
+    readonly "segmented fallback": {
+        readonly row: "A16";
+        readonly carrier: "value";
+        readonly props: readonly ["ui.control segmented"];
+        readonly fields: readonly ["ui.control segmented"];
+        readonly bound: "SEGMENTED_MAX";
+        readonly status: "pending:C3";
+    };
+    readonly "fieldset (derived)": {
+        readonly row: "A17";
+        readonly carrier: "value";
+        readonly props: readonly ["ui.group (prop group)"];
+        readonly fields: readonly ["content_models.fieldsets"];
+        readonly status: "landed";
+    };
+    readonly "itemNoun (derived)": {
+        readonly row: "A18";
+        readonly carrier: "value";
+        readonly props: readonly ["ui.itemLabel"];
+        readonly fields: readonly ["ui.itemTitle"];
+        readonly status: "landed";
+    };
+    readonly "reference filter": {
+        readonly row: "A19";
+        readonly carrier: "value";
+        readonly props: readonly ["config.filter"];
+        readonly fields: readonly ["config.filter"];
+        readonly bound: "REFERENCE_FILTER_MAX";
+        readonly status: "landed";
+    };
+    readonly condition: {
+        readonly row: "A20";
+        readonly carrier: "value";
+        readonly props: readonly ["showIf (+ scope)"];
+        readonly fields: readonly ["showIf (+ scope)"];
+        readonly bound: "SHOW_IF_SCOPES";
+        readonly status: "pending:C3";
+    };
+    readonly openMode: {
+        readonly row: "A21";
+        readonly carrier: "value";
+        readonly props: readonly ["props[].openMode"];
+        readonly fields: readonly ["fields[].openMode"];
+        readonly bound: "OPEN_MODE_TYPES";
+        readonly status: "pending:C9";
+    };
+    readonly "slot allow": {
+        readonly row: "A23";
+        readonly carrier: "value";
+        readonly props: readonly ["config.allow"];
+        readonly fields: readonly ["config.blockSlugs"];
+        readonly bound: "SLOT_ALLOW";
+        readonly status: "landed";
+    };
+    readonly "type:polymorphic-array": {
+        readonly row: "B structural";
+        readonly carrier: "value";
+        readonly props: readonly ["props[] type table (config.mode types)"];
+        readonly fields: readonly ["fields[] type modular"];
+        readonly status: "pending:C3";
+    };
+    readonly "item chrome (types)": {
+        readonly row: "B structural";
+        readonly carrier: "value";
+        readonly props: readonly ["config.itemTypes[i] {icon, preview}"];
+        readonly fields: readonly ["ui.blocks[slug] {icon, preview}"];
+        readonly status: "pending:C3";
+    };
+    readonly "type:primitive-array": {
+        readonly row: "B decided";
+        readonly carrier: "value";
+        readonly props: readonly ["config.itemType (widened)"];
+        readonly fields: readonly ["config.itemType (widened)"];
+        readonly status: "pending:C3";
+    };
+    readonly "depth>10": {
+        readonly row: "B decided";
+        readonly carrier: "value";
+        readonly props: readonly ["nesting"];
+        readonly fields: readonly ["nesting"];
+        readonly bound: "DEPTH_MAX";
+        readonly status: "landed";
+    };
+    readonly slotSettings: {
+        readonly row: "B decided (BUILD)";
+        readonly carrier: "value";
+        readonly props: readonly ["config.settings: FieldDef[]"];
+        readonly fields: readonly ["config.settings: FieldDef[]"];
+        readonly bound: "SLOT_SETTINGS_MAX";
+        readonly status: "pending:C3";
+    };
+    readonly "block placement": {
+        readonly row: "B catalog";
+        readonly carrier: "value";
+        readonly props: readonly ["components.v2.placement"];
+        readonly fields: readonly ["content_models.v2.placement"];
+        readonly status: "pending:C5";
+    };
+    readonly "seeded instance": {
+        readonly row: "B catalog";
+        readonly carrier: "excluded";
+        readonly props: readonly [];
+        readonly fields: readonly [];
+        readonly status: "landed";
+    };
+    readonly "not applicable (props)": {
+        readonly row: "B catalog";
+        readonly carrier: "excluded";
+        readonly props: readonly [];
+        readonly fields: readonly [];
+        readonly status: "landed";
+    };
+    readonly "type name": FacetRow;
+    readonly "group name>40": FacetRow;
+    readonly "group title": FacetRow;
+    readonly "group default": FacetRow;
+    readonly "group icon": FacetRow;
+    readonly "group name collision": FacetRow;
+    readonly "prop tab limit": FacetRow;
+    readonly "fieldset spans groups": FacetRow;
+    readonly "fieldset (props)": FacetRow;
+    readonly "fieldset name>limit": FacetRow;
+    readonly "duplicate name": FacetRow;
+    readonly "reserved name": {
+        readonly row: "B corpus-fix";
+        readonly carrier: "value";
+        readonly props: readonly [];
+        readonly fields: readonly ["fields[].key"];
+        readonly bound: "KEY_RESERVED + KEY_FORMAT";
+        readonly status: "landed";
+    };
+    readonly rows: FacetRow;
+    readonly synced: FacetRow;
+    readonly valueShape: FacetRow;
+    readonly "default value": FacetRow;
+    readonly icon: FacetRow;
+    readonly layout: FacetRow;
+    readonly "help>limit": FacetRow;
+    readonly "option icon": FacetRow;
+    readonly "option description": FacetRow;
+    readonly access: FacetRow;
+    readonly timezone: FacetRow;
+    readonly "reference order": FacetRow;
+    readonly "numeric unit": FacetRow;
+    readonly "rating bounds": FacetRow;
+    readonly "scale rules": FacetRow;
+    readonly "validation.patternMessage": FacetRow;
+    readonly "validation.pattern": FacetRow;
+    readonly "validation.length": FacetRow;
+    readonly "validation.items": FacetRow;
+    readonly "validation.unique": FacetRow;
+    readonly "validation.recommendedMax": FacetRow;
+    readonly "item identity": FacetRow;
+    readonly "item settings": FacetRow;
+    readonly itemNoun: FacetRow;
+    readonly "item icon": FacetRow;
+    readonly "preview icon": FacetRow;
+    readonly "preview path": FacetRow;
+    readonly "unsupported key": FacetRow;
+};
+export declare const facetOf: (feature: string) => FacetRow | undefined;
+/** The owner-signed exclusions: what may be lost by design (shopify until its pipeline, and two deliberate backend rules). */
+export declare const EXCLUDED: readonly V2Facet[];