From 68f32db869fb01a3cb9f415427f705ac4855195c Mon Sep 17 00:00:00 2001 From: bymyself Date: Fri, 30 Oct 2026 22:19:43 +0000 Subject: [PATCH 1/3] test: pin the #21091 add-versus-edit residual and DynamicGroup layout edges ADR-039 accepts the same-index race as a V1 residual and claims every replica converges; nothing asserted that. Pin both stamp outcomes in both arrival orders. Cover the layout branches line coverage showed untested: unknown entries, unset counts, name-keyed refusal, a controller repeated across selectors, and the no-selector producer order. --- test/dynamic-group-layout-edges.test.ts | 123 ++++++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 test/dynamic-group-layout-edges.test.ts diff --git a/test/dynamic-group-layout-edges.test.ts b/test/dynamic-group-layout-edges.test.ts new file mode 100644 index 0000000..4971253 --- /dev/null +++ b/test/dynamic-group-layout-edges.test.ts @@ -0,0 +1,123 @@ +import * as Y from "yjs"; +import { describe, expect, it } from "vitest"; +import { applyOps, mint, project, type TopLevelSetWidgetOp, type WidgetCatalog, type WidgetCatalogEntry, type WorkflowJSON } from "../src/index.js"; +import { widgetOrderForProducerOrder, widgetOrderForValues } from "../src/dynamic-combos.js"; +import { DynamicGroupCountError, fieldGroupOf, groupLayout, isDynamicGroupField } from "../src/dynamic-groups.js"; + +const group = { min: 0, max: 8, widgets: ["lora_name", "strength"], defaults: { strength: 1 } }; +const entry: WidgetCatalogEntry = { widget_order: ["loras", "tail"], dynamic_groups: { loras: group } }; +const catalog: WidgetCatalog = { types: { Loras: entry } }; +const workflow: WorkflowJSON = { + last_node_id: 1, last_link_id: 0, links: [], groups: [], version: 0.4, + nodes: [{ id: 1, type: "Loras", pos: [0, 0], size: [100, 100], flags: {}, order: 0, mode: 0, inputs: [], outputs: [], properties: {}, widgets_values: [0, "t"] }], +}; + +const write = (widget: string, value: unknown, stamp: number, actor: string) => ({ + op: "set_widget", node_id: 1, widget, value, + op_id: `${actor.padEnd(2, "0")}${stamp.toString(16).padStart(30, "0")}`, actor, base_version: 1, stamp: [stamp, actor], +} satisfies TopLevelSetWidgetOp); + +describe("#21091 same-index add versus peer edit (ADR-039 V1 residual)", () => { + const addAndAnnounce = (stamp: number) => [ + write("loras", 1, stamp, "aa"), + write("loras.0.lora_name", "default.safetensors", stamp + 2, "aa"), + ]; + const addAndEdit = (stamp: number) => [ + write("loras", 1, stamp, "bb"), + write("loras.0.lora_name", "picked.safetensors", stamp + 1, "bb"), + ]; + const settle = (first: TopLevelSetWidgetOp[], second: TopLevelSetWidgetOp[]) => { + const doc = mint(workflow, catalog); + for (const op of [...first, ...second]) applyOps(doc, [op], catalog); + const node = project(doc, catalog).nodes[0]!; + const state = { values: node.widgets_values, named: node.widgets_values_named }; + doc.destroy(); + return state; + }; + + it("converges on the later-stamped default and loses the peer's edit in either arrival order", () => { + const announced = addAndAnnounce(5); + const edited = addAndEdit(5); + const oneWay = settle(announced, edited); + + expect(settle(edited, announced)).toEqual(oneWay); + expect(oneWay.values).toEqual([1, "default.safetensors", 1, "t"]); + }); + + it("keeps the peer's edit when it carries the later stamp, in either arrival order", () => { + const announced = addAndAnnounce(1); + const edited = addAndEdit(9); + const oneWay = settle(announced, edited); + + expect(settle(edited, announced)).toEqual(oneWay); + expect(oneWay.values).toEqual([1, "picked.safetensors", 1, "t"]); + }); +}); + +describe("DynamicGroup layout edges", () => { + it("answers no group for an unknown catalog entry", () => { + expect(fieldGroupOf(undefined, "loras.0.strength")).toBeUndefined(); + expect(isDynamicGroupField(undefined, "loras.0.strength")).toBe(false); + }); + + it("recognises only in-range row fields of a declared group", () => { + expect(fieldGroupOf(entry, "loras.0.strength")).toBe("loras"); + expect(fieldGroupOf(entry, "loras.00.strength")).toBeUndefined(); + expect(fieldGroupOf(entry, "loras.0.missing")).toBeUndefined(); + expect(fieldGroupOf({ widget_order: ["loras"] }, "loras.0.strength")).toBeUndefined(); + }); + + it("lays out the group minimum when no count is stored and leaves undeclared defaults to the reader", () => { + const layout = groupLayout({ ...entry, dynamic_groups: { loras: { ...group, min: 1 } } }, "loras", undefined)!; + + expect(layout.order).toEqual(["loras.0.lora_name", "loras.0.strength"]); + expect([...layout.defaults]).toEqual([["loras", 1], ["loras.0.strength", 1]]); + }); + + it("has no layout for a name that is not a controller", () => { + expect(groupLayout(entry, "tail", 1)).toBeUndefined(); + }); + + it("refuses an out-of-range stored count before laying out rows", () => { + expect(() => groupLayout(entry, "loras", -1)).toThrow(DynamicGroupCountError); + }); +}); + +describe("widget order for DynamicGroup values", () => { + it("has no order without a catalog entry", () => { + expect(widgetOrderForValues(undefined, [1])).toBeUndefined(); + }); + + it("falls back to the group minimum when a node holds no values", () => { + const minOne: WidgetCatalogEntry = { ...entry, dynamic_groups: { loras: { ...group, min: 1 } } }; + + expect(widgetOrderForValues(minOne, null)).toEqual(["loras", "loras.0.lora_name", "loras.0.strength", "tail"]); + }); + + it("refuses a name-keyed count outside the group's range", () => { + expect(() => widgetOrderForValues(entry, { loras: -1 })).toThrow(DynamicGroupCountError); + }); + + it("ignores a name-keyed form that omits the count", () => { + expect(widgetOrderForValues(entry, { tail: "t" })).toEqual(["loras", "tail"]); + }); + + it("refuses a selected layout that repeats a controller", () => { + const repeated: WidgetCatalogEntry = { + widget_order: ["first", "second"], + dynamic_groups: { loras: group }, + dynamic_combos: { + first: { default: "on", options: { on: { widgets: ["loras"], defaults: {} } } }, + second: { default: "on", options: { on: { widgets: ["loras"], defaults: {} } } }, + }, + }; + + expect(() => widgetOrderForValues(repeated, ["on", 0, "on", 0])).toThrow("DynamicGroup controller 'loras' is duplicated"); + }); + + it("keeps the producer's order for a group node with no selector", () => { + const widgets = new Y.Doc().getMap("widgets"); + + expect(widgetOrderForProducerOrder(entry, ["tail", "loras"], widgets)).toEqual(["tail", "loras"]); + }); +}); From 63b682854dbf5a20a79d13212f708275524d5ae2 Mon Sep 17 00:00:00 2001 From: bymyself Date: Fri, 30 Oct 2026 22:20:29 +0000 Subject: [PATCH 2/3] test: assert the catalog refusal for a controller shared across selectors --- test/dynamic-group-layout-edges.test.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/dynamic-group-layout-edges.test.ts b/test/dynamic-group-layout-edges.test.ts index 4971253..2c612c1 100644 --- a/test/dynamic-group-layout-edges.test.ts +++ b/test/dynamic-group-layout-edges.test.ts @@ -102,8 +102,8 @@ describe("widget order for DynamicGroup values", () => { expect(widgetOrderForValues(entry, { tail: "t" })).toEqual(["loras", "tail"]); }); - it("refuses a selected layout that repeats a controller", () => { - const repeated: WidgetCatalogEntry = { + it("refuses a catalog whose selectors can both offer one controller", () => { + const shared: WidgetCatalogEntry = { widget_order: ["first", "second"], dynamic_groups: { loras: group }, dynamic_combos: { @@ -112,7 +112,7 @@ describe("widget order for DynamicGroup values", () => { }, }; - expect(() => widgetOrderForValues(repeated, ["on", 0, "on", 0])).toThrow("DynamicGroup controller 'loras' is duplicated"); + expect(() => widgetOrderForValues(shared, ["on", 0, "on", 0])).toThrow("DynamicGroup controller 'loras' can"); }); it("keeps the producer's order for a group node with no selector", () => { From fc6b62366baaab7b02c9928239564bc9c10a1623 Mon Sep 17 00:00:00 2001 From: bymyself Date: Fri, 30 Oct 2026 22:39:45 +0000 Subject: [PATCH 3/3] test: replay the race ops as no-ops in both arrival orders --- test/dynamic-group-layout-edges.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/dynamic-group-layout-edges.test.ts b/test/dynamic-group-layout-edges.test.ts index 2c612c1..3ea76eb 100644 --- a/test/dynamic-group-layout-edges.test.ts +++ b/test/dynamic-group-layout-edges.test.ts @@ -31,6 +31,11 @@ describe("#21091 same-index add versus peer edit (ADR-039 V1 residual)", () => { for (const op of [...first, ...second]) applyOps(doc, [op], catalog); const node = project(doc, catalog).nodes[0]!; const state = { values: node.widgets_values, named: node.widgets_values_named }; + const settled = Y.encodeStateAsUpdate(doc); + for (const op of [...first, ...second]) { + expect(applyOps(doc, [op], catalog).outcomes[0]?.outcome).toBe("no-op"); + expect(Y.encodeStateAsUpdate(doc)).toEqual(settled); + } doc.destroy(); return state; };