@yahoo/uds-create-config 5.22.0 → 5.23.0

package/dist/entities/system/Component.js

@@ -1,5 +1,5 @@
 import { reject, rejectData } from "../../framework/rejection.js";
-import { canonicalCondition, isRef, kindOf, memberRef, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
+import { canonicalCondition, collectRefs, isRef, kindOf, memberRef, pathOf, ref, refLeaf, refSchema, splitRef } from "../../framework/utils/refs.js";
 import { isPlainObject } from "../../framework/utils/field-path.js";
 import { pathInput } from "../../framework/schemas.js";
 import { derivedColor, gradient, oklchColor } from "./color.js";
@@ -1724,6 +1724,10 @@ const ComponentEntity = defineEntity({
 	nameEdges: bagNameEdges(componentBags),
 	styleBags: componentBags,
 	rewriteName: bagRewriteName(componentBags),
+	structuralBody: (data) => {
+		const { layers, anatomy } = data;
+		return { renders: collectRefs([...Object.values(layers ?? {}), ...Object.values(anatomy ?? {}).map((node) => node?.element)]).filter((target) => kindOf(target) === "component").map((target) => ({ __ref: target })) };
+	},
 	schemas: {
 		create: {
 			data: componentFields,

package/dist/entities/system/Token.js

@@ -1,4 +1,4 @@
-import { isRef, pathOf, ref, refKey, sourceOf } from "../../framework/utils/refs.js";
+import { isRef, kindOf, pathOf, ref, refKey, sourceOf } from "../../framework/utils/refs.js";
 import { composedValueSchemas } from "./composed-values.js";
 import { defineEntity } from "../../framework/defineEntity.js";
 import { defineSubEntity } from "../../framework/defineSubEntity.js";
@@ -141,6 +141,10 @@ const TokenEntity = defineEntity({
 		cssVariables: z.boolean().optional().describe("`false` writes the group's tokens into the values that use them instead of declaring a custom property for each, as Tailwind's `@theme inline` does. A token's own `cssVariable` wins. A config that holds the group from a linked system keeps it unless it sets its own.")
 	}),
 	subEntities: { overrides: Override },
+	structuralBody: (data) => {
+		const { value, overrides } = data;
+		return { aliases: [value, ...Object.values(overrides ?? {}).map((override) => override?.value)].filter((alias) => isRef(alias) && kindOf(alias.__ref) === "token") };
+	},
 	schemas: { create: { description: `Create a token at \`<group>/<name>\` — \`data.value\` is the CSS value. The first path segment is its group, and a style property takes a whole group as one ref (\`${JSON.stringify(ref("token", "<group>"))}\`), so put the tokens one prop should offer in one group rather than listing values on the prop.` } }
 });
 /**

package/dist/framework/Config.d.ts

@@ -985,8 +985,18 @@ declare class Config {
    *  under an id of its own and has to settle that row when the write lands, so it needs the pending
    *  entry and its own staging to agree — and an id minted here would be a second source that
    *  silently disagrees with it. Omitted, one is minted, which is what every non-optimistic caller
-   *  wants. */
+   *  wants.
+   *
+   *  A delete records more than one patch when items declare they cannot outlive the target
+   *  ({@link EntityKind.structuralBody}): a delete per dependent, leaves first, then the target, as
+   *  one changeset. `id` then names the first of them and the changeset. */
   apply(patch: Patch, id?: string): this;
+  /**
+   * {@link apply} for exactly the patch it is given: a delete takes nothing with it. For replaying a
+   * patch as it was recorded, since a recorded delete's cascade was recorded beside it, ahead of it.
+   * Deleting again what the base gained since would remove it with no patch saying so.
+   */
+  applyRecorded(patch: Patch, id?: string): this;
   /**
    * `run` with each kind's invariants judged once, on the config it returns, rather than after every
    * `apply` inside it. An invariant walks its whole kind, so a pass that writes a row per entity and
@@ -1024,7 +1034,62 @@ declare class Config {
    *
    * Several patches are one gesture, so they share one changeset; a single patch carries none.
    */
-  applyAll(patches: readonly Patch[]): this;
+  applyAll(requested: readonly Patch[]): this;
+  /**
+   * `patches` with each delete preceded by the deletes that go with it, each judged against the state
+   * the patches before it produce. A later delete of something the batch already took is dropped, so
+   * a caller listing both the entity and its dependent, in either order, deletes each once.
+   *
+   * Applied unchecked to a scratch snapshot to learn those states. A refusal there stops the
+   * expansion and hands back the rest of `patches` as given, so the real pass refuses at the same
+   * patch, with the same message, a single `apply` would.
+   */
+  private withStructuralDependents;
+  /** The kinds that declare {@link EntityKind.structuralBody}, with it. */
+  private cascadingKinds;
+  /**
+   * Every structural ref the stored items of the cascading kinds hold, keyed by the kind it names,
+   * with bare leaves spelled out in full. A ref into a source names the source's entity, never this
+   * config's, so it is left out, and so is a row a source minted.
+   */
+  private structuralEdges;
+  /**
+   * The deletes that go with `patch`, leaves first: one for every item of a kind declaring
+   * {@link EntityKind.structuralBody} whose structural refs name the deleted entity, under any
+   * spelling {@link refAliases} admits, or anything under its path, preceded by whatever goes with
+   * that item in turn. Empty unless `patch` is a delete.
+   *
+   * `edges` may come from an earlier state, so an edge whose item is gone is skipped.
+   */
+  private structuralDependentsOf;
+  /**
+   * What deleting `kind:path` takes with it, in the order the delete writes them, whether or not the
+   * delete would be refused. {@link EntityKind.structuralBody} decides what counts.
+   */
+  cascadeOf({
+    kind,
+    path
+  }: {
+    kind: string;
+    path: string;
+  }): {
+    kind: string;
+    path: string;
+  }[];
+  /**
+   * Refuse a delete whose cascade takes something that an entity outside it still refers to, naming
+   * the entity the caller deleted. Without this the refusal comes from the dependent's own delete, and
+   * names an entity the caller never asked to delete. A referrer of the target itself is left to the
+   * delete's own rule.
+   */
+  private assertCascadeUnblocked;
+  /**
+   * `deletes` reordered so each one comes after every other one whose entity still refers to it, by
+   * any ref, since each delete is refused while something still points at it. The structural walk
+   * already puts a dependent before what it depends on; this also covers a plain ref between two
+   * dependents. Members of a cycle keep their order, and the delete that meets the cycle refuses.
+   */
+  private referrersFirst;
   /**
    * Whether patches on kinds that name no source can change the rows a derive mints between `before`
    * and `after`: they wrote a pin (an edit to a minted row lands in its pin's `options`), or a row

package/dist/framework/Config.js

@@ -1265,8 +1265,26 @@ var Config = class Config {
 	*  under an id of its own and has to settle that row when the write lands, so it needs the pending
 	*  entry and its own staging to agree — and an id minted here would be a second source that
 	*  silently disagrees with it. Omitted, one is minted, which is what every non-optimistic caller
-	*  wants. */
+	*  wants.
+	*
+	*  A delete records more than one patch when items declare they cannot outlive the target
+	*  ({@link EntityKind.structuralBody}): a delete per dependent, leaves first, then the target, as
+	*  one changeset. `id` then names the first of them and the changeset. */
 	apply(patch, id) {
+		const dependents = this.structuralDependentsOf({ patch });
+		if (dependents.length === 0) return this.applyRecorded(patch, id);
+		const since = this.state.pending.length;
+		return [...dependents, patch].reduce((config, each) => config.applyRecorded(each), this).withChangeset({
+			since,
+			id
+		});
+	}
+	/**
+	* {@link apply} for exactly the patch it is given: a delete takes nothing with it. For replaying a
+	* patch as it was recorded, since a recorded delete's cascade was recorded beside it, ahead of it.
+	* Deleting again what the base gained since would remove it with no patch saying so.
+	*/
+	applyRecorded(patch, id) {
 		const deferred = this.state.deferredInvariants;
 		if (deferred?.open) deferred.kinds.add(patch.kind);
 		const applied = this.applyPatch(patch, id, !deferred?.open);
@@ -1361,8 +1379,9 @@ var Config = class Config {
 	*
 	* Several patches are one gesture, so they share one changeset; a single patch carries none.
 	*/
-	applyAll(patches) {
-		if (patches.length === 0) return this;
+	applyAll(requested) {
+		if (requested.length === 0) return this;
+		const patches = this.withStructuralDependents(requested);
 		const changeset = patches.length > 1 ? crypto.randomUUID() : void 0;
 		const stampOf = (patch) => stamp(patch, void 0, changeset);
 		const touched = new Set(patches.map((patch) => patch.kind));
@@ -1412,6 +1431,196 @@ var Config = class Config {
 		return config.derivedForEdit(actionOf(patches));
 	}
 	/**
+	* `patches` with each delete preceded by the deletes that go with it, each judged against the state
+	* the patches before it produce. A later delete of something the batch already took is dropped, so
+	* a caller listing both the entity and its dependent, in either order, deletes each once.
+	*
+	* Applied unchecked to a scratch snapshot to learn those states. A refusal there stops the
+	* expansion and hands back the rest of `patches` as given, so the real pass refuses at the same
+	* patch, with the same message, a single `apply` would.
+	*/
+	withStructuralDependents(patches) {
+		const cascading = this.cascadingKinds();
+		if (cascading.length === 0) return patches;
+		if (!patches.some((patch) => patch.operation === "delete")) return patches;
+		if (!(cascading.some(({ kind }) => this.state.snapshot.slice(kind).items.size > 0) || patches.some((patch) => cascading.some(({ kind }) => kind === patch.kind)))) return patches;
+		const expanded = [];
+		const cascaded = /* @__PURE__ */ new Set();
+		const movesSource = patches.some((patch) => this.entityOf(patch.kind)?.sourceIdentity);
+		let view = movesSource ? this : this.derive({ snapshot: this.state.snapshot.drafting() });
+		let edges;
+		for (const [index, patch] of patches.entries()) {
+			if (patch.operation === "delete" && cascaded.has(`${patch.kind}:${patch.path}`) && !view.state.snapshot.has(patch.kind, view.leafPath(patch.kind, patch.path) ?? patch.path)) continue;
+			if (patch.operation === "delete") edges ??= view.structuralEdges();
+			const step = [...view.structuralDependentsOf({
+				patch,
+				edges
+			}), patch];
+			expanded.push(...step);
+			try {
+				for (const each of step) view = movesSource ? view.applyPatch(each, void 0, false) : view.derive({ snapshot: view.computeApply(view.state.snapshot, each, "write", false) });
+			} catch (error) {
+				if (!isConfigRejection(error)) throw error;
+				return [...expanded, ...patches.slice(index + 1)];
+			}
+			if (patch.operation !== "delete") edges = void 0;
+			for (const each of step) if (each !== patch && each.operation === "delete") for (const spelling of view.refAliases(each.kind, each.path)) cascaded.add(spelling);
+		}
+		return expanded;
+	}
+	/** The kinds that declare {@link EntityKind.structuralBody}, with it. */
+	cascadingKinds() {
+		const cascading = [];
+		for (const [kind, entry] of this.state.entities) if (entry.structuralBody) cascading.push({
+			kind,
+			structuralBody: entry.structuralBody
+		});
+		return cascading;
+	}
+	/**
+	* Every structural ref the stored items of the cascading kinds hold, keyed by the kind it names,
+	* with bare leaves spelled out in full. A ref into a source names the source's entity, never this
+	* config's, so it is left out, and so is a row a source minted.
+	*/
+	structuralEdges() {
+		const edges = /* @__PURE__ */ new Map();
+		for (const { kind, structuralBody } of this.cascadingKinds()) for (const entity of this.state.snapshot.values(kind)) {
+			const body = entity.toJSON();
+			if (isMintedRow(body)) continue;
+			const fields = isExtendedRef(body) ? body.extend : body;
+			for (const ref of collectRefs(structuralBody(fields))) {
+				if (sourceOf(ref) !== void 0) continue;
+				const target = splitRef(ref);
+				const named = edges.get(target.kind) ?? [];
+				named.push({
+					targetPath: this.leafPath(target.kind, target.qualifiedPath) ?? target.qualifiedPath,
+					kind,
+					path: entity.path
+				});
+				edges.set(target.kind, named);
+			}
+		}
+		return edges;
+	}
+	/**
+	* The deletes that go with `patch`, leaves first: one for every item of a kind declaring
+	* {@link EntityKind.structuralBody} whose structural refs name the deleted entity, under any
+	* spelling {@link refAliases} admits, or anything under its path, preceded by whatever goes with
+	* that item in turn. Empty unless `patch` is a delete.
+	*
+	* `edges` may come from an earlier state, so an edge whose item is gone is skipped.
+	*/
+	structuralDependentsOf({ patch, edges: given, checked = true }) {
+		if (patch.operation !== "delete") return [];
+		if (this.cascadingKinds().length === 0) return [];
+		if (this.declaringSource(patch.kind, patch.path) !== void 0) return [];
+		const edges = given ?? this.structuralEdges();
+		if (edges.size === 0) return [];
+		const seen = new Set([`${patch.kind}:${patch.path}`]);
+		const ordered = [];
+		const visit = ({ kind, path }) => {
+			const spellings = new Set(this.refAliases(kind, path));
+			const fullPath = this.leafPath(kind, path) ?? path;
+			for (const edge of edges.get(kind) ?? []) {
+				if (!(spellings.has(`${kind}:${edge.targetPath}`) || edge.targetPath.startsWith(`${fullPath}/`))) continue;
+				const key = `${edge.kind}:${edge.path}`;
+				if (seen.has(key)) continue;
+				if (!this.state.snapshot.has(edge.kind, edge.path)) continue;
+				seen.add(key);
+				if (this.declaringSource(edge.kind, edge.path) === void 0) visit({
+					kind: edge.kind,
+					path: edge.path
+				});
+				ordered.push({
+					kind: edge.kind,
+					operation: "delete",
+					path: edge.path
+				});
+			}
+		};
+		visit({
+			kind: patch.kind,
+			path: patch.path
+		});
+		if (checked) this.assertCascadeUnblocked({
+			patch,
+			cascade: ordered
+		});
+		return this.referrersFirst(ordered);
+	}
+	/**
+	* What deleting `kind:path` takes with it, in the order the delete writes them, whether or not the
+	* delete would be refused. {@link EntityKind.structuralBody} decides what counts.
+	*/
+	cascadeOf({ kind, path }) {
+		return this.structuralDependentsOf({
+			patch: {
+				kind,
+				operation: "delete",
+				path
+			},
+			checked: false
+		}).flatMap((each) => each.operation === "delete" ? [{
+			kind: each.kind,
+			path: each.path
+		}] : []);
+	}
+	/**
+	* Refuse a delete whose cascade takes something that an entity outside it still refers to, naming
+	* the entity the caller deleted. Without this the refusal comes from the dependent's own delete, and
+	* names an entity the caller never asked to delete. A referrer of the target itself is left to the
+	* delete's own rule.
+	*/
+	assertCascadeUnblocked({ patch, cascade }) {
+		if (!("path" in patch)) return;
+		const keyOf = (target) => {
+			const { kind, qualifiedPath } = splitRef(target);
+			return `${kind}:${qualifiedPath}`;
+		};
+		const target = `${patch.kind}:${patch.path}`;
+		const going = new Set([target, ...cascade.map((each) => `${each.kind}:${"path" in each ? each.path : ""}`)]);
+		const snapshot = this.state.snapshot;
+		for (const each of cascade) {
+			if (!("path" in each)) continue;
+			if (this.declaringSource(each.kind, each.path) !== void 0) continue;
+			const blockers = this.referrersOf(snapshot, each.kind, each.path).filter((referrer) => !going.has(keyOf(referrer))).filter((referrer) => !isMintedAt(snapshot, referrer));
+			if (blockers.length === 0) continue;
+			rejectReferrers({
+				message: `Cannot delete ${target} — it would also delete ${each.kind}:${each.path}, which ${blockers.join(", ")} still ${blockers.length === 1 ? "references" : "reference"}.`,
+				referrers: blockers
+			});
+		}
+	}
+	/**
+	* `deletes` reordered so each one comes after every other one whose entity still refers to it, by
+	* any ref, since each delete is refused while something still points at it. The structural walk
+	* already puts a dependent before what it depends on; this also covers a plain ref between two
+	* dependents. Members of a cycle keep their order, and the delete that meets the cycle refuses.
+	*/
+	referrersFirst(deletes) {
+		const keyOf = (target) => {
+			const { kind, qualifiedPath } = splitRef(target);
+			return `${kind}:${qualifiedPath}`;
+		};
+		const remaining = new Map(deletes.map((each) => [`${each.kind}:${"path" in each ? each.path : ""}`, each]));
+		const sorted = [];
+		const referredToFromRemaining = (key) => {
+			const { kind, qualifiedPath } = splitRef(key);
+			return this.referrersOf(this.state.snapshot, kind, qualifiedPath).some((referrer) => keyOf(referrer) !== key && remaining.has(keyOf(referrer)));
+		};
+		while (remaining.size > 0) {
+			const next = [...remaining.keys()].find((key) => !referredToFromRemaining(key));
+			if (next === void 0) {
+				sorted.push(...remaining.values());
+				break;
+			}
+			const each = remaining.get(next);
+			if (each) sorted.push(each);
+			remaining.delete(next);
+		}
+		return sorted;
+	}
+	/**
 	* Whether patches on kinds that name no source can change the rows a derive mints between `before`
 	* and `after`: they wrote a pin (an edit to a minted row lands in its pin's `options`), or a row
 	* they touched points at a source, changes which source-qualified refs it holds, or appears or

package/dist/framework/defineEntity.d.ts

@@ -163,7 +163,9 @@ GI extends GroupInputs = Record<never, never>> = Omit<RefSchema, 'extend'> & {
   /** Create an item of this kind — `Component.create(config, 'Button', {…})`. Typed body; returns
    *  the config for chaining. (The typed twin of `config.apply({kind, operation:'create', …})`.) */
   create<C extends Config>(config: C, path: string, data: CreateInput<F>): C; /** Update an item — a partial patch merged over the current value. */
-  update<C extends Config>(config: C, path: string, data: Partial<z.infer<F>>): C; /** Delete an item (refused while other entities still reference it). */
+  update<C extends Config>(config: C, path: string, data: Partial<z.infer<F>>): C;
+  /** Delete an item, with whatever cannot exist without it ({@link EntityKind.structuralBody}). Refused
+   *  while anything else still references it. */
   delete<C extends Config>(config: C, path: string): C; /** Rename an item's path — references cascade. */
   rename<C extends Config>(config: C, path: string, to: string): C;
   /**
@@ -321,7 +323,8 @@ declare function defineEntity<F extends FieldsSchema, G extends FieldsSchema = z
   /** Fields holding prose with mentions, authored through the class's `text` tag — see
    *  {@link EntityKind.mentionFields}. */
   mentionFields?: readonly string[]; /** Cross-item rules the kind holds — see {@link EntityKind.invariants}. */
-  invariants?: (config: Config) => string[];
+  invariants?: (config: Config) => string[]; /** See {@link EntityKind.structuralBody}. */
+  structuralBody?: (data: unknown) => Record<string, unknown>;
   /**
    * For a source kind that can be resolved: the two schemas its resolutions are validated against —
    * `{ resolved, unavailable }`. Declare it alongside `sourceIdentity` for a kind a config lists in its

package/dist/framework/defineEntity.js

@@ -132,7 +132,8 @@ function defineEntity(spec) {
 		uniqueLeaves: spec.uniqueLeaves,
 		authoredValue: spec.authoredValue,
 		mentionFields: spec.mentionFields,
-		invariants: spec.invariants
+		invariants: spec.invariants,
+		structuralBody: spec.structuralBody
 	});
 	const schema = refTo(spec.kind);
 	/**

package/dist/framework/plan.d.ts

@@ -37,8 +37,12 @@ interface RenamePlan {
 }
 interface DeletePlan {
   readonly path: string;
-  /** What still points at the entity. Each has to move or go before the delete is allowed. */
+  /** What still points at the entity. Each has to move or go before the delete is allowed, unless it
+   *  is in `cascade`. */
   readonly dependents: readonly EntityAddress[];
+  /** What the delete takes with it, in the order it deletes them, ahead of the entity itself. Reported
+   *  even when the delete would be refused, as what it would take. */
+  readonly cascade: readonly EntityAddress[];
   /** Why the delete would be refused. `undefined` when it would go through. */
   readonly blocked?: string;
 }

package/dist/framework/plan.js

@@ -66,9 +66,14 @@ function planDelete({ config, kind, path }) {
 		operation: "delete",
 		path
 	}]));
+	const cascade = config.cascadeOf({
+		kind,
+		path
+	});
 	return {
 		path,
 		dependents: addresses(config.dependentsOf(kind, path)),
+		cascade,
 		...blocked === void 0 ? {} : { blocked }
 	};
 }

package/dist/framework/registry.d.ts

@@ -338,6 +338,13 @@ interface EntityKind {
    * a stored artifact stays loadable.
    */
   readonly invariants?: (config: Config) => string[];
+  /**
+   * The slice of an item's stored fields whose refs it cannot exist without. Deleting the entity one
+   * of these refs names, or an entity whose path it is nested under, deletes the item too, in the
+   * same changeset and ahead of the entity. A kind that declares nothing here keeps a plain referrer,
+   * which refuses the delete. `group-delete` does not cascade.
+   */
+  readonly structuralBody?: (data: unknown) => Record<string, unknown>;
   /**
    * Rewrite one name wherever this kind's data holds it as a key — the cascade half of
    * {@link nameEdges}, applied by `Config.apply`'s rename alongside `rewriteRefs`.

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, prepareLinkedBody, rebaseLinkedBody, layerKeys, 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, mentionFields, invariants } = spec;
+	const { name, prepareLinkedBody, rebaseLinkedBody, layerKeys, 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, mentionFields, invariants, structuralBody } = spec;
 	const allComputed = {
 		sources: ({ member, config }) => sourceSlugs(member, config),
 		borrowedFrom: ({ config, path }) => config.borrowedFrom(name, path),
@@ -82,7 +82,8 @@ function buildKind(spec) {
 		...uniqueLeaves ? { uniqueLeaves } : {},
 		...authoredValue ? { authoredValue } : {},
 		...mentionFields?.length ? { mentionFields } : {},
-		...invariants ? { invariants } : {}
+		...invariants ? { invariants } : {},
+		...structuralBody ? { structuralBody } : {}
 	};
 }
 /** Every operation a kind exposes — its merged `schemas` map, flattened to `{ kind, verb, ... }`.

package/dist/framework/schemas.js

@@ -150,7 +150,7 @@ function defaultSchemas(kind, declaredFields, groupFields, subEntities, { single
 			input: z.object({ path: PATH }),
 			readOnly: false,
 			label: "Delete",
-			description: `Delete the ${kind} at \`path\` — refused while other entities still reference it.`,
+			description: `Delete the ${kind} at \`path\`, together with any entity that cannot exist without it, such as a token aliasing it or a component whose layers render it. Refused while anything else still references it; \`delete-plan\` names both first.`,
 			scope: "item",
 			approval: "destructive",
 			handler: (i, c) => c.apply({
@@ -222,7 +222,7 @@ function defaultSchemas(kind, declaredFields, groupFields, subEntities, { single
 			input: z.object({ path: PATH }),
 			readOnly: true,
 			label: "Plan a delete",
-			description: `What deleting the ${kind} at \`path\` runs into — the entities still pointing at it, as data, and the refusal the delete would answer with. Same input as \`delete\`; writes nothing.`,
+			description: `What deleting the ${kind} at \`path\` would do: the entities still pointing at it, the ones the delete takes with it (\`cascade\`), and the refusal the delete would answer with. Same input as \`delete\`; writes nothing.`,
 			scope: "item",
 			title: (entity) => `Plan deleting ${entity}`,
 			handler: (i, c) => planDelete({

package/dist/framework/session.d.ts

@@ -183,7 +183,11 @@ declare class ConfigSession<C extends Config = Config> implements LiveConfig {
    * so a patch removed only here reappears on the next change notification — any peer edit, any
    * reconnect. See {@link ConfigSink.retract}.
    */
-  drop(patchIds: readonly string[]): void;
+  drop(patchIds: readonly string[], {
+    patchesOnly
+  }?: {
+    patchesOnly?: boolean;
+  }): void;
   /** Hand the pending batch to the sink now. Resolves once the sink has taken it. */
   flush(): Promise<void>;
   /** Detach from the source. The config value remains readable — it just stops advancing. */

package/dist/framework/session.js

@@ -201,18 +201,21 @@ var ConfigSession = class {
 	* so a patch removed only here reappears on the next change notification — any peer edit, any
 	* reconnect. See {@link ConfigSink.retract}.
 	*/
-	drop(patchIds) {
+	drop(patchIds, { patchesOnly = false } = {}) {
 		if (patchIds.length === 0) return;
-		const refused = new Set(patchIds);
+		const named = new Set(patchIds);
 		const before = this.#config.pending;
-		const kept = before.filter((entry) => !refused.has(entry.id) && !(entry.changeset !== void 0 && refused.has(entry.changeset)));
+		const refused = new Set(before.filter((entry) => named.has(entry.id) || !patchesOnly && entry.changeset !== void 0 && named.has(entry.changeset)).map((entry) => entry.id));
+		const kept = before.filter((entry) => !refused.has(entry.id));
 		if (kept.length === before.length) return;
 		const neverSent = new Set(this.#uncommitted.map((entry) => entry.id));
 		this.#uncommitted = this.#uncommitted.filter((entry) => !refused.has(entry.id));
 		this.#config = this.#afterRebase(this.#config.withDraft(kept), "drop");
 		this.#notify();
 		const survived = new Set(this.#config.pending.map((entry) => entry.id));
-		this.#retract(before.map((entry) => entry.id).filter((id) => !survived.has(id) && !neverSent.has(id)));
+		const removed = new Set(before.map((entry) => entry.id).filter((id) => !survived.has(id)));
+		this.#uncommitted = this.#uncommitted.filter((entry) => !removed.has(entry.id));
+		this.#retract([...removed].filter((id) => !neverSent.has(id)));
 	}
 	/** Write a removal through to the sink, deferring any id whose own commit is still in flight. */
 	#retract(ids) {