From 4dbf160c0c4eee1142d78a5e12eef00d9fb838dc Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 27 Oct 2026 16:41:10 +0000 Subject: [PATCH 1/3] fix: lay out a selector refresh before writing the selector A set_widget on a dynamic-combo selector of a declared ARRAY form wrote the selector register first and refreshed the form afterwards. When the refresh refused the prospective layout (a declared form carrying a row count outside its group range), the op was rejected without recording its op_id while the selector write stayed in the document (KA-4). Compute the refreshed order with the pending value overlaid, then write. --- src/applier.ts | 17 ++++++++++------- src/dynamic-combos.ts | 10 ++++++++-- test/dynamic-group.test.ts | 14 ++++++++++++++ 3 files changed, 32 insertions(+), 9 deletions(-) diff --git a/src/applier.ts b/src/applier.ts index a02c891..c971841 100644 --- a/src/applier.ts +++ b/src/applier.ts @@ -1609,14 +1609,17 @@ function writeWidgetValue( value: unknown, ): void { const widgets = widgetsOf(node); - mset(widgets, widgetStorageKey(widget, occurrence), structuredClone(value)); - + const key = widgetStorageKey(widget, occurrence); const form = storedWidgetFormOf(node); - if (!form || form.shape !== "array") return; - const entry = catalogEntry(catalog, String(node.get("type") ?? "")); - if (!entry?.dynamic_combos || !Object.hasOwn(entry.dynamic_combos, widget)) return; - - const order = widgetOrderForProducerOrder(entry, form.order, widgets); + const entry = form?.shape === "array" ? catalogEntry(catalog, String(node.get("type") ?? "")) : undefined; + // Lay out the prospective selection before writing: the refresh can refuse + // it (a stored row count outside the group range), and a rejected op must + // leave the document untouched (KA-4). + const order = form && entry?.dynamic_combos && Object.hasOwn(entry.dynamic_combos, widget) + ? widgetOrderForProducerOrder(entry, form.order, widgets, { key, value }) + : undefined; + mset(widgets, key, structuredClone(value)); + if (!form || !order) return; if (order.length === form.order.length && order.every((name, index) => name === form.order[index])) return; mset(node, WIDGET_FORM_KEY, { ...structuredClone(form), order: [...order] }); } diff --git a/src/dynamic-combos.ts b/src/dynamic-combos.ts index f9d553f..180a21a 100644 --- a/src/dynamic-combos.ts +++ b/src/dynamic-combos.ts @@ -166,12 +166,15 @@ export function widgetOrderForWidgets( * write wins. `producerOrder` may already contain the previous selection's * children; {@link expand} removes every catalog-owned child before expanding * the selectors from their stored values, so repeated A→B→A switches remain - * anchored to the same producer-local order. + * anchored to the same producer-local order. `pending` overlays one register + * write that has not been stored yet, so a caller can lay out the prospective + * selection and refuse it before mutating anything (KA-4). */ export function widgetOrderForProducerOrder( entry: WidgetCatalogEntry, producerOrder: readonly string[], widgets: Y.Map | undefined, + pending?: { key: string; value: unknown }, ): readonly string[] { const combos = combosOf(entry); if (!combos) return [...producerOrder]; @@ -180,7 +183,10 @@ export function widgetOrderForProducerOrder( return expand( entry, combos, - (name, _index, occurrence) => widgets?.get(widgetStorageKey(name, occurrence)), + (name, _index, occurrence) => { + const key = widgetStorageKey(name, occurrence); + return pending?.key === key ? pending.value : widgets?.get(key); + }, producerOrder, declaredGroups, ).order; diff --git a/test/dynamic-group.test.ts b/test/dynamic-group.test.ts index e6a672a..00b104a 100644 --- a/test/dynamic-group.test.ts +++ b/test/dynamic-group.test.ts @@ -514,6 +514,20 @@ describe("DynamicGroup catalog layout", () => { }, ); + it.each([-1, 1_000_000])("refuses a selector write before mutation when the declared form stores count %s", (count) => { + // A declared form is accepted as the producer wrote it, so it can carry a + // count the group range refuses. Selecting the option that lays that group + // out must be rejected whole, not after the selector register is written. + const workflow = structuredClone(cases.empty); + const node = workflow.nodes[0]!; + delete node["widgets_values_named"]; + node.widgets_values = ["first", "off", count, "last"]; + node.widgets_values_form = { order: ["before", "mode", "loras", "after"] }; + + assertRejectedWithoutMutation(workflow, edit("mode", "on"), "apply_failed", conditionalCatalog, + edit("after", "must not run", 2)); + }); + it("preserves rows above a newer catalog's advertised maximum", () => { const smaller = structuredClone(catalog); smaller.types["DevToolsNodeWithDynamicGroup"]!.dynamic_groups!["loras"]!.max = 1; From 763d7128828dbfeed2f50e053125ebb30e76d7a9 Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 27 Oct 2026 16:49:34 +0000 Subject: [PATCH 2/3] fix: lay out the same clone the selector write stores --- src/applier.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/applier.ts b/src/applier.ts index c971841..078d907 100644 --- a/src/applier.ts +++ b/src/applier.ts @@ -1610,15 +1610,17 @@ function writeWidgetValue( ): void { const widgets = widgetsOf(node); const key = widgetStorageKey(widget, occurrence); + // Lay out exactly what will be stored, as the stored-then-refreshed order did. + const stored = structuredClone(value); const form = storedWidgetFormOf(node); const entry = form?.shape === "array" ? catalogEntry(catalog, String(node.get("type") ?? "")) : undefined; // Lay out the prospective selection before writing: the refresh can refuse // it (a stored row count outside the group range), and a rejected op must // leave the document untouched (KA-4). const order = form && entry?.dynamic_combos && Object.hasOwn(entry.dynamic_combos, widget) - ? widgetOrderForProducerOrder(entry, form.order, widgets, { key, value }) + ? widgetOrderForProducerOrder(entry, form.order, widgets, { key, value: stored }) : undefined; - mset(widgets, key, structuredClone(value)); + mset(widgets, key, stored); if (!form || !order) return; if (order.length === form.order.length && order.every((name, index) => name === form.order[index])) return; mset(node, WIDGET_FORM_KEY, { ...structuredClone(form), order: [...order] }); From 02ffaec3d59024cf33dffc7570613cbc82766979 Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 27 Oct 2026 16:55:34 +0000 Subject: [PATCH 3/3] test: expect the DynamicGroup count code after rebasing onto the rejection codes --- test/dynamic-group.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/dynamic-group.test.ts b/test/dynamic-group.test.ts index 00b104a..48684b0 100644 --- a/test/dynamic-group.test.ts +++ b/test/dynamic-group.test.ts @@ -524,7 +524,7 @@ describe("DynamicGroup catalog layout", () => { node.widgets_values = ["first", "off", count, "last"]; node.widgets_values_form = { order: ["before", "mode", "loras", "after"] }; - assertRejectedWithoutMutation(workflow, edit("mode", "on"), "apply_failed", conditionalCatalog, + assertRejectedWithoutMutation(workflow, edit("mode", "on"), "dynamic_group_count_out_of_range", conditionalCatalog, edit("after", "must not run", 2)); });