@yahoo/uds-create-config 4.12.1 → 4.14.0

package/dist/entities/system/Component.js

@@ -1,5 +1,5 @@
-import { canonicalCondition, isRef, kindOf, memberOf, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
-import { childrenPolicy } from "./element.js";
+import { canonicalCondition, isRef, kindOf, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
+import { childrenPolicy, forwardedPropName } from "./element.js";
 import { reject, rejectData } from "../../framework/rejection.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
 import { pathInput } from "../../framework/schemas.js";
@@ -213,14 +213,6 @@ const Layer = defineSubEntity({
 * name this component, so a rename cascades and a delete is refused. `'*'` holds no ref and so
 * cannot rot — it tracks a rename for free.
 */
-/** The prop name a forwarding member ref identifies, or `undefined` for any other ref shape. */
-function forwardedPropName(value) {
-	if (!isRef(value) || kindOf(value.__ref) !== "component") return void 0;
-	const member = memberOf(value);
-	if (!member?.startsWith("props/")) return void 0;
-	const name = member.slice(6);
-	return name && !name.includes("/") ? name : void 0;
-}
 const forwardedPropRef = refSchema.check((ctx) => {
 	if (forwardedPropName(ctx.value) !== void 0) return;
 	ctx.issues.push({
@@ -1033,7 +1025,22 @@ const stateCondition = z.strictObject({
 	...test,
 	$state: test.$state.startsWith("/") ? test.$state : `/${test.$state}`
 }));
-const orCondition = z.strictObject({ $or: z.array(z.union([stateCondition, z.array(stateCondition)])) });
+const itemCondition = z.strictObject({
+	$item: z.string(),
+	...comparisonOperands,
+	not: z.literal(true).optional()
+});
+const indexCondition = z.strictObject({
+	$index: z.literal(true),
+	...comparisonOperands,
+	not: z.literal(true).optional()
+});
+const singleCondition = z.union([
+	stateCondition,
+	itemCondition,
+	indexCondition
+]);
+const orCondition = z.strictObject({ $or: z.array(z.union([singleCondition, z.array(singleCondition)])) });
 /**
 * The flat condition an editor collects — `{ variant: 'solid' }` — compiled to the grammar above.
 *
@@ -1072,9 +1079,9 @@ const flatCondition = z.record(z.string(), z.union([
 	return conditions.length === 1 ? conditions[0] : conditions;
 });
 const visibility = z.union([
-	stateCondition,
+	singleCondition,
 	orCondition,
-	z.array(z.union([stateCondition, orCondition])),
+	z.array(z.union([singleCondition, orCondition])),
 	z.literal(false),
 	flatCondition
 ], { error: "a condition is `{ \"$state\": \"<prop>\" }` for a prop that is set, `{ \"$state\": \"<prop>\", \"eq\": \"<value>\" }` for one value of it (`neq`, `gt`, `gte`, `lt`, `lte` and `not: true` also work), `{ \"$or\": [ … ] }` for any of several, a list of conditions that must all hold, or `false` for a position only an interaction shows" });
@@ -1232,6 +1239,10 @@ const AnatomyNode = defineSubEntity({
 				values: anatomyPropValue
 			}) : z.record(z.string(), anatomyPropValue)).optional().describe("Props passed to what the node renders, keyed by prop or style-property name, as literal values. Content is not set here: a `slot` prop's content lands where a `{ \"element\": \"Slot\", \"props\": { \"name\": \"<prop>\" } }` node sits among a parent's `children` (on the root when there is none), and a `forward` prop (`{ \"type\": \"forward\", \"target\": \"label/children\" }`) routes it into that layer with no node entry. `$state` belongs to `visible` and to an `element` a prop chooses."),
 			text: z.string().optional().describe("Literal text content, for a node that renders a fixed string."),
+			repeat: z.strictObject({
+				source: z.unknown(),
+				group: z.string().optional()
+			}).optional().describe("The node renders once per item of a list: `source` is a prop binding (`{ \"$state\": \"/stops\" }`) or a computed value (`{ \"$computed\": \"<function ref>\", \"args\": { … } }`). Inside the node, `{ \"$item\": \"<field>\" }` reads the current item (`\"\"` for the whole item) and `{ \"$index\": true }` its position."),
 			on: nodeActions.optional().describe("What an event on the node does to the state model, in json-render's `on` grammar: `{ \"press\": [{ \"action\": \"setState\", \"params\": { \"statePath\": \"/checked\", \"value\": … } }] }`. Read off the render's own handlers; a preview runs them so the composition responds as the component does.")
 		};
 		if (!config || !body) return z.object({

package/dist/entities/system/element.d.ts

@@ -1,17 +1,6 @@
 import { Config } from "../../framework/Config.js";
 
 //#region src/entities/system/element.d.ts
-/**
- * A component's forwarded layers, as `{ [layer]: '*' | Ref[] }` — the ONE reader of the field.
- *
- * A field read directly is a field that has to be found again when its shape changes; there were six
- * such callers once, and three read it raw.
- *
- * It used to fall back to `inherits`, the pre-migration spelling, read as `{ [layer]: '*' }`. That
- * reader is gone: `v1-artifact` folds a v1 config straight to `forwards`, so nothing mints the old
- * field, and a stored config still carrying it now forwards nothing rather than being quietly
- * translated. Deliberate — one name for one concept beats two where the second is invisible.
- */
 declare function forwardsOf(body: {
   forwards?: Record<string, unknown> | undefined;
 }): Record<string, unknown>;

package/dist/entities/system/element.js

@@ -1,4 +1,4 @@
-import { memberOf, splitRef } from "../../framework/utils/refs.js";
+import { isRef, kindOf, memberOf, splitRef } from "../../framework/utils/refs.js";
 //#region src/entities/system/element.ts
 /** The path a value points at when it's a ref to a component, else `undefined`. */
 function componentPathOf(value) {
@@ -18,6 +18,15 @@ function componentPathOf(value) {
 * field, and a stored config still carrying it now forwards nothing rather than being quietly
 * translated. Deliberate — one name for one concept beats two where the second is invisible.
 */
+/** The prop name a forwarding member ref identifies (`component:Input#props/disabled` → `disabled`),
+*  or `undefined` for any other ref shape. */
+function forwardedPropName(value) {
+	if (!isRef(value) || kindOf(value.__ref) !== "component") return void 0;
+	const member = memberOf(value);
+	if (!member?.startsWith("props/")) return void 0;
+	const name = member.slice(6);
+	return name && !name.includes("/") ? name : void 0;
+}
 function forwardsOf(body) {
 	return body.forwards ?? {};
 }
@@ -170,4 +179,4 @@ function partsOf(config, path) {
 	return config.list("component").filter((item) => ownerOf(config, item.path) === path).map((item) => item.path);
 }
 //#endregion
-export { VOID_ELEMENTS, childrenPolicy, forwardsOf, ownerOf, partsOf, renderedElement, renderedTarget, rootLayerOf };
+export { VOID_ELEMENTS, childrenPolicy, forwardedPropName, forwardsOf, ownerOf, partsOf, renderedElement, renderedTarget, rootLayerOf };

package/dist/framework/Config.d.ts

@@ -72,7 +72,7 @@ interface RecordedSource {
  * The dense-counter `2` a short-lived scheme stamped before the chain existed reads as the mint
  * that replaced it (see `detectedWireVersion`).
  */
-declare const SERIALIZED_CONFIG_VERSION = 20260923005318;
+declare const SERIALIZED_CONFIG_VERSION = 20260923112910;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;

package/dist/framework/Config.js

@@ -4836,7 +4836,7 @@ var Config = class Config {
 	*  links from the provided sources. A declared `linkedKind` with no provided source throws. */
 	hydrateFrom(stored, options) {
 		const claimed = schemaVersionOf(stored);
-		if (claimed > 20260923005318) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20260923112910) throw new SchemaVersionTooNew(claimed);
 		const wire = upgradeSerializedConfig(stored);
 		if (!Array.isArray(wire.ownedKinds) || typeof wire.items !== "object" || wire.items === null) throw new ConfigFormatError(`Config "${stored.name ?? "system-config"}" cannot be hydrated: this is not a serialized config-v2 config (no "ownedKinds"/"items"). A pre-cutover build artifact converts through the registered cutover migration — import the config type's module (e.g. \`configs/system\`) before hydrating, or port the repo once with \`uds migrate\`.`);
 		const leftover = wire.options;

package/dist/framework/projections.js

@@ -1,5 +1,5 @@
 import { isRef, kindOf, memberOf, pathOf, ref, refLeaf, sourceOf, splitRef } from "./utils/refs.js";
-import { forwardsOf } from "../entities/system/element.js";
+import { forwardedPropName, forwardsOf } from "../entities/system/element.js";
 import { classPrefixOf, varPrefixOf } from "../entities/system/Settings.js";
 import { isDerivedColor, isGradient, renderDerivedColor, renderGradient } from "../entities/system/color.js";
 import { fontFamilyStack } from "../entities/system/Font.js";
@@ -799,13 +799,22 @@ function computeComponentProps(config, path, seen) {
 		const element = body.layers?.[layer];
 		if (!isRef(element)) continue;
 		const exposed = resolveComponentProps(config, pathOf(element.__ref), new Set(seen));
-		const taken = entry === "*" ? exposed : Object.fromEntries((Array.isArray(entry) ? entry : []).map((r) => isRef(r) ? memberOf(r)?.split("/").pop() : void 0).filter((name) => !!name && name in exposed).map((name) => [name, exposed[name]]));
-		for (const [name, decl] of Object.entries(taken)) if (!(name in merged)) merged[name] = decl;
+		for (const [name, decl] of Object.entries(takenByForward({
+			entry,
+			exposed
+		}))) if (!(name in merged)) merged[name] = decl;
 	}
 	for (const [name, prop] of Object.entries(body.props ?? {})) if (prop === null) delete merged[name];
 	else merged[name] = prop;
 	return merged;
 }
+/** The props a `forwards` entry takes from what its element exposes: `'*'` is the whole surface, a
+*  list is an allowlist of the names it spells. A list never subtracts, which is what a `null` own
+*  prop is for. */
+function takenByForward({ entry, exposed }) {
+	if (entry === "*") return exposed;
+	return Object.fromEntries((Array.isArray(entry) ? entry : []).map(forwardedPropName).filter((name) => !!name && name in exposed).map((name) => [name, exposed[name]]));
+}
 /**
 * Which component actually declared one of a component's resolved props — its ultimate owner.
 *
@@ -835,7 +844,7 @@ function propOwner(config, path, prop, seen = /* @__PURE__ */ new Set()) {
 	for (const [layer, entry] of Object.entries(forwardsOf(body))) {
 		const element = body.layers?.[layer];
 		if (!isRef(element)) continue;
-		if (Array.isArray(entry) && !entry.some((r) => isRef(r) && memberOf(r)?.split("/").pop() === prop)) continue;
+		if (Array.isArray(entry) && !entry.some((r) => forwardedPropName(r) === prop)) continue;
 		const owner = propOwner(config, pathOf(element.__ref), prop, new Set(seen));
 		if (owner) return owner;
 	}
@@ -1210,4 +1219,4 @@ function declaredPropDefaults(props) {
 	return out;
 }
 //#endregion
-export { authoredBag, authoredValue, className, cssPropValue, cssVar, cssVarRef, declaredPropDefaults, declaredPropRouting, glyphComponentOf, glyphLibrariesOf, glyphPropsOf, glyphPropsOfBody, holdingPreviewConditions, iconToolAxisOptions, iconToolOf, keyedPreviewConditions, memberFromLeaf, memberLeaves, negatedCssValue, opacityPercentage, previewConditionalProps, previewConditions, previewDefaults, previewMatrix, propOwner, propValueDomain, propValueFromAxis, refListOf, renderStyleValue, resolveComponentProps, resolveFieldValue, resolveTokenValue, resolveTokenValueUnder, routedBag, sourceVarPrefix, styleAliasesOf, styleDeclarations, stylePropEntries, stylePropLeafForToken, stylePropNegates, stylePropTokenGroup, stylePropTokenPath, stylePropTokenValues, stylePropValueFromLeaf, stylePropValueLeaves, stylePropValues, stylePropertiesWriting, stylePropertyAccepts, stylePropertyFor, stylePropertyPathFor, validateComponentProps };
+export { authoredBag, authoredValue, className, cssPropValue, cssVar, cssVarRef, declaredPropDefaults, declaredPropRouting, glyphComponentOf, glyphLibrariesOf, glyphPropsOf, glyphPropsOfBody, holdingPreviewConditions, iconToolAxisOptions, iconToolOf, keyedPreviewConditions, memberFromLeaf, memberLeaves, negatedCssValue, opacityPercentage, previewConditionalProps, previewConditions, previewDefaults, previewMatrix, propOwner, propValueDomain, propValueFromAxis, refListOf, renderStyleValue, resolveComponentProps, resolveFieldValue, resolveTokenValue, resolveTokenValueUnder, routedBag, sourceVarPrefix, styleAliasesOf, styleDeclarations, stylePropEntries, stylePropLeafForToken, stylePropNegates, stylePropTokenGroup, stylePropTokenPath, stylePropTokenValues, stylePropValueFromLeaf, stylePropValueLeaves, stylePropValues, stylePropertiesWriting, stylePropertyAccepts, stylePropertyFor, stylePropertyPathFor, takenByForward, validateComponentProps };

package/dist/framework/prop-surface.d.ts

@@ -147,7 +147,30 @@ interface ForwardClaims {
   readonly own: ReadonlySet<string>;
   /** Forwarded name → the layer whose entry delivers it. The first entry in key order wins an overlap. */
   readonly forwarded: ReadonlyMap<string, string>;
+  /** Own declarations that change the type of a name a forwards entry offers, one row per prop. */
+  readonly shadowed: readonly ShadowedForward[];
+}
+interface ShadowedForward {
+  readonly component: string;
+  readonly prop: string;
+  /** The layer whose entry would have delivered the prop, and that layer's element with its source. */
+  readonly layer: string;
+  readonly element: string;
+  /** How this component declares the prop (`variant`, `string`, …). */
+  readonly declared: string;
+  /** How the layer's element declares it. */
+  readonly forwarded: string;
 }
 declare function forwardClaims(config: Config, componentPath: string): ForwardClaims;
+/** A component's own props that redeclare, as another type, a name a `forwards` entry offers. The
+ *  own declaration wins, so the element's prop of that name is unreachable through this component
+ *  and a call site's value means something else than it does on the element. */
+declare function shadowedForwards({
+  config,
+  path
+}: {
+  readonly config: Config;
+  readonly path: string;
+}): ShadowedForward[];
 //#endregion
-export { ForwardClaims, SurfaceCompositeProp, SurfaceProp, SurfacePropCondition, SurfacePropKind, SurfaceScalarProp, SurfaceSlotProp, SurfaceStylePropertyProp, SurfaceVariantProp, forwardClaims, forwardedLayers, intoName, propApplies, propRegistryRef, routedProp, routedPropIn, routesContent, surfaceProp, surfaceProps };
+export { ForwardClaims, ShadowedForward, SurfaceCompositeProp, SurfaceProp, SurfacePropCondition, SurfacePropKind, SurfaceScalarProp, SurfaceSlotProp, SurfaceStylePropertyProp, SurfaceVariantProp, forwardClaims, forwardedLayers, intoName, propApplies, propRegistryRef, routedProp, routedPropIn, routesContent, shadowedForwards, surfaceProp, surfaceProps };

package/dist/framework/prop-surface.js

@@ -1,6 +1,6 @@
-import { isRef, kindOf, memberOf, pathOf, refLeaf } from "./utils/refs.js";
+import { isRef, kindOf, memberOf, pathOf, refLeaf, splitRef } from "./utils/refs.js";
 import { forwardsOf, rootLayerOf } from "../entities/system/element.js";
-import { propValueDomain, refListOf, resolveComponentProps } from "./projections.js";
+import { propValueDomain, refListOf, resolveComponentProps, takenByForward } from "./projections.js";
 import { Component } from "../entities/system/Component.js";
 //#region src/framework/prop-surface.ts
 /**
@@ -302,9 +302,12 @@ function computeForwardClaims(config, componentPath) {
 	const body = Component.get(config, componentPath)?.toJSON();
 	const own = /* @__PURE__ */ new Set();
 	const forwarded = /* @__PURE__ */ new Map();
+	const shadowed = [];
+	const seenShadow = /* @__PURE__ */ new Set();
 	if (!body) return {
 		own,
 		forwarded,
+		shadowed,
 		rootLayer: void 0
 	};
 	const { layers = {}, props = {}, forwards } = body;
@@ -313,19 +316,42 @@ function computeForwardClaims(config, componentPath) {
 	for (const [layer, entry] of Object.entries(forwardsOf({ forwards }))) {
 		const element = layers[layer];
 		if (!isRef(element)) continue;
-		const exposed = resolveComponentProps(config, pathOf(element.__ref));
-		const names = entry === "*" ? Object.keys(exposed) : (Array.isArray(entry) ? entry : []).map((ref) => isRef(ref) ? memberOf(ref)?.split("/").pop() : void 0).filter((name) => !!name && name in exposed);
-		for (const name of names) {
-			if (own.has(name) || forwarded.has(name)) continue;
+		const taken = takenByForward({
+			entry,
+			exposed: resolveComponentProps(config, pathOf(element.__ref))
+		});
+		for (const [name, theirs] of Object.entries(taken)) {
+			if (own.has(name)) {
+				if (seenShadow.has(name)) continue;
+				seenShadow.add(name);
+				const declared = declaredTypeOf(props[name]);
+				const forwardedType = declaredTypeOf(theirs);
+				if (props[name] === null || declared === "forward" || declared === forwardedType) continue;
+				shadowed.push({
+					component: componentPath,
+					prop: name,
+					layer,
+					element: splitRef(element.__ref).qualifiedPath,
+					declared,
+					forwarded: forwardedType
+				});
+				continue;
+			}
+			if (forwarded.has(name)) continue;
 			forwarded.set(name, layer);
 		}
 	}
 	return {
 		own,
 		forwarded,
+		shadowed,
 		rootLayer
 	};
 }
+function declaredTypeOf(decl) {
+	const type = decl?.type;
+	return typeof type === "string" ? type : "unknown";
+}
 /**
 * Each non-root layer a component forwards to, and the sorted prop names each one receives — the
 * emitter's view, which writes a literal key set per layer. Root is absent on purpose: it takes
@@ -344,11 +370,18 @@ function forwardedLayers(config, componentPath) {
 	return out;
 }
 function forwardClaims(config, componentPath) {
-	const { own, forwarded } = computeForwardClaims(config, componentPath);
+	const { own, forwarded, shadowed } = computeForwardClaims(config, componentPath);
 	return {
 		own,
-		forwarded
+		forwarded,
+		shadowed
 	};
 }
+/** A component's own props that redeclare, as another type, a name a `forwards` entry offers. The
+*  own declaration wins, so the element's prop of that name is unreachable through this component
+*  and a call site's value means something else than it does on the element. */
+function shadowedForwards({ config, path }) {
+	return computeForwardClaims(config, path).shadowed;
+}
 //#endregion
-export { forwardClaims, forwardedLayers, intoName, propApplies, propRegistryRef, routedProp, routedPropIn, routesContent, routesIntoText, surfaceProp, surfaceProps };
+export { forwardClaims, forwardedLayers, intoName, propApplies, propRegistryRef, routedProp, routedPropIn, routesContent, routesIntoText, shadowedForwards, surfaceProp, surfaceProps };

package/dist/framework/render-spec.d.ts

@@ -1,5 +1,5 @@
 import { Config } from "./Config.js";
-import { StateCondition } from "@json-render/core";
+import { ComputedFunction, StateCondition } from "@json-render/core";
 
 //#region src/framework/render-spec.d.ts
 /** A node in a flat render spec — json-render's own shape, which is what a canvas paints.
@@ -30,6 +30,44 @@ interface ComponentSpecs {
   readonly render?: RenderSpec;
   readonly preview?: RenderSpec;
 }
+/**
+ * A node the render writes once per item of a list (`visiblePages.map((item, index) => …)`).
+ * `source` is the list: a prop's binding (`{ $state: '/stops' }`) or a value a module-scope function
+ * computes from props (`{ $computed, args }`). `group` names the `.map` the node came from, so the
+ * arms of one map (`item === 'ellipsis' ? <Gap/> : <Cell/>`) unroll together in item order. Inside
+ * the node, `{ $item: '<field>' }` reads the current item (`''` for the whole item) and
+ * `{ $index: true }` its position, in json-render's own grammar. Where the expansion cannot settle
+ * the list, the node emits once as the example row.
+ */
+interface RepeatSpec {
+  readonly source: unknown;
+  readonly group?: string;
+}
+/** A value a module-scope function computes at paint time from values the cell supplies: json-render's
+ *  `$computed`, naming the function by ref (`file:src/…/pagination.tsx#computeVisiblePages`). `args`
+ *  are keyed by the function's parameter names and resolved before the call. */
+interface ComputedValue {
+  readonly $computed: string;
+  readonly args?: Record<string, unknown>;
+}
+/** The functions `$computed` values call, by ref — what a preview bundle registers and an
+ *  expansion or renderer is handed. */
+type ComputedFunctions = Record<string, ComputedFunction>;
+/** The current item of a repeated node while its row is emitted. */
+interface RepeatRow {
+  readonly item: unknown;
+  readonly index: number;
+}
+/** What settling a value needs beyond the prop bag: the functions `$computed` may call and, inside
+ *  a repeated node, the current row. */
+interface ResolveContext {
+  readonly functions?: ComputedFunctions;
+  readonly row?: RepeatRow;
+  /** Read a bare `$state` binding as its value. Off for an element's props, where a binding is
+   *  left for the renderer (and where fill routing reads it); on inside a `$computed`'s arguments
+   *  and a repeat's source, which have to be values before the call. */
+  readonly settle?: boolean;
+}
 /**
  * The registry key of an element rendered THROUGH a package factory — `motion.create(Box)`, spelled
  * `package:motion/react#motion(component:Box)`.
@@ -165,6 +203,9 @@ interface ExpandOptions {
    * with no registry to consult gets.
    */
   readonly rendered?: ReadonlySet<string>;
+  /** The functions `$computed` values call. Absent, a computed value stays on the element for the
+   *  renderer, and a node repeated over a computed list emits once. */
+  readonly functions?: ComputedFunctions;
 }
 interface ExpansionResult {
   readonly spec: RenderSpec;
@@ -190,7 +231,8 @@ interface ExpansionResult {
  * A condition that does not resolve is left exactly as it was, so nothing is claimed about it.
  */
 declare function specWithResolvedVisibility(spec: RenderSpec, state: Record<string, unknown>, options?: {
-  /** Props the renderer keeps deciding at paint time — a choice reading one is left as it is. */readonly live?: ReadonlySet<string>;
+  /** Props the renderer keeps deciding at paint time — a choice reading one is left as it is. */readonly live?: ReadonlySet<string>; /** The functions `$computed` values call; absent, a computed value is left for the renderer. */
+  readonly functions?: ComputedFunctions;
 }): RenderSpec;
 /** The comparison a `$state` test can make: json-render's own operator set, minus the state pointer
  *  and the `not` modifier. Typed off the library so an operator it adds is a typecheck failure here
@@ -254,7 +296,14 @@ declare function anatomyElementComponent({
 }): string | undefined;
 /** A value in json-render's `visible` grammar, resolved against a prop bag. `undefined` when this
  *  reader can't settle it, which leaves the condition on the element for the renderer to judge. */
-declare function resolveVisibility(condition: unknown, state: Record<string, unknown>): boolean | undefined;
+declare function resolveVisibility(condition: unknown, state: Record<string, unknown>, context?: ResolveContext): boolean | undefined;
+/**
+ * A value settled against a prop bag as far as this reader can: a `$state` reads the bag, `$item`
+ * and `$index` the current row, `$cond` picks its arm, `$computed` calls its function when the
+ * expansion has it and every argument settled, and a plain object or list settles member by member.
+ * Whatever cannot be settled is returned as written, for the renderer.
+ */
+declare function resolveValue(value: unknown, state: Record<string, unknown>, context?: ResolveContext): unknown;
 /**
  * Which PROPS a `visible` condition reads, in the order they appear.
  *
@@ -424,4 +473,4 @@ declare function expandSpec(config: Config, spec: RenderSpec, options?: ExpandOp
  */
 declare function expandComponent(config: Config, path: string, props?: Record<string, unknown>, options?: ExpandOptions): ExpansionResult;
 //#endregion
-export { ANATOMY_MARKER, ComponentSpec, ComponentSpecs, ExpandOptions, ExpansionResult, RenderElement, RenderSpec, SlotTarget, VisibilityOperator, VisibilityTerm, anatomyElementComponent, anatomyTextProp, boundElementType, componentSpec, deriveSpec, entryKeyOf, expandComponent, expandSpec, instanceSpec, layerTextProp, liveStateProps, previewSpec, propInto, propsIntoLayer, readStatePointer, resolveVisibility, routeOf, slotTargetsOf, specWithResolvedVisibility, statePointerProp, valueForwardsOf, visibilityStateProps, visibilityTerms, withoutTruthyTerm, wrappedElementKey };
+export { ANATOMY_MARKER, ComponentSpec, ComponentSpecs, ComputedFunctions, ComputedValue, ExpandOptions, ExpansionResult, RenderElement, RenderSpec, RepeatRow, RepeatSpec, ResolveContext, SlotTarget, VisibilityOperator, VisibilityTerm, anatomyElementComponent, anatomyTextProp, boundElementType, componentSpec, deriveSpec, entryKeyOf, expandComponent, expandSpec, instanceSpec, layerTextProp, liveStateProps, previewSpec, propInto, propsIntoLayer, readStatePointer, resolveValue, resolveVisibility, routeOf, slotTargetsOf, specWithResolvedVisibility, statePointerProp, valueForwardsOf, visibilityStateProps, visibilityTerms, withoutTruthyTerm, wrappedElementKey };