@yahoo/uds-create-config 4.36.0 → 4.37.0

package/dist/entities/system/style-bag.d.ts

@@ -1,3 +1,6 @@
+import { SubEntityClass } from "../../framework/defineSubEntity.js";
+import { RegisteredModifiers, RegisteredStyleProps } from "../../framework/registered.js";
+import { Named } from "../../framework/named.js";
 import { ComposedValue } from "./composed-values.js";
 import { z } from "zod";
 
@@ -16,5 +19,28 @@ type StyleValue = string | number | boolean | {
 } | ComposedValue | {
   readonly [key: string]: StyleValue;
 };
+/**
+ * A style bag as a keyed COLLECTION — style-prop key → {@link styleValue}, with each key a member
+ * in its own right.
+ *
+ * Being a sub-entity is what makes a per-declaration edit addressable: setting `boxShadow` names
+ * `boxShadow`, rather than being an update of the whole bag that first has to read the current one
+ * to avoid erasing its siblings. It also gives the bag a rename that keeps a key's position, which
+ * matters because key order is declaration order in the emitted rule — for a shorthand/longhand
+ * pair, moving one changes what gets painted.
+ */
+declare const StyleDefinition: SubEntityClass<z.ZodType<StyleValue, unknown, z.core.$ZodTypeInternals<StyleValue, unknown>>>;
+interface StyleClass extends Named<typeof StyleDefinition> {}
+/** The style props the system registers, each taking any value a bag stores. */
+type RegisteredStyleBag = { [K in keyof RegisteredStyleProps]?: StyleValue };
+/**
+ * A bag as a config file writes one when nothing but style props and modifiers may key it: the style
+ * props the system registers, and a `_modifier` block of the same. Open until the build has filled
+ * `RegisteredStyleProps`, since before that no key can be told from a style prop.
+ */
+type AuthoredStyleBag = [keyof RegisteredStyleProps] extends [never] ? Record<string, StyleValue> : RegisteredStyleBag & { [M in keyof RegisteredModifiers]?: RegisteredStyleBag };
+/** {@link Style} as a field whose authored input is an {@link AuthoredStyleBag}. The stored value is
+ *  unchanged. */
+type AuthoredStyleField = z.ZodType<z.output<StyleClass>, AuthoredStyleBag>;
 //#endregion
-export { StyleValue };
+export { AuthoredStyleBag, AuthoredStyleField, RegisteredStyleBag, StyleClass, StyleValue };

package/dist/entities/system/style-bag.js

@@ -32,16 +32,6 @@ const anatomyPropValue = z.lazy(() => z.union([
 	])),
 	z.record(z.string(), anatomyPropValue)
 ]));
-/**
-* A style bag as a keyed COLLECTION — style-prop key → {@link styleValue}, with each key a member
-* in its own right.
-*
-* Being a sub-entity is what makes a per-declaration edit addressable: setting `boxShadow` names
-* `boxShadow`, rather than being an update of the whole bag that first has to read the current one
-* to avoid erasing its siblings. It also gives the bag a rename that keeps a key's position, which
-* matters because key order is declaration order in the emitted rule — for a shorthand/longhand
-* pair, moving one changes what gets painted.
-*/
 const Style = defineSubEntity({
 	name: "style",
 	label: "Style",

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 = 20260925143319;
+declare const SERIALIZED_CONFIG_VERSION = 20260928180801;
 interface SerializedConfig {
   /** See {@link SERIALIZED_CONFIG_VERSION}. Always written; a stored artifact may lack it. */
   readonly version: number;
@@ -2056,9 +2056,12 @@ declare class Config {
    */
   private computeSourceClosure;
   /**
-   * A refusal for a pin patch whose derive pass would retire a minted row that something authored
-   * here still points at. A minted row has no body of its own, so once it goes the referrer dangles;
+   * A refusal for a patch whose derive pass would retire a minted row that something authored here
+   * still points at. A minted row has no body of its own, so once it goes the referrer dangles;
    * copying what is used, or breaking the link with `keep`, is how the value stays.
+   *
+   * `action` names what is refused, after "Cannot": a pin patch removes the link, and any other patch
+   * that reaches derivation — a deleted extension whose source reached the row — says what it did.
    */
   private assertDerivedDropsUnreferenced;
   /**
@@ -2089,6 +2092,8 @@ declare class Config {
    * system's namespace, which this config has no `@slug` for and no claim on.
    */
   withDerivedRows(): this;
+  /** {@link withDerivedRows} for a derivation already in hand. */
+  private withRowsOf;
   /**
    * The rows an edit changes, derived inside that edit's own apply.
    *
@@ -2411,6 +2416,17 @@ declare class Config {
   /** Every `kind:path` whose definition references the given entity — the reverse
    *  dependency graph, harvested generically from refs in each item's data. */
   dependentsOf(kind: string, path: string, opts?: TraverseOptions): string[];
+  /**
+   * The dependents of `kind:path` that use it only through a source: rows here that point whole at a
+   * source entity which, in that source, points at `kind:path`. A rename's cascade can't rewrite
+   * them, since the body that names the path is the source's.
+   *
+   * A pointer row's body lives in its source, so the index here holds only the pointer. Each source's
+   * own index answers what its bodies name, and a source's bare ref means the path here, so each
+   * referrer there comes back as the rows here pointing at it: the row the link minted, or an
+   * extension of it. A source's pins are its own, so a pin here has none of these.
+   */
+  sourceDependentsOf(kind: string, path: string, opts?: TraverseOptions): string[];
   /** The inverse: what `kind:path` needs in order to resolve. `{ transitive: true }` returns the
    *  whole closure — what a sealed/exported copy would have to carry along with it. */
   dependenciesOf(kind: string, path: string, opts?: TraverseOptions): string[];

package/dist/framework/Config.js

@@ -564,6 +564,15 @@ function rekeyAt(node, path, from, to) {
 	};
 }
 /** Whether `ref` names a row or folder the build minted, at the item or group the snapshot holds. */
+/** What a refused edit of several patches is called. */
+const EDIT_ACTION = "make this edit";
+/** What an edit does, for a refusal that begins "Cannot": `delete component:Mine` for one patch. */
+function actionOf(patches) {
+	const list = Array.isArray(patches) ? patches : [patches];
+	const [only] = list;
+	if (list.length !== 1 || !only || !("path" in only)) return EDIT_ACTION;
+	return `${only.operation} ${only.kind}:${only.path}`;
+}
 function isMintedAt(snapshot, ref) {
 	const kind = kindOf(ref);
 	const path = pathOf(ref);
@@ -1218,7 +1227,7 @@ var Config = class Config {
 			deferred.reached = true;
 			return applied;
 		}
-		return applied.derivedForEdit();
+		return applied.derivedForEdit(actionOf(patch));
 	}
 	/**
 	* `run` with each kind's invariants judged once, on the config it returns, rather than after every
@@ -1245,7 +1254,8 @@ var Config = class Config {
 			deferred.open = false;
 			const settled = result.derive({ deferredInvariants: void 0 });
 			settled.assertInvariantsOf(settled.state.snapshot, deferred.kinds);
-			return deferred.reached ? settled.derivedForEdit() : settled;
+			if (!deferred.reached) return settled;
+			return settled.derivedForEdit(EDIT_ACTION);
 		} catch {
 			deferred.open = false;
 			return run(this);
@@ -1319,11 +1329,12 @@ var Config = class Config {
 			};
 			const landed = settled();
 			const edits = patches.filter((patch) => !this.entityOf(patch.kind)?.sourceIdentity);
-			return edits.length > 0 && this.reachesDerivation({
+			if (!(edits.length > 0 && this.reachesDerivation({
 				patches: edits,
 				before: this.state.snapshot,
 				after: landed.state.snapshot
-			}) ? landed.derivedForEdit() : landed;
+			}))) return landed;
+			return landed.derivedForEdit(actionOf(edits));
 		}
 		const land = (checked) => {
 			let config = checked ? this : this.derive({ snapshot: this.state.snapshot.drafting() });
@@ -1340,11 +1351,12 @@ var Config = class Config {
 			}
 		};
 		const config = settle().derive({ pending: [...this.state.pending, ...patches.map(stampOf)] });
-		return this.reachesDerivation({
+		if (!this.reachesDerivation({
 			patches,
 			before: this.state.snapshot,
 			after: config.state.snapshot
-		}) ? config.derivedForEdit() : config;
+		})) return config;
+		return config.derivedForEdit(actionOf(patches));
 	}
 	/**
 	* Whether patches on kinds that name no source can change the rows a derive mints between `before`
@@ -3932,20 +3944,23 @@ var Config = class Config {
 		return [...reached].sort();
 	}
 	/**
-	* A refusal for a pin patch whose derive pass would retire a minted row that something authored
-	* here still points at. A minted row has no body of its own, so once it goes the referrer dangles;
+	* A refusal for a patch whose derive pass would retire a minted row that something authored here
+	* still points at. A minted row has no body of its own, so once it goes the referrer dangles;
 	* copying what is used, or breaking the link with `keep`, is how the value stays.
+	*
+	* `action` names what is refused, after "Cannot": a pin patch removes the link, and any other patch
+	* that reaches derivation — a deleted extension whose source reached the row — says what it did.
 	*/
-	assertDerivedDropsUnreferenced() {
+	assertDerivedDropsUnreferenced({ action = "remove the link", derivation = this.rowDerivation() } = {}) {
 		const { snapshot } = this.state;
 		const stranded = [];
-		for (const change of this.rowDerivation().changes) {
+		for (const change of derivation.changes) {
 			if (change.value !== void 0) continue;
 			const referrers = this.referrersOf(snapshot, change.kind, change.path).filter((referrer) => !isMintedAt(snapshot, referrer));
 			if (referrers.length > 0) stranded.push(`${change.kind}:${change.path} (used by ${referrers.join(", ")})`);
 		}
 		if (stranded.length === 0) return;
-		reject("REFERRERS_BLOCK", `Cannot remove the link — it would take away ${stranded.join("; ")}. Copy what is used first (\`linked-system/copy\`), or break the link keeping its values (\`linked-system/break\` with \`keep: true\`).`);
+		reject("REFERRERS_BLOCK", `Cannot ${action} — it would take away ${stranded.join("; ")}. Copy what is used first (\`linked-system/copy\`), or break the link keeping its values (\`linked-system/break\` with \`keep: true\`).`);
 	}
 	/**
 	* This config with a row for every entity it inherits — the build's output. A pin patch runs this
@@ -3976,7 +3991,11 @@ var Config = class Config {
 	*/
 	withDerivedRows() {
 		if (derivedInEdit.has(this)) return this;
-		const moved = this.rowDerivation().changes.filter((change) => !this.holdsDerivedRow(change));
+		return this.withRowsOf(this.rowDerivation());
+	}
+	/** {@link withDerivedRows} for a derivation already in hand. */
+	withRowsOf(derived) {
+		const moved = derived.changes.filter((change) => !this.holdsDerivedRow(change));
 		if (moved.length === 0) return this;
 		return this.derive({ snapshot: this.state.snapshot.withChanges(moved) });
 	}
@@ -3987,8 +4006,14 @@ var Config = class Config {
 	* derive passes: this one and the session's. The mark covers this instance only, and any later
 	* write is a new config, so each edit still gets exactly one pass, as it did from the session alone.
 	*/
-	derivedForEdit() {
-		const derived = this.withDerivedRows();
+	derivedForEdit(action) {
+		if (derivedInEdit.has(this)) return this;
+		const derivation = this.rowDerivation();
+		this.assertDerivedDropsUnreferenced({
+			action,
+			derivation
+		});
+		const derived = this.withRowsOf(derivation);
 		derivedInEdit.add(derived);
 		return derived;
 	}
@@ -4819,7 +4844,37 @@ var Config = class Config {
 	/** Every `kind:path` whose definition references the given entity — the reverse
 	*  dependency graph, harvested generically from refs in each item's data. */
 	dependentsOf(kind, path, opts) {
-		return this.referrersOf(this.state.snapshot, kind, path, opts);
+		const own = this.referrersOf(this.state.snapshot, kind, path, opts);
+		const drawn = this.sourceDependentsOf(kind, path, opts);
+		return drawn.length === 0 ? own : [...own, ...drawn];
+	}
+	/**
+	* The dependents of `kind:path` that use it only through a source: rows here that point whole at a
+	* source entity which, in that source, points at `kind:path`. A rename's cascade can't rewrite
+	* them, since the body that names the path is the source's.
+	*
+	* A pointer row's body lives in its source, so the index here holds only the pointer. Each source's
+	* own index answers what its bodies name, and a source's bare ref means the path here, so each
+	* referrer there comes back as the rows here pointing at it: the row the link minted, or an
+	* extension of it. A source's pins are its own, so a pin here has none of these.
+	*/
+	sourceDependentsOf(kind, path, opts) {
+		if (this.entityOf(kind)?.sourceIdentity !== void 0) return [];
+		const { snapshot } = this.state;
+		const own = new Set(this.referrersOf(snapshot, kind, path, opts));
+		const found = /* @__PURE__ */ new Set();
+		for (const slug of this.sourceSlugs()) {
+			const source = this.sourceFor(slug);
+			if (!source) continue;
+			for (const referrer of source.dependentsOf(kind, path, opts)) {
+				const pointer = ref(kindOf(referrer), pathOf(referrer), slug).__ref;
+				for (const row of snapshot.refs.dependents(pointer)) {
+					const body = snapshot.get(kindOf(row), pathOf(row))?.toJSON();
+					if (isRef(body) && body.__ref === pointer && !own.has(row)) found.add(row);
+				}
+			}
+		}
+		return [...found];
 	}
 	/** The inverse: what `kind:path` needs in order to resolve. `{ transitive: true }` returns the
 	*  whole closure — what a sealed/exported copy would have to carry along with it. */
@@ -5080,7 +5135,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 > 20260925143319) throw new SchemaVersionTooNew(claimed);
+		if (claimed > 20260928180801) 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/class-names.js

@@ -529,6 +529,7 @@ function splitStyleProps({ config, bag, through }) {
 			}
 			continue;
 		}
+		if (key.startsWith("_")) continue;
 		const name = stylePropertyPathFor({
 			config,
 			through,

package/dist/framework/defineConfig.d.ts

@@ -44,7 +44,7 @@ type ConfigKind<C> = C extends {
  * elements describes no gesture anyone makes, and a caller replacing one writes the whole list.
  */
 type Matched = any;
-type PartialBodyOf<E> = E extends EntityClass<infer F extends FieldsSchema, FieldsSchema, infer _K, Matched, Matched, Matched> ? DeepPartial<CreateInput<F>> : never;
+type PartialBodyOf<E> = E extends Omit<EntityClass<infer F extends FieldsSchema, FieldsSchema, infer _K, Matched, Matched, Matched>, 'ref'> ? DeepPartial<CreateInput<F>> : never;
 /** Optional at every depth, stopping at refs, arrays and primitives. */
 type DeepPartial<T> = T extends Ref | readonly unknown[] ? T : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
 /**
@@ -68,7 +68,7 @@ declare function kindsOf<T extends readonly {
  *  mean. */
 type RecordFor<E> = E extends {
   readonly singleton: true;
-} ? E extends EntityClass<infer F, FieldsSchema, infer _K, Matched, Matched, true> ? Partial<z.input<F>> : never : E extends EntityClass<infer F, infer G, infer _K, Matched, Matched, Matched> ? Record<string, AuthoredEntry<F, G>> : never;
+} ? E extends Omit<EntityClass<infer F, FieldsSchema, infer _K, Matched, Matched, true>, 'ref'> ? Partial<z.input<F>> : never : E extends Omit<EntityClass<infer F, infer G, infer _K, Matched, Matched, Matched>, 'ref'> ? Record<string, AuthoredEntry<F, G>> : never;
 /**
  * What a config DRAWS ON — keyed by the accessor name of the kind whose items ARE the sources, valued
  * by a thunk yielding the config type each one resolves to.

package/dist/framework/defineEntity.d.ts

@@ -69,13 +69,26 @@ type GroupRead<F extends FieldsSchema, G extends FieldsSchema, GC extends GroupC
   path: string;
   meta: GroupBody<F, G> & GroupComputedValues<GC>;
 };
+/** An entity's op table as the type level holds it: each op's `input` schema and nothing else, which
+ *  is all {@link OpInput} reads. */
+type OpInputTable = Readonly<Record<string, {
+  readonly input?: z.ZodTypeAny;
+}>>;
+/** The {@link OpInputTable} of an op table as written. */
+type OpInputsOf<S extends UserSchemas> = { readonly [V in keyof S as S[V] extends {
+  input: z.ZodTypeAny;
+} ? V : never]: S[V] extends {
+  input: infer I extends z.ZodTypeAny;
+} ? {
+  readonly input: I;
+} : never };
 type EntityClass<F extends FieldsSchema, G extends FieldsSchema,
 /** The kind as a literal, so `ref` can narrow to the paths a consumer's config declares. Defaults
  *  to `string`, which is what every 2-argument use of this type keeps getting. */
 K extends string = string,
-/** The op schemas as written, so a consumer can infer an operation's input type off the entity
+/** Each op's input schema, so a consumer can infer an operation's input type off the entity
  *  instead of restating it. See {@link OpInput}. */
-S extends UserSchemas = UserSchemas,
+S extends OpInputTable = OpInputTable,
 /** The kind's `computed` map as written, so `Token.get(...).link` is typed off the function that
  *  produces it rather than restated. Defaults to none. */
 C extends ComputedFields = Record<never, never>,
@@ -94,7 +107,8 @@ GI extends GroupInputs = Record<never, never>> = Omit<RefSchema, 'extend'> & {
    *  it, but methods compare bivariantly and a required parameter matches an optional one. */
   readonly singleton: Single;
   /**
-   * The entity's own op schemas, at the type level.
+   * The entity's own op input schemas, at the type level. The value is the full op table; the type
+   * keeps only each op's `input`.
    *
    * Present so `OpInput<typeof Component, 'element-insert'>` resolves. Every consumer that wrote an
    * operation used to hand-declare its input shape — 20 files did, because the zod schema was defined
@@ -165,7 +179,7 @@ GI extends GroupInputs = Record<never, never>> = Omit<RefSchema, 'extend'> & {
    * class must never do the same: its schema is the member shape, and `deriveCreateSchema` really
    * does call zod's `extend` on it.
    */
-  extend<F2 extends ShapeOverride = Record<never, never>, G2 extends ShapeOverride = Record<never, never>, S2 extends UserSchemas = S>(overrides: {
+  extend<F2 extends ShapeOverride = Record<never, never>, G2 extends ShapeOverride = Record<never, never>, S2 extends UserSchemas = never>(overrides: {
     fields?: F2;
     groupFields?: G2;
     subEntities?: Partial<Record<string, SubEntityClass | null>>;
@@ -176,7 +190,7 @@ GI extends GroupInputs = Record<never, never>> = Omit<RefSchema, 'extend'> & {
      *  from the kind can name it — and a source writer that guesses emits the base's class into a
      *  Config that never imported it. See {@link EntityKind.entityName}. */
     entityName?: string;
-  }): EntityClass<ExtendedFields<F, F2>, ExtendedFields<G, G2>, K, S2, C, Single, GC, GI>;
+  }): EntityClass<ExtendedFields<F, F2>, ExtendedFields<G, G2>, K, [S2] extends [never] ? S : OpInputsOf<S2>, C, Single, GC, GI>;
 };
 declare function defineEntity<F extends FieldsSchema, G extends FieldsSchema = z.ZodObject<Record<never, never>>, K extends string = string, const S extends UserSchemas = Record<never, never>, const C extends ComputedFields = Record<never, never>, Single extends boolean = false, const GC extends GroupComputedFields = Record<never, never>, const GI extends GroupInputs = Record<never, never>>(spec: {
   kind: K;
@@ -341,7 +355,13 @@ declare function defineEntity<F extends FieldsSchema, G extends FieldsSchema = z
     element?: unknown;
   }[];
   rewriteName?: (data: unknown, from: string, to: string) => unknown;
-}): EntityClass<F, G, K, S, C, Single, GC, GI>;
+}): EntityClass<F, G, K, { readonly [V in keyof S as S[V] extends {
+  input: z.ZodTypeAny;
+} ? V : never]: S[V] extends {
+  input: infer I extends z.ZodTypeAny;
+} ? {
+  readonly input: I;
+} : never }, C, Single, GC, GI>;
 /**
  * The input type of one of an entity's operations — `OpInput<typeof Component, 'element-insert'>`.
  *
@@ -350,7 +370,7 @@ declare function defineEntity<F extends FieldsSchema, G extends FieldsSchema = z
  * a field the op has no input for: the write is silently dropped, and nothing catches it until a merge.
  */
 type OpInput<E extends {
-  readonly schemas: UserSchemas;
+  readonly schemas: OpInputTable;
 }, V extends keyof E['schemas']> = E['schemas'][V] extends {
   input: infer I extends z.ZodTypeAny;
 } ? z.input<I> : never;

package/dist/framework/named.d.ts

@@ -0,0 +1,9 @@
+//#region src/framework/named.d.ts
+/**
+ * `T` itself, spelled so an interface can extend it: `interface TokenClass extends
+ * Named<typeof TokenDefinition> {}`. Declaration output refers to an interface by name, where an
+ * inferred entity type would be re-expanded, schema and all, at every place it's referenced.
+ */
+type Named<T> = T;
+//#endregion
+export { Named };

package/dist/framework/plan.d.ts

@@ -29,6 +29,9 @@ interface RenamePlan {
   readonly to: string;
   /** Every entity the cascade rewrites: a body holding a ref to the old path, or its name as a key. */
   readonly rewrites: readonly EntityAddress[];
+  /** Rows that use the entity through a source, whose body names it there. The cascade can't rewrite
+   *  them, so after the rename they name a path this config no longer holds. */
+  readonly throughSource: readonly EntityAddress[];
   /** Why the rename would be refused. `undefined` when it would go through. */
   readonly blocked?: string;
 }

package/dist/framework/plan.js

@@ -50,10 +50,13 @@ function planRename({ config, kind, path, to }) {
 		path,
 		to
 	}]));
+	const throughSource = config.sourceDependentsOf(kind, path);
+	const drawn = new Set(throughSource);
 	return {
 		from: path,
 		to,
-		rewrites: addresses(config.dependentsOf(kind, path)),
+		rewrites: addresses(config.dependentsOf(kind, path).filter((ref) => !drawn.has(ref))),
+		throughSource: addresses(throughSource),
 		...blocked === void 0 ? {} : { blocked }
 	};
 }

package/dist/framework/schema-version.d.ts

@@ -15,7 +15,7 @@ import { Patch, SerializedConfig } from "./Config.js";
  * sets this constant to its own older timestamp; the merge ref then carries a registered migration
  * newer than the constant, and the assertion fails until the author re-mints.
  */
-declare const CURRENT_SCHEMA_VERSION = 20260925143319;
+declare const CURRENT_SCHEMA_VERSION = 20260928180801;
 /** What the walkers need to see of an envelope — loose on purpose, so a typed `SerializedConfig`
  *  and a raw old-shape record both flow in without casts. */
 interface VersionStamped {

package/dist/framework/schema-version.js

@@ -13,7 +13,7 @@ import { ConfigFormatError } from "./rejection.js";
 * sets this constant to its own older timestamp; the merge ref then carries a registered migration
 * newer than the constant, and the assertion fails until the author re-mints.
 */
-const CURRENT_SCHEMA_VERSION = 20260925143319;
+const CURRENT_SCHEMA_VERSION = 20260928180801;
 /** The mint that moved `options` into the `settings` kind — restated here, rather than imported
 *  from the migration that owns it, because that migration imports this module. */
 const SETTINGS_AS_KIND_VERSION = 20260908171448;
@@ -45,7 +45,7 @@ function registerSchemaMigrations(...migrations) {
 	for (const migration of migrations) {
 		if (migration.version !== 1 && !isMintTimestamp(migration.version)) throw new Error(`Schema migration version ${migration.version} is not a mint timestamp — mint one with \`date +%Y%m%d%H%M%S\`, like a supabase migration.`);
 		if (REGISTERED.has(migration.version)) throw new Error(`A schema migration at version ${migration.version} is already registered.`);
-		if (migration.version > 20260925143319) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
+		if (migration.version > 20260928180801) throw new Error(`Schema migration ${migration.version} is newer than CURRENT_SCHEMA_VERSION (${CURRENT_SCHEMA_VERSION}) — a stale branch merged, or the mint forgot to bump the constant. Re-mint: set CURRENT_SCHEMA_VERSION to the newest migration version.`);
 		REGISTERED.set(migration.version, migration);
 	}
 }
@@ -102,7 +102,7 @@ function pendingFor(version, target, options) {
 * Already-current input passes through untouched — same reference, so hot paths pay nothing.
 */
 function upgradeSerializedConfig(json, options) {
-	const target = options?.target ?? 20260925143319;
+	const target = options?.target ?? 20260928180801;
 	const version = detectedWireVersion(json);
 	if (version > target) throw new SchemaVersionTooNew(version, target);
 	const raw = json;
@@ -160,7 +160,7 @@ function upgradedSources(json, options) {
 * meaning under the current schema and replay skips it — reported by the caller, not swallowed here.
 */
 function upgradePatch(patch, writtenAt, options) {
-	const target = options?.target ?? 20260925143319;
+	const target = options?.target ?? 20260928180801;
 	if (writtenAt > target) throw new SchemaVersionTooNew(writtenAt, target);
 	let current = patch;
 	for (const migration of pendingFor(writtenAt, target, options)) {
@@ -179,7 +179,7 @@ function upgradePatch(patch, writtenAt, options) {
 * stamp would cause.
 */
 function upgradeDraftEntries(draft, options) {
-	const target = options?.target ?? 20260925143319;
+	const target = options?.target ?? 20260928180801;
 	const entries = [];
 	const held = [];
 	const retired = [];

package/dist/framework/utils/group.d.ts

@@ -12,7 +12,7 @@ declare const GROUP: unique symbol;
  * `'color/text/primary'` or `color: { text: { primary } }` — so a record of these is admissible at
  * every level, exactly as `register` flattens them.
  */
-type AuthoredEntry<F extends FieldsSchema, G extends FieldsSchema> = CreateInput<F> | GroupBody<F, G> | Authored | string | number | Ref | NestedEntries<F, G>;
+type AuthoredEntry<F extends FieldsSchema, G extends FieldsSchema> = CreateInput<F> | EntryGroup<F, G> | Authored | string | number | Ref | NestedEntries<F, G>;
 /**
  * A record of entries under a shared prefix.
  *
@@ -21,9 +21,11 @@ type AuthoredEntry<F extends FieldsSchema, G extends FieldsSchema> = CreateInput
  * is a malformed item either way, and this is what makes the type say so rather than silently
  * reading `{ valuee: '#fff' }` as a nested token named `valuee`.
  */
-type NestedEntries<F extends FieldsSchema, G extends FieldsSchema> = {
-  readonly [key: string]: CreateInput<F> | GroupBody<F, G> | Authored | Ref | NestedEntries<F, G>;
-};
+type NestedEntries<F extends FieldsSchema, G extends FieldsSchema> = NestedRecord<F, G> & { readonly [K in ItemFieldKeys<F, G>]?: never };
+/** {@link NestedEntries}' records. An interface, so the recursion resolves lazily. */
+interface NestedRecord<F extends FieldsSchema, G extends FieldsSchema> {
+  readonly [key: string]: CreateInput<F> | EntryGroup<F, G> | Authored | Ref | NestedEntries<F, G>;
+}
 /** A group node — its own fields, plus the members that live under its path. */
 type GroupBody<F extends FieldsSchema, G extends FieldsSchema> = CreateInput<G> & {
   /** The group's members, keyed by the segment that extends its path. Stating the prefix once is
@@ -47,7 +49,15 @@ type GroupInputHandler<I> = (args: {
 type GroupInputs = Readonly<Record<string, GroupInputHandler<never>>>;
 /** The input keys a kind's `group()` takes, typed off each handler's declared input. */
 type GroupInputValues<GI extends GroupInputs> = { readonly [K in keyof GI]?: GI[K] extends GroupInputHandler<infer I> ? I : never };
+/** The kind's own item fields, which never name a path segment or sit on an unmarked group. */
+type ItemFieldKeys<F extends FieldsSchema, G extends FieldsSchema> = Exclude<keyof CreateInput<F>, keyof CreateInput<G>>;
+/**
+ * A group body in an entry's place. It may not carry the kind's item fields: only `<Entity>.group()`
+ * marks a group, so a body with an item field is an item, and typing it as a group would let an item
+ * with a wrong field through.
+ */
+type EntryGroup<F extends FieldsSchema, G extends FieldsSchema> = GroupBody<F, G> & { readonly [K in ItemFieldKeys<F, G>]?: never };
 declare function brandGroup<F extends FieldsSchema, G extends FieldsSchema>(meta: GroupBody<F, G>): GroupBody<F, G>;
 declare function isGroupBody(value: unknown): boolean;
 //#endregion
-export { AuthoredEntry, GROUP, GroupBody, GroupInputValues, GroupInputs, brandGroup, isGroupBody };
+export { AuthoredEntry, EntryGroup, GROUP, GroupBody, GroupInputValues, GroupInputs, brandGroup, isGroupBody };