@yahoo/uds-create-config 4.10.2 → 4.10.4

package/dist/framework/prop-surface.js

@@ -1,6 +1,6 @@
 import { isRef, kindOf, memberOf, pathOf, refLeaf } from "./utils/refs.js";
 import { forwardsOf, rootLayerOf } from "../entities/system/element.js";
-import { propValueDomain, resolveComponentProps } from "./projections.js";
+import { propValueDomain, refListOf, resolveComponentProps } from "./projections.js";
 import { Component } from "../entities/system/Component.js";
 //#region src/framework/prop-surface.ts
 /**
@@ -56,18 +56,16 @@ function acceptsRefs(accepts) {
 	return (Array.isArray(accepts) ? accepts : [accepts]).filter(isRef).map((ref) => ref.__ref);
 }
 /**
-* The icon library a variant's value domain delegates to, when the domain is
-* the GROUP itself (`icon:phosphor` — one leaf per glyph). A facet ref keeps
-* its `#field` marker and is not a library: its leaves are the group node's
-* own field values, which a plain list control serves fine. A ref at one ITEM
-* (`icon:phosphor/StarIcon`) is a single-leaf domain, not a library either.
+* The icon libraries a variant's value domain delegates to, when the domain is
+* a group itself (`icon:phosphor` — one leaf per glyph) or a list of groups. A
+* facet ref keeps its `#field` marker and is not a library: its leaves are the
+* group node's own field values, which a plain list control serves fine. A ref
+* at one item (`icon:phosphor/StarIcon`) is a single-leaf domain, not a library
+* either. `undefined` when no element of the domain is a library.
 */
-function variantIconLibrary(config, value) {
-	if (!isRef(value) || kindOf(value) !== "icon") return void 0;
-	if (memberOf(value) !== void 0) return void 0;
-	const path = pathOf(value);
-	if (config.resolve("icon", path)) return void 0;
-	return path;
+function variantIconLibraries(config, value) {
+	const libraries = (refListOf(value) ?? (isRef(value) ? [value.__ref] : [])).filter((target) => kindOf(target) === "icon" && memberOf(target) === void 0 && !config.resolve("icon", pathOf(target)));
+	return libraries.length > 0 ? libraries.map(pathOf) : void 0;
 }
 /**
 * The prop a slot routes INTO, resolved through the layer it targets: the layer's element is a
@@ -205,13 +203,13 @@ function surfaceProps(config, componentPath, seen = /* @__PURE__ */ new Set()) {
 			continue;
 		}
 		if (decl.type === "variant") {
-			const iconLibrary = variantIconLibrary(config, decl.value);
+			const iconLibraries = variantIconLibraries(config, decl.value);
 			props.push(conditioned({
 				name,
 				kind: "variant",
 				required,
 				values: propValueDomain(config, decl)?.leaves ?? [],
-				...iconLibrary !== void 0 ? { iconLibrary } : {}
+				...iconLibraries !== void 0 ? { iconLibraries } : {}
 			}, when));
 			continue;
 		}

package/dist/framework/registry.d.ts

@@ -41,6 +41,12 @@ type Linkable = boolean | ((args: {
   readonly config: Config;
   readonly source: Config;
 }) => boolean);
+/** See {@link EntityKind.authoredValue}. */
+type AuthoredValueForm = (ctx: {
+  readonly config: Config; /** The ref the domain names: an item, a group, or a facet of this kind. */
+  readonly target: string; /** The leaves the target offers, which is what the form has to answer with. */
+  readonly leaves: readonly string[];
+}) => z.ZodTypeAny | undefined;
 interface EntityKind {
   readonly name: string;
   /** The entity class's name (`style-property` → `StyleProperty`) — what a consumer writes to reach
@@ -259,6 +265,16 @@ interface EntityKind {
    * leaf, since neither can hold a slash.
    */
   readonly uniqueLeaves?: boolean;
+  /**
+   * An extra authored form for a value whose domain is this kind, beside the leaf and the ref every
+   * domain takes. Asked when a ref domain's schema is built, with the target the domain names and the
+   * leaves it offers; the schema answers the leaf the value stands for, and the domain binds that
+   * leaf the way it binds a written one. `undefined` adds no form.
+   *
+   * Declared by the kind rather than tested for by name: the value-domain rule knows "a kind may
+   * take its values in another spelling" as a property, never which kind or which spelling.
+   */
+  readonly authoredValue?: AuthoredValueForm;
   /**
    * Rules that hold across the kind's items and groups together, which no single item's schema can
    * see — a typed group nested under another typed group. Returns the violations as sentences; a
@@ -298,4 +314,4 @@ interface EntityKind {
  *  kind def a `Config` holds (`config.entityOf(kind)`); `undefined` → no ops. */
 declare function opsForKind(entry: EntityKind | undefined, config?: Config): DerivedOp[];
 //#endregion
-export { ComputedFields, ComputedInput, EntityKind, Linkable, opsForKind };
+export { AuthoredValueForm, ComputedFields, ComputedInput, EntityKind, Linkable, opsForKind };

package/dist/framework/registry.js

@@ -32,7 +32,7 @@ function titleCase(kind) {
 /** Derive a kind's immutable metadata from its field schemas — the value a `defineEntity`/
 *  `defineDerivedEntity` attaches to its class and a `Config.register` stores in `#entities`. */
 function buildKind(spec) {
-	const { name, fields, groupFields, subEntities = {}, computed, label, labelPlural, schemas: userSchemas, derived, sourceIdentity, sourceOrigin, authoredRefs, linkable, localGroupFields, emergentGroups, singleton = false, bareMember, sourceResolution, bulkAdopts, bulkOverlay, bulkDirectives, bulkOverlayWrite, nameEdges, rewriteName, styleBags, uniqueLeaves, invariants } = spec;
+	const { name, fields, groupFields, subEntities = {}, computed, label, labelPlural, schemas: userSchemas, derived, sourceIdentity, sourceOrigin, authoredRefs, linkable, localGroupFields, emergentGroups, singleton = false, bareMember, sourceResolution, bulkAdopts, bulkOverlay, bulkDirectives, bulkOverlayWrite, nameEdges, rewriteName, styleBags, uniqueLeaves, authoredValue, invariants } = spec;
 	const allComputed = {
 		sources: ({ member, config }) => sourceSlugs(member, config),
 		borrowedFrom: ({ config, path }) => config.borrowedFrom(name, path),
@@ -77,6 +77,7 @@ function buildKind(spec) {
 		rewriteName,
 		styleBags,
 		...uniqueLeaves ? { uniqueLeaves } : {},
+		...authoredValue ? { authoredValue } : {},
 		...invariants ? { invariants } : {}
 	};
 }

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

@@ -314,7 +314,7 @@ declare function withoutTruthyTerm({
   prop: string;
 }): unknown;
 /**
- * The type a BOUND element resolves to, given the value its prop was handed.
+ * The type a bound element resolves to, given the value its prop was handed.
  *
  * This is the one thing json-render has no vocabulary for — `UIElement.type` is a plain string — so
  * a stored spec can't hold it and `deriveSpec` declines. An expansion is a different position: the
@@ -323,10 +323,11 @@ declare function withoutTruthyTerm({
  * rather than 51 conditioned siblings copying a library's index into every component that draws a
  * glyph.
  *
- * Two ways the domain is known, in order: the prop DELEGATES it (`value` is a ref to the library,
- * which is the shape that keeps 1,530 names in one place), or the prop enumerates its values and the
- * member is found by asking which group declares it. The second exists because a config migrated
- * from v1 spells an icon prop as an enumeration, and a glyph is no less resolvable for it.
+ * Two ways the domain is known, in order: the prop delegates it (`value` is a ref to the library, or
+ * a list of refs for a host drawing from several, which is the shape that keeps 1,530 names in one
+ * place), or the prop enumerates its values and the member is found by asking which group declares
+ * it. The second exists because a config migrated from v1 spells an icon prop as an enumeration, and
+ * a glyph is no less resolvable for it.
  */
 declare function boundElementType(config: Config, componentPath: string, prop: string, value: unknown): string | undefined;
 /** Where one slot prop's content lands. */

package/dist/framework/render-spec.js

@@ -2,7 +2,7 @@ import { isRef, kindOf, memberOf, pathOf, ref, splitRef } from "./utils/refs.js"
 import { renderedElement } from "../entities/system/element.js";
 import { createSliceMemo } from "./memo.js";
 import { unconditionalPreviewProps } from "./preview-store.js";
-import { authoredBag, authoredValue, declaredPropDefaults, memberFromLeaf, resolveComponentProps, stylePropertyPathFor } from "./projections.js";
+import { authoredBag, authoredValue, declaredPropDefaults, memberFromLeaf, refListOf, resolveComponentProps, stylePropertyPathFor } from "./projections.js";
 import { forwardedLayers, intoName, routesContent } from "./prop-surface.js";
 import { graftPreviewElements } from "../spec/preview-elements.js";
 import { componentLayerClass, componentPropClasses, componentRuleClasses, layerRoutedProps, splitStyleProps, styleRuleMotionClasses } from "./class-names.js";
@@ -720,7 +720,7 @@ function spentBy({ condition, prop }) {
 	return test.$state.replace(/^\//, "") === prop && test.not !== true && (operatorOf(test) === void 0 || operatorOf(test) === "eq" && test.eq === true);
 }
 /**
-* The type a BOUND element resolves to, given the value its prop was handed.
+* The type a bound element resolves to, given the value its prop was handed.
 *
 * This is the one thing json-render has no vocabulary for — `UIElement.type` is a plain string — so
 * a stored spec can't hold it and `deriveSpec` declines. An expansion is a different position: the
@@ -729,20 +729,25 @@ function spentBy({ condition, prop }) {
 * rather than 51 conditioned siblings copying a library's index into every component that draws a
 * glyph.
 *
-* Two ways the domain is known, in order: the prop DELEGATES it (`value` is a ref to the library,
-* which is the shape that keeps 1,530 names in one place), or the prop enumerates its values and the
-* member is found by asking which group declares it. The second exists because a config migrated
-* from v1 spells an icon prop as an enumeration, and a glyph is no less resolvable for it.
+* Two ways the domain is known, in order: the prop delegates it (`value` is a ref to the library, or
+* a list of refs for a host drawing from several, which is the shape that keeps 1,530 names in one
+* place), or the prop enumerates its values and the member is found by asking which group declares
+* it. The second exists because a config migrated from v1 spells an icon prop as an enumeration, and
+* a glyph is no less resolvable for it.
 */
 function boundElementType(config, componentPath, prop, value) {
 	if (typeof value !== "string" || !value) return void 0;
 	if (value.includes("/")) return void 0;
 	const decl = resolveComponentProps(config, componentPath)[prop];
-	const target = refOf(decl?.value);
-	if (target) {
-		if (memberOf(target) !== void 0) return void 0;
-		const member = memberFromLeaf(config, target, value);
-		return member ? `${kindOf(target)}:${member}` : void 0;
+	const single = refOf(decl?.value);
+	const targets = refListOf(decl?.value) ?? (single ? [single] : []);
+	if (targets.length > 0) {
+		for (const target of targets) {
+			if (memberOf(target) !== void 0) continue;
+			const member = memberFromLeaf(config, target, value);
+			if (member) return `${kindOf(target)}:${member}`;
+		}
+		return;
 	}
 	const matches = config.list("icon").filter((member) => (member.path.split("/").pop() ?? "") === value);
 	return matches.length === 1 ? `icon:${matches[0]?.path}` : void 0;

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 = 20260920161309;
+declare const CURRENT_SCHEMA_VERSION = 20260922013625;
 /** 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 = 20260920161309;
+const CURRENT_SCHEMA_VERSION = 20260922013625;
 /** 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 > 20260920161309) 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 > 20260922013625) 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 ?? 20260920161309;
+	const target = options?.target ?? 20260922013625;
 	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 ?? 20260920161309;
+	const target = options?.target ?? 20260922013625;
 	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 ?? 20260920161309;
+	const target = options?.target ?? 20260922013625;
 	const entries = [];
 	const held = [];
 	const retired = [];

package/dist/framework/signature.js

@@ -9,6 +9,10 @@ import { z } from "zod";
 * `address` describe away. Two levels is enough to show a kind's fields and the shape of each field's
 * members; a token's color operation is recursive and would otherwise unfold without end.
 */
+/** A schema no value satisfies — `{ not: {} }`. */
+function isNever(node) {
+	return node.not !== void 0 && typeof node.not === "object" && Object.keys(node.not).length === 0 && Object.keys(node).length === 1;
+}
 const DEFAULT_DEPTH = 2;
 const DEFAULT_ENUM_LIMIT = 8;
 function isNode(value) {
@@ -39,7 +43,7 @@ function renderSignature(schema, options = {}) {
 			return shown.join(" | ");
 		}
 		const variants = node.anyOf ?? node.oneOf;
-		if (variants) return unique(variants.map((member) => render(member, remaining))).join(" | ");
+		if (variants) return unique(variants.filter((member) => !isNever(member)).map((member) => render(member, remaining))).join(" | ");
 		if (node.allOf) return unique(node.allOf.map((member) => render(member, remaining))).join(" & ");
 		if (Array.isArray(node.type)) return unique(node.type.map((type) => render({
 			...node,

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

@@ -31,7 +31,21 @@ type GroupBody<F extends FieldsSchema, G extends FieldsSchema> = CreateInput<G>
   readonly items?: Readonly<Record<string, AuthoredEntry<F, G>>>;
   readonly [GROUP]?: true;
 };
+/**
+ * A registration-time input: a key of an authored group body that the kind's `group()` hands to this
+ * handler, with the rest of the body, and then strips. It is never stored, never part of the group
+ * schema, and never seen by a hydrated config. What the handler does with it is the kind's business.
+ */
+type GroupInputHandler<I> = (args: {
+  readonly input: I; /** The body without its inputs: the members under `items` and the group's own fields. */
+  readonly body: Readonly<Record<string, unknown>>;
+}) => void;
+/** A kind's registration-time inputs, keyed by the body key each one consumes. `never` is the
+ *  parameter position's bottom, so a handler declaring any input type fits. */
+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 };
 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, brandGroup, isGroupBody };
+export { AuthoredEntry, GROUP, GroupBody, GroupInputValues, GroupInputs, brandGroup, isGroupBody };

package/dist/framework/utils/ref-grammar.d.ts

@@ -0,0 +1,35 @@
+//#region src/framework/utils/ref-grammar.d.ts
+/**
+ * The ref grammar — `kind:path[@source][#member]` — and its one reader, with nothing else imported.
+ * A renderer bundle reads a stored ref through this module without carrying the schema half of
+ * `refs.ts`; everything there re-exports from here.
+ */
+interface Ref {
+  readonly __ref: string;
+}
+/** A ref's parts. */
+interface RefParts {
+  readonly kind: string;
+  readonly source: string | undefined;
+  /** without the source — `pathOf`'s answer. */
+  readonly path: string;
+  /** with the source, when there is one — the form an authored value and an emitted union spell,
+   *  because a string in value position has nowhere to put a second argument. */
+  readonly qualifiedPath: string;
+  readonly member: string | undefined;
+  /** whether a `kind:` marker was present — without one, `kind` and `path` are both the whole
+   *  string, and each caller reads the one it means. */
+  readonly marked: boolean;
+}
+/**
+ * `kind:path[@source][#member]`, split — the one place a ref is read. This is the ref spelling of the
+ * address grammar written down whole in `framework/config-op.ts`.
+ *
+ * Every accessor below goes through this, and so does anything outside this file that needs a part of
+ * a ref. Code that slices at `indexOf(':')` or tests `startsWith('token:')` has its own copy of the
+ * grammar, which means the grammar cannot move without hunting for the copies — and a copy that is
+ * subtly wrong (a prefix test that a sourced ref fails) is silent.
+ */
+declare function splitRef(target: string | Ref): RefParts;
+//#endregion
+export { Ref, splitRef };

package/dist/framework/utils/ref-grammar.js

@@ -0,0 +1,76 @@
+/** The `@source` suffix for a ref, or `''` when it's local. */
+const qualifier = (source) => source === void 0 ? "" : `@${source}`;
+/**
+* Splits a qualified path into what it names and where from.
+*
+* A path can OPEN with `@`: a package's path is an npm specifier, and `package:@ariakit/react` is
+* scoped. So the source is the last `@`, and never a leading one — a scope opens a path, it doesn't
+* qualify it. `package:@ariakit/react@yahoo-os` is that package, as their system has it.
+*
+* Total for every path {@link isEntityPath} admits, which is what makes "the last `@`" a rule rather
+* than a heuristic: with at most a leading `@` in the path, any later one is the marker.
+*/
+function splitSource(qualified) {
+	const at = qualified.lastIndexOf("@");
+	if (at <= 0) return [qualified, void 0];
+	return [qualified.slice(0, at), qualified.slice(at + 1)];
+}
+/**
+* `kind:path[@source][#member]`, split — the one place a ref is read. This is the ref spelling of the
+* address grammar written down whole in `framework/config-op.ts`.
+*
+* Every accessor below goes through this, and so does anything outside this file that needs a part of
+* a ref. Code that slices at `indexOf(':')` or tests `startsWith('token:')` has its own copy of the
+* grammar, which means the grammar cannot move without hunting for the copies — and a copy that is
+* subtly wrong (a prefix test that a sourced ref fails) is silent.
+*/
+function splitRef(target) {
+	const raw = isRef(target) ? target.__ref : target;
+	const hash = raw.indexOf("#");
+	const entity = hash === -1 ? raw : raw.slice(0, hash);
+	const member = hash === -1 ? void 0 : raw.slice(hash + 1);
+	const colon = entity.indexOf(":");
+	const kind = colon === -1 ? entity : entity.slice(0, colon);
+	const qualifiedPath = colon === -1 ? entity : entity.slice(colon + 1);
+	const [path, source] = splitSource(qualifiedPath);
+	return {
+		kind,
+		source,
+		path,
+		qualifiedPath,
+		member,
+		marked: colon !== -1
+	};
+}
+/** The member half (`props/gap`), or `undefined` for a plain entity ref. Takes the ref itself or its
+*  string form, like {@link pathOf} / {@link kindOf} / {@link sourceOf}. */
+function memberOf(target) {
+	const raw = isRef(target) ? target.__ref : target;
+	const at = raw.indexOf("#");
+	return at === -1 ? void 0 : raw.slice(at + 1);
+}
+/** The path of the entity a ref points at — kind, source and any member stripped, so a member ref
+*  resolves to the item that contains it (`component:buttons/Primary#props/gap` → `buttons/Primary`)
+*  and a linked ref yields the path as its source spells it (`token:color/brand@yahoo-os` →
+*  `color/brand`). Takes the ref itself or its string form, so a caller holding a ref field never
+*  spells `__ref`. */
+function pathOf(target) {
+	return splitRef(target).path;
+}
+/** The source half — the link slug a ref points through, or `undefined` when it points at something
+*  in this config. This is the one question that distinguishes a linked entity from a local one, and
+*  it replaces reading a per-entity provenance marker. */
+function sourceOf(target) {
+	return splitRef(target).source;
+}
+/** The kind a ref points at (`component:buttons/Primary#props/gap` → `component`) — the twin of
+*  {@link pathOf}, so a consumer holding a `kind:path` string (a `dependentsOf` result) never splits
+*  it by hand. Takes the ref itself or its string form. */
+function kindOf(target) {
+	return splitRef(target).kind;
+}
+function isRef(value) {
+	return typeof value === "object" && value !== null && "__ref" in value;
+}
+//#endregion
+export { isRef, kindOf, memberOf, pathOf, qualifier, sourceOf, splitRef };

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

@@ -1,9 +1,19 @@
+import { Ref as Ref$1, splitRef as splitRef$1 } from "./ref-grammar.js";
 import { z } from "zod";
 
 //#region src/framework/utils/refs.d.ts
-interface Ref {
-  readonly __ref: string;
-}
+type Ref = Ref$1;
+/** `kind:path[@source][#member]`, split — the one reader of the ref grammar. */
+declare function splitRef(target: string | Ref): ReturnType<typeof splitRef$1>;
+declare function isRef(value: unknown): value is Ref;
+/** The kind a ref points at (`component:buttons/Primary#props/gap` → `component`). */
+declare function kindOf(target: string | Ref): string;
+/** The path of the entity a ref points at — kind, source and any member stripped. */
+declare function pathOf(target: string | Ref): string;
+/** The source half — the link slug a ref points through, or `undefined` for a local one. */
+declare function sourceOf(target: string | Ref): string | undefined;
+/** The member half (`props/gap`), or `undefined` for a plain entity ref. */
+declare function memberOf(target: string | Ref): string | undefined;
 /** A ref as the authoring API returns it. The method is non-enumerable, so an ordinary ref remains
  * exactly `{ __ref }` in JSON and anywhere that walks its data. Calling it produces the explicit
  * wire value below: a base ref plus the sparse fields this config owns.
@@ -43,30 +53,6 @@ interface ExtendedRef<Delta extends Record<string, unknown> = Record<string, unk
 declare function isEntityPath(path: string): boolean;
 /** What a refused path should say, in one place, so a create, a rename and a register word it alike. */
 declare const ENTITY_PATH_MESSAGE = "An entity path may not contain \"@\" except as a leading npm scope \u2014 \"@\" marks the source a ref is drawn from, so a path carrying one cannot be told apart from a borrowed address.";
-/** A ref's parts. */
-interface RefParts {
-  readonly kind: string;
-  readonly source: string | undefined;
-  /** without the source — `pathOf`'s answer. */
-  readonly path: string;
-  /** with the source, when there is one — the form an authored value and an emitted union spell,
-   *  because a string in value position has nowhere to put a second argument. */
-  readonly qualifiedPath: string;
-  readonly member: string | undefined;
-  /** whether a `kind:` marker was present — without one, `kind` and `path` are both the whole
-   *  string, and each caller reads the one it means. */
-  readonly marked: boolean;
-}
-/**
- * `kind:path[@source][#member]`, split — the one place a ref is read. This is the ref spelling of the
- * address grammar written down whole in `framework/config-op.ts`.
- *
- * Every accessor below goes through this, and so does anything outside this file that needs a part of
- * a ref. Code that slices at `indexOf(':')` or tests `startsWith('token:')` has its own copy of the
- * grammar, which means the grammar cannot move without hunting for the copies — and a copy that is
- * subtly wrong (a prefix test that a sourced ref fails) is silent.
- */
-declare function splitRef(target: string | Ref): RefParts;
 /**
  * A reference to another entity: `ref('token', 'color/brand')`. Resolution is prefix-or-leaf against
  * the flat store.
@@ -84,23 +70,6 @@ declare function memberRef(kind: string, path: string, sub: string, member: stri
 /** The entity half of any ref — a plain entity ref is itself. This is the form the dependency
  *  graph and kind-narrowing speak, so a member ref participates in both unchanged. */
 declare function entityRefOf(target: string): string;
-/** The member half (`props/gap`), or `undefined` for a plain entity ref. Takes the ref itself or its
- *  string form, like {@link pathOf} / {@link kindOf} / {@link sourceOf}. */
-declare function memberOf(target: string | Ref): string | undefined;
-/** The path of the entity a ref points at — kind, source and any member stripped, so a member ref
- *  resolves to the item that contains it (`component:buttons/Primary#props/gap` → `buttons/Primary`)
- *  and a linked ref yields the path as its source spells it (`token:color/brand@yahoo-os` →
- *  `color/brand`). Takes the ref itself or its string form, so a caller holding a ref field never
- *  spells `__ref`. */
-declare function pathOf(target: string | Ref): string;
-/** The source half — the link slug a ref points through, or `undefined` when it points at something
- *  in this config. This is the one question that distinguishes a linked entity from a local one, and
- *  it replaces reading a per-entity provenance marker. */
-declare function sourceOf(target: string | Ref): string | undefined;
-/** The kind a ref points at (`component:buttons/Primary#props/gap` → `component`) — the twin of
- *  {@link pathOf}, so a consumer holding a `kind:path` string (a `dependentsOf` result) never splits
- *  it by hand. Takes the ref itself or its string form. */
-declare function kindOf(target: string | Ref): string;
 /** The zod schema of a ref value — used via {@link orRef} so a field never spells the
  *  `{ __ref }` shape by hand. `.meta({ ref: true })` marks it as a ref for any consumer (JSON
  *  Schema, an authoring UI) — this generic form carries no target kind (use an entity as the field
@@ -112,7 +81,6 @@ declare const refSchema: z.ZodObject<{
 declare function orRef<T extends z.ZodTypeAny>(schema: T): z.ZodUnion<readonly [T, z.ZodObject<{
   __ref: z.ZodString;
 }, z.core.$strip>]>;
-declare function isRef(value: unknown): value is Ref;
 /** Whether a ref is the stored result of `.extend(delta)`. Kept separate from {@link isRef}: every
  * existing ref consumer should continue to see the base pointer, while Config is the place that
  * gives the sibling delta its merge semantics. */