@yahoo/uds-create-config 4.6.0 → 4.7.0

package/dist/migrations/20260920004019_preview_conditions_keyed.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A component's preview content is one keyed collection, `preview`, shaped like `styles`: the
+ * `previewProps` every cell read become the `*` entry (`{ "when": null, "props": { ... } }`), and each
+ * `previewWhen` list entry sits under the canonical spelling of its condition (`type=header`,
+ * `size=xs&type=default`), the key a style rule is stored under. The collection is a sub-entity from
+ * this version, so one entry is addressed by `sub-update` and `sub-delete`, a prop rename moves the
+ * names an entry holds, and deleting a prop or a value drops the entries conditioned on it.
+ *
+ * `up` folds both stored fields; list entries spelling one condition collapse onto the later one,
+ * which is the entry the reader answered with before. `upPatch` folds the same fields on a component
+ * patch: a whole `previewProps` or `previewWhen` value, and a `previewProps.<prop>` field path.
+ * Neither field was ever a sub-collection, so no stored sub-op names them.
+ *
+ * Deletable once no stored artifact predates it.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const PREVIEW_CONDITIONS_KEYED_VERSION = 20260920004019;
+/**
+ * The `preview` collection the two old fields fold into, over whatever `preview` already holds: the
+ * `*` entry from `previewProps`, one keyed entry per `previewWhen` list item.
+ */
+export declare function foldedPreview({ preview, previewProps, previewWhen, }: {
+    preview?: unknown;
+    previewProps?: unknown;
+    previewWhen?: unknown;
+}): Record<string, unknown>;
+export declare const previewConditionsKeyedMigration: SchemaMigration;

package/dist/migrations/20260920004019_preview_conditions_keyed.js

@@ -0,0 +1,148 @@
+import { isPlainObject } from "../framework/utils/field-path.js";
+import { z } from "zod";
+//#region src/migrations/20260920004019_preview_conditions_keyed.ts
+/**
+* A component's preview content is one keyed collection, `preview`, shaped like `styles`: the
+* `previewProps` every cell read become the `*` entry (`{ "when": null, "props": { ... } }`), and each
+* `previewWhen` list entry sits under the canonical spelling of its condition (`type=header`,
+* `size=xs&type=default`), the key a style rule is stored under. The collection is a sub-entity from
+* this version, so one entry is addressed by `sub-update` and `sub-delete`, a prop rename moves the
+* names an entry holds, and deleting a prop or a value drops the entries conditioned on it.
+*
+* `up` folds both stored fields; list entries spelling one condition collapse onto the later one,
+* which is the entry the reader answered with before. `upPatch` folds the same fields on a component
+* patch: a whole `previewProps` or `previewWhen` value, and a `previewProps.<prop>` field path.
+* Neither field was ever a sub-collection, so no stored sub-op names them.
+*
+* Deletable once no stored artifact predates it.
+*/
+const PREVIEW_CONDITIONS_KEYED_VERSION = 20260920004019;
+const UNCONDITIONAL = "*";
+const before = z.looseObject({ items: z.looseObject({ component: z.record(z.string(), z.looseObject({
+	previewProps: z.record(z.string(), z.unknown()).optional(),
+	previewWhen: z.array(z.unknown()).optional()
+})).optional() }).optional() });
+const after = z.looseObject({ items: z.looseObject({ component: z.record(z.string(), z.looseObject({ preview: z.record(z.string(), z.unknown()).optional() })).optional() }).optional() });
+/** A condition value read to the name it spells: a ref's last path segment, else the value itself. */
+function leafOf(value) {
+	if (isPlainObject(value) && typeof value.__ref === "string") {
+		const path = /^[^:]*:(.*)$/.exec(value.__ref)?.[1] ?? value.__ref;
+		return /([^/]*)$/.exec(path)?.[1] ?? path;
+	}
+	return String(value);
+}
+/** The key an entry is stored under, frozen here: the condition's entries sorted by prop. */
+function keyOf(when) {
+	const entries = Object.entries(isPlainObject(when) ? when : {}).filter(([, value]) => value !== void 0 && value !== null).sort(([a], [b]) => a.localeCompare(b));
+	return entries.length === 0 ? UNCONDITIONAL : entries.map(([prop, value]) => `${prop}=${leafOf(value)}`).join("&");
+}
+/**
+* The `preview` collection the two old fields fold into, over whatever `preview` already holds: the
+* `*` entry from `previewProps`, one keyed entry per `previewWhen` list item.
+*/
+function foldedPreview({ preview, previewProps, previewWhen }) {
+	const keyed = isPlainObject(preview) ? { ...preview } : {};
+	if (isPlainObject(previewProps)) keyed[UNCONDITIONAL] = {
+		when: null,
+		props: previewProps
+	};
+	if (Array.isArray(previewWhen)) for (const entry of previewWhen) {
+		if (!isPlainObject(entry)) continue;
+		keyed[keyOf(entry.when)] = entry;
+	}
+	return keyed;
+}
+/** Whether a body still spells preview content the old way. */
+function hasOldPreview(body) {
+	return body.previewProps !== void 0 || body.previewWhen !== void 0;
+}
+/** A body with its old preview fields folded into `preview`. */
+function foldedBody(body) {
+	const { previewProps, previewWhen, ...rest } = body;
+	const preview = foldedPreview({
+		preview: rest.preview,
+		previewProps,
+		previewWhen
+	});
+	return Object.keys(preview).length > 0 ? {
+		...rest,
+		preview
+	} : rest;
+}
+/** A component body, or a pointer's `extend` delta, with its preview fields folded. */
+function keyedBody(body) {
+	if (!isPlainObject(body)) return body;
+	let next = body;
+	if (hasOldPreview(body)) next = foldedBody(body);
+	if (isPlainObject(body.extend) && hasOldPreview(body.extend)) next = {
+		...next,
+		extend: foldedBody(body.extend)
+	};
+	return next;
+}
+/** A component patch's `data`, its old preview fields folded: whole values become entries, and a
+*  `previewProps.<prop>` field path becomes `preview.*.props.<prop>`. */
+function foldedPatchData(data) {
+	const next = {};
+	let previewProps;
+	let previewWhen;
+	for (const [field, value] of Object.entries(data)) {
+		if (field === "previewProps") {
+			if (isPlainObject(value)) previewProps = value;
+			else if (value === null) next["preview.*"] = null;
+			continue;
+		}
+		if (field === "previewWhen") {
+			previewWhen = value;
+			continue;
+		}
+		if (field.startsWith("previewProps.")) {
+			next[`preview.*.props.${field.slice(13)}`] = value;
+			continue;
+		}
+		next[field] = value;
+	}
+	if (previewProps !== void 0) next["preview.*"] = {
+		when: null,
+		props: previewProps
+	};
+	if (Array.isArray(previewWhen)) for (const [key, entry] of Object.entries(foldedPreview({ previewWhen }))) next[`preview.${key}`] = entry;
+	return next;
+}
+const previewConditionsKeyedMigration = {
+	version: PREVIEW_CONDITIONS_KEYED_VERSION,
+	up(json) {
+		const items = json.items;
+		if (!isPlainObject(items) || !isPlainObject(items.component)) return json;
+		let changed = false;
+		const component = {};
+		for (const [path, body] of Object.entries(items.component)) {
+			const next = keyedBody(body);
+			if (next !== body) changed = true;
+			component[path] = next;
+		}
+		return changed ? {
+			...json,
+			items: {
+				...items,
+				component
+			}
+		} : json;
+	},
+	upPatch(patch) {
+		if (patch.kind !== "component") return patch;
+		const { operation } = patch;
+		if ((operation === "create" || operation === "update" || operation === "replace") && isPlainObject(patch.data)) {
+			const data = patch.data;
+			return Object.keys(data).some((field) => field === "previewWhen" || field.startsWith("previewProps")) ? {
+				...patch,
+				data: foldedPatchData(data)
+			} : patch;
+		}
+		return patch;
+	},
+	fromSchema: before,
+	toSchema: after
+};
+//#endregion
+export { PREVIEW_CONDITIONS_KEYED_VERSION, previewConditionsKeyedMigration };

package/dist/migrations/20260920161309_prefixed_token_group.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A style property's `values` take one more form: a prefixed token group, `{ value: <group ref>,
+ * prefix: "canvas" }`, which offers every token of the group under `<prefix>/<name>` so a group bound
+ * beside others reads as its own. Additive — no stored value reshapes, so `up` is the identity — but
+ * the `values` member schema is what the wire gate hashes, and a build at the previous version would
+ * strip the new form on write.
+ *
+ * Deletable once no stored artifact predates it.
+ */
+import type { SchemaMigration } from '../framework/schema-version';
+export declare const PREFIXED_TOKEN_GROUP_VERSION = 20260920161309;
+export declare const prefixedTokenGroupMigration: SchemaMigration;

package/dist/migrations/20260920161309_prefixed_token_group.js

@@ -0,0 +1,10 @@
+//#region src/migrations/20260920161309_prefixed_token_group.ts
+const PREFIXED_TOKEN_GROUP_VERSION = 20260920161309;
+const prefixedTokenGroupMigration = {
+	version: PREFIXED_TOKEN_GROUP_VERSION,
+	up(json) {
+		return json;
+	}
+};
+//#endregion
+export { PREFIXED_TOKEN_GROUP_VERSION, prefixedTokenGroupMigration };

package/dist/renderer/wrapRegistry.js

@@ -1,5 +1,6 @@
 import { FragmentRenderer } from "./primitives/FragmentRenderer.js";
 import { SlotRenderer } from "./primitives/SlotRenderer.js";
+import { wrapComponentRefs } from "./wrappers/component-refs.js";
 import { wrapEventBridge } from "./wrappers/event-bridge.js";
 import { wrapNormalizeHex } from "./wrappers/hex-normalize.js";
 import { aliasHtmlTypes } from "./wrappers/html-aliases.js";
@@ -18,15 +19,20 @@ import { wrapInlineStyleProps } from "./wrappers/inline-styles.js";
 * its outer wrappers haven't yet seen the element.
 */
 function wrapRegistry(reg, descriptor) {
-	return aliasHtmlTypes(wrapInlineStyleProps(wrapNormalizeHex(wrapEventBridge({
+	const base = {
 		...reg,
 		Fragment: reg.Fragment ?? FragmentRenderer,
 		Slot: reg.Slot ?? SlotRenderer
-	})), {
+	};
+	const stylePropNames = descriptor?.stylePropClasses ? new Set([...Object.keys(descriptor.stylePropClasses), ...Object.values(descriptor.cssPropertyToStyleProp ?? {})]) : void 0;
+	const holder = {};
+	const final = aliasHtmlTypes(wrapInlineStyleProps(wrapNormalizeHex(wrapEventBridge(wrapComponentRefs(base, (type) => holder.registry?.[type])), stylePropNames), {
 		cssPropertyToStyleProp: descriptor?.cssPropertyToStyleProp,
 		layoutComponents: descriptor?.layoutComponents,
 		textComponents: descriptor?.textComponents
 	}), descriptor?.stylePropClasses);
+	holder.registry = final;
+	return final;
 }
 //#endregion
 export { wrapRegistry };

package/dist/renderer/wrappers/component-refs.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentRegistry, ComponentRenderer } from '@json-render/react';
+/**
+ * A component handed as a prop VALUE (`icon={DotsThreeIcon}`) crosses the config as a bare ref,
+ * `{ __ref: 'icon:phosphor/DotsThreeIcon' }`, keyed the way the registry keys the component. This
+ * wrapper hands the receiving component the component back: one that renders the registry's
+ * renderer for that key with whatever props it is called with, so `<Glyph size={12} />` inside
+ * `Icon` paints the glyph at 12px. It runs after json-render has resolved the element's props, which
+ * is the only point a ref can be told from ordinary data.
+ *
+ * `resolve` reads the FINAL registry, so the revived component goes through the whole wrapper stack
+ * like any spec element. One component per ref, so the receiving component's element type is stable
+ * across renders and React keeps the glyph mounted.
+ */
+export declare function wrapComponentRefs(reg: ComponentRegistry, resolve: (type: string) => ComponentRenderer | undefined): ComponentRegistry;

package/dist/renderer/wrappers/component-refs.js

@@ -0,0 +1,79 @@
+import { isComponentRef } from "../../spec/preview-elements.js";
+import React from "react";
+//#region src/renderer/wrappers/component-refs.tsx
+/** A revived ref is called by the component that received it, outside any spec event routing. */
+const NO_EVENT = {
+	emit: () => {},
+	shouldPreventDefault: false,
+	bound: false
+};
+/**
+* Whether anything under a value is a stored component ref. Stops at a live React element: walking
+* its owner Fiber reaches a circular structure, and an element never holds an un-revived ref.
+*/
+function hasRefDeep(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if ("$$typeof" in value) return false;
+	if (isComponentRef(value)) return true;
+	return (Array.isArray(value) ? value : Object.values(value)).some(hasRefDeep);
+}
+function reviveDeep(value, revive) {
+	if (typeof value !== "object" || value === null) return value;
+	if ("$$typeof" in value) return value;
+	if (isComponentRef(value)) return revive(value);
+	if (Array.isArray(value)) return value.map((item) => reviveDeep(item, revive));
+	const out = {};
+	for (const [key, member] of Object.entries(value)) out[key] = reviveDeep(member, revive);
+	return out;
+}
+/**
+* A component handed as a prop VALUE (`icon={DotsThreeIcon}`) crosses the config as a bare ref,
+* `{ __ref: 'icon:phosphor/DotsThreeIcon' }`, keyed the way the registry keys the component. This
+* wrapper hands the receiving component the component back: one that renders the registry's
+* renderer for that key with whatever props it is called with, so `<Glyph size={12} />` inside
+* `Icon` paints the glyph at 12px. It runs after json-render has resolved the element's props, which
+* is the only point a ref can be told from ordinary data.
+*
+* `resolve` reads the FINAL registry, so the revived component goes through the whole wrapper stack
+* like any spec element. One component per ref, so the receiving component's element type is stable
+* across renders and React keeps the glyph mounted.
+*/
+function wrapComponentRefs(reg, resolve) {
+	const revived = /* @__PURE__ */ new Map();
+	const revive = (ref) => {
+		const type = ref.__ref;
+		const cached = revived.get(type);
+		if (cached) return cached;
+		function RevivedRef(props) {
+			const Renderer = resolve(type);
+			if (!Renderer) return null;
+			return React.createElement(Renderer, {
+				element: {
+					type,
+					props
+				},
+				emit: () => {},
+				on: () => NO_EVENT
+			});
+		}
+		RevivedRef.displayName = `RevivedRef(${type})`;
+		revived.set(type, RevivedRef);
+		return RevivedRef;
+	};
+	const wrapped = { ...reg };
+	const makeWrapper = (Comp) => function ComponentRefsWrapper(renderProps) {
+		const props = renderProps.element.props;
+		if (!props || !hasRefDeep(props)) return React.createElement(Comp, renderProps);
+		return React.createElement(Comp, {
+			...renderProps,
+			element: {
+				...renderProps.element,
+				props: reviveDeep(props, revive)
+			}
+		});
+	};
+	for (const [name, Comp] of Object.entries(reg)) wrapped[name] = makeWrapper(Comp);
+	return wrapped;
+}
+//#endregion
+export { wrapComponentRefs };

package/dist/renderer/wrappers/hex-normalize.d.ts

@@ -2,13 +2,11 @@ import { ComponentRegistry } from "@json-render/react";
 
 //#region src/renderer/wrappers/hex-normalize.d.ts
 /**
- * Normalize raw hex prop values (e.g. from `$state` resolution at
- * runtime) to UDS arbitrary-value syntax (`[#ef4444]`). `$state`
- * resolves a hex string verbatim, but UDS's style-prop processor
- * expects brackets around arbitrary literals — without normalisation
- * the value falls through to the default token-lookup path and the
- * styling silently fails.
+ * A raw hex on a style prop (`bg="#1f1f1f"`, or a `$state` resolved to one) is an off-scale value,
+ * spelled `[#1f1f1f]` for the class it compiles to; unwrapped it falls through to the token lookup
+ * and styles nothing. A value prop (`swatchColor`, `spotColor`) carries the color itself, so with
+ * the style prop names known only those are wrapped; without them every hex string is.
  */
-declare function wrapNormalizeHex(reg: ComponentRegistry): ComponentRegistry;
+declare function wrapNormalizeHex(reg: ComponentRegistry, styleProps?: ReadonlySet<string>): ComponentRegistry;
 //#endregion
 export { wrapNormalizeHex };

package/dist/renderer/wrappers/hex-normalize.js

@@ -2,23 +2,24 @@ import React from "react";
 //#region src/renderer/wrappers/hex-normalize.tsx
 const RAW_HEX_RE = /^#[0-9a-fA-F]{3,8}$/;
 /**
-* Normalize raw hex prop values (e.g. from `$state` resolution at
-* runtime) to UDS arbitrary-value syntax (`[#ef4444]`). `$state`
-* resolves a hex string verbatim, but UDS's style-prop processor
-* expects brackets around arbitrary literals — without normalisation
-* the value falls through to the default token-lookup path and the
-* styling silently fails.
+* A raw hex on a style prop (`bg="#1f1f1f"`, or a `$state` resolved to one) is an off-scale value,
+* spelled `[#1f1f1f]` for the class it compiles to; unwrapped it falls through to the token lookup
+* and styles nothing. A value prop (`swatchColor`, `spotColor`) carries the color itself, so with
+* the style prop names known only those are wrapped; without them every hex string is.
 */
-function wrapNormalizeHex(reg) {
+function wrapNormalizeHex(reg, styleProps) {
 	const wrapped = { ...reg };
 	const makeHexNormalizeWrapper = (Comp) => function HexNormalizeWrapper(renderProps) {
 		const props = renderProps.element.props;
 		if (!props) return React.createElement(Comp, renderProps);
 		let patched = false;
 		const newProps = { ...props };
-		for (const [propName, value] of Object.entries(newProps)) if (typeof value === "string" && RAW_HEX_RE.test(value)) {
-			newProps[propName] = `[${value}]`;
-			patched = true;
+		for (const [propName, value] of Object.entries(newProps)) {
+			if (styleProps && !styleProps.has(propName)) continue;
+			if (typeof value === "string" && RAW_HEX_RE.test(value)) {
+				newProps[propName] = `[${value}]`;
+				patched = true;
+			}
 		}
 		if (!patched) return React.createElement(Comp, renderProps);
 		return React.createElement(Comp, {

package/dist/spec/cell.d.ts

@@ -0,0 +1,171 @@
+import { ConfigEdit } from "../framework/config-op.js";
+import { Ref } from "../framework/utils/refs.js";
+import { Config } from "../framework/Config.js";
+import { IndexedPreviewCondition } from "../framework/projections.js";
+import { PreviewElement } from "./preview-elements.js";
+import { PreviewContentAddress, PreviewValueSource } from "./preview-content.js";
+import { Slot, SlotCell } from "./slot.js";
+import { SurfacePropCondition } from "../framework/prop-surface.js";
+
+//#region src/spec/cell.d.ts
+/**
+ * The stored condition in force for a layer at a cell: a style rule or a preview entry, keyed as
+ * stored. Styles and content authored at the cell both write under it.
+ */
+interface GoverningCondition {
+  readonly source: 'style' | 'preview';
+  readonly key: string;
+  /** The condition as leaves: a stored ref reads as the value name it points at. */
+  readonly when: Record<string, unknown>;
+}
+declare class Cell {
+  private readonly config;
+  /** The component the cell shows. */
+  readonly component: string;
+  /** The axis values the cell pins; empty for the component's own row. */
+  readonly coordinate: SlotCell;
+  private memoDefaults;
+  private memoConditional;
+  private memoProps;
+  private memoEntry;
+  private memoHolding;
+  private memoOwn;
+  private memoOwnConditions;
+  private readonly slotViews;
+  /** Built by {@link cellAt}; a surface reaches one through `Component.cell`. */
+  constructor(config: Config, component: string, coordinate: SlotCell);
+  /** What every cell starts from: the declared defaults, `defaultProps`, then the `*` preview entry. */
+  get defaults(): Record<string, unknown>;
+  /** What the conditional `preview` entries that hold for this cell add, later entries over earlier. */
+  get conditional(): Record<string, unknown>;
+  /** The values in force: the defaults, what holds for the cell, then the coordinate itself. */
+  get props(): Record<string, unknown>;
+  /** The `preview` entry whose condition is exactly this coordinate, or `undefined`. */
+  get entry(): IndexedPreviewCondition | undefined;
+  /** The conditional `preview` entries that hold for this cell, in stored order. */
+  get holding(): IndexedPreviewCondition[];
+  /**
+   * The props this cell shows as its own: the ones a condition reveals under its values, and the
+   * ones its holding preview entries set. What every cell shares belongs to the component's own
+   * row, so a cell repeats none of it.
+   */
+  get own(): ReadonlySet<string>;
+  /**
+   * The conditions the own props are shown under, each once. A gated prop is shown under its own
+   * `when`, which can be wider than the cell (`type = color` on a `color, xs` cell). A prop the
+   * cell's preview pins has no `when` of its own, so the coordinate is what shows it.
+   */
+  get ownConditions(): readonly SurfacePropCondition[];
+  /** Whether the coordinate is the component's defaults, so its preview is every tile's. A forced
+   *  modifier is a state the defaults never show, so a cell with one is not the defaults. */
+  isDefaults(modifiers?: readonly string[]): boolean;
+  /** Whether a stored condition holds at this cell, by the same test a style rule is applied with. */
+  holds(when: Record<string, unknown> | null | undefined): boolean;
+  /**
+   * The condition in force for `layer` at this cell, or `null` when only the base holds and an edit
+   * is this cell's alone.
+   *
+   * The candidates are the conditions that hold here and speak only of the axes the coordinate pins,
+   * so a reach can be spelled as cells of the grid: the style rules whose bag names the layer, the
+   * preview entries that set a prop routed into the layer, and every preview entry holding at the
+   * cell, since an entry such as `type = color` is what defines that row. A condition with a list
+   * value is not a coordinate and is left out. The most specific wins; at equal specificity a
+   * preview entry beats a style rule, since an entry is what defines a row, one that reaches the
+   * layer beats one that does not, and a later stored one beats an earlier.
+   *
+   * A preview content key (`messages__children__2`) names an element a slot's content placed, so the
+   * entries filling that slot are what reach it.
+   */
+  governing(layer?: string | null): GoverningCondition | null;
+  /** The condition an edit to `layer` at this cell writes under: {@link governing}'s, else the
+   *  coordinate itself. */
+  whenFor(layer?: string | null): Record<string, unknown>;
+  /** The stored field the value this cell shows for `prop` comes from, or `undefined` when the
+   *  component stores none. */
+  sourceOf(prop: string): PreviewValueSource | undefined;
+  /** The component's slots, each read and written at this coordinate. */
+  slots(): readonly CellSlot[];
+  /** The slot a prop names, read and written at this coordinate; `undefined` when the prop is not one. */
+  slot(prop: string): CellSlot | undefined;
+  private view;
+}
+/**
+ * A slot as one cell shows it: the route and acceptance of the {@link Slot}, with its content read
+ * and written at the cell's coordinate, so a gesture on a cell never hands the coordinate back.
+ */
+declare class CellSlot {
+  private readonly slot;
+  private readonly coordinate;
+  constructor(slot: Slot, coordinate: SlotCell);
+  get component(): string;
+  /** The prop the content arrives as on the instance. */
+  get from(): string;
+  /** The layer that holds the content. */
+  get layer(): string;
+  /** The prop the content lands under on the layer's element. */
+  get into(): string;
+  /** The refs the slot accepts; empty when unconstrained. */
+  get accepts(): readonly string[];
+  get isChildren(): boolean;
+  /** Whether the slot takes an element — see {@link Slot.takes}. */
+  takes(element: string | Ref): boolean;
+  /** The elements this cell shows in the slot, in order. */
+  get content(): PreviewElement[];
+  /** The stored field this cell reads the content from, or `undefined` when nothing is stored. */
+  get source(): PreviewValueSource | undefined;
+  /** Append to the content under this coordinate — see {@link Slot.append}. */
+  append(element: PreviewElement): ConfigEdit[];
+  /** The content with one element placed at an address — see {@link Slot.placed}. */
+  placed({
+    address,
+    element
+  }: {
+    address: PreviewContentAddress;
+    element: PreviewElement;
+  }): PreviewElement[] | undefined;
+  /** The element at an address — see {@link Slot.elementAt}. */
+  elementAt(address: PreviewContentAddress): PreviewElement | undefined;
+  /** The element at one address moved to another — see {@link Slot.moveAt}. */
+  moveAt({
+    from,
+    to
+  }: {
+    from: PreviewContentAddress;
+    to: PreviewContentAddress;
+  }): ConfigEdit[];
+  /** A copy of the element at an address, placed after it — see {@link Slot.duplicateAt}. */
+  duplicateAt(address: PreviewContentAddress): ConfigEdit[];
+  /** Write one element at an address — see {@link Slot.insertAt}. */
+  insertAt({
+    address,
+    element
+  }: {
+    address: PreviewContentAddress;
+    element: PreviewElement;
+  }): ConfigEdit[];
+  /** Swap one element in place — see {@link Slot.replaceAt}. */
+  replaceAt({
+    address,
+    element
+  }: {
+    address: PreviewContentAddress;
+    element: PreviewElement;
+  }): ConfigEdit[];
+  /** Take one element out — see {@link Slot.removeAt}. */
+  removeAt(address: PreviewContentAddress): ConfigEdit[];
+  /** Store the whole content under this coordinate — see {@link Slot.set}. */
+  set(elements: readonly PreviewElement[]): ConfigEdit[];
+}
+/** The component under a coordinate. Always answers: a path naming no component reads as a cell
+ *  that stores nothing. The same config, path and coordinate hand back the same cell. */
+declare function cellAt({
+  config,
+  path,
+  cell
+}: {
+  config: Config;
+  path: string;
+  cell: SlotCell;
+}): Cell;
+//#endregion
+export { Cell, CellSlot, GoverningCondition, cellAt };