@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/entities/system/runtime-modules.d.ts

@@ -0,0 +1,25 @@
+import { Config } from "../../framework/Config.js";
+
+//#region src/entities/system/runtime-modules.d.ts
+/** One npm module named by this config's runtime declarations. */
+interface DeclaredRuntimeModule {
+  /** The bare module specifier, exactly as authored (`@ariakit/react`, `motion/react`). */
+  readonly specifier: string;
+  /** The build-pinned package version, when known. */
+  readonly version?: string;
+  /** Package exports that rendered specs can address. */
+  readonly exports?: readonly string[];
+  /** This module also supplies the members of an icon library. */
+  readonly iconLibrary?: true;
+}
+/**
+ * The npm modules this config itself declares at runtime.
+ *
+ * Package rows and icon-library group metadata are already Config v2's durable declarations. This
+ * projection keeps serving and vendoring code on those facts instead of introducing another module
+ * registry that could drift from them. Linked sources remain separate: callers that need their
+ * declarations walk each attached source and call this projection there.
+ */
+declare function declaredRuntimeModules(config: Config): DeclaredRuntimeModule[];
+//#endregion
+export { DeclaredRuntimeModule, declaredRuntimeModules };

package/dist/entities/system/runtime-modules.js

@@ -0,0 +1,38 @@
+import { Icon } from "./Icon.js";
+//#region src/entities/system/runtime-modules.ts
+/**
+* The npm modules this config itself declares at runtime.
+*
+* Package rows and icon-library group metadata are already Config v2's durable declarations. This
+* projection keeps serving and vendoring code on those facts instead of introducing another module
+* registry that could drift from them. Linked sources remain separate: callers that need their
+* declarations walk each attached source and call this projection there.
+*/
+function declaredRuntimeModules(config) {
+	const bySpecifier = /* @__PURE__ */ new Map();
+	for (const row of config.list("package")) {
+		const { version, exports } = row.body;
+		const exportNames = Object.keys(exports ?? {}).sort();
+		bySpecifier.set(row.path, {
+			specifier: row.path,
+			...version ? { version } : {},
+			...exportNames.length > 0 ? { exports: exportNames } : {}
+		});
+	}
+	for (const group of Icon.groups(config)) {
+		const specifier = group.meta.module;
+		if (typeof specifier !== "string") continue;
+		const existing = bySpecifier.get(specifier);
+		const groupVersion = group.meta.version;
+		const version = existing?.version ?? (typeof groupVersion === "string" ? groupVersion : void 0);
+		bySpecifier.set(specifier, {
+			specifier,
+			...version ? { version } : {},
+			...existing?.exports ? { exports: existing.exports } : {},
+			iconLibrary: true
+		});
+	}
+	return [...bySpecifier.values()].sort((left, right) => left.specifier.localeCompare(right.specifier));
+}
+//#endregion
+export { declaredRuntimeModules };

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

@@ -0,0 +1,20 @@
+import { DerivedColor, Gradient } from "./color.js";
+import { z } from "zod";
+
+//#region src/entities/system/style-bag.d.ts
+/**
+ * A style bag — what a component layer / composite / variant applies. The key is a
+ * style-prop name (open: any registered prop), but the VALUE is constrained: a literal
+ * (`'row'`, `4`), a `token(...)` ref, or a nested modifier block (`_hover: { ... }`) whose
+ * own values are style values (recursive). Typing the value instead of `z.unknown()`
+ * tightens the derived MCP tool — the AI sees token-or-literal, not "any" — and the
+ * harness's strictness checker recurses into the constrained value instead of flagging the
+ * bag as fully open.
+ */
+type StyleValue = string | number | boolean | {
+  readonly __ref: string;
+} | DerivedColor | Gradient | {
+  readonly [key: string]: StyleValue;
+};
+//#endregion
+export { StyleValue };

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

@@ -0,0 +1,246 @@
+import { isExtendedRef, isRef, ref, refSchema, splitRef } from "../../framework/utils/refs.js";
+import { defineSubEntity } from "../../framework/defineSubEntity.js";
+import { derivedColor, gradient } from "./color.js";
+import { isCssProperty, kebabCase } from "../../css/values.js";
+import { valueSchemaOf } from "../../framework/value-domain.js";
+import { stylePropTokenPath } from "../../framework/projections.js";
+import { z } from "zod";
+//#region src/entities/system/style-bag.ts
+/** The explicit type annotation breaks the `z.lazy` self-reference cycle and keeps the
+*  authored value type tight (a bare `z.lazy` infers `unknown`). */
+const styleValue = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	refSchema,
+	derivedColor,
+	gradient,
+	z.record(z.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.
+*/
+const Style = defineSubEntity({
+	name: "style",
+	label: "Style",
+	labelPlural: "Styles",
+	/**
+	* A FACTORY, so a declaration's value binds like any other declared reference.
+	*
+	* The member's KEY is the style property being set, which is the declaration — so the value's domain
+	* is that property's, and `valueSchemaOf` stores the token it names as a ref. Without this a bag on a
+	* composite named its token as a bare leaf, invisible to the graph: renaming the token left the old
+	* name behind and deleting it wasn't refused.
+	*
+	* `styleValue` stays as the second arm, and it is what most keys take: a modifier block (a nested
+	* bag), a computed colour, a gradient, an off-system literal, and any key that isn't a style property
+	* at all. The union is ordered so the narrowed domain gets first refusal.
+	*/
+	fields: ({ config, parent, key }) => {
+		if (!config || key === void 0) return styleValue;
+		if (key.startsWith("_")) return openBag(config);
+		const bound = (config, declaration) => z.union([valueSchemaOf(declaration, config), styleValue]);
+		const declared = parent?.props?.[key];
+		if (isRef(declared?.value)) return bound(config, declared);
+		if (!config.resolve("style-property", key)) return styleValue;
+		return bound(config, {
+			type: "styleProperty",
+			value: ref("style-property", key)
+		});
+	}
+});
+/** A plain object: not an array, not a ref, so a computed colour or a gradient isn't walked as a bag. */
+function isPlainRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && !isRef(value);
+}
+/**
+* Collect a bag and every modifier block nested in it, PARENTS FIRST.
+*
+* The order is part of the contract: {@link bagRewriteName} walks the result backwards so a child is
+* written into its parent before that parent is rebuilt. A modifier block holds a bag of the same
+* shape, so this is the only recursion either hook needs.
+*/
+function collectBag(bag, write, out) {
+	if (!isPlainRecord(bag)) return;
+	out.push({
+		bag,
+		write
+	});
+	for (const [key, value] of Object.entries(bag)) {
+		if (!key.startsWith("_") || !isPlainRecord(value)) continue;
+		collectBag(value, (next) => {
+			bag[key] = next;
+		}, out);
+	}
+}
+/**
+* The edges a kind's bags imply by NAME — each key names a style property, and a `_`-prefixed key
+* names the modifier whose block it opens.
+*
+* A key is not a ref, so `collectRefs` can't see it: nothing said a component depended on the style
+* property its bag sets, so renaming that property left every bag keyed by a name that no longer
+* existed and deleting one in use wasn't refused.
+*
+* PURE in the body it is handed, which is what lets these ride the same incremental index as
+* ref-borne edges — see `EntityKind.nameEdges`. An edge is therefore minted for EVERY key rather than
+* only for keys that currently resolve, and `Config.dependenciesOf` filters the outgoing direction
+* live instead.
+*/
+function bagNameEdges(sites) {
+	return (data) => {
+		const edges = /* @__PURE__ */ new Set();
+		const bags = isExtendedRef(data) ? data.extend : data;
+		for (const { bag } of sites(bags)) for (const key of Object.keys(bag)) if (key.startsWith("_")) edges.add(`modifier:${key.slice(1)}`);
+		else edges.add(`style-property:${key}`);
+		return [...edges];
+	};
+}
+/**
+* Rewrite a style-property or modifier name wherever a bag holds it as a key — the cascade half of
+* {@link bagNameEdges}.
+*
+* Key ORDER is preserved, because a bag's order is declaration order in the emitted rule: for a
+* shorthand/longhand pair, moving one changes what paints. So a key is swapped in place, which needs
+* a fresh object, which is why the walk runs bottom-up.
+*/
+const leafOf = (path) => path.slice(path.lastIndexOf("/") + 1);
+function bagRewriteName(sites) {
+	return (data, from, to) => {
+		const source = splitRef(from);
+		const target = splitRef(to);
+		if (source.kind !== "style-property" && source.kind !== "modifier") return data;
+		const modifier = source.kind === "modifier";
+		const oldKey = modifier ? `_${leafOf(source.path)}` : source.qualifiedPath;
+		const newKey = modifier ? `_${leafOf(target.path)}` : target.qualifiedPath;
+		const next = structuredClone(data);
+		let changed = false;
+		for (const { bag, write } of [...sites(next)].reverse()) {
+			if (!(oldKey in bag)) continue;
+			write(Object.fromEntries(Object.entries(bag).map(([key, value]) => [key === oldKey ? newKey : key, value])));
+			changed = true;
+		}
+		return changed ? next : data;
+	};
+}
+/**
+* Bind a bag's token-named values to the tokens they name — `{ bg: 'brand' }` is stored as
+* `{ bg: { __ref: 'token:color/brand' } }`.
+*
+* This is the same coercion {@link conditionValue} performs on a rule's condition, for the same
+* reason: a name in a plain string is invisible to the ref graph, so nothing a component actually
+* USED was an edge and `dependentsOf('token', …)` answered with the declarations alone. Confidently
+* wrong rather than missing — a model told a token has no dependents can reasonably propose deleting
+* it (model gap 8).
+*
+* Per BAG rather than per prop, because the narrowed per-prop shape only exists for a layer whose
+* element resolves to a component. A raw-tag layer (`div`) and every catchall key get the open bag,
+* which is most of a real system's styling, so a per-prop transform would convert a minority of it
+* and leave the graph just as wrong.
+*
+* Only a leaf that RESOLVES as a token converts. A keyword (`row`) names no entity, an off-scale
+* literal (`[100%]`) isn't in the domain, and a ref to a token that doesn't exist would be a
+* dangling edge — worse than the missing one it replaced.
+*
+* Returns the bag it was GIVEN when nothing converted, so an unchanged bag keeps its identity and
+* the snapshot slice it sits in doesn't churn.
+*/
+function bindBagTokens(config, bag) {
+	const out = {};
+	let changed = false;
+	for (const [key, value] of Object.entries(bag)) {
+		if (key.startsWith("_") && config.resolve("modifier", key.slice(1)) && value && typeof value === "object" && !Array.isArray(value) && !isRef(value)) {
+			const inner = bindBagTokens(config, value);
+			out[key] = inner;
+			changed ||= inner !== value;
+			continue;
+		}
+		if (typeof value === "string" && config.resolve("style-property", key)) {
+			const token = stylePropTokenPath(config, key, value);
+			if (token) {
+				out[key] = ref("token", token);
+				changed = true;
+				continue;
+			}
+		}
+		out[key] = value;
+	}
+	return changed ? out : bag;
+}
+/** `border-radius` → `borderRadius`: the JSX spelling of a hyphenated name. */
+const camelCase = (name) => name.replace(/-+([a-z0-9])/g, (_match, char) => char.toUpperCase());
+/** The style property that declares this CSS property among its `properties`, if the system has one. */
+function stylePropertyBehind(config, cssProperty) {
+	return config.list("style-property").find((entry) => {
+		const properties = entry.body.properties;
+		return Array.isArray(properties) && properties.some((property) => camelCase(String(property)) === cssProperty);
+	})?.path;
+}
+/**
+* Why a bag key cannot be a style prop, or `undefined` when it can be.
+*
+* The emitter writes JSX, and JSX spells every attribute camelCase except `data-*` and `aria-*`, so
+* a hyphenated key is a CSS property name written where a style-prop name belongs. The bag is open,
+* so without this the key would pass as an element attribute and paint nothing.
+*/
+function bagKeyIssue(config, key, declared, { cssBehind = true } = {}) {
+	if (key.startsWith("data-") || key.startsWith("aria-")) return void 0;
+	if (key.includes("-")) {
+		const camel = camelCase(key);
+		if (config.resolve("style-property", camel)) return `\`${key}\` is not a style property; a layer key is the style-prop name, \`${camel}\`.`;
+		return `\`${key}\` is not a style property of this system, and a hyphenated key is passed to the element as an attribute, which paints nothing. Use a style-prop name (see style-property/list).`;
+	}
+	if (!cssBehind || declared?.has(key) || config.resolve("style-property", key)) return;
+	const behind = stylePropertyBehind(config, key);
+	if (behind) return `\`${key}\` is the CSS property behind the style property \`${behind}\`; a layer key is the style-prop name, \`${behind}\`.`;
+	if (isCssProperty(key)) return `\`${key}\` is a CSS property, and this system has no style property that sets it, so it would be passed to the element as an attribute and paint nothing. Declare one — \`{ "kind": "style-property", "operation": "create", "path": "${key}", "data": { "properties": ["${kebabCase(key)}"], "values": [] } }\` with keywords or a token group ref in \`values\` — expose it on the primitive as \`{ "type": "styleProperty", "value": { "__ref": "style-property:${key}" } }\`, then set it here by one of its values.`;
+}
+/** A registered modifier's block, which holds a bag of the same shape. */
+function isModifierBlock(config, key, value) {
+	return key.startsWith("_") && config.resolve("modifier", key.slice(1)) !== void 0 && typeof value === "object" && value !== null && !Array.isArray(value) && !isRef(value);
+}
+/**
+* Report every refused key in a bag. `nested` walks into modifier blocks; the built bag routes
+* those through itself, so it reports its own level only and the nested bag reports the rest.
+*/
+function addBagKeyIssues({ config, bag, ctx, nested, declared, cssBehind = true, path = [] }) {
+	for (const [key, value] of Object.entries(bag)) {
+		const message = bagKeyIssue(config, key, declared, { cssBehind });
+		if (message) {
+			ctx.addIssue({
+				code: "custom",
+				path: [...path, key],
+				message
+			});
+			continue;
+		}
+		if (nested && isModifierBlock(config, key, value)) addBagKeyIssues({
+			config,
+			bag: value,
+			ctx,
+			nested,
+			declared,
+			cssBehind,
+			path: [...path, key]
+		});
+	}
+}
+/** The open bag — every key a style value, with token names bound to their tokens. `cssBehind`
+*  as in {@link bagKeyIssue}: off for a bag that may reach an intrinsic element's attributes. */
+function openBag(config, { cssBehind = true } = {}) {
+	return z.record(z.string(), styleValue).superRefine((bag, ctx) => addBagKeyIssues({
+		config,
+		bag,
+		ctx,
+		nested: true,
+		cssBehind
+	})).transform((bag) => bindBagTokens(config, bag));
+}
+//#endregion
+export { Style, addBagKeyIssues, bagNameEdges, bagRewriteName, bindBagTokens, camelCase, collectBag, isPlainRecord, openBag, styleValue };

package/dist/entities/system/token-index.d.ts

@@ -0,0 +1,89 @@
+import { Config } from "../../framework/Config.js";
+
+//#region src/entities/system/token-index.d.ts
+interface TokenBinding {
+  /**
+   * The token's path — its identity AND its display label. Never split into namespace + name.
+   *
+   * QUALIFIED when the binding is borrowed (`palette/violet@ds`), because the source is half of what
+   * the ref names: the same bare path can exist in this config and in three of its sources, denoting
+   * four different colours.
+   */
+  readonly path: string;
+  /** The slug the binding is borrowed through, or `undefined` when it is this config's own. Carried
+   *  beside {@link path} so a surface can badge the provenance without re-parsing the ref. */
+  readonly source: string | undefined;
+  /**
+   * The token's own DECLARED type, when it declares one. Never inherited from a binding target.
+   *
+   * Stays declared-only because "untyped" is a state callers reason about: an untyped token is a
+   * plausible candidate for most types, so `searchTokens` offers it alongside a type filter and takes
+   * `untyped: 'exclude'` for a cell that cannot take one. Sniffing a type here would answer that
+   * question for them, and an untyped `gradient/*` would stop being offered to a colour cell.
+   *
+   * A surface CHOOSING A VISUAL wants {@link valueType} instead.
+   */
+  readonly type: string | undefined;
+  /**
+   * The EFFECTIVE type — {@link type}, else the shape of the literal the chase ends at.
+   *
+   * What a swatch or a glyph is picked from, and the reason it exists is that every such site had to
+   * remember the fallback itself and five of six didn't. A raw palette is authored as bare hex with no
+   * `type`, so the declared tier alone is `undefined` for exactly the tokens most worth painting — the
+   * reference badge, the composite layer cell and the autocomplete rows all dropped their swatch and
+   * showed the generic hexagon.
+   *
+   * Beside `type` rather than replacing it because the two answer different questions, and the filter
+   * above genuinely wants the declared one.
+   */
+  readonly valueType: string | undefined;
+  /** The literal with aliases chased — what a swatch paints. The base, unless the binding was read
+   *  under a condition, in which case what that condition shows. */
+  readonly value: string | number | undefined;
+}
+/** A candidate for something the user typed. Same shape as a binding: a match IS a binding. */
+interface TokenMatch extends TokenBinding {}
+/**
+ * What `value` binds to, or `undefined` when it is a literal.
+ *
+ * Accepts a `Ref` (or a `kind:path` marker string) and nothing else. A `var(--…)` string is a
+ * literal here by design — see the module note.
+ *
+ * Read in the config the ref NAMES, via the same `configFor` routing every other read uses. It used to
+ * strip the `@source` and look the bare path up locally, which for a borrowed ref answers with OUR
+ * token of that path — `brand/primary` borrowing `palette/violet@ds` painted the local
+ * `palette/violet`, a confidently wrong colour with nothing to signal it, and fell back to "not a
+ * binding" when we happened to have no such token. That is the fallback `resolveFieldValue` and
+ * `configFor` both refuse for the same reason.
+ */
+declare function tokenBinding(config: Config, value: unknown, options?: {
+  /** The override condition the binding is read under, so `value` is what that condition shows.
+   *  `null`, the default, is the base. */
+  under?: string | null;
+}): TokenBinding | undefined;
+/**
+ * Which token this name names EXACTLY — the token flavour of {@link matchEntities}, adding the type
+ * and the resolved literal so a caller needs no second lookup.
+ *
+ * More than one result means the name is genuinely ambiguous and the caller must disambiguate.
+ */
+declare function matchTokens(config: Config, query: string, opts?: {
+  type?: string;
+  limit?: number;
+}): TokenMatch[];
+/**
+ * Tokens a partial query might mean, best first — the token flavour of {@link searchEntities}.
+ *
+ * `untyped` is the one rule that is genuinely about tokens rather than searching: a token declaring no
+ * type of its own is usually a plausible candidate, but a colour cell offering untyped `gradient/*` and
+ * `flex/*` tokens was a real bug. `'include'` (the default) over-suggests; `'exclude'` is for a field
+ * that cannot survive a wrong one. The CALLER decides, because which value types are fussy is a
+ * property of the surface, not of the config.
+ */
+declare function searchTokens(config: Config, query: string, opts?: {
+  type?: string;
+  limit?: number;
+  untyped?: 'include' | 'exclude';
+}): TokenMatch[];
+//#endregion
+export { TokenBinding, TokenMatch, matchTokens, searchTokens, tokenBinding };

package/dist/entities/system/token-index.js

@@ -0,0 +1,112 @@
+import { isRef, splitRef } from "../../framework/utils/refs.js";
+import { resolveTokenValueUnder } from "../../framework/projections.js";
+import { resolveValueType } from "../../css/value-type.js";
+import { matchEntities, searchEntities } from "../../framework/entity-search.js";
+//#region src/entities/system/token-index.ts
+/**
+* Token identity, in the one direction that round-trips.
+*
+* A token's identity is its PATH. `var(--…)` is an emit-time projection ({@link cssVarRef}) and
+* deliberately not accepted here as a way to name a token, because the encoding is many-to-one:
+* `cssVar` kebab-cases the group and collapses `/` and `.` in the leaf, so `spectrum/purple/9` and
+* `spectrum/purple-9` produce the same custom property, as do `borderColor/x` and `border/color/x`.
+* A reverse map over vars therefore cannot be correct in general — it silently answers with whichever
+* claimant it indexed last. So there is no var→token direction here at all. Code that has to read
+* legacy var-shaped data (a one-time migration) builds its own index at that boundary and discards
+* it; nothing permanent should depend on an encoding that cannot express identity.
+*
+* So: a stored value either REFS a token (`{ __ref: 'token:<path>' }`) or is a literal. Those are the
+* only two things a consumer has to handle. A ref may be `@source`-qualified, which decides WHERE it is
+* read, never whether it is a ref — see {@link tokenBinding}.
+*/
+/** A token's own declared type, read off the stored body. */
+function declaredTypeOf(config, path) {
+	const token = config.resolve("token", path);
+	if (!token) return void 0;
+	const type = token.toJSON().type;
+	return typeof type === "string" ? type : void 0;
+}
+/**
+* A binding read in the config that ANSWERS for it.
+*
+* `config` is where the token lives, which for a borrowed ref is not the config that holds the ref;
+* `label` is how the ref spells it, which is what a chip shows and what a rebind writes back. Split,
+* because collapsing them is exactly the bug below.
+*/
+function bindingFor(config, path, label = path, source, under = null) {
+	if (!config.resolve("token", path)) return void 0;
+	const type = declaredTypeOf(config, path);
+	const value = resolveTokenValueUnder(config, path, under);
+	return {
+		path: label,
+		source,
+		type,
+		valueType: resolveValueType({
+			type,
+			value
+		}),
+		value
+	};
+}
+/**
+* What `value` binds to, or `undefined` when it is a literal.
+*
+* Accepts a `Ref` (or a `kind:path` marker string) and nothing else. A `var(--…)` string is a
+* literal here by design — see the module note.
+*
+* Read in the config the ref NAMES, via the same `configFor` routing every other read uses. It used to
+* strip the `@source` and look the bare path up locally, which for a borrowed ref answers with OUR
+* token of that path — `brand/primary` borrowing `palette/violet@ds` painted the local
+* `palette/violet`, a confidently wrong colour with nothing to signal it, and fell back to "not a
+* binding" when we happened to have no such token. That is the fallback `resolveFieldValue` and
+* `configFor` both refuse for the same reason.
+*/
+function tokenBinding(config, value, options = {}) {
+	if (!isRef(value)) return void 0;
+	const { kind, path, qualifiedPath, source } = splitRef(value);
+	if (kind !== "token") return void 0;
+	const target = config.configFor(value);
+	if (!target) return void 0;
+	return bindingFor(target, path, qualifiedPath, source, options.under ?? null);
+}
+/** Turn paths into bindings, dropping any that no longer resolve. */
+function bindingsFor(config, paths) {
+	const matches = [];
+	for (const path of paths) {
+		const binding = bindingFor(config, path);
+		if (binding) matches.push(binding);
+	}
+	return matches;
+}
+/**
+* Which token this name names EXACTLY — the token flavour of {@link matchEntities}, adding the type
+* and the resolved literal so a caller needs no second lookup.
+*
+* More than one result means the name is genuinely ambiguous and the caller must disambiguate.
+*/
+function matchTokens(config, query, opts) {
+	const matches = bindingsFor(config, matchEntities(config, "token", query));
+	const kept = opts?.type === void 0 ? matches : matches.filter((match) => match.type === opts.type);
+	return opts?.limit === void 0 ? kept : kept.slice(0, opts.limit);
+}
+/**
+* Tokens a partial query might mean, best first — the token flavour of {@link searchEntities}.
+*
+* `untyped` is the one rule that is genuinely about tokens rather than searching: a token declaring no
+* type of its own is usually a plausible candidate, but a colour cell offering untyped `gradient/*` and
+* `flex/*` tokens was a real bug. `'include'` (the default) over-suggests; `'exclude'` is for a field
+* that cannot survive a wrong one. The CALLER decides, because which value types are fussy is a
+* property of the surface, not of the config.
+*/
+function searchTokens(config, query, opts) {
+	return bindingsFor(config, searchEntities(config, "token", query, {
+		limit: opts?.limit,
+		filter: opts?.type === void 0 ? void 0 : (path) => {
+			const type = declaredTypeOf(config, path);
+			if (type === opts.type) return true;
+			return type === void 0 && opts.untyped !== "exclude";
+		}
+	}));
+}
+//#endregion
+export { matchTokens, searchTokens, tokenBinding };