@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/entities/system/icon-library.js

@@ -0,0 +1,112 @@
+import { pathOf } from "../../framework/utils/refs.js";
+import { resolveComponentProps } from "../../framework/projections.js";
+import { Component } from "./Component.js";
+import { Icon } from "./Icon.js";
+import { parseAssetType } from "../../spec/asset-jsx.js";
+//#region src/entities/system/icon-library.ts
+/**
+* The icon-library READ projection — an icon group's node and members as one plain value, beside
+* the entity that stores them.
+*
+* An icon is an entity (`icon:phosphor/StarIcon`) and everything describing the SET lives on the
+* emergent group node — the sizes and variants it ships, and the component a placed glyph renders
+* through. {@link IconLibrary} is that group node read once, so a surface asks a plain value
+* rather than re-querying the config per member.
+*
+* A placed glyph's spec `type` IS the member's ref (`icon:phosphor/StarIcon`) — the same identity
+* the config uses, which is what `parseAssetType` reads.
+*
+* This is the one home for the question "what icon sets does this system have" — Studio owns only
+* UI policy on top (picker state, grid geometry, recents, search ranking). Like `Component.list`,
+* the functions here build fresh values per call: consume them in place or memoize on the config.
+*/
+const EMPTY_VARIANTS = Object.freeze([]);
+const EMPTY_SIZES = Object.freeze({});
+const EMPTY_CATEGORIES = Object.freeze([]);
+/** The spec `type` a placed glyph of this library carries — its own ref. */
+function assetType(library, member) {
+	return `icon:${library.path}/${member}`;
+}
+/** One library by its group path — `undefined` when the config has no such set. */
+function iconLibrary(config, path) {
+	if (!config) return void 0;
+	const meta = config.groupMeta("icon", path);
+	if (!meta) return void 0;
+	const component = meta.component ? pathOf(meta.component) : void 0;
+	const defaults = component ? Component.get(config, component)?.defaultProps : void 0;
+	const defaultVariant = typeof defaults?.variant === "string" ? defaults.variant : void 0;
+	const defaultSizeKey = typeof defaults?.size === "string" ? defaults.size : void 0;
+	return {
+		path,
+		members: config.members("icon", path).map((member) => member.path.startsWith(`${path}/`) ? member.path.slice(path.length + 1) : member.path),
+		sizes: meta.sizes ?? EMPTY_SIZES,
+		variants: meta.variants ?? EMPTY_VARIANTS,
+		...component !== void 0 ? { component } : {},
+		...typeof meta.module === "string" ? { module: meta.module } : {},
+		...meta.version !== void 0 ? { version: meta.version } : {},
+		...defaultVariant !== void 0 ? { defaultVariant } : {},
+		...defaultSizeKey !== void 0 ? { defaultSizeKey } : {}
+	};
+}
+/** Every icon library the config declares. */
+function iconLibraries(config) {
+	if (!config) return [];
+	return Icon.groups(config).map(({ path }) => iconLibrary(config, path)).filter((library) => library !== void 0);
+}
+/**
+* The library a surface should show: the hinted one when a caller carries a slug (a slot's
+* `accepts` ref, a stored fill), else the first library that actually has members. One home for
+* that policy — the toolbar, placement, and the panel all resolve through here, so no surface
+* carries its own idea of a default set. A hint that names no library resolves to `undefined`
+* rather than falling back: the caller knows whether a stale slug should show empty or pick anew.
+*/
+function resolveIconLibrary(config, hint) {
+	if (hint) return iconLibrary(config, hint);
+	return iconLibraries(config).find((library) => library.members.length > 0);
+}
+/**
+* Every category the library's members carry, RAW as stored (lowercase, unsorted within a member,
+* plural per member), deduplicated and sorted for a filter menu. Casing is display policy — a
+* surface title-cases for headings; values compare and filter by the stored form.
+*/
+function iconCategories(config, libraryPath) {
+	if (!config) return EMPTY_CATEGORIES;
+	const categories = /* @__PURE__ */ new Set();
+	for (const member of config.members("icon", libraryPath)) {
+		const glyph = Icon.get(config, member.path);
+		for (const category of glyph?.categories ?? []) categories.add(category);
+	}
+	return [...categories].sort((a, b) => a.localeCompare(b));
+}
+/**
+* The variants a placed glyph may take.
+*
+* The whole library's variants: nothing in the model describes one glyph's own set yet
+* (config-v2 model gap 8 — per-item `variants` narrowing). So a set that ships a variant only
+* some of its glyphs support will offer it for all of them until that closes.
+*/
+function memberVariantOptions(library, _member) {
+	return library.variants;
+}
+/**
+* Whether an element type declares a prop that may survive layer-style projection. A placed
+* glyph's type isn't a component, so its prop surface comes from its library instead: the
+* component the set renders through, plus the size and variant axes the set ships.
+*/
+function isDeclaredElementProp(config, elementType, propName) {
+	if (!config) return false;
+	const component = Component.get(config, elementType);
+	if (component) return resolveComponentProps(config, component.path)[propName] !== void 0;
+	const parsed = parseAssetType(elementType);
+	if (!parsed) return false;
+	const library = iconLibrary(config, parsed.slug);
+	if (!library?.members.includes(parsed.member)) return false;
+	if (library.component) {
+		if (resolveComponentProps(config, library.component)[propName] !== void 0) return true;
+	}
+	if (propName === "size") return Object.keys(library.sizes).length > 0;
+	if (propName === "variant") return memberVariantOptions(library, parsed.member).length > 0;
+	return false;
+}
+//#endregion
+export { assetType, iconCategories, iconLibraries, iconLibrary, isDeclaredElementProp, memberVariantOptions, resolveIconLibrary };

package/dist/entities/system/icon-metadata.d.ts

@@ -0,0 +1,72 @@
+import { SubEntityClass } from "../../framework/defineSubEntity.js";
+import { EntityClass } from "../../framework/defineEntity.js";
+import { z } from "zod";
+
+//#region src/entities/system/icon-metadata.d.ts
+/**
+ * Icon metadata formats — the pluggable-ingest half of `metadata: { from, format }`.
+ *
+ * Every catalog carries the same facts about a glyph (categories, tags, codepoint); nobody agrees
+ * on the shape. So the FIELDS are fixed here and each format gets a named adapter: a pure function
+ * from a source's raw export to `Record<memberName, metadata>`. The host supplies the bytes — this
+ * module runs in the browser too, so nothing here touches a filesystem or resolves a module.
+ *
+ * The format list is closed on purpose: an entry exists only when its adapter ships, so a config
+ * can never declare an ingest nothing implements. Widening is additive (add the adapter, add the
+ * name). The list and the adapter table are one file so they cannot drift apart.
+ */
+/** The formats an icon group's `metadata.format` may declare — exactly the shipped adapters. */
+declare const ICON_METADATA_FORMATS: readonly ["phosphor", "uds"];
+declare const iconMetadataFormat: z.ZodEnum<{
+  uds: "uds";
+  phosphor: "phosphor";
+}>;
+type IconMetadataFormat = (typeof ICON_METADATA_FORMATS)[number];
+/**
+ * One member's descriptive facts — the same schema `Icon.fields` registers, owned here so the
+ * adapters' output contract and the entity's stored shape cannot diverge.
+ */
+declare const iconMemberMetadata: z.ZodObject<{
+  categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  codepoint: z.ZodOptional<z.ZodNumber>;
+  knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type IconMemberMetadata = z.infer<typeof iconMemberMetadata>;
+/**
+ * The `metadata` group field: where a set's member facts come from (`from`, a ref to the source's
+ * Package group) and how to read them (`format`, a shipped adapter). `Package` is the only source
+ * kind that exists; when `File`/`Url` land, `from` widens to a union — the shape stays.
+ */
+declare const iconMetadataDeclaration: z.ZodObject<{
+  from: EntityClass<z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+    exports: z.ZodOptional<SubEntityClass<z.ZodObject<{}, z.core.$strict>>>;
+  }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "package", Record<never, never>, Record<never, never>, false>;
+  format: z.ZodEnum<{
+    uds: "uds";
+    phosphor: "phosphor";
+  }>;
+}, z.core.$strict>;
+type IconMetadataDeclaration = z.infer<typeof iconMetadataDeclaration>;
+/** A format adapter: raw source data in, per-member metadata out. Throws on a shape it can't read. */
+type IconMetadataAdapter = (raw: unknown) => Record<string, IconMemberMetadata>;
+/**
+ * The uds format IS this file schema — `{ [memberName]: { categories?, tags?, codepoint?,
+ * knockoutVariants? } }` —
+ * the escape hatch a consumer's own script writes. Exported (with a JSON-Schema form below) so
+ * writing that script is a validated contract rather than a guess.
+ */
+declare const iconMetadataFile: z.ZodRecord<z.ZodString, z.ZodObject<{
+  categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  codepoint: z.ZodOptional<z.ZodNumber>;
+  knockoutVariants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
+type IconMetadataFile = z.infer<typeof iconMetadataFile>;
+/** The uds file contract as JSON Schema — what a generator stamps into `$schema`-aware tooling. */
+declare function iconMetadataFileJsonSchema(): Record<string, unknown>;
+/** Run the named format's adapter. The host resolved and read `raw`; this stays pure. */
+declare function iconMetadata(format: IconMetadataFormat, raw: unknown): Record<string, IconMemberMetadata>;
+//#endregion
+export { ICON_METADATA_FORMATS, IconMemberMetadata, IconMetadataAdapter, IconMetadataDeclaration, IconMetadataFile, IconMetadataFormat, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat };

package/dist/entities/system/icon-metadata.js

@@ -0,0 +1,111 @@
+import { Package } from "./Package.js";
+import { z } from "zod";
+//#region src/entities/system/icon-metadata.ts
+/**
+* Icon metadata formats — the pluggable-ingest half of `metadata: { from, format }`.
+*
+* Every catalog carries the same facts about a glyph (categories, tags, codepoint); nobody agrees
+* on the shape. So the FIELDS are fixed here and each format gets a named adapter: a pure function
+* from a source's raw export to `Record<memberName, metadata>`. The host supplies the bytes — this
+* module runs in the browser too, so nothing here touches a filesystem or resolves a module.
+*
+* The format list is closed on purpose: an entry exists only when its adapter ships, so a config
+* can never declare an ingest nothing implements. Widening is additive (add the adapter, add the
+* name). The list and the adapter table are one file so they cannot drift apart.
+*/
+/** The formats an icon group's `metadata.format` may declare — exactly the shipped adapters. */
+const ICON_METADATA_FORMATS = ["phosphor", "uds"];
+const iconMetadataFormat = z.enum(ICON_METADATA_FORMATS);
+/**
+* One member's descriptive facts — the same schema `Icon.fields` registers, owned here so the
+* adapters' output contract and the entity's stored shape cannot diverge.
+*/
+const iconMemberMetadata = z.strictObject({
+	/** Grouping, PLURAL — every real catalogue lets a glyph belong to several (most of Phosphor's
+	*  do), or none. Stored RAW as the source spells them (`'health & wellness'`); casing and
+	*  which one a section heading shows are display policy, not stored facts. */
+	categories: z.array(z.string().min(1)).optional(),
+	/** Search terms beyond the name. Order carries no meaning; a reorder is not an edit. */
+	tags: z.array(z.string()).optional(),
+	/** The glyph's code point in a font-backed set — what a native glyphmap reads. */
+	codepoint: z.number().optional(),
+	/** Variants whose glyph paints a literal white fill by design (a "knockout" meant for dark or
+	*  branded surfaces) rather than `currentColor`. Such a glyph is invisible on a light surface,
+	*  so pickers and catalogs preview these variants on a dark one. Rendering is untouched — the
+	*  field is presentation advice for browsing UIs, and member-owned like the set's `variants`:
+	*  only a source that knows its own knockouts can flag them. */
+	knockoutVariants: z.array(z.string().min(1)).optional()
+});
+/**
+* The `metadata` group field: where a set's member facts come from (`from`, a ref to the source's
+* Package group) and how to read them (`format`, a shipped adapter). `Package` is the only source
+* kind that exists; when `File`/`Url` land, `from` widens to a union — the shape stays.
+*/
+const iconMetadataDeclaration = z.strictObject({
+	from: Package,
+	format: iconMetadataFormat
+});
+/**
+* The uds format IS this file schema — `{ [memberName]: { categories?, tags?, codepoint?,
+* knockoutVariants? } }` —
+* the escape hatch a consumer's own script writes. Exported (with a JSON-Schema form below) so
+* writing that script is a validated contract rather than a guess.
+*/
+const iconMetadataFile = z.record(z.string().min(1), iconMemberMetadata);
+/** The uds file contract as JSON Schema — what a generator stamps into `$schema`-aware tooling. */
+function iconMetadataFileJsonSchema() {
+	return z.toJSONSchema(iconMetadataFile);
+}
+/** One zod failure as a message an author can act on — path-first, every issue, one line. */
+function describeIssues(error) {
+	return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+/**
+* Phosphor's catalogue: `@phosphor-icons/core` exports `icons`, an array of entries keyed by
+* `pascal_name`. Parsed narrow and LOOSE — only the fields the adapter reads are declared, so a
+* core release adding fields is a no-op and one reshaping them is a clean failure, without this
+* package depending on `@phosphor-icons/core` for its types.
+*/
+const phosphorCatalog = z.looseObject({ icons: z.array(z.looseObject({
+	pascal_name: z.string().min(1),
+	categories: z.array(z.string().min(1)).optional(),
+	tags: z.array(z.string()).optional(),
+	codepoint: z.number().optional(),
+	/** A retired name the react package still exports for back-compat — the SAME drawing, so it
+	*  carries the same facts. Emitting it is what makes the join total: without alias rows, the
+	*  18 aliased exports would sit uncategorized forever. */
+	alias: z.looseObject({ pascal_name: z.string().min(1) }).optional()
+})) });
+const phosphor = (raw) => {
+	const parsed = phosphorCatalog.safeParse(raw);
+	if (!parsed.success) throw new Error(`phosphor metadata source did not match @phosphor-icons/core's catalogue shape — ${describeIssues(parsed.error)}`);
+	const members = {};
+	const aliases = {};
+	for (const entry of parsed.data.icons) {
+		const body = {
+			...entry.categories ? { categories: [...entry.categories] } : {},
+			...entry.tags ? { tags: [...entry.tags] } : {},
+			...entry.codepoint !== void 0 ? { codepoint: entry.codepoint } : {}
+		};
+		members[`${entry.pascal_name}Icon`] = body;
+		if (entry.alias) aliases[`${entry.alias.pascal_name}Icon`] = body;
+	}
+	for (const [name, body] of Object.entries(aliases)) members[name] ??= body;
+	return members;
+};
+const uds = (raw) => {
+	const parsed = iconMetadataFile.safeParse(raw);
+	if (!parsed.success) throw new Error(`uds metadata source did not match the uds file contract ({ [memberName]: { categories?, tags?, codepoint?, knockoutVariants? } }) — ${describeIssues(parsed.error)}`);
+	return parsed.data;
+};
+/** Exhaustive by type: a format added to the list without an adapter here fails to compile. */
+const ADAPTERS = {
+	phosphor,
+	uds
+};
+/** Run the named format's adapter. The host resolved and read `raw`; this stays pure. */
+function iconMetadata(format, raw) {
+	return ADAPTERS[format](raw);
+}
+//#endregion
+export { ICON_METADATA_FORMATS, iconMemberMetadata, iconMetadata, iconMetadataDeclaration, iconMetadataFile, iconMetadataFileJsonSchema, iconMetadataFormat };

package/dist/entities/system/link-declaration.d.ts

@@ -0,0 +1,27 @@
+import type { Config } from '../../framework/Config';
+import type { LinkDeclaration } from './LinkedSystem';
+export declare const PIN_KIND = "linked-system";
+/** The pin's `link` as stored. */
+export declare function declarationOf(config: Config, slug: string): LinkDeclaration | undefined;
+/** Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder above it. */
+export declare function covers({ declared, accessor, path, }: {
+    declared: LinkDeclaration | undefined;
+    accessor: string;
+    path: string;
+}): boolean;
+/**
+ * The declaration with `removal` taken out of it, or `undefined` when nothing stays declared.
+ *
+ * A declaration of everything is spelled out first, one kind per accessor the source has rows for, so
+ * one kind can be taken out of it; a kind taken whole is spelled out as the source's top-level paths
+ * so some can go; a declared folder above a removed path is spelled out as its other members, so the
+ * rest of it stays covered.
+ */
+export declare function narrowDeclaration({ config, slug, current, removal, verb, }: {
+    config: Config;
+    slug: string;
+    current: LinkDeclaration;
+    removal: ReadonlyMap<string, '*' | readonly string[]>;
+    /** The op asking, for the refusal. */
+    verb: string;
+}): LinkDeclaration | undefined;

package/dist/entities/system/link-declaration.js

@@ -0,0 +1,64 @@
+import { rejectData } from "../../framework/rejection.js";
+//#region src/entities/system/link-declaration.ts
+const PIN_KIND = "linked-system";
+/** The pin's `link` as stored. */
+function declarationOf(config, slug) {
+	const pin = config.storedBody(PIN_KIND, slug);
+	if (!pin) rejectData(`No linked system "${slug}".`);
+	return pin.link;
+}
+/** Whether a declaration covers the accessor's path: the whole source, the kind, the path, or a folder above it. */
+function covers({ declared, accessor, path }) {
+	if (declared === void 0) return false;
+	if (declared === "*") return true;
+	const paths = declared[accessor];
+	if (paths === void 0) return false;
+	if (paths === "*") return true;
+	return paths.some((declaredPath) => declaredPath === path || path.startsWith(`${declaredPath}/`));
+}
+/**
+* The declaration with `removal` taken out of it, or `undefined` when nothing stays declared.
+*
+* A declaration of everything is spelled out first, one kind per accessor the source has rows for, so
+* one kind can be taken out of it; a kind taken whole is spelled out as the source's top-level paths
+* so some can go; a declared folder above a removed path is spelled out as its other members, so the
+* rest of it stays covered.
+*/
+function narrowDeclaration({ config, slug, current, removal, verb }) {
+	const source = config.sourceFor(slug);
+	const next = {};
+	if (current === "*") for (const kind of config.borrowableKinds(slug)) {
+		if (source && source.list(kind).length === 0) continue;
+		next[config.accessorOf(kind) ?? kind] = "*";
+	}
+	else Object.assign(next, current);
+	for (const [accessor, paths] of removal) {
+		const before = next[accessor];
+		if (before === void 0) continue;
+		if (paths === "*") {
+			delete next[accessor];
+			continue;
+		}
+		const kind = config.accessors()[accessor]?.kind ?? accessor;
+		let declaredPaths;
+		if (before === "*") {
+			if (!source) rejectData(`Cannot ${verb} ${paths.join(", ")} through "${slug}" — the declaration takes every "${accessor}", and nothing has resolved that link to spell them out. Unlink the kind (\`{ "${accessor}": "*" }\`) instead.`, ["data", accessor]);
+			declaredPaths = source.tree(kind).map((node) => node.path);
+		} else declaredPaths = before;
+		const removed = (candidate) => paths.some((path) => path === candidate || candidate.startsWith(`${path}/`));
+		const kept = [];
+		for (const declaredPath of declaredPaths) {
+			if (removed(declaredPath)) continue;
+			if (!paths.some((path) => path.startsWith(`${declaredPath}/`)) || !source) {
+				kept.push(declaredPath);
+				continue;
+			}
+			for (const member of source.members(kind, declaredPath)) if (!removed(member.path)) kept.push(member.path);
+		}
+		if (kept.length === 0) delete next[accessor];
+		else next[accessor] = kept;
+	}
+	return Object.keys(next).length === 0 ? void 0 : next;
+}
+//#endregion
+export { PIN_KIND, covers, declarationOf, narrowDeclaration };

package/dist/entities/system/link-plan.d.ts

@@ -0,0 +1,160 @@
+import { EntityAddress } from "../../framework/plan.js";
+import { LinkDeclaration } from "./LinkedSystem.js";
+import { Config, Patch, TreeNode } from "../../framework/Config.js";
+
+//#region src/entities/system/link-plan.d.ts
+/** What one op names, keyed by accessor the way the pin's `link` is: every entry of the kind, or the
+ *  source's paths, where a folder names its members. `'*'` alone is every kind the source offers. */
+type LinkPaths = '*' | Readonly<Record<string, '*' | readonly string[]>>;
+interface LinkPlanInput {
+  /** The pin's slug. */
+  readonly path: string;
+  readonly data: LinkPaths;
+}
+/** One row a link mints. `named` when a path the call named covers it; otherwise it comes along
+ *  because something linked points at it. */
+interface LinkArrival extends EntityAddress {
+  readonly named: boolean;
+}
+interface LinkPlan {
+  /** The pin's `link` once the op has run. */
+  readonly declared: LinkDeclaration | undefined;
+  /** Every row the link mints that is not here through this pin already, named or brought along. */
+  readonly arriving: readonly LinkArrival[];
+  /** How many rows of this config's own the link writes over — `addresses.length`. */
+  readonly replaces: number;
+  /** Rows of this config's own deleted so the source's row shows through at the path. */
+  readonly addresses: readonly EntityAddress[];
+  /** Rows held through another pin, turned into extensions through this one. */
+  readonly extended: readonly EntityAddress[];
+  /** Members already here from the source's own origin, left alone and kept out of the declaration. */
+  readonly shared: readonly EntityAddress[];
+  readonly patches: readonly Patch[];
+}
+interface UnlinkPlanInput {
+  readonly path: string;
+  /** What to stop drawing; everything when omitted. */
+  readonly data?: LinkPaths;
+}
+interface UnlinkPlan {
+  readonly declared: LinkDeclaration | undefined;
+  /** The minted rows the narrower declaration no longer reaches, `cascade` among them. */
+  readonly removed: readonly EntityAddress[];
+  /** Linked rows unlinked with the named ones because they point at them: left linked, they would
+   *  bring the named rows back on the next derive. */
+  readonly cascade: readonly EntityAddress[];
+  /** Why the config would refuse. `undefined` when it would go through. */
+  readonly blocked?: string;
+  readonly patches: readonly Patch[];
+}
+interface BreakPlanInput {
+  readonly path: string;
+  /** Whether every value drawn through the pin becomes this config's own before the pin goes. */
+  readonly keep?: boolean;
+  /** One entity or folder detached through `copy` instead of the whole pin; a read only. */
+  readonly data?: LinkPaths;
+}
+type BreakOutcome = 'copied' | 'rebound' | 'follows' | 'dropped';
+type BreakReach = 'direct' | 'taken' | 'indirect' | 'linked';
+interface BreakPlanRow {
+  readonly kind: string;
+  readonly path: string;
+  readonly folder: boolean;
+  /** The refs that tie the row to what moves, as this config spells them. */
+  readonly refs: readonly string[];
+  readonly outcome: BreakOutcome;
+  readonly reach: BreakReach;
+}
+interface BreakPlan {
+  readonly rows: readonly BreakPlanRow[];
+  readonly blocked?: string;
+  readonly patches: readonly Patch[];
+}
+/** One top-level node of a source, read against what this config holds at each member path. */
+interface SourceRowState {
+  readonly kind: string;
+  /** The source's own path, which is also where a link lands it. */
+  readonly path: string;
+  readonly type: TreeNode['type'];
+  readonly name: string;
+  /** Members this config can hold. A folder counts its leaves, an item counts one. */
+  readonly members: number;
+  /** Every member is held through this pin. */
+  readonly linked: boolean;
+  /** Rows of this config's own a `link` would write over. */
+  readonly replaces: number;
+  /** Members already here from the source's own origin, through another pin. */
+  readonly shared: number;
+  /** That origin's name, when `shared` is above zero. */
+  readonly sharedOrigin?: string;
+}
+/**
+ * Link paths of a source: the declaration that mints them, then the edits that let them show through
+ * where this config already holds something.
+ *
+ * The declaration goes first. A row of this config's own that other rows point at can only be deleted
+ * once the declaration covers the path, since the config refuses a delete that leaves a referrer
+ * dangling. A row held through another pin is not deleted — that pin's declaration would mint it
+ * again, and declaring one path on two pins is a collision nothing derives — so it becomes an
+ * extension through this pin: a row of this config's own that shadows the other pin's and follows this
+ * source. A member already here from the source's own origin is left alone and kept out of the
+ * declaration, so a folder that holds one is declared by its other members.
+ */
+declare function planLink({
+  config,
+  input
+}: {
+  readonly config: Config;
+  readonly input: LinkPlanInput;
+}): LinkPlan;
+/**
+ * Stop drawing paths of a source. The declaration narrows, or clears, and the rows it minted retire
+ * with it inside the apply; nothing authored here moves. Named paths take the linked rows that point
+ * at them along (`cascade`), since left linked those would bring them back. A row of this config's own
+ * pointing at a minted row would be stranded, and the config refuses that, which `blocked` reports.
+ */
+declare function planUnlink({
+  config,
+  input
+}: {
+  readonly config: Config;
+  readonly input: UnlinkPlanInput;
+}): UnlinkPlan;
+/**
+ * Break a link: everything drawn through the pin becomes this config's own, or is dropped, and the
+ * pin goes.
+ *
+ * With `keep`, every entity drawn through the pin is copied in — the value the source holds today,
+ * written as a row of this config's own — and a row of yours that pointed through the pin has its
+ * targets copied too, with the copy pointing it at the copies. The declaration is then cleared and
+ * the pin deleted; nothing refers to it by then. Without `keep`, the declaration is cleared and the
+ * pin deleted, and a row of yours still pointing through it is what refuses the break.
+ *
+ * With `data`, the pin stays and the account is of those paths alone: with `keep`, detaching them
+ * through `copy` — the rows the copy lands, the rows of yours it rebinds, and the rows still linked
+ * that reference what moves; without it, an `unlink` of them — the rows that go, and the refusal a
+ * row of yours pointing at one would raise.
+ */
+declare function planBreak({
+  config,
+  input
+}: {
+  readonly config: Config;
+  readonly input: BreakPlanInput;
+}): BreakPlan;
+/**
+ * The source's top-level tree, one row per node, read against what this config holds at each path.
+ *
+ * Reads the live source, since the closure only carries what this config already reached and a source
+ * with nothing linked would list nothing. Kinds are `borrowableKinds`, the intersection of what the
+ * source has and this config can hold. Nothing when no source is attached.
+ */
+declare function sourceRowStates({
+  config,
+  slug
+}: {
+  readonly config: Config;
+  readonly slug: string;
+}): SourceRowState[];
+//#endregion
+export { BreakOutcome, BreakPlan, BreakPlanInput, BreakPlanRow, BreakReach, LinkArrival, LinkPaths, LinkPlan, LinkPlanInput, SourceRowState, UnlinkPlan, UnlinkPlanInput, planBreak, planLink, planUnlink, sourceRowStates };