@miragon/modeler-api 0.0.0-stage → 1.1.0

package/dist/conformance.js

@@ -0,0 +1,1049 @@
+import {
+  MODELER_API_VERSION
+} from "./chunk-32BMH76T.js";
+
+// src/conformance.ts
+function attachedHost(width = 800, height = 600) {
+  const wrapper = document.createElement("div");
+  wrapper.style.cssText = `width:${width}px;height:${height}px;position:absolute;left:0;top:0;overflow:hidden`;
+  const host = document.createElement("div");
+  host.style.cssText = "width:100%;height:100%";
+  wrapper.append(host);
+  document.body.append(wrapper);
+  return host;
+}
+function apiVersionsCompatible(a, b) {
+  const [aMajor = "", aMinor = ""] = a.split(".");
+  const [bMajor = "", bMinor = ""] = b.split(".");
+  if (aMajor !== bMajor) return false;
+  return aMajor !== "0" || aMinor === bMinor;
+}
+function fail(message) {
+  throw new Error(`modeler-api conformance: ${message}`);
+}
+var skip = (reason) => ({ skipped: reason });
+function exportOrFail(modeler, when) {
+  try {
+    return modeler.exportText();
+  } catch (e) {
+    fail(`exportText threw ${when}: ${String(e)}`);
+  }
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function assertFinite(state, when) {
+  const json = JSON.stringify(
+    state,
+    (_k, v) => typeof v === "number" && !Number.isFinite(v) ? "__non_finite__" : v
+  );
+  if (json?.includes("__non_finite__")) {
+    fail(
+      `getViewState() ${when} contains a non-finite number \u2014 the host has no size (mount into attachedHost())`
+    );
+  }
+}
+var defaultSettle = () => new Promise((resolve) => setTimeout(resolve, 0));
+var PRE_IMPORT_CALL_BOUND_MS = 2e3;
+async function toleratedCall(action, ms) {
+  let timer;
+  const call = Promise.resolve().then(action).catch(() => void 0);
+  const bound = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms);
+  });
+  try {
+    await Promise.race([call, bound]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function changeEvents(harness, modeler, action) {
+  const settle = harness.settle ?? defaultSettle;
+  let calls = 0;
+  let exportAtEmit;
+  const off = modeler.onContentChanged(() => {
+    calls += 1;
+    exportAtEmit = modeler.exportText();
+  });
+  try {
+    await action();
+    await settle();
+  } finally {
+    off();
+  }
+  return { calls, exportAtEmit };
+}
+var lettersAndDigits = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+var secondText = (h) => h.canonicalTexts[1] ?? h.canonicalTexts[0] ?? "";
+var mutationsOf = (h) => [
+  { name: "mutate (element command)", run: (m) => h.mutate(m) },
+  ...h.configMutations ?? []
+];
+var sortedIds = (m) => m.elements ? [...m.elements.list().map((e) => e.id)].sort() : void 0;
+var namesById = (m) => m.elements ? new Map(m.elements.list().map((e) => [e.id, e.name])) : void 0;
+async function importOrFail(m, text, failure) {
+  await m.importText(text).catch((e) => fail(`${failure}: ${String(e)}`));
+}
+var describeProbe = (probe) => {
+  const excerpt = probe.text.length > 40 ? `${probe.text.slice(0, 40)}\u2026` : probe.text;
+  return `${probe.label} (${JSON.stringify(excerpt)})`;
+};
+function probesOf(h) {
+  const probes = [];
+  h.canonicalTexts.forEach((text, index) => {
+    const source = `canonicalTexts[${index}]`;
+    const codePoints = Array.from(text);
+    const cut = (length) => codePoints.slice(0, length).join("");
+    probes.push(
+      { label: `the first half of ${source}`, text: cut(Math.floor(codePoints.length / 2)) },
+      { label: `the first third of ${source}`, text: cut(Math.floor(codePoints.length / 3)) },
+      { label: `${source} without its last character`, text: cut(codePoints.length - 1) },
+      { label: `${source} followed by a NUL character`, text: `${text}\0` }
+    );
+  });
+  (h.probeTexts ?? []).forEach((text, index) => probes.push({ label: `probeTexts[${index}]`, text }));
+  const seen = /* @__PURE__ */ new Set();
+  return probes.filter((probe) => {
+    if (seen.has(probe.text)) return false;
+    seen.add(probe.text);
+    return true;
+  });
+}
+async function importContentText(h, m) {
+  for (const text of h.canonicalTexts) {
+    await m.importText(text);
+    if (!m.elements || m.elements.list().length > 0) return text;
+  }
+  fail("L5 needs a canonical text that renders at least one element \u2014 an empty document has no fitted view");
+}
+function conformanceCases() {
+  return [
+    {
+      name: "meta declares the notation, editability and a compatible apiVersion",
+      async run(h) {
+        const m = await h.create();
+        try {
+          if (!m.meta.notation) fail("meta.notation is empty");
+          if (m.meta.editable !== true)
+            fail("create() must return an EDITABLE modeler (meta.editable === true)");
+          if (!apiVersionsCompatible(m.meta.apiVersion, MODELER_API_VERSION)) {
+            fail(`apiVersion ${m.meta.apiVersion} is not compatible with ${MODELER_API_VERSION}`);
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "calls before the first import never wedge the instance",
+      async run(h) {
+        const m = await h.create();
+        let control;
+        try {
+          try {
+            m.exportText();
+          } catch {
+          }
+          await toleratedCall(() => h.mutate(m), PRE_IMPORT_CALL_BOUND_MS);
+          await (h.settle ?? defaultSettle)();
+          control = await h.create();
+          const texts = h.canonicalTexts.length > 0 ? h.canonicalTexts.slice(0, 2) : [""];
+          let last = "";
+          for (const [index, text] of texts.entries()) {
+            const source = `canonicalTexts[${index}]`;
+            await control.importText(text);
+            const expected = exportOrFail(control, `after importing ${source} into a fresh instance`);
+            await importOrFail(
+              m,
+              text,
+              `importText(${source}) rejected on an instance that ran exportText() and a user command before its first import (wedged)`
+            );
+            last = exportOrFail(m, `after importing ${source} into an instance used before its first import`);
+            if (last !== expected) {
+              fail(
+                `importText(${source}) on an instance that ran exportText() and a user command before its first import did not render that document:
+--- expected (a fresh instance's export)
+${expected}
+--- got
+${last}`
+              );
+            }
+          }
+          const { calls } = await changeEvents(h, m, () => h.mutate(m));
+          if (calls === 0) {
+            fail(
+              "a user mutation fired no onContentChanged on an instance used before its first import (wedged)"
+            );
+          }
+          if (exportOrFail(m, "after a user mutation on an instance used before its first import") === last) {
+            fail("a user mutation did not apply on an instance used before its first import (wedged)");
+          }
+        } finally {
+          m.destroy();
+          control?.destroy();
+        }
+      }
+    },
+    {
+      name: "L1: importText is silent (no change events, for canonical, loose and foreign inputs)",
+      async run(h) {
+        const m = await h.create();
+        try {
+          const texts = [
+            ...h.canonicalTexts,
+            ...h.looseTexts ?? [],
+            ...(h.foreignTexts ?? []).map((f) => f.text)
+          ];
+          for (const text of texts) {
+            const { calls } = await changeEvents(h, m, () => m.importText(text).then(() => void 0));
+            if (calls > 0) fail(`importText fired onContentChanged ${calls}x`);
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L1: importText over EXISTING undo history is silent too",
+      async run(h) {
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          await h.mutate(m);
+          await (h.settle ?? defaultSettle)();
+          const { calls } = await changeEvents(h, m, () => m.importText(secondText(h)).then(() => void 0));
+          if (calls > 0) fail(`importText over a non-empty undo history fired onContentChanged ${calls}x`);
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L1: an interaction open during importText never commits",
+      async run(h) {
+        if (!h.openInteraction) {
+          return skip(
+            "openInteraction is undefined \u2014 an interaction open during an import (a label editor with typed input) was not verified"
+          );
+        }
+        const openInteraction = h.openInteraction;
+        const first = h.canonicalTexts[0] ?? "";
+        const second = h.canonicalTexts[1];
+        const m = await h.create();
+        try {
+          const legs = [];
+          if (second !== void 0) {
+            await m.importText(second);
+            const expected = exportOrFail(m, "after importing canonicalTexts[1]");
+            legs.push({ text: second, expected, what: "a different document (canonicalTexts[1])" });
+          }
+          await m.importText(first);
+          const firstExport = exportOrFail(m, "after importing canonicalTexts[0]");
+          legs.push({
+            text: first,
+            expected: firstExport,
+            what: "the same document again (canonicalTexts[0])"
+          });
+          let advice;
+          for (const [index, leg] of legs.entries()) {
+            await m.importText(first);
+            await openInteraction(m);
+            await (h.settle ?? defaultSettle)();
+            const opened = h.interactionState?.(m);
+            if (h.interactionState && opened === void 0) {
+              fail("interactionState reports no interaction after openInteraction \u2014 the case proves nothing");
+            }
+            const { calls } = await changeEvents(h, m, () => m.importText(leg.text).then(() => void 0));
+            if (calls > 0) {
+              fail(
+                `importing ${leg.what} over an open interaction fired onContentChanged ${calls}x \u2014 the interaction committed during or because of the import (if every import emits, see the L1 cases first)`
+              );
+            }
+            const reopened = h.interactionState?.(m);
+            if (exportOrFail(m, `after importing ${leg.what} over an open interaction`) !== leg.expected) {
+              fail(
+                `importing ${leg.what} over an open interaction did not leave that document \u2014 the interaction's input was applied to it`
+              );
+            }
+            if (h.undo) {
+              await h.undo(m);
+              await (h.settle ?? defaultSettle)();
+              if (exportOrFail(m, `after an undo that followed importing ${leg.what}`) !== leg.expected) {
+                fail(
+                  `undo after importing ${leg.what} over an open interaction changed the document \u2014 the interaction was committed onto the fresh undo history (L4)`
+                );
+              }
+            }
+            const sameDocument = index === legs.length - 1;
+            const kept = reopened?.elementId === opened?.elementId && reopened?.text === opened?.text;
+            if (sameDocument && opened !== void 0 && !kept) {
+              const input = opened.text === void 0 ? "" : ` with the input ${JSON.stringify(opened.text)}`;
+              const after = reopened === void 0 ? "closed it" : `left ${JSON.stringify(reopened)} open`;
+              advice = `an interaction on '${opened.elementId}'${input} did not survive a re-import of the same document (the import ${after}) \u2014 RECOMMENDED: keep the typed input and reopen the interaction on the element with the same id, so a remote re-import does not cost the user what they were typing`;
+            }
+          }
+          const unverified = [
+            ...second === void 0 ? [
+              "canonicalTexts holds one text \u2014 importing a DIFFERENT document over an open interaction was not verified (add a second canonical text)"
+            ] : [],
+            ...h.interactionState ? [] : [
+              "interactionState is undefined \u2014 the RECOMMENDED keep-and-reopen of an interaction across an import was not checked (pass interactionState to check it)"
+            ]
+          ];
+          return {
+            ...unverified.length > 0 ? { skipped: unverified.join("; ") } : {},
+            ...advice === void 0 ? {} : { advisories: [advice] }
+          };
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L2: canonical texts are byte fixpoints of import \u2192 export",
+      async run(h) {
+        if (h.canonicalTexts.length === 0) fail("harness provides no canonicalTexts");
+        const m = await h.create();
+        try {
+          for (const text of h.canonicalTexts) {
+            await m.importText(text);
+            const out = m.exportText();
+            if (out !== text)
+              fail(`export after import differs from the canonical input:
+--- in
+${text}
+--- out
+${out}`);
+            if (m.exportText() !== out)
+              fail("exportText is not deterministic \u2014 two exports of one document differ");
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L2: canonicalization of loose input is idempotent",
+      async run(h) {
+        if (h.looseTexts === void 0)
+          return skip("looseTexts is undefined \u2014 pass [] if the notation has no loose form");
+        if (h.looseTexts.length === 0) return;
+        const m = await h.create();
+        try {
+          for (const text of h.looseTexts) {
+            await m.importText(text);
+            const canonical = m.exportText();
+            await m.importText(canonical);
+            const again = m.exportText();
+            if (again !== canonical) fail("canonicalization is not idempotent on loose input");
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L3: a scripted user mutation fires onContentChanged, and the export already reflects it inside the listener",
+      async run(h) {
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          const before = m.exportText();
+          const { calls, exportAtEmit } = await changeEvents(h, m, () => h.mutate(m));
+          if (calls === 0) fail("a user mutation fired no onContentChanged");
+          const after = m.exportText();
+          if (after === before)
+            fail("the harness mutation did not change the export \u2014 the case proves nothing");
+          if (exportAtEmit !== after) {
+            fail(
+              "exportText() inside the onContentChanged listener did not return the post-change document (emit before apply)"
+            );
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L3: config/axis edits fire onContentChanged too, with the export already updated",
+      async run(h) {
+        if (h.configMutations === void 0) {
+          return skip(
+            "configMutations is undefined \u2014 pass [] if the notation has no config/axis/title surface"
+          );
+        }
+        for (const mutation of h.configMutations) {
+          const m = await h.create();
+          try {
+            await m.importText(h.canonicalTexts[0] ?? "");
+            const before = m.exportText();
+            const { calls, exportAtEmit } = await changeEvents(h, m, () => mutation.run(m));
+            if (calls === 0) fail(`config mutation "${mutation.name}" fired no onContentChanged`);
+            const after = m.exportText();
+            if (after === before) {
+              fail(`config mutation "${mutation.name}" did not change the export \u2014 the case proves nothing`);
+            }
+            if (exportAtEmit !== after) {
+              fail(
+                `exportText() inside the listener of config mutation "${mutation.name}" did not return the post-change document`
+              );
+            }
+          } finally {
+            m.destroy();
+          }
+        }
+      }
+    },
+    {
+      name: "L3: unsubscribe stops delivery",
+      async run(h) {
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          let calls = 0;
+          const off = m.onContentChanged(() => {
+            calls += 1;
+          });
+          off();
+          await h.mutate(m);
+          await (h.settle ?? defaultSettle)();
+          if (calls > 0) fail("onContentChanged delivered after unsubscribe");
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L3: undo and redo fire onContentChanged and restore the export",
+      async run(h) {
+        if (!h.undo) return skip("undo is undefined \u2014 the notation declares no undo");
+        const undo = h.undo;
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          const before = m.exportText();
+          await h.mutate(m);
+          await (h.settle ?? defaultSettle)();
+          const mutated = m.exportText();
+          const undone = await changeEvents(h, m, () => undo(m));
+          if (undone.calls === 0)
+            fail("undo fired no onContentChanged \u2014 the host would never export the undone state");
+          if (m.exportText() !== before)
+            fail("undo of a single mutation did not restore the pre-mutation export");
+          if (undone.exportAtEmit !== before)
+            fail("exportText() inside the undo listener did not return the undone document");
+          if (!h.redo)
+            return skip(
+              "redo is undefined \u2014 the redo half of this case was not verified (pass redo to verify it)"
+            );
+          const redo = h.redo;
+          const redone = await changeEvents(h, m, () => redo(m));
+          if (redone.calls === 0) fail("redo fired no onContentChanged");
+          if (m.exportText() !== mutated) fail("redo did not restore the mutated export");
+          if (redone.exportAtEmit !== mutated)
+            fail("exportText() inside the redo listener did not return the redone document");
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L4: undo directly after an import is a no-op",
+      async run(h) {
+        if (!h.undo) return skip("undo is undefined \u2014 the notation declares no undo");
+        const first = h.canonicalTexts[0];
+        const second = h.canonicalTexts[1];
+        if (first === void 0 || second === void 0 || first === second) {
+          fail("the L4 case needs TWO DISTINCT canonicalTexts \u2014 with one, stale undo is undetectable");
+        }
+        const m = await h.create();
+        try {
+          await m.importText(first);
+          await h.mutate(m);
+          await h.mutate(m);
+          const mutated = m.exportText();
+          await m.importText(mutated);
+          const baselineSame = m.exportText();
+          const idsSame = sortedIds(m);
+          const { calls } = await changeEvents(h, m, () => h.undo(m));
+          if (calls > 0)
+            fail(
+              "undo directly after importText fired onContentChanged \u2014 history housekeeping is not a change"
+            );
+          if (m.exportText() !== baselineSame || idsSame && !same(idsSame, sortedIds(m))) {
+            fail(
+              "undo after importText removed a re-imported element by id coincidence (stale history applied)"
+            );
+          }
+          await h.mutate(m);
+          await m.importText(second);
+          const baseline = m.exportText();
+          await h.undo(m);
+          await h.undo(m);
+          if (m.exportText() !== baseline) {
+            fail("undo after importText mutated the freshly imported document (stale history applied)");
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L5: getViewState never throws before the first import",
+      async run(h) {
+        const m = await h.create();
+        try {
+          let state;
+          try {
+            state = m.getViewState();
+          } catch (e) {
+            fail(`getViewState threw before the first import: ${String(e)}`);
+          }
+          if (state !== void 0) assertFinite(state, "before the first import");
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L5: view state round-trips across a re-import, an import fits the view \u2014 and none of it is document content",
+      async run(h) {
+        if (h.viewState === void 0) {
+          return skip(
+            "viewState is undefined \u2014 supply a panned/zoomed state, a no-op setViewState is otherwise undetectable"
+          );
+        }
+        const alt = h.viewState;
+        const m = await h.create();
+        try {
+          const text = await importContentText(h, m);
+          const doc = m.exportText();
+          const fitted = m.getViewState();
+          assertFinite(fitted, "after the first import");
+          m.setViewState(alt);
+          const applied = m.getViewState();
+          assertFinite(applied, "after setViewState");
+          if (same(applied, fitted)) {
+            fail("setViewState(viewState) had no effect \u2014 supply a state that differs from the fitted view");
+          }
+          await m.importText(text);
+          if (!same(m.getViewState(), fitted)) {
+            fail(
+              "an import must leave the view FITTED to the content (the same state the first import produced)"
+            );
+          }
+          const { calls } = await changeEvents(h, m, () => m.setViewState(applied));
+          if (calls > 0) fail("setViewState fired onContentChanged \u2014 view state is not document content");
+          if (m.exportText() !== doc)
+            fail("setViewState changed the export \u2014 view state leaked into the document");
+          if (!same(m.getViewState(), applied)) {
+            fail(
+              "view state did not survive re-import + restore (setting the modeler's own readback must yield that readback)"
+            );
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "elements (when present): stable ids across re-imports and unrelated edits, reveal and selection semantics",
+      async run(h) {
+        const m = await h.create();
+        try {
+          const text = h.canonicalTexts[0] ?? "";
+          await m.importText(text);
+          const elements = m.elements;
+          if (!elements)
+            return skip("the modeler exposes no elements surface (optional) \u2014 nothing to verify");
+          const ids = elements.list().map((e) => e.id);
+          if (new Set(ids).size !== ids.length) fail("element ids are not unique");
+          await m.importText(text);
+          const again = elements.list().map((e) => e.id);
+          if (!same([...ids].sort(), [...again].sort()))
+            fail("element ids are not stable across re-imports of the same text");
+          if (elements.reveal("__modeler_api_no_such_id__") !== false)
+            fail("reveal(unknown id) must return false");
+          const firstId = ids[0];
+          if (firstId !== void 0) {
+            const deliveries = [];
+            const off = elements.onSelection((selected) => deliveries.push([...selected]));
+            const { calls } = await changeEvents(h, m, () => {
+              if (elements.reveal(firstId) !== true) fail("reveal(known id) must return true");
+            });
+            if (calls > 0) fail("reveal fired onContentChanged \u2014 revealing is view behavior, not an edit");
+            if (!deliveries.some((d) => d.includes(firstId))) {
+              fail(
+                `reveal('${firstId}') delivered no selection containing the id \u2014 is it a selectable element (not a root or a label)?`
+              );
+            }
+            for (const d of deliveries) {
+              for (const id of d) {
+                if (!again.includes(id)) {
+                  fail(
+                    `onSelection reported an id that is not an element: '${id}' (label ids must resolve to their target)`
+                  );
+                }
+              }
+            }
+            if (!elements.selection().includes(firstId)) fail("selection() does not contain the revealed id");
+            const seen = deliveries.length;
+            off();
+            const otherId = ids[1];
+            if (otherId !== void 0) elements.reveal(otherId);
+            else await h.mutate(m);
+            await (h.settle ?? defaultSettle)();
+            if (deliveries.length !== seen) fail("onSelection delivered after unsubscribe");
+          }
+          const namesBefore = new Map(elements.list().map((e) => [e.id, e.name]));
+          await h.mutate(m);
+          await (h.settle ?? defaultSettle)();
+          const afterEdit = new Map(elements.list().map((e) => [e.id, e.name]));
+          if (afterEdit.size <= namesBefore.size) {
+            fail(
+              "the harness mutate must ADD an element (the elements case verifies ids under an unrelated edit)"
+            );
+          }
+          for (const [id, name] of namesBefore) {
+            if (!afterEdit.has(id)) {
+              fail(
+                `element id '${id}' vanished after an unrelated edit \u2014 ids must survive edits to other elements`
+              );
+            }
+            if (name !== void 0 && afterEdit.get(id) !== name) {
+              fail(
+                `element id '${id}' names a different element after an unrelated edit ('${name}' \u2192 '${String(afterEdit.get(id))}')`
+              );
+            }
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "elements (when present): ids and names survive export \u2192 import, in this and in a fresh instance",
+      async run(h) {
+        const m = await h.create();
+        const others = [];
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          const elements = m.elements;
+          if (!elements)
+            return skip("the modeler exposes no elements surface (optional) \u2014 nothing to verify");
+          await h.mutate(m);
+          await (h.settle ?? defaultSettle)();
+          const session = new Map(elements.list().map((e) => [e.id, e.name]));
+          const exported = exportOrFail(m, "after a user mutation");
+          const expectSessionIds = (target, where) => {
+            const after = namesById(target);
+            if (!after) fail(`${where} exposes no elements surface \u2014 the editor does`);
+            for (const [id, name] of session) {
+              if (!after.has(id)) {
+                fail(
+                  `element id '${id}' is gone after export \u2192 import ${where} \u2014 the id a session reports must be the element's id in the document (write it back)`
+                );
+              }
+              if (name !== void 0 && (after.get(id) ?? "") !== name) {
+                fail(
+                  `element id '${id}' names a different element after export \u2192 import ${where} ('${name}' \u2192 '${String(after.get(id))}')`
+                );
+              }
+            }
+          };
+          await importOrFail(m, exported, "importText rejected the modeler's own export");
+          expectSessionIds(m, "into the same instance");
+          const fresh = await h.create();
+          others.push(fresh);
+          await importOrFail(fresh, exported, "a fresh instance rejected the modeler's own export");
+          expectSessionIds(fresh, "into a fresh instance");
+          if (h.createReadonly) {
+            const viewer = await h.createReadonly();
+            others.push(viewer);
+            await importOrFail(viewer, exported, "the viewer rejected the editor's export");
+            if (viewer.elements) expectSessionIds(viewer, "into the viewer");
+          }
+        } finally {
+          m.destroy();
+          for (const other of others) other.destroy();
+        }
+      }
+    },
+    {
+      name: "elements (when present, recommended): ids created on two peers at the same time do not collide",
+      async run(h) {
+        const text = h.canonicalTexts[0] ?? "";
+        const peers = [];
+        try {
+          const created = [];
+          for (let count = 0; count < 2; count += 1) {
+            const peer = await h.create();
+            peers.push(peer);
+            await peer.importText(text);
+            if (!peer.elements)
+              return skip("the modeler exposes no elements surface (optional) \u2014 nothing to verify");
+            const before = new Set(peer.elements.list().map((e) => e.id));
+            await h.mutate(peer);
+            await (h.settle ?? defaultSettle)();
+            const added = new Map(
+              peer.elements.list().filter((e) => !before.has(e.id)).map((e) => [e.id, e.name])
+            );
+            if (added.size === 0) {
+              fail(
+                "the harness mutate must ADD an element (the elements cases compare the ids two instances allocate)"
+              );
+            }
+            created.push(added);
+          }
+          const [
+            onFirst = /* @__PURE__ */ new Map(),
+            onSecond = /* @__PURE__ */ new Map()
+          ] = created;
+          const shared = [...onFirst.keys()].filter((id) => onSecond.has(id));
+          const derivedFromContent = (id) => {
+            const name = onFirst.get(id) ?? "";
+            if (name === "" || name !== (onSecond.get(id) ?? "")) return false;
+            const spelled = lettersAndDigits(name);
+            return spelled !== "" && lettersAndDigits(id).includes(spelled);
+          };
+          const allocated = shared.filter((id) => !derivedFromContent(id));
+          const quoted = (ids) => ids.map((id) => `'${id}'`).join(", ");
+          if (allocated.length > 0) {
+            return {
+              advisories: [
+                `two instances that imported the same document and each created one element, not of the same name, allocated the same id (${quoted(allocated)}) \u2014 RECOMMENDED: allocate ids for new elements that do not collide across peers (random or peer-scoped, not a per-instance counter); once both edits merge, two elements share one id`
+              ]
+            };
+          }
+          if (shared.length > 0) {
+            return skip(
+              `both instances created an element of the same name and allocated the same id, one derived from that name (${quoted(shared)}) \u2014 such ids collide for identical content by design, so the check is inconclusive: let mutate's elements differ in content (a counter the harness shares across instances)`
+            );
+          }
+        } finally {
+          for (const peer of peers) peer.destroy();
+        }
+      }
+    },
+    {
+      name: "L6: export is total after imports, user mutations and undo",
+      async run(h) {
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          for (const mutation of mutationsOf(h)) {
+            await mutation.run(m);
+            exportOrFail(m, `after ${mutation.name}`);
+          }
+          if (h.undo) {
+            await h.undo(m);
+            exportOrFail(m, "after an undo");
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L6: foreign content survives an import \u2192 export round-trip",
+      async run(h) {
+        if (h.foreignTexts === void 0) {
+          return skip("foreignTexts is undefined \u2014 pass [] if the notation has no foreign form");
+        }
+        if (h.foreignTexts.length === 0) return;
+        const m = await h.create();
+        try {
+          await foreignRoundTrips(h, m, "");
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L7: a rejected import leaves no trace",
+      async run(h) {
+        if (h.invalidTexts === void 0) {
+          return skip("invalidTexts is undefined \u2014 pass [] if the notation has no non-importable text");
+        }
+        if (h.invalidTexts.length === 0) return;
+        const m = await h.create();
+        try {
+          const text = h.canonicalTexts[0] ?? "";
+          await m.importText(text);
+          const beforeEdit = m.exportText();
+          if (h.undo) {
+            await h.mutate(m);
+            await (h.settle ?? defaultSettle)();
+          }
+          const doc = m.exportText();
+          const ids = sortedIds(m);
+          for (const bad of h.invalidTexts) {
+            let rejected = false;
+            const { calls } = await changeEvents(
+              h,
+              m,
+              () => m.importText(bad).then(
+                () => void 0,
+                () => {
+                  rejected = true;
+                }
+              )
+            );
+            if (!rejected) fail("importText resolved for a non-importable input \u2014 it must REJECT");
+            if (calls > 0) fail("a rejected import fired onContentChanged");
+            if (m.exportText() !== doc)
+              fail("a rejected import changed the document \u2014 the previous state must stay intact");
+            if (ids && !same(ids, sortedIds(m))) {
+              fail(
+                "a rejected import changed the rendered elements \u2014 the canvas must keep the previous document"
+              );
+            }
+          }
+          if (h.undo) {
+            await h.undo(m);
+            if (m.exportText() !== beforeEdit) {
+              fail(
+                "a rejected import erased the undo history \u2014 the previous document's history must stay intact"
+              );
+            }
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L7: the modeler stays usable after a rejected import",
+      async run(h) {
+        if (h.invalidTexts === void 0) {
+          return skip("invalidTexts is undefined \u2014 pass [] if the notation has no non-importable text");
+        }
+        const bad = h.invalidTexts[0];
+        if (bad === void 0) return;
+        const m = await h.create();
+        try {
+          await m.importText(h.canonicalTexts[0] ?? "");
+          await m.importText(bad).then(
+            () => fail("importText resolved for a non-importable input \u2014 it must REJECT"),
+            () => void 0
+          );
+          const next = secondText(h);
+          await m.importText(next).catch((e) => fail(`the next VALID import after a rejection did not render: ${String(e)}`));
+          if (m.exportText() !== next)
+            fail("the next valid import after a rejection did not replace the document");
+          const before = m.exportText();
+          const { calls } = await changeEvents(h, m, () => h.mutate(m));
+          if (calls === 0) fail("a user mutation after a rejected import fired no onContentChanged (wedged)");
+          if (exportOrFail(m, "after a mutation that followed a rejected import") === before) {
+            fail("a user mutation after a rejected import did not apply (wedged)");
+          }
+          if (h.undo) {
+            await h.undo(m);
+            exportOrFail(m, "after an undo that followed a rejected import");
+          }
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "L7: every rejection of a derived probe leaves no trace",
+      async run(h) {
+        const base = h.canonicalTexts[0] ?? "";
+        const m = await h.create();
+        try {
+          await m.importText(base);
+          const baseline = exportOrFail(m, "after importing canonicalTexts[0]");
+          const baseIds = sortedIds(m);
+          let previous;
+          const reimportBase = async () => {
+            if (previous === void 0) return;
+            const after = `after importing ${describeProbe(previous)}`;
+            await importOrFail(m, base, `the next valid import ${after} did not render`);
+            const doc = exportOrFail(m, `on the next valid import ${after}`);
+            if (doc !== baseline || baseIds && !same(baseIds, sortedIds(m))) {
+              fail(`the next valid import ${after} did not replace the document (wedged)`);
+            }
+          };
+          const mutateAndExpectApplied = async () => {
+            await h.mutate(m);
+            await (h.settle ?? defaultSettle)();
+            const doc = exportOrFail(m, "after a user mutation");
+            if (doc === baseline) {
+              fail(
+                previous === void 0 ? "the harness mutation did not change the export \u2014 the case proves nothing" : `a user mutation after importing ${describeProbe(previous)} did not apply (wedged)`
+              );
+            }
+            return doc;
+          };
+          for (const probe of probesOf(h)) {
+            await reimportBase();
+            const doc = await mutateAndExpectApplied();
+            const ids = sortedIds(m);
+            const what = `importText(${describeProbe(probe)})`;
+            let rejected = false;
+            const { calls } = await changeEvents(
+              h,
+              m,
+              () => m.importText(probe.text).then(
+                () => void 0,
+                () => {
+                  rejected = true;
+                }
+              )
+            );
+            if (rejected) {
+              if (calls > 0) fail(`a rejected ${what} fired onContentChanged ${calls}x (L7)`);
+              if (exportOrFail(m, `after a rejected ${what}`) !== doc) {
+                fail(`a rejected ${what} changed the document \u2014 the previous state must stay intact (L7)`);
+              }
+              if (ids && !same(ids, sortedIds(m))) {
+                fail(
+                  `a rejected ${what} changed the rendered elements \u2014 the canvas must keep the previous document (L7)`
+                );
+              }
+              if (h.undo) {
+                await h.undo(m);
+                if (exportOrFail(m, `after an undo that followed a rejected ${what}`) !== baseline) {
+                  fail(
+                    `a rejected ${what} erased the undo history \u2014 the previous document's history must stay intact (L7)`
+                  );
+                }
+              }
+            } else {
+              if (calls > 0)
+                fail(`${what} resolved and fired onContentChanged ${calls}x \u2014 an import is silent (L1)`);
+              exportOrFail(m, `after ${what} resolved (L6)`);
+            }
+            previous = probe;
+          }
+          await reimportBase();
+          await mutateAndExpectApplied();
+        } finally {
+          m.destroy();
+        }
+      }
+    },
+    {
+      name: "viewer (when shipped): read-only, silent, canonical, fits, reveals, keeps foreign content, unshaken by a rejected import",
+      async run(h) {
+        if (!h.createReadonly) return skip("createReadonly is undefined \u2014 the package ships no viewer mount");
+        const v = await h.createReadonly();
+        try {
+          if (v.meta.editable !== false)
+            fail("createReadonly() must return a viewer (meta.editable === false)");
+          try {
+            const fresh = v.getViewState();
+            if (fresh !== void 0) assertFinite(fresh, "on the viewer before the first import");
+          } catch (e) {
+            fail(`the viewer's getViewState threw before the first import: ${String(e)}`);
+          }
+          let calls = 0;
+          const off = v.onContentChanged(() => {
+            calls += 1;
+          });
+          try {
+            for (const text of h.canonicalTexts) {
+              await v.importText(text).catch((e) => fail(`the viewer rejected a canonical text: ${String(e)}`));
+              if (exportOrFail(v, "on the viewer") !== text)
+                fail("the viewer's export is not the canonical text");
+            }
+            const doc = v.exportText();
+            const ids = sortedIds(v);
+            if (v.elements) {
+              const firstId = v.elements.list()[0]?.id;
+              if (firstId !== void 0) {
+                const deliveries = [];
+                const offSel = v.elements.onSelection((s) => deliveries.push([...s]));
+                if (v.elements.reveal(firstId) !== true)
+                  fail("the viewer's reveal(known id) must return true");
+                await (h.settle ?? defaultSettle)();
+                if (!deliveries.some((d) => d.includes(firstId)))
+                  fail("the viewer's reveal delivered no selection containing the id");
+                if (!v.elements.selection().includes(firstId))
+                  fail("the viewer's selection() does not contain the revealed id");
+                offSel();
+              }
+              if (v.elements.reveal("__modeler_api_no_such_id__") !== false)
+                fail("the viewer's reveal(unknown id) must return false");
+            }
+            for (const bad of h.invalidTexts ?? []) {
+              await v.importText(bad).then(
+                () => fail("the viewer resolved a non-importable input \u2014 it must REJECT"),
+                () => void 0
+              );
+              if (v.exportText() !== doc) fail("a rejected import changed the viewer's document");
+              if (ids && !same(ids, sortedIds(v)))
+                fail("a rejected import changed the viewer's rendered elements");
+            }
+            await foreignRoundTrips(h, v, "the viewer's ");
+            if (h.viewState !== void 0) {
+              const text = await importContentText(h, v);
+              const fitted = v.getViewState();
+              assertFinite(fitted, "on the viewer after import");
+              v.setViewState(h.viewState);
+              const applied = v.getViewState();
+              if (same(applied, fitted)) fail("the viewer's setViewState had no effect");
+              await v.importText(text);
+              if (!same(v.getViewState(), fitted))
+                fail("the viewer's import must leave the view fitted (L5)");
+              v.setViewState(applied);
+              if (!same(v.getViewState(), applied))
+                fail("setting the viewer's own readback did not yield that readback");
+            }
+            await (h.settle ?? defaultSettle)();
+            if (calls > 0)
+              fail(`the viewer fired onContentChanged ${calls}x \u2014 a viewer never changes content`);
+          } finally {
+            off();
+          }
+        } finally {
+          v.destroy();
+          v.destroy();
+        }
+      }
+    },
+    {
+      name: "destroy is safe to call twice",
+      async run(h) {
+        const m = await h.create();
+        m.destroy();
+        m.destroy();
+      }
+    }
+  ];
+}
+async function foreignRoundTrips(h, m, who) {
+  for (const { text, mustSurvive } of h.foreignTexts ?? []) {
+    if (mustSurvive.length === 0) fail("a foreignTexts entry must name at least one fragment in mustSurvive");
+    await m.importText(text);
+    const first = exportOrFail(m, `${who}after importing a document with foreign content`);
+    for (const fragment of mustSurvive) {
+      if (!first.includes(fragment))
+        fail(`${who}foreign content was dropped on import \u2192 export: '${fragment}' is missing`);
+    }
+    await m.importText(first);
+    const second = exportOrFail(m, `${who}after re-importing its own export of foreign content`);
+    if (second !== first) fail(`${who}foreign content did not survive a second import \u2192 export round-trip`);
+  }
+}
+function registerConformance(harness, test, options = {}) {
+  const onSkip = options.onSkip ?? ((name, reason) => {
+    console.warn(`modeler-api conformance: SKIPPED "${name}" \u2014 ${reason}`);
+  });
+  const onAdvisory = options.onAdvisory ?? ((name, advice) => {
+    console.warn(`modeler-api conformance: ADVISORY "${name}" \u2014 ${advice}`);
+  });
+  for (const conformanceCase of conformanceCases()) {
+    test(`conformance: ${conformanceCase.name}`, async () => {
+      const outcome = await conformanceCase.run(harness);
+      if (outcome?.skipped) onSkip(conformanceCase.name, outcome.skipped);
+      for (const advice of outcome?.advisories ?? []) onAdvisory(conformanceCase.name, advice);
+    });
+  }
+}
+export {
+  apiVersionsCompatible,
+  attachedHost,
+  conformanceCases,
+  registerConformance
+};
+//# sourceMappingURL=conformance.js.map