@bettercms-ai/kit 0.1.1 → 2.0.0

package/dist/controls/slot-register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/controls/slot-register.js

@@ -0,0 +1,16 @@
+import { JsonControl } from "./json.js";
+import { CONTROLS } from "../engine/kit-field.js";
+import { ComponentSlotControl } from "./slot.js";
+import { createElement } from "react";
+//#region src/controls/slot-register.ts
+/**
+* Lane L3: a component slot (a json field the host marks `componentSlot`) draws the slot control; every other json
+* field keeps the json editor. Imported after json-register (kit barrel), so it wraps the registered json control.
+*/
+var Json = CONTROLS.json ?? JsonControl;
+CONTROLS.json = function JsonOrSlotControl(props) {
+	return createElement(props.field.componentSlot ? ComponentSlotControl : Json, props);
+};
+//#endregion
+
+//# sourceMappingURL=slot-register.js.map

package/dist/controls/slot-register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-register.js","names":[],"sources":["../../src/controls/slot-register.ts"],"sourcesContent":["/**\n * Lane L3: a component slot (a json field the host marks `componentSlot`) draws the slot control; every other json\n * field keeps the json editor. Imported after json-register (kit barrel), so it wraps the registered json control.\n */\nimport { createElement } from \"react\";\nimport type { ControlProps } from \"../types\";\nimport { CONTROLS } from \"../engine/kit-field\";\nimport { JsonControl } from \"./json\";\nimport { ComponentSlotControl } from \"./slot\";\n\nconst Json = CONTROLS.json ?? JsonControl;\nCONTROLS.json = function JsonOrSlotControl(props: ControlProps) {\n  return createElement(props.field.componentSlot ? ComponentSlotControl : Json, props);\n};\n"],"mappings":";;;;;;;;;AAUA,IAAM,OAAO,SAAS,QAAQ;AAC9B,SAAS,OAAO,SAAS,kBAAkB,OAAqB;CAC9D,OAAO,cAAc,MAAM,MAAM,gBAAgB,uBAAuB,MAAM,KAAK;AACrF"}

package/dist/controls/slot-services.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Component slots (lane L3): the services the slot control reads and the reading of a stored slot value, declared as
+ * augmentations so context.tsx and schema/types.ts stay untouched by this lane.
+ *
+ * A prod `slot` prop holds component instances, not V2 blocks:
+ *   single   `{ componentId, overrides? }` (a detached slot is `{ componentId: "" }`)
+ *   multiple `[{ componentId, overrides?, style?, window? }, …]`; a single object reads as a list of one
+ * The host marks such a field with `componentSlot` (the dock reads it off the prop's config) and the slot control draws
+ * it; the value is written back in exactly that shape, each item spread with the keys this control does not show.
+ *
+ *   useSlotCatalog → a React HOOK: the components this slot may take, with the SERVER's insertability verdicts
+ *                    (GET /components/section-catalog) already turned into words, and the name of any component id
+ *   SlotChild      → the host's editor for one child's own props (its overrides), drawn under the child's row
+ */
+import type { ComponentType } from "react";
+/** One component the slot picker lists. `insertable: false` always carries `reason`, a sentence the picker shows. */
+export interface KitSlotEntry {
+    id: string;
+    title: string;
+    /** the section family ("Hero"), shown as the picker's group */
+    category?: string | null;
+    description?: string | null;
+    icon?: string;
+    insertable: boolean;
+    reason?: string;
+}
+export interface KitSlotCatalog {
+    entries: KitSlotEntry[];
+    loading?: boolean;
+    /** a whole sentence naming what failed ("Sections couldn't be loaded: …") */
+    error?: string;
+    /** a sentence under the picker's list naming what can never fill a slot and why (built-in sections) */
+    note?: string;
+    /** a component id's name; `missing` when the project has no such component (deleted, or another project's) */
+    nameOf: (componentId: string) => {
+        title: string;
+        missing?: boolean;
+    } | undefined;
+}
+export interface KitSlotChildProps {
+    componentId: string;
+    title: string;
+    overrides: Record<string, unknown>;
+    onChange: (next: Record<string, unknown>) => void;
+    readOnly?: boolean;
+    /** how many slots deep this child sits (1 for a top-level slot's child) */
+    depth: number;
+}
+/** The slot's own rules, mirrored from the prop's config so a save is not refused (BE slot-values.ts). */
+export interface KitComponentSlot {
+    multiple: boolean;
+    /** config.componentIds: the only components it takes (empty or absent: any) */
+    componentIds?: string[];
+    /** config.minItems (multiple only) */
+    min: number;
+    /** config.maxItems, defaulted to 12 and capped at 50 (multiple only; a single slot holds one) */
+    max: number;
+}
+declare module "../context" {
+    interface KitServices {
+        useSlotCatalog?: (req: {
+            componentIds?: string[];
+        }) => KitSlotCatalog;
+        SlotChild?: ComponentType<KitSlotChildProps>;
+    }
+}
+declare module "../schema/types" {
+    interface FieldSchema {
+        /** a component slot (prod `slot` prop): drawn by the slot control instead of the json editor */
+        componentSlot?: KitComponentSlot;
+    }
+}
+/** SLOT_MAX_ITEMS / SLOT_ITEMS_CAP (@bettercms-ai/types): the default and the hard cap of a multiple slot. */
+export declare const SLOT_MAX_ITEMS = 12;
+export declare const SLOT_ITEMS_CAP = 50;
+/** The renderers' nesting cap: past it a tree renders as nothing, so the editor refuses to nest further. */
+export declare const SLOT_DEPTH_MAX = 10;
+export interface KitSlotItem {
+    componentId: string;
+    overrides?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface SlotReading {
+    items: KitSlotItem[];
+    /** the value is the component's own content (its child blocks), shown until an item is added */
+    inherited: boolean;
+    /** entries this control can't read and would drop on a write (V2 block children, malformed rows) */
+    unreadable: number;
+}
+/**
+ * A stored slot value as its instances (`slotItems`, the one reading of a slot value): a list is its items, a single
+ * `{ componentId }` is a list of one, a detached `{ componentId: "" }` is none. A non-empty list with no instance and no
+ * V2 child is the component's own child blocks (the inherited value), not something to drop.
+ */
+export declare function readSlot(value: unknown): SlotReading;
+/** Write a multiple slot: the items as they are (no `_key` the engine's list helpers add, which prod never stores). */
+export declare function slotList(items: unknown[]): KitSlotItem[];
+export declare function slotItemsFromStored(value: unknown): unknown;
+export declare function slotItemsToStored(value: unknown): unknown;
+type Values = Record<string, unknown>;
+/** A legacy `{ componentId, overrides }` item has no `_key`: its row is keyed by position, stable while the list is. */
+export declare const legacyChildKey: (i: number) => string;
+/**
+ * A stored slot value as SlotField's V2 children `{ _key, _type, _settings?, ...values }` (`_type` the component id),
+ * each child's own values read by `read` (the host converts them per the CHILD's definition):
+ *   a V2 child           → itself, values read
+ *   `{ componentId, … }` → a child keyed `legacy-<i>`, its overrides as the values; `style` / `window` (and any other
+ *                          key) ride in `_legacy` so a write keeps them
+ *   a single object      → a list of one; a detached `{ componentId: "" }` → none
+ *   a component's own child blocks (no instance, no child) → none: the inherited content, shown until a block is added
+ * An entry that is none of these is named through `lose` (a write would drop it).
+ */
+export declare function slotChildrenFromStored(value: unknown, read: (type: string, values: Values, at: string) => Values, lose?: (at: string, reason: string) => void): unknown;
+/**
+ * SlotField's children back as the slot stores them, each child's values written by `write` (per its definition). A
+ * multiple slot stores V2 children `{ _key, _type, _settings?, ...values }`; a child read from a legacy item that
+ * carried placement keys (`_legacy`) is written back as that item, keys and all. A single slot stores
+ * `{ componentId, overrides? }` (none: `{ componentId: "" }`). A child `_variant` is named through `lose`: the backend
+ * refuses one on a prop slot (a component variant is its own component, named in `_type`).
+ */
+export declare function slotChildrenToStored(value: unknown, multiple: boolean, write: (type: string, values: Values, at: string) => Values, lose: (at: string) => void): unknown;
+export {};

package/dist/controls/slot-services.js

@@ -0,0 +1,155 @@
+//#region src/controls/slot-services.ts
+/** SLOT_MAX_ITEMS / SLOT_ITEMS_CAP (@bettercms-ai/types): the default and the hard cap of a multiple slot. */
+var SLOT_MAX_ITEMS = 12;
+var SLOT_ITEMS_CAP = 50;
+/** The renderers' nesting cap: past it a tree renders as nothing, so the editor refuses to nest further. */
+var SLOT_DEPTH_MAX = 10;
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isItem = (v) => isObj(v) && typeof v.componentId === "string" && v.componentId !== "";
+/**
+* A stored slot value as its instances (`slotItems`, the one reading of a slot value): a list is its items, a single
+* `{ componentId }` is a list of one, a detached `{ componentId: "" }` is none. A non-empty list with no instance and no
+* V2 child is the component's own child blocks (the inherited value), not something to drop.
+*/
+function readSlot(value) {
+	if (Array.isArray(value)) {
+		const items = value.filter(isItem);
+		const rest = value.filter((v) => !isItem(v));
+		const v2 = rest.filter((v) => isObj(v) && v.componentId === void 0 && ("_type" in v || "_key" in v));
+		const inherited = items.length === 0 && v2.length === 0 && rest.length > 0;
+		return {
+			items,
+			inherited,
+			unreadable: inherited ? 0 : rest.length
+		};
+	}
+	return {
+		items: isItem(value) ? [value] : [],
+		inherited: false,
+		unreadable: 0
+	};
+}
+/** Write a multiple slot: the items as they are (no `_key` the engine's list helpers add, which prod never stores). */
+function slotList(items) {
+	return items.filter(isItem).map((it) => {
+		if (!("_key" in it)) return it;
+		const { _key, ...rest } = it;
+		return rest;
+	});
+}
+/**
+* A stored V2 slot child (`{ _key, _type, _settings?, ...props }`, `_type` the component id: BE slot-values.ts isV2Child)
+* as the item this control edits, and back. The child's props are its overrides; its `_key` rides along as `_v2Key` (the
+* engine's own `_key` is stripped on write, slotList) and its `_settings` as they are, so an edit writes the child in
+* the shape it was read. Items stored as `{ componentId, overrides? }` (and a component's own child blocks) pass as
+* they are.
+*/
+var isV2Child = (v) => isObj(v) && v.componentId === void 0 && ("_type" in v || "_key" in v);
+function slotItemsFromStored(value) {
+	if (!Array.isArray(value)) return value;
+	return value.map((child) => {
+		if (!isV2Child(child)) return child;
+		const { _key, _type, _settings, ...overrides } = child;
+		return {
+			componentId: typeof _type === "string" ? _type : "",
+			overrides,
+			...typeof _key === "string" ? { _v2Key: _key } : {},
+			..._settings !== void 0 ? { _settings } : {}
+		};
+	});
+}
+function slotItemsToStored(value) {
+	if (!Array.isArray(value)) return value;
+	return value.map((item) => {
+		if (!isObj(item) || typeof item._v2Key !== "string") return item;
+		const { _v2Key, componentId, overrides, _settings, ...rest } = item;
+		return {
+			_key: _v2Key,
+			_type: componentId,
+			..._settings !== void 0 ? { _settings } : {},
+			...rest,
+			...isObj(overrides) ? overrides : {}
+		};
+	});
+}
+/** The child's reserved keys (BE slot-child.ts SLOT_CHILD_KEYS) plus `_legacy`, where a legacy item's placement keys ride. */
+var RESERVED = /* @__PURE__ */ new Set([
+	"_key",
+	"_type",
+	"_variant",
+	"_settings",
+	"_legacy"
+]);
+var ownValues = (child) => Object.fromEntries(Object.entries(child).filter(([k]) => !RESERVED.has(k)));
+/** A legacy `{ componentId, overrides }` item has no `_key`: its row is keyed by position, stable while the list is. */
+var legacyChildKey = (i) => `legacy-${i}`;
+/**
+* A stored slot value as SlotField's V2 children `{ _key, _type, _settings?, ...values }` (`_type` the component id),
+* each child's own values read by `read` (the host converts them per the CHILD's definition):
+*   a V2 child           → itself, values read
+*   `{ componentId, … }` → a child keyed `legacy-<i>`, its overrides as the values; `style` / `window` (and any other
+*                          key) ride in `_legacy` so a write keeps them
+*   a single object      → a list of one; a detached `{ componentId: "" }` → none
+*   a component's own child blocks (no instance, no child) → none: the inherited content, shown until a block is added
+* An entry that is none of these is named through `lose` (a write would drop it).
+*/
+function slotChildrenFromStored(value, read, lose) {
+	const one = (v, i) => {
+		if (isItem(v)) {
+			const { componentId, overrides, ...extras } = v;
+			return [{
+				_key: legacyChildKey(i),
+				_type: componentId,
+				...Object.keys(extras).length ? { _legacy: extras } : {},
+				...read(componentId, isObj(overrides) ? overrides : {}, `${i}`)
+			}];
+		}
+		if (isV2Child(v)) {
+			const type = typeof v._type === "string" ? v._type : "";
+			return [{
+				...Object.fromEntries(Object.entries(v).filter(([k]) => RESERVED.has(k) && k !== "_legacy")),
+				...read(type, ownValues(v), `${i}`)
+			}];
+		}
+		lose?.(`${i}`, "This slot entry is neither a block instance nor a slot child, so a write would drop it.");
+		return [];
+	};
+	if (!Array.isArray(value)) {
+		if (isObj(value) && value.componentId === "") return [];
+		return isItem(value) || isV2Child(value) ? one(value, 0) : value;
+	}
+	if (value.length && !value.some((v) => isItem(v) || isV2Child(v))) return [];
+	return value.flatMap(one);
+}
+/**
+* SlotField's children back as the slot stores them, each child's values written by `write` (per its definition). A
+* multiple slot stores V2 children `{ _key, _type, _settings?, ...values }`; a child read from a legacy item that
+* carried placement keys (`_legacy`) is written back as that item, keys and all. A single slot stores
+* `{ componentId, overrides? }` (none: `{ componentId: "" }`). A child `_variant` is named through `lose`: the backend
+* refuses one on a prop slot (a component variant is its own component, named in `_type`).
+*/
+function slotChildrenToStored(value, multiple, write, lose) {
+	if (!Array.isArray(value)) return value;
+	const out = value.map((c, i) => {
+		if (!isObj(c)) return c;
+		const type = typeof c._type === "string" ? c._type : "";
+		if (c._variant !== void 0) lose(`${i}/_variant`);
+		const own = write(type, ownValues(c), `${i}`);
+		if (!multiple || isObj(c._legacy)) return {
+			componentId: type,
+			...Object.keys(own).length ? { overrides: own } : {},
+			...isObj(c._legacy) ? c._legacy : {}
+		};
+		return {
+			_key: c._key,
+			_type: type,
+			...c._settings !== void 0 ? { _settings: c._settings } : {},
+			...own
+		};
+	});
+	return multiple ? out : out[0] ?? { componentId: "" };
+}
+//#endregion
+export { SLOT_DEPTH_MAX, SLOT_ITEMS_CAP, SLOT_MAX_ITEMS, legacyChildKey, readSlot, slotChildrenFromStored, slotChildrenToStored, slotItemsFromStored, slotItemsToStored, slotList };
+
+//# sourceMappingURL=slot-services.js.map

package/dist/controls/slot-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-services.js","names":[],"sources":["../../src/controls/slot-services.ts"],"sourcesContent":["/**\n * Component slots (lane L3): the services the slot control reads and the reading of a stored slot value, declared as\n * augmentations so context.tsx and schema/types.ts stay untouched by this lane.\n *\n * A prod `slot` prop holds component instances, not V2 blocks:\n *   single   `{ componentId, overrides? }` (a detached slot is `{ componentId: \"\" }`)\n *   multiple `[{ componentId, overrides?, style?, window? }, …]`; a single object reads as a list of one\n * The host marks such a field with `componentSlot` (the dock reads it off the prop's config) and the slot control draws\n * it; the value is written back in exactly that shape, each item spread with the keys this control does not show.\n *\n *   useSlotCatalog → a React HOOK: the components this slot may take, with the SERVER's insertability verdicts\n *                    (GET /components/section-catalog) already turned into words, and the name of any component id\n *   SlotChild      → the host's editor for one child's own props (its overrides), drawn under the child's row\n */\nimport type { ComponentType } from \"react\";\n\n/** One component the slot picker lists. `insertable: false` always carries `reason`, a sentence the picker shows. */\nexport interface KitSlotEntry {\n  id: string;\n  title: string;\n  /** the section family (\"Hero\"), shown as the picker's group */\n  category?: string | null;\n  description?: string | null;\n  icon?: string;\n  insertable: boolean;\n  reason?: string;\n}\n\nexport interface KitSlotCatalog {\n  entries: KitSlotEntry[];\n  loading?: boolean;\n  /** a whole sentence naming what failed (\"Sections couldn't be loaded: …\") */\n  error?: string;\n  /** a sentence under the picker's list naming what can never fill a slot and why (built-in sections) */\n  note?: string;\n  /** a component id's name; `missing` when the project has no such component (deleted, or another project's) */\n  nameOf: (componentId: string) => { title: string; missing?: boolean } | undefined;\n}\n\nexport interface KitSlotChildProps {\n  componentId: string;\n  title: string;\n  overrides: Record<string, unknown>;\n  onChange: (next: Record<string, unknown>) => void;\n  readOnly?: boolean;\n  /** how many slots deep this child sits (1 for a top-level slot's child) */\n  depth: number;\n}\n\n/** The slot's own rules, mirrored from the prop's config so a save is not refused (BE slot-values.ts). */\nexport interface KitComponentSlot {\n  multiple: boolean;\n  /** config.componentIds: the only components it takes (empty or absent: any) */\n  componentIds?: string[];\n  /** config.minItems (multiple only) */\n  min: number;\n  /** config.maxItems, defaulted to 12 and capped at 50 (multiple only; a single slot holds one) */\n  max: number;\n}\n\ndeclare module \"../context\" {\n  interface KitServices {\n    useSlotCatalog?: (req: { componentIds?: string[] }) => KitSlotCatalog;\n    SlotChild?: ComponentType<KitSlotChildProps>;\n  }\n}\n\ndeclare module \"../schema/types\" {\n  interface FieldSchema {\n    /** a component slot (prod `slot` prop): drawn by the slot control instead of the json editor */\n    componentSlot?: KitComponentSlot;\n  }\n}\n\n/** SLOT_MAX_ITEMS / SLOT_ITEMS_CAP (@bettercms-ai/types): the default and the hard cap of a multiple slot. */\nexport const SLOT_MAX_ITEMS = 12;\nexport const SLOT_ITEMS_CAP = 50;\n/** The renderers' nesting cap: past it a tree renders as nothing, so the editor refuses to nest further. */\nexport const SLOT_DEPTH_MAX = 10;\n\nexport interface KitSlotItem {\n  componentId: string;\n  overrides?: Record<string, unknown>;\n  [key: string]: unknown;\n}\n\nexport interface SlotReading {\n  items: KitSlotItem[];\n  /** the value is the component's own content (its child blocks), shown until an item is added */\n  inherited: boolean;\n  /** entries this control can't read and would drop on a write (V2 block children, malformed rows) */\n  unreadable: number;\n}\n\nconst isObj = (v: unknown): v is Record<string, unknown> => !!v && typeof v === \"object\" && !Array.isArray(v);\nconst isItem = (v: unknown): v is KitSlotItem => isObj(v) && typeof v.componentId === \"string\" && v.componentId !== \"\";\n\n/**\n * A stored slot value as its instances (`slotItems`, the one reading of a slot value): a list is its items, a single\n * `{ componentId }` is a list of one, a detached `{ componentId: \"\" }` is none. A non-empty list with no instance and no\n * V2 child is the component's own child blocks (the inherited value), not something to drop.\n */\nexport function readSlot(value: unknown): SlotReading {\n  if (Array.isArray(value)) {\n    const items = value.filter(isItem);\n    const rest = value.filter((v) => !isItem(v));\n    const v2 = rest.filter((v) => isObj(v) && v.componentId === undefined && (\"_type\" in v || \"_key\" in v));\n    const inherited = items.length === 0 && v2.length === 0 && rest.length > 0;\n    return { items, inherited, unreadable: inherited ? 0 : rest.length };\n  }\n  return { items: isItem(value) ? [value] : [], inherited: false, unreadable: 0 };\n}\n\n/** Write a multiple slot: the items as they are (no `_key` the engine's list helpers add, which prod never stores). */\nexport function slotList(items: unknown[]): KitSlotItem[] {\n  return items.filter(isItem).map((it) => {\n    if (!(\"_key\" in it)) return it;\n    const { _key, ...rest } = it;\n    void _key;\n    return rest as KitSlotItem;\n  });\n}\n\n/**\n * A stored V2 slot child (`{ _key, _type, _settings?, ...props }`, `_type` the component id: BE slot-values.ts isV2Child)\n * as the item this control edits, and back. The child's props are its overrides; its `_key` rides along as `_v2Key` (the\n * engine's own `_key` is stripped on write, slotList) and its `_settings` as they are, so an edit writes the child in\n * the shape it was read. Items stored as `{ componentId, overrides? }` (and a component's own child blocks) pass as\n * they are.\n */\nconst isV2Child = (v: unknown): v is Record<string, unknown> => isObj(v) && v.componentId === undefined && (\"_type\" in v || \"_key\" in v);\n\nexport function slotItemsFromStored(value: unknown): unknown {\n  if (!Array.isArray(value)) return value;\n  return value.map((child) => {\n    if (!isV2Child(child)) return child;\n    const { _key, _type, _settings, ...overrides } = child;\n    return {\n      componentId: typeof _type === \"string\" ? _type : \"\",\n      overrides,\n      ...(typeof _key === \"string\" ? { _v2Key: _key } : {}),\n      ...(_settings !== undefined ? { _settings } : {}),\n    };\n  });\n}\n\nexport function slotItemsToStored(value: unknown): unknown {\n  if (!Array.isArray(value)) return value;\n  return value.map((item) => {\n    if (!isObj(item) || typeof item._v2Key !== \"string\") return item;\n    const { _v2Key, componentId, overrides, _settings, ...rest } = item;\n    return { _key: _v2Key, _type: componentId, ...(_settings !== undefined ? { _settings } : {}), ...rest, ...(isObj(overrides) ? overrides : {}) };\n  });\n}\n\n/* ── V2 slot children (SlotField) ───────────────────────────────────────── */\ntype Values = Record<string, unknown>;\n/** The child's reserved keys (BE slot-child.ts SLOT_CHILD_KEYS) plus `_legacy`, where a legacy item's placement keys ride. */\nconst RESERVED = new Set([\"_key\", \"_type\", \"_variant\", \"_settings\", \"_legacy\"]);\nconst ownValues = (child: Values): Values => Object.fromEntries(Object.entries(child).filter(([k]) => !RESERVED.has(k)));\n/** A legacy `{ componentId, overrides }` item has no `_key`: its row is keyed by position, stable while the list is. */\nexport const legacyChildKey = (i: number) => `legacy-${i}`;\n\n/**\n * A stored slot value as SlotField's V2 children `{ _key, _type, _settings?, ...values }` (`_type` the component id),\n * each child's own values read by `read` (the host converts them per the CHILD's definition):\n *   a V2 child           → itself, values read\n *   `{ componentId, … }` → a child keyed `legacy-<i>`, its overrides as the values; `style` / `window` (and any other\n *                          key) ride in `_legacy` so a write keeps them\n *   a single object      → a list of one; a detached `{ componentId: \"\" }` → none\n *   a component's own child blocks (no instance, no child) → none: the inherited content, shown until a block is added\n * An entry that is none of these is named through `lose` (a write would drop it).\n */\nexport function slotChildrenFromStored(value: unknown, read: (type: string, values: Values, at: string) => Values, lose?: (at: string, reason: string) => void): unknown {\n  const one = (v: unknown, i: number): Values[] => {\n    if (isItem(v)) {\n      const { componentId, overrides, ...extras } = v;\n      return [{ _key: legacyChildKey(i), _type: componentId, ...(Object.keys(extras).length ? { _legacy: extras } : {}), ...read(componentId, isObj(overrides) ? overrides : {}, `${i}`) }];\n    }\n    if (isV2Child(v)) {\n      const type = typeof v._type === \"string\" ? v._type : \"\";\n      const kept = Object.fromEntries(Object.entries(v).filter(([k]) => RESERVED.has(k) && k !== \"_legacy\"));\n      return [{ ...kept, ...read(type, ownValues(v), `${i}`) }];\n    }\n    lose?.(`${i}`, \"This slot entry is neither a block instance nor a slot child, so a write would drop it.\");\n    return [];\n  };\n  if (!Array.isArray(value)) {\n    if (isObj(value) && value.componentId === \"\") return [];\n    return isItem(value) || isV2Child(value) ? one(value, 0) : value;\n  }\n  if (value.length && !value.some((v) => isItem(v) || isV2Child(v))) return [];\n  return value.flatMap(one);\n}\n\n/**\n * SlotField's children back as the slot stores them, each child's values written by `write` (per its definition). A\n * multiple slot stores V2 children `{ _key, _type, _settings?, ...values }`; a child read from a legacy item that\n * carried placement keys (`_legacy`) is written back as that item, keys and all. A single slot stores\n * `{ componentId, overrides? }` (none: `{ componentId: \"\" }`). A child `_variant` is named through `lose`: the backend\n * refuses one on a prop slot (a component variant is its own component, named in `_type`).\n */\nexport function slotChildrenToStored(value: unknown, multiple: boolean, write: (type: string, values: Values, at: string) => Values, lose: (at: string) => void): unknown {\n  if (!Array.isArray(value)) return value;\n  const out = value.map((c, i) => {\n    if (!isObj(c)) return c;\n    const type = typeof c._type === \"string\" ? c._type : \"\";\n    if (c._variant !== undefined) lose(`${i}/_variant`);\n    const own = write(type, ownValues(c), `${i}`);\n    if (!multiple || isObj(c._legacy)) return { componentId: type, ...(Object.keys(own).length ? { overrides: own } : {}), ...(isObj(c._legacy) ? c._legacy : {}) };\n    return { _key: c._key, _type: type, ...(c._settings !== undefined ? { _settings: c._settings } : {}), ...own };\n  });\n  return multiple ? out : (out[0] ?? { componentId: \"\" });\n}\n"],"mappings":"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"}

package/dist/controls/slot.d.ts

@@ -0,0 +1,33 @@
+/**
+ * COMPONENT SLOT — a prop that holds component instances (prod `slot`), on the engine's slot surface (engine/slot.tsx,
+ * V2 HEAD 9829bf1): the block rows (icon tile, name, ⋯ menu, drag to reorder) and the compact searchable picker.
+ *
+ * What differs from V2's block slot is where the rows come from and what they store:
+ *   - the picker lists the host's slot catalog (`useSlotCatalog`): the project's components with the SERVER's
+ *     insertability verdict for each; one that can't go here stays in the list, disabled, with the reason under its name;
+ *   - a row opens in place and edits that child's own props through the host's `SlotChild`;
+ *   - the value is written in the stored shape (slot-services.ts): one `{ componentId, overrides? }`, or a list of them
+ *     for a multiple slot, every item spread back with the keys this control does not show (style, window).
+ *
+ * Refusals are said in words, never by an inert control: no catalog service, an unreadable stored value, the nesting cap.
+ */
+import * as React from "react";
+import type { ControlProps } from "../types";
+import { type KitSlotEntry } from "./slot-services";
+/** How many slots deep the control sits: the host's SlotChild editor sits inside a provider one level down. */
+export declare const SlotDepthContext: React.Context<number>;
+export declare function ComponentSlotControl({ field, value, onChange, readOnly, id, path }: ControlProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * The compact block picker (engine/slot.tsx BlockPicker), over the slot catalog: grouped by family, searchable, ↵ adds.
+ * A component the server says can't go here is listed disabled with its reason in place of the description.
+ */
+export declare function SlotPicker({ entries, loading, error, note, current, label, disabled, onPick, }: {
+    entries: KitSlotEntry[];
+    loading?: boolean;
+    error?: string;
+    note?: string;
+    current?: string;
+    label: string;
+    disabled?: boolean;
+    onPick: (componentId: string) => void;
+}): import("react/jsx-runtime").JSX.Element;