@rslsp1/fa-app-tools 10.1.3 → 10.3.2

package/dist/szenen-contract.js

@@ -1,1481 +1,20 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-// src/szenen-contract.ts
-var szenen_contract_exports = {};
-__export(szenen_contract_exports, {
-  describeElementStoreContract: () => describeElementStoreContract
-});
-module.exports = __toCommonJS(szenen_contract_exports);
-
-// src/lib/szenen/storeContractVitest.ts
-var import_vitest = require("vitest");
-
-// src/lib/szenen/versionDag.ts
-var VersionDagError = class extends Error {
-};
-function buildVersionDag(versions) {
-  if (versions.length === 0) {
-    throw new VersionDagError("Versions-DAG ohne Versionen ist nicht aufbaubar.");
-  }
-  const elementId = versions[0].element_id;
-  const nodes = /* @__PURE__ */ new Map();
-  const children = /* @__PURE__ */ new Map();
-  for (const version of versions) {
-    if (!version.version_id) {
-      throw new VersionDagError("Version ohne version_id.");
-    }
-    if (version.element_id !== elementId) {
-      throw new VersionDagError(
-        `Version ${version.version_id} gehoert zu Element ${version.element_id}, erwartet ${elementId}. Ein DAG umfasst genau ein Element.`
-      );
-    }
-    if (nodes.has(version.version_id)) {
-      throw new VersionDagError(`Version ${version.version_id} kommt doppelt vor.`);
-    }
-    nodes.set(version.version_id, version);
-    if (!children.has(version.version_id)) children.set(version.version_id, []);
-  }
-  for (const version of versions) {
-    const seenParents = /* @__PURE__ */ new Set();
-    for (const link of version.parents) {
-      if (link.parent_version_id === version.version_id) {
-        throw new VersionDagError(`Version ${version.version_id} ist ihr eigener Parent.`);
-      }
-      if (!nodes.has(link.parent_version_id)) {
-        throw new VersionDagError(
-          `Version ${version.version_id} verweist auf unbekannten Parent ${link.parent_version_id}. Der Graph waere unvollstaendig.`
-        );
-      }
-      if (seenParents.has(link.parent_version_id)) {
-        throw new VersionDagError(
-          `Version ${version.version_id} nennt Parent ${link.parent_version_id} doppelt.`
-        );
-      }
-      seenParents.add(link.parent_version_id);
-      children.get(link.parent_version_id).push(version.version_id);
-    }
-  }
-  assertAcyclic(nodes);
-  const versionIds = versions.map((v) => v.version_id);
-  const closure = (start, step) => {
-    const seen = /* @__PURE__ */ new Set();
-    const stack = [...step(start)];
-    while (stack.length > 0) {
-      const current = stack.pop();
-      if (seen.has(current)) continue;
-      seen.add(current);
-      stack.push(...step(current));
-    }
-    return seen;
-  };
-  const parentIdsOf = (id) => (nodes.get(id)?.parents ?? []).map((p) => p.parent_version_id);
-  const childIdsOf = (id) => children.get(id) ?? [];
-  return {
-    elementId,
-    versionIds,
-    get: (versionId) => nodes.get(versionId),
-    parentsOf: (versionId) => nodes.get(versionId)?.parents ?? [],
-    childrenOf: (versionId) => childIdsOf(versionId),
-    heads: () => versionIds.filter((id) => childIdsOf(id).length === 0),
-    roots: () => versionIds.filter((id) => parentIdsOf(id).length === 0),
-    hasFork() {
-      return this.heads().length > 1;
-    },
-    ancestorsOf: (versionId) => closure(versionId, parentIdsOf),
-    descendantsOf: (versionId) => closure(versionId, childIdsOf),
-    isAncestorOf(candidate, versionId) {
-      return this.ancestorsOf(versionId).has(candidate);
-    }
-  };
-}
-function assertAcyclic(nodes) {
-  const OPEN = 1;
-  const DONE = 2;
-  const state = /* @__PURE__ */ new Map();
-  for (const start of nodes.keys()) {
-    if (state.get(start) === DONE) continue;
-    const stack = [
-      { id: start, next: 0, path: [start] }
-    ];
-    state.set(start, OPEN);
-    while (stack.length > 0) {
-      const frame = stack[stack.length - 1];
-      const parents = nodes.get(frame.id).parents;
-      if (frame.next >= parents.length) {
-        state.set(frame.id, DONE);
-        stack.pop();
-        continue;
-      }
-      const parentId = parents[frame.next++].parent_version_id;
-      const parentState = state.get(parentId);
-      if (parentState === OPEN) {
-        throw new VersionDagError(
-          `Zyklus im Versions-DAG: ${[...frame.path, parentId].join(" -> ")}`
-        );
-      }
-      if (parentState !== DONE) {
-        state.set(parentId, OPEN);
-        stack.push({ id: parentId, next: 0, path: [...frame.path, parentId] });
-      }
-    }
-  }
-}
-function resolvePreferredHead(options) {
-  const { dag, workingContextId, inheritanceChain = [], owningContextId, selections = [] } = options;
-  const heads = dag.heads();
-  const ignoredSelections = [];
-  const byContext = /* @__PURE__ */ new Map();
-  for (const selection of selections) {
-    if (!dag.get(selection.version_id)) {
-      ignoredSelections.push(selection);
-      continue;
-    }
-    if (!byContext.has(selection.context_id)) byContext.set(selection.context_id, selection);
-  }
-  const candidates = [
-    { contextId: workingContextId, source: "context" },
-    ...inheritanceChain.map((contextId) => ({ contextId, source: "inherited" })),
-    ...owningContextId ? [{ contextId: owningContextId, source: "owning" }] : []
-  ];
-  for (const candidate of candidates) {
-    const selection = byContext.get(candidate.contextId);
-    if (!selection) continue;
-    return {
-      resolution: {
-        kind: "selected",
-        versionId: selection.version_id,
-        source: candidate.source,
-        contextId: candidate.contextId,
-        heads,
-        stale: !heads.includes(selection.version_id)
-      },
-      ignoredSelections
-    };
-  }
-  if (heads.length === 1) {
-    return { resolution: { kind: "single", versionId: heads[0], heads }, ignoredSelections };
-  }
-  return { resolution: { kind: "fork", heads }, ignoredSelections };
-}
-
-// src/lib/szenen/storeContract.ts
-var STYLE_PAYLOAD = {
-  role: "medium",
-  name: "Kohlezeichnung",
-  text: "grobe Kohle auf Papier",
-  locale: "de"
-};
-var STYLE_PAYLOAD_V2 = {
-  role: "medium",
-  name: "Kohlezeichnung, weicher",
-  text: "weiche Kohle, gewischt",
-  locale: "de"
-};
-var ABSENT_ID = "00000000-0000-7000-8000-0000000affff";
-var SCENE_PAYLOAD = {
-  nodes: [{ node_id: "tisch", type: "object", semantic: { description: "ein Tisch" } }],
-  relations: []
-};
-var CAMERA_PRESET_PAYLOAD = {
-  name: "50mm",
-  projection: "perspective",
-  lens: { focal_length_mm: 50, sensor_width_mm: 36 },
-  focus_policy: "autofocus_on_framing_target"
-};
-var ContractViolation = class extends Error {
-};
-var fail = (message) => {
-  throw new ContractViolation(message);
-};
-var show = (value) => {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-};
-var isTrue = (condition, message) => {
-  if (!condition) fail(message);
-};
-var equal = (actual, expected, what) => {
-  if (actual !== expected) fail(`${what}: erwartet ${show(expected)}, war ${show(actual)}`);
-};
-var canonical = (value) => {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value && typeof value === "object") {
-    const entries = Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`);
-    return `{${entries.join(",")}}`;
-  }
-  return show(value);
-};
-var deepEqual = (actual, expected, what) => {
-  if (canonical(actual) !== canonical(expected)) {
-    fail(`${what}: erwartet ${show(expected)}, war ${show(actual)}`);
-  }
-};
-var hasLength = (actual, expected, what) => {
-  equal(actual?.length ?? -1, expected, `${what} (Anzahl)`);
-};
-function ok(result, what) {
-  if (result.kind !== "ok") {
-    fail(`${what}: erwartet ok, war "${result.kind}" \u2014 ${show(result)}`);
-  }
-  return result.value;
-}
-function kindIs(result, expected, what) {
-  equal(result.kind, expected, what);
-}
-async function snapshotOf(store, elementId) {
-  const read = await store.getElement(elementId);
-  if (read.kind !== "ok") {
-    throw new ContractViolation(`getElement: erwartet ok, war ${show(read)}`);
-  }
-  if (!read.value) {
-    throw new ContractViolation(`getElement(${elementId}): erwartet einen Stand, war null`);
-  }
-  return read.value;
-}
-async function seedElement(store, type = "style", title = "Kohle", contextId) {
-  const element = ok(await store.createElement({ type, title, contextId }), "createElement");
-  return element.element_id;
-}
-async function seedVersion(store, elementId, payload = STYLE_PAYLOAD, parents) {
-  return ok(
-    await store.publishVersion({
-      elementId,
-      payload,
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag",
-      parents
-    }),
-    "publishVersion"
-  );
-}
-async function seedSceneSetupUmgebung(store) {
-  const sceneId = await seedElement(store, "scene", "Szene");
-  const scene = await seedVersion(store, sceneId, SCENE_PAYLOAD);
-  const presetElement = ok(
-    await store.createElement({ type: "camera_preset", title: "50mm" }),
-    "createElement(camera_preset)"
-  );
-  const preset = await seedVersion(store, presetElement.element_id, CAMERA_PRESET_PAYLOAD);
-  const setupElement = ok(
-    await store.createElement({ type: "scene_setup", title: "Aufbau" }),
-    "createElement(scene_setup)"
-  );
-  return {
-    elementId: setupElement.element_id,
-    /** Ein Aufbau mit genau diesen Kamerakennungen. */
-    payloadMit(cameraIds, size = "wide_shot") {
-      return {
-        scene_ref: { element_id: sceneId, version_id: scene.version_id },
-        camera_rig: {
-          cameras: cameraIds.map((camera_id) => ({
-            camera_id,
-            preset_ref: {
-              element_id: presetElement.element_id,
-              version_id: preset.version_id
-            },
-            placement: { mode: "absolute", position: [0, -3, 1.6] },
-            orientation: { mode: "look_at", target: { node_ref: "tisch" } },
-            framing: { size, target: { node_ref: "tisch" } }
-          }))
-        }
-      };
-    }
-  };
-}
-function elementStoreContractChecks() {
-  const checks = [];
-  const check = (group, name, run, requires) => checks.push({ group, name, run, requires });
-  check("Anlegen und Lesen", "gibt ein angelegtes Element unveraendert zurueck", async (store) => {
-    const element = ok(
-      await store.createElement({ type: "style", title: "Kohle", contextId: "ctx" }),
-      "createElement"
-    );
-    equal(element.type, "style", "type");
-    equal(element.context_id, "ctx", "context_id");
-    equal(element.retired, false, "retired");
-    const snapshot = await snapshotOf(store, element.element_id);
-    deepEqual(snapshot.element, element, "gelesenes Element");
-    equal(snapshot.metadata?.title, "Kohle", "Titel");
-    equal(snapshot.metadata?.revision, 1, "Metadaten-Revision");
-    hasLength(snapshot.versions, 0, "Versionen");
-    equal(snapshot.draft, null, "Draft");
-    equal(snapshot.draftFork, null, "Draft-Fork");
-  });
-  check("Anlegen und Lesen", "liefert null fuer ein unbekanntes Element, keinen Fehler", async (store) => {
-    const read = await store.getElement(ABSENT_ID);
-    kindIs(read, "ok", "getElement auf Unbekanntes");
-    equal(read.kind === "ok" ? read.value : void 0, null, "Ergebnis");
-  });
-  check("Anlegen und Lesen", "vergibt fuer jedes Element eine eigene Kennung", async (store) => {
-    const a = await seedElement(store, "style", "A");
-    const b = await seedElement(store, "style", "B");
-    isTrue(a !== b, `Kennungen muessen sich unterscheiden, beide waren ${a}`);
-  });
-  check("Anlegen und Lesen", "filtert nach Typ und Kontext", async (store) => {
-    await seedElement(store, "style", "A", "ctx1");
-    await seedElement(store, "scene", "B", "ctx1");
-    await seedElement(store, "style", "C", "ctx2");
-    const byContext = await store.listElements({ contextId: "ctx1" });
-    isTrue(byContext.kind === "ok", "listElements nach Kontext");
-    hasLength(byContext.kind === "ok" ? byContext.value : void 0, 2, "Elemente in ctx1");
-    if (byContext.kind === "ok") {
-      equal(byContext.value.find((element) => element.type === "style")?.title, "A", "Titel in ElementRecord");
-      equal(byContext.value.find((element) => element.type === "scene")?.title, "B", "Titel in ElementRecord");
-    }
-    const byType = await store.listElements({ contextId: "ctx1", type: "style" });
-    hasLength(byType.kind === "ok" ? byType.value : void 0, 1, "style-Elemente in ctx1");
-    const byTypes = await store.listElements({ contextId: "ctx1", types: ["style", "scene"] });
-    hasLength(byTypes.kind === "ok" ? byTypes.value : void 0, 2, "style- und scene-Elemente in ctx1");
-  });
-  check("Versionszugriff", "liefert eine veroeffentlichte Version mit Typ und Sichtbarkeit", async (store) => {
-    const elementId = await seedElement(store, "style", "Kohle", "ctx");
-    const version = await seedVersion(store, elementId);
-    const read = await store.getVersion(version.version_id);
-    kindIs(read, "ok", "getVersion");
-    const value = read.kind === "ok" ? read.value : null;
-    isTrue(value !== null, `getVersion(${version.version_id}) lieferte null`);
-    equal(value.version_id, version.version_id, "version_id");
-    equal(value.element_id, elementId, "element_id");
-    equal(value.type, "style", "type");
-    equal(value.visible, true, "visible");
-  });
-  check("Versionszugriff", "liefert null fuer eine unbekannte Version, keinen Fehler", async (store) => {
-    const read = await store.getVersion(ABSENT_ID);
-    kindIs(read, "ok", "getVersion auf Unbekanntes");
-    equal(read.kind === "ok" ? read.value : void 0, null, "Ergebnis");
-  });
-  check("Versionszugriff", "gibt einen Entwurf nicht als Version aus", async (store) => {
-    const elementId = await seedElement(store);
-    const draft = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "writeDraft"
-    );
-    const read = await store.getVersion(draft.draft_id);
-    kindIs(read, "ok", "getVersion auf eine Draft-Kennung");
-    equal(read.kind === "ok" ? read.value : void 0, null, "Ergebnis");
-  });
-  check(
-    "Versionszugriff",
-    "meldet eine Version stillgelegt statt sie zu verschweigen",
-    async (store) => {
-      const elementId = await seedElement(store);
-      const version = await seedVersion(store, elementId);
-      ok(await store.retireElement(elementId), "retireElement");
-      const read = await store.getVersion(version.version_id);
-      kindIs(read, "ok", "getVersion nach Stilllegung");
-      const value = read.kind === "ok" ? read.value : null;
-      isTrue(value !== null, "stillgelegte Version wurde verschwiegen statt ausgewiesen");
-      equal(value.visible, false, "visible");
-    },
-    "retireElement"
-  );
-  const seedTargetModel = async (store, key, contextId, options = {}) => {
-    const element = ok(
-      await store.createElement({
-        type: "target_model",
-        title: options.name ?? key,
-        contextId
-      }),
-      "createElement(target_model)"
-    );
-    const version = await seedVersion(store, element.element_id, {
-      key,
-      name: options.name ?? key,
-      provider: "google",
-      prompt_language: "en",
-      supports_negative_prompt: false,
-      supports_weighting: false,
-      supported_control_inputs: []
-    });
-    if (options.retired) ok(await store.retireElement(element.element_id), "retireElement");
-    return { elementId: element.element_id, versionId: version.version_id };
-  };
-  const seedShot = async (store, contextId) => {
-    const element = ok(
-      await store.createElement({ type: "shot", title: "Shot", contextId }),
-      "createElement(shot)"
-    );
-    return element.element_id;
-  };
-  const resolved = async (store, input) => {
-    const result = await store.resolveTargetModel(input);
-    kindIs(result, "ok", `resolveTargetModel(${input.key})`);
-    return result.kind === "ok" ? result.value : fail("unerreichbar");
-  };
-  check("Zielmodell", "B13b \u2014 findet ein Modell im direkten Kontext", async (store) => {
-    const model = await seedTargetModel(store, "imagen_4", "ctx");
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "resolved", "Ausgang");
-    if (value.kind !== "resolved") return;
-    equal(value.elementId, model.elementId, "elementId");
-    equal(value.versionId, model.versionId, "versionId");
-    equal(value.chainIndex, 0, "chainIndex");
-    hasLength(value.shadowedRetired, 0, "shadowedRetired");
-  });
-  check("Zielmodell", "B13c \u2014 wertet einen geerbten Zwischenkontext aus", async (store) => {
-    const model = await seedTargetModel(store, "imagen_4", "eltern");
-    const shot = await seedShot(store, "kind");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["kind", "eltern", null]
-    });
-    equal(value.kind, "resolved", "Ausgang");
-    if (value.kind !== "resolved") return;
-    equal(value.elementId, model.elementId, "elementId");
-    equal(value.chainIndex, 1, "chainIndex \u2014 der Zwischenkontext");
-  });
-  check("Zielmodell", "B13d \u2014 faellt auf den globalen Kontext zurueck", async (store) => {
-    const model = await seedTargetModel(store, "imagen_4", void 0);
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "resolved", "Ausgang");
-    if (value.kind !== "resolved") return;
-    equal(value.elementId, model.elementId, "elementId");
-    equal(value.contextId, null, "contextId \u2014 global");
-    equal(value.chainIndex, 1, "chainIndex \u2014 das letzte Glied");
-  });
-  check("Zielmodell", "B13e \u2014 das fruehere Kettenglied gewinnt, ohne Mehrdeutigkeit", async (store) => {
-    const nah = await seedTargetModel(store, "imagen_4", "ctx", { name: "lokal" });
-    await seedTargetModel(store, "imagen_4", void 0, { name: "global" });
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "resolved", "Ausgang \u2014 Rangfolge, nicht ambiguous");
-    if (value.kind !== "resolved") return;
-    equal(value.elementId, nah.elementId, "der naehere Treffer gewinnt");
-    equal(value.chainIndex, 0, "chainIndex");
-  });
-  check("Zielmodell", "B13e \u2014 der Zwischenkontext schlaegt global", async (store) => {
-    const mitte = await seedTargetModel(store, "imagen_4", "eltern", { name: "geerbt" });
-    await seedTargetModel(store, "imagen_4", void 0, { name: "global" });
-    const shot = await seedShot(store, "kind");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["kind", "eltern", null]
-    });
-    equal(value.kind, "resolved", "Ausgang");
-    if (value.kind !== "resolved") return;
-    equal(value.elementId, mitte.elementId, "der geerbte Treffer gewinnt");
-  });
-  check("Zielmodell", "B13f \u2014 zwei Treffer auf demselben Glied sind mehrdeutig", async (store) => {
-    await seedTargetModel(store, "imagen_4", "ctx", { name: "A" });
-    await seedTargetModel(store, "imagen_4", "ctx", { name: "B" });
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "ambiguous", "Ausgang");
-    if (value.kind !== "ambiguous") return;
-    equal(value.chainIndex, 0, "chainIndex");
-    hasLength(value.candidates, 2, "Kandidaten");
-  });
-  check(
-    "Zielmodell",
-    "B13g \u2014 eine Stilllegung sperrt den Fallback nicht, bleibt aber sichtbar",
-    async (store) => {
-      const lokal = await seedTargetModel(store, "imagen_4", "ctx", { retired: true });
-      const global = await seedTargetModel(store, "imagen_4", void 0);
-      const shot = await seedShot(store, "ctx");
-      const value = await resolved(store, {
-        key: "imagen_4",
-        forElementId: shot,
-        contextChain: ["ctx", null]
-      });
-      equal(value.kind, "resolved", "Ausgang");
-      if (value.kind !== "resolved") return;
-      equal(value.elementId, global.elementId, "der globale Treffer greift");
-      hasLength(value.shadowedRetired, 1, "shadowedRetired");
-      equal(value.shadowedRetired[0]?.elementId, lokal.elementId, "uebergangener Kandidat");
-    },
-    "retireElement"
-  );
-  check(
-    "Zielmodell",
-    'B13h \u2014 sind alle Kandidaten stillgelegt, ist das nicht "nicht gefunden"',
-    async (store) => {
-      const a = await seedTargetModel(store, "imagen_4", "ctx", { retired: true, name: "A" });
-      const b = await seedTargetModel(store, "imagen_4", void 0, { retired: true, name: "B" });
-      const shot = await seedShot(store, "ctx");
-      const value = await resolved(store, {
-        key: "imagen_4",
-        forElementId: shot,
-        contextChain: ["ctx", null]
-      });
-      equal(value.kind, "retired", "Ausgang");
-      if (value.kind !== "retired") return;
-      hasLength(value.candidates, 2, "Kandidaten");
-      const ids = value.candidates.map((candidate) => candidate.elementId).sort();
-      deepEqual(ids, [a.elementId, b.elementId].sort(), "Kandidatenkennungen");
-    },
-    "retireElement"
-  );
-  check("Zielmodell", "B13a \u2014 meldet einen fehlenden Key mit der durchsuchten Kette", async (store) => {
-    await seedTargetModel(store, "sdxl", "ctx");
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "not_found", "Ausgang");
-    if (value.kind !== "not_found") return;
-    deepEqual(value.chain, ["ctx", null], "durchsuchte Kette");
-  });
-  check("Zielmodell", "B13a \u2014 ein anderer Elementtyp mit gleichem Key ist kein Treffer", async (store) => {
-    const fremd = ok(
-      await store.createElement({ type: "style", title: "Falle", contextId: "ctx" }),
-      "createElement(style)"
-    );
-    await seedVersion(store, fremd.element_id, STYLE_PAYLOAD);
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "not_found", "Ausgang");
-  });
-  check(
-    "Zielmodell",
-    "B13i \u2014 mehrere Heads ohne greifende Auswahl blockieren",
-    async (store) => {
-      const element = ok(
-        await store.createElement({ type: "target_model", title: "imagen", contextId: "ctx" }),
-        "createElement(target_model)"
-      );
-      const payload = {
-        key: "imagen_4",
-        name: "Imagen 4",
-        provider: "google",
-        prompt_language: "en",
-        supports_negative_prompt: false,
-        supports_weighting: false,
-        supported_control_inputs: []
-      };
-      const basis = await seedVersion(store, element.element_id, payload);
-      await seedVersion(store, element.element_id, { ...payload, name: "A" }, [
-        { parent_version_id: basis.version_id, relation: "derived_from" }
-      ]);
-      await seedVersion(store, element.element_id, { ...payload, name: "B" }, [
-        { parent_version_id: basis.version_id, relation: "derived_from" }
-      ]);
-      const shot = await seedShot(store, "ctx");
-      const value = await resolved(store, {
-        key: "imagen_4",
-        forElementId: shot,
-        contextChain: ["ctx", null]
-      });
-      equal(value.kind, "fork", "Ausgang");
-      if (value.kind !== "fork") return;
-      hasLength(value.heads, 2, "Heads");
-    }
-  );
-  check(
-    "Zielmodell",
-    "B13i \u2014 eine greifende Auswahl loest den Fork auf",
-    async (store) => {
-      const element = ok(
-        await store.createElement({ type: "target_model", title: "imagen", contextId: "ctx" }),
-        "createElement(target_model)"
-      );
-      const payload = {
-        key: "imagen_4",
-        name: "Imagen 4",
-        provider: "google",
-        prompt_language: "en",
-        supports_negative_prompt: false,
-        supports_weighting: false,
-        supported_control_inputs: []
-      };
-      const basis = await seedVersion(store, element.element_id, payload);
-      const a = await seedVersion(store, element.element_id, { ...payload, name: "A" }, [
-        { parent_version_id: basis.version_id, relation: "derived_from" }
-      ]);
-      await seedVersion(store, element.element_id, { ...payload, name: "B" }, [
-        { parent_version_id: basis.version_id, relation: "derived_from" }
-      ]);
-      ok(
-        await store.setPreferredHead({
-          elementId: element.element_id,
-          contextId: "ctx",
-          versionId: a.version_id,
-          expectedRevision: 0,
-          selectedBy: "vertrag"
-        }),
-        "setPreferredHead"
-      );
-      const shot = await seedShot(store, "ctx");
-      const value = await resolved(store, {
-        key: "imagen_4",
-        forElementId: shot,
-        contextChain: ["ctx", null]
-      });
-      equal(value.kind, "resolved", "Ausgang");
-      if (value.kind !== "resolved") return;
-      equal(value.versionId, a.version_id, "die gewaehlte Version");
-    },
-    "setPreferredHead"
-  );
-  check("Zielmodell", "B13j \u2014 Suche und Head-Aufloesung sehen dieselbe Kette", async (store) => {
-    const element = ok(
-      await store.createElement({ type: "target_model", title: "imagen" }),
-      "createElement(target_model)"
-    );
-    const payload = {
-      key: "imagen_4",
-      name: "Imagen 4",
-      provider: "google",
-      prompt_language: "en",
-      supports_negative_prompt: false,
-      supports_weighting: false,
-      supported_control_inputs: []
-    };
-    const basis = await seedVersion(store, element.element_id, payload);
-    const a = await seedVersion(store, element.element_id, { ...payload, name: "A" }, [
-      { parent_version_id: basis.version_id, relation: "derived_from" }
-    ]);
-    await seedVersion(store, element.element_id, { ...payload, name: "B" }, [
-      { parent_version_id: basis.version_id, relation: "derived_from" }
-    ]);
-    ok(
-      await store.setPreferredHead({
-        elementId: element.element_id,
-        contextId: "eltern",
-        versionId: a.version_id,
-        expectedRevision: 0,
-        selectedBy: "vertrag"
-      }),
-      "setPreferredHead"
-    );
-    const shot = await seedShot(store, "kind");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["kind", "eltern", null]
-    });
-    equal(value.kind, "resolved", "Ausgang");
-    if (value.kind !== "resolved") return;
-    equal(value.versionId, a.version_id, "die im Zwischenkontext gewaehlte Version");
-  }, "setPreferredHead");
-  check("Zielmodell", "B13k \u2014 eine Kette, die nicht zum Element gehoert, wird abgelehnt", async (store) => {
-    await seedTargetModel(store, "imagen_4", "ctx");
-    const shot = await seedShot(store, "ctx");
-    const result = await store.resolveTargetModel({
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["fremd", null]
-    });
-    kindIs(result, "error", "resolveTargetModel mit fremder Kette");
-  });
-  check("Zielmodell", "B13k \u2014 eine leere Kette wird abgelehnt, nicht als leere Suche gefahren", async (store) => {
-    const shot = await seedShot(store, "ctx");
-    const result = await store.resolveTargetModel({
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: []
-    });
-    kindIs(result, "error", "resolveTargetModel ohne Kette");
-  });
-  check("Zielmodell", "B13k \u2014 global mitten in der Kette wird abgelehnt", async (store) => {
-    const shot = await seedShot(store, "ctx");
-    const result = await store.resolveTargetModel({
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null, "eltern"]
-    });
-    kindIs(result, "error", "resolveTargetModel mit global in der Mitte");
-  });
-  check("Zielmodell", "B13k \u2014 ein unbekanntes Element wird gemeldet, nicht ignoriert", async (store) => {
-    const result = await store.resolveTargetModel({
-      key: "imagen_4",
-      forElementId: ABSENT_ID,
-      contextChain: [null]
-    });
-    kindIs(result, "error", "resolveTargetModel fuer ein unbekanntes Element");
-  });
-  check("Zielmodell", "ein Entwurf allein macht ein Zielmodell nicht auffindbar", async (store) => {
-    const element = ok(
-      await store.createElement({ type: "target_model", title: "imagen", contextId: "ctx" }),
-      "createElement(target_model)"
-    );
-    ok(
-      await store.writeDraft({
-        elementId: element.element_id,
-        payload: {
-          key: "imagen_4",
-          name: "Imagen 4",
-          provider: "google",
-          prompt_language: "en",
-          supports_negative_prompt: false,
-          supports_weighting: false,
-          supported_control_inputs: []
-        },
-        expectedRevision: 0
-      }),
-      "writeDraft"
-    );
-    const shot = await seedShot(store, "ctx");
-    const value = await resolved(store, {
-      key: "imagen_4",
-      forElementId: shot,
-      contextChain: ["ctx", null]
-    });
-    equal(value.kind, "not_found", "Ausgang");
-  });
-  check("Eingaben \xA76", "lehnt einen unbekannten Elementtyp ab", async (store) => {
-    const result = await store.createElement({
-      type: "weltmodell",
-      title: "X"
-    });
-    kindIs(result, "error", "createElement mit unbekanntem Typ");
-  });
-  check("Eingaben \xA76", "lehnt einen leeren Titel ab", async (store) => {
-    kindIs(
-      await store.createElement({ type: "style", title: "   " }),
-      "error",
-      "createElement mit leerem Titel"
-    );
-  });
-  check("Eingaben \xA76", "lehnt eine erwartete Revision ab, die keine Zahl ist", async (store) => {
-    const elementId = await seedElement(store);
-    const result = await store.writeDraft({
-      elementId,
-      payload: STYLE_PAYLOAD,
-      expectedRevision: Number.NaN
-    });
-    kindIs(result, "error", "writeDraft mit NaN als erwarteter Revision");
-  });
-  check("Eingaben \xA76", "lehnt eine negative erwartete Revision ab", async (store) => {
-    const elementId = await seedElement(store);
-    kindIs(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: -1 }),
-      "error",
-      "writeDraft mit negativer Revision"
-    );
-  });
-  check("Eingaben \xA76", "lehnt parents ab, das kein Array ist", async (store) => {
-    const elementId = await seedElement(store);
-    const result = await store.publishVersion({
-      elementId,
-      payload: STYLE_PAYLOAD,
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag",
-      parents: "kaputt"
-    });
-    kindIs(result, "error", "publishVersion mit parents als String");
-  });
-  check("Eingaben \xA76", "lehnt einen Parent-Eintrag ohne relation ab", async (store) => {
-    const elementId = await seedElement(store);
-    const version = await seedVersion(store, elementId);
-    const result = await store.publishVersion({
-      elementId,
-      payload: STYLE_PAYLOAD_V2,
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag",
-      parents: [{ parent_version_id: version.version_id }]
-    });
-    kindIs(result, "error", "publishVersion mit unvollstaendigem Parent");
-  });
-  check("Eingaben \xA76", "meldet Eingabefehler als endgueltig, nicht als wiederholbar", async (store) => {
-    const result = await store.createElement({ type: "weltmodell", title: "X" });
-    if (result.kind === "error") {
-      equal(result.retryable, false, "retryable bei Eingabefehler");
-    }
-  });
-  check("Drafts \xA73.1", "schreibt den ersten Draft auf Revision 1", async (store) => {
-    const elementId = await seedElement(store);
-    const draft = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "writeDraft"
-    );
-    equal(draft.revision, 1, "Revision des ersten Drafts");
-    const snapshot = await snapshotOf(store, elementId);
-    deepEqual(snapshot.draft?.payload, STYLE_PAYLOAD, "gelesene Draft-Payload");
-    equal(snapshot.draft?.revision, 1, "gelesene Draft-Revision");
-  });
-  check("Drafts \xA73.1", "zaehlt die Revision bei jedem Schreiben hoch", async (store) => {
-    const elementId = await seedElement(store);
-    await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 });
-    const second = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD_V2, expectedRevision: 1 }),
-      "zweiter writeDraft"
-    );
-    equal(second.revision, 2, "Revision nach zweitem Schreiben");
-  });
-  check("Drafts \xA73.1", "haelt die Draft-Kennung ueber Fortschreibungen stabil", async (store) => {
-    const elementId = await seedElement(store);
-    const first = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "erster writeDraft"
-    );
-    const second = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD_V2, expectedRevision: 1 }),
-      "zweiter writeDraft"
-    );
-    equal(second.draft_id, first.draft_id, "draft_id");
-  });
-  check("Drafts \xA73.1", "haelt die Draft-Kennung auch ueber ein Publish hinweg", async (store) => {
-    const elementId = await seedElement(store);
-    const entwurf = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "erster writeDraft"
-    );
-    ok(
-      await store.publishVersion({
-        elementId,
-        payload: STYLE_PAYLOAD,
-        schemaVersion: "1.0.0",
-        publishedBy: "contract"
-      }),
-      "publishVersion"
-    );
-    const weiter = ok(
-      await store.writeDraft({
-        elementId,
-        payload: STYLE_PAYLOAD_V2,
-        expectedRevision: entwurf.revision
-      }),
-      "writeDraft nach Publish"
-    );
-    equal(weiter.draft_id, entwurf.draft_id, "draft_id nach Publish");
-  });
-  check("Drafts \xA73.1", "nennt im Konflikt den bestehenden Draft mit seiner Kennung", async (store) => {
-    const elementId = await seedElement(store);
-    const erste = ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "erster writeDraft"
-    );
-    const veraltet = await store.writeDraft({
-      elementId,
-      payload: STYLE_PAYLOAD_V2,
-      expectedRevision: 0
-    });
-    kindIs(veraltet, "conflict", "Schreibversuch auf veralteter Revision");
-    if (veraltet.kind === "conflict") {
-      equal(veraltet.current?.draft_id, erste.draft_id, "draft_id im Konflikt");
-    }
-  });
-  check("Drafts \xA76.6", "schreibt und liest Kettenmetadaten am Draft", async (store) => {
-    const szene = await seedElement(store, "scene", "Kettenszene");
-    const geschrieben = ok(
-      await store.writeDraft({
-        elementId: szene,
-        payload: SCENE_PAYLOAD,
-        expectedRevision: 0,
-        chain: { chain_id: "kette-1", source_run_id: "lauf-1", links: [] }
-      }),
-      "writeDraft mit Kette"
-    );
-    equal(geschrieben.chain?.chain_id, "kette-1", "chain_id im Rueckgabewert");
-    const gelesen = ok(await store.getElement(szene), "getElement");
-    equal(gelesen?.draft?.chain?.chain_id, "kette-1", "chain_id im gelesenen Draft");
-    equal(gelesen?.draft?.chain?.source_run_id, "lauf-1", "source_run_id");
-  });
-  check("Drafts \xA76.6", "laesst einen Draft ohne Kette unveraendert ohne Kette", async (store) => {
-    const elementId = await seedElement(store);
-    ok(
-      await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 }),
-      "writeDraft ohne Kette"
-    );
-    const gelesen = ok(await store.getElement(elementId), "getElement");
-    equal("chain" in (gelesen?.draft ?? {}), false, "chain fehlt am Einzelentwurf");
-  });
-  check("Drafts \xA76.6", "behaelt die Kette, wenn nur die Payload fortgeschrieben wird", async (store) => {
-    const szene = await seedElement(store, "scene", "Kettenszene");
-    const erste = ok(
-      await store.writeDraft({
-        elementId: szene,
-        payload: SCENE_PAYLOAD,
-        expectedRevision: 0,
-        chain: { chain_id: "kette-2", source_run_id: "lauf-2", links: [] }
-      }),
-      "erster writeDraft"
-    );
-    ok(
-      await store.writeDraft({
-        elementId: szene,
-        payload: SCENE_PAYLOAD,
-        expectedRevision: erste.revision
-      }),
-      "zweiter writeDraft ohne chain"
-    );
-    const gelesen = ok(await store.getElement(szene), "getElement");
-    equal(gelesen?.draft?.chain?.chain_id, "kette-2", "chain_id nach Fortschreibung");
-  });
-  check("Drafts \xA76.6", "loest die Kette bei ausdruecklichem null", async (store) => {
-    const szene = await seedElement(store, "scene", "Kettenszene");
-    const erste = ok(
-      await store.writeDraft({
-        elementId: szene,
-        payload: SCENE_PAYLOAD,
-        expectedRevision: 0,
-        chain: { chain_id: "kette-3", source_run_id: "lauf-3", links: [] }
-      }),
-      "erster writeDraft"
-    );
-    ok(
-      await store.writeDraft({
-        elementId: szene,
-        payload: SCENE_PAYLOAD,
-        expectedRevision: erste.revision,
-        chain: null
-      }),
-      "writeDraft mit chain: null"
-    );
-    const gelesen = ok(await store.getElement(szene), "getElement");
-    equal("chain" in (gelesen?.draft ?? {}), false, "chain nach ausdruecklichem null");
-  });
-  check("Drafts \xA76.6", "lehnt eine Kante am falschen Elementtyp ab", async (store) => {
-    const szene = await seedElement(store, "scene", "Kettenszene");
-    const abgelehnt = await store.writeDraft({
-      elementId: szene,
-      payload: SCENE_PAYLOAD,
-      expectedRevision: 0,
-      chain: {
-        chain_id: "kette-4",
-        source_run_id: "lauf-4",
-        links: [{
-          field: "scene_ref",
-          target_element_id: ABSENT_ID,
-          target_draft_id: ABSENT_ID
-        }]
-      }
-    });
-    kindIs(abgelehnt, "error", "writeDraft mit falscher Kante");
-  });
-  check("Drafts \xA76.6", "lehnt unvollstaendige Kettenmetadaten ab", async (store) => {
-    const szene = await seedElement(store, "scene", "Kettenszene");
-    const ohneLauf = await store.writeDraft({
-      elementId: szene,
-      payload: SCENE_PAYLOAD,
-      expectedRevision: 0,
-      // `source_run_id` fehlt — ohne sie ist die Herkunft nicht rekonstruierbar
-      // (B3), und genau das ist die Zusage der Kette.
-      chain: { chain_id: "kette-5", links: [] }
-    });
-    kindIs(ohneLauf, "error", "writeDraft ohne source_run_id");
-  });
-  check("Drafts \xA73.1", "lehnt eine veraltete Revision ab und liefert den aktuellen Stand", async (store) => {
-    const elementId = await seedElement(store);
-    await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 });
-    const stale = await store.writeDraft({
-      elementId,
-      payload: STYLE_PAYLOAD_V2,
-      expectedRevision: 0
-    });
-    kindIs(stale, "conflict", "zweiter Schreibversuch auf veralteter Revision");
-    if (stale.kind === "conflict") {
-      equal(stale.expectedRevision, 0, "gemeldete erwartete Revision");
-      equal(stale.actualRevision, 1, "gemeldete tatsaechliche Revision");
-    }
-  });
-  check("Drafts \xA73.1", "schreibt bei einem Konflikt nichts", async (store) => {
-    const elementId = await seedElement(store);
-    await store.writeDraft({ elementId, payload: STYLE_PAYLOAD, expectedRevision: 0 });
-    await store.writeDraft({ elementId, payload: STYLE_PAYLOAD_V2, expectedRevision: 0 });
-    const snapshot = await snapshotOf(store, elementId);
-    deepEqual(snapshot.draft?.payload, STYLE_PAYLOAD, "Payload nach abgelehntem Schreiben");
-    equal(snapshot.draft?.revision, 1, "Revision nach abgelehntem Schreiben");
-  });
-  check("Drafts \xA73.1", "lehnt eine unbekannte base_version_id ab", async (store) => {
-    const elementId = await seedElement(store);
-    const result = await store.writeDraft({
-      elementId,
-      payload: STYLE_PAYLOAD,
-      expectedRevision: 0,
-      baseVersionId: ABSENT_ID
-    });
-    kindIs(result, "error", "writeDraft mit unbekannter base_version_id");
-  });
-  check("Drafts \xA73.1", "lehnt eine base_version_id eines fremden Elements ab", async (store) => {
-    const fremd = await seedElement(store, "style", "Fremd");
-    const fremdeVersion = await seedVersion(store, fremd);
-    const eigenes = await seedElement(store, "scene", "Eigen");
-    const result = await store.writeDraft({
-      elementId: eigenes,
-      payload: { nodes: [] },
-      expectedRevision: 0,
-      baseVersionId: fremdeVersion.version_id
-    });
-    kindIs(result, "error", "writeDraft mit fremder base_version_id");
-  });
-  check("Drafts \xA73.1", "akzeptiert eine eigene base_version_id", async (store) => {
-    const elementId = await seedElement(store);
-    const version = await seedVersion(store, elementId);
-    const draft = ok(
-      await store.writeDraft({
-        elementId,
-        payload: STYLE_PAYLOAD_V2,
-        expectedRevision: 0,
-        baseVersionId: version.version_id
-      }),
-      "writeDraft mit eigener base_version_id"
-    );
-    equal(draft.base_version_id, version.version_id, "base_version_id");
-  });
-  check("Drafts \xA73.1", "meldet einen Draft auf einem unbekannten Element als Fehler", async (store) => {
-    const result = await store.writeDraft({
-      elementId: ABSENT_ID,
-      payload: STYLE_PAYLOAD,
-      expectedRevision: 0
-    });
-    kindIs(result, "error", "writeDraft auf unbekanntes Element");
-  });
-  check("Veroeffentlichen", "veroeffentlicht eine gueltige Payload", async (store) => {
-    const elementId = await seedElement(store);
-    const version = await seedVersion(store, elementId);
-    equal(version.element_id, elementId, "element_id der Version");
-    hasLength(version.parents, 0, "Parents der ersten Version");
-    const snapshot = await snapshotOf(store, elementId);
-    hasLength(snapshot.versions, 1, "Versionen nach Veroeffentlichung");
-    deepEqual(snapshot.versions[0].payload, STYLE_PAYLOAD, "gelesene Payload");
-  });
-  check("Veroeffentlichen", "lehnt eine schemawidrige Payload ab \u2014 in JEDEM Port (R-2)", async (store) => {
-    const elementId = await seedElement(store);
-    const result = await store.publishVersion({
-      elementId,
-      payload: { role: "gibt-es-nicht", name: "X", text: "Y", locale: "de" },
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag"
-    });
-    kindIs(result, "rejected", "Publish mit unzulaessigem role-Wert");
-    if (result.kind === "rejected") {
-      isTrue(result.errors.length > 0, "Ablehnung muss Befunde nennen");
-    }
-  });
-  check("Veroeffentlichen", "waehlt das Payload-Schema ueber den Typ des Elements", async (store) => {
-    const elementId = await seedElement(store, "scene", "Szene");
-    const result = await store.publishVersion({
-      elementId,
-      payload: STYLE_PAYLOAD,
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag"
-    });
-    kindIs(result, "rejected", "style-Payload unter scene-Element");
-  });
-  check("Veroeffentlichen", "setzt die Publish-Regeln durch, nicht nur das Schema (D-58)", async (store) => {
-    const element = ok(
-      await store.createElement({ type: "sequence", title: "Sequenz" }),
-      "createElement(sequence)"
-    );
-    const result = await store.publishVersion({
-      elementId: element.element_id,
-      payload: {
-        name: "Testsequenz",
-        // Schemagueltig: zwei Stationen mit item-Zielen. Nur P-09 haelt sie auf.
-        stations: [
-          { rank: 0, target: { kind: "item", item_id: "item-a" } },
-          { rank: 1, target: { kind: "item", item_id: "item-b" } }
-        ]
-      },
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag"
-    });
-    kindIs(result, "rejected", "Publish einer sequence");
-    if (result.kind === "rejected") {
-      const mentionsP09 = result.errors.some(
-        (e) => e.keyword === "P-09" || e.message.includes("P-09")
-      );
-      isTrue(mentionsP09, `Ablehnung muss P-09 nennen: ${show(result.errors)}`);
-    }
-    const snapshot = await snapshotOf(store, element.element_id);
-    hasLength(snapshot.versions, 0, "Versionen nach abgelehnter Publish-Regel");
-  });
-  check("Veroeffentlichen", "setzt P-03 ueber die Abstammung durch (D-60)", async (store) => {
-    const setup = await seedSceneSetupUmgebung(store);
-    const v1 = await seedVersion(store, setup.elementId, setup.payloadMit(["cam_a"]));
-    const v2 = ok(
-      await store.publishVersion({
-        elementId: setup.elementId,
-        payload: setup.payloadMit(["cam_b"]),
-        // cam_a entfernt
-        schemaVersion: "1.0.0",
-        publishedBy: "vertrag",
-        parents: [{ parent_version_id: v1.version_id, relation: "derived_from" }]
-      }),
-      "publishVersion(v2 ohne cam_a)"
-    );
-    ok(
-      await store.publishVersion({
-        elementId: setup.elementId,
-        payload: setup.payloadMit(["cam_b"], "medium_close_up"),
-        schemaVersion: "1.0.0",
-        publishedBy: "vertrag",
-        parents: [{ parent_version_id: v2.version_id, relation: "derived_from" }]
-      }),
-      "publishVersion(Eigenschaftswechsel bei stabiler camera_id)"
-    );
-    const recycled = await store.publishVersion({
-      elementId: setup.elementId,
-      payload: setup.payloadMit(["cam_b", "cam_a"]),
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag",
-      parents: [{ parent_version_id: v2.version_id, relation: "derived_from" }]
-    });
-    kindIs(recycled, "rejected", "Publish mit wiederverwendeter camera_id");
-    if (recycled.kind === "rejected") {
-      const nenntP03 = recycled.errors.some(
-        (e) => e.keyword === "P-03" || e.message.includes("P-03")
-      );
-      isTrue(nenntP03, `Ablehnung muss P-03 nennen: ${show(recycled.errors)}`);
-    }
-    ok(
-      await store.publishVersion({
-        elementId: setup.elementId,
-        payload: setup.payloadMit(["cam_b", "cam_neu"]),
-        schemaVersion: "1.0.0",
-        publishedBy: "vertrag",
-        parents: [{ parent_version_id: v2.version_id, relation: "derived_from" }]
-      }),
-      "publishVersion(Wiedereinfuehrung mit neuer camera_id)"
-    );
-  });
-  check("Veroeffentlichen", "schreibt bei Ablehnung nichts", async (store) => {
-    const elementId = await seedElement(store);
-    await store.publishVersion({
-      elementId,
-      payload: {},
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag"
-    });
-    const snapshot = await snapshotOf(store, elementId);
-    hasLength(snapshot.versions, 0, "Versionen nach abgelehntem Publish");
-  });
-  check("Veroeffentlichen", "verweigert eine Version mit unbekanntem Parent", async (store) => {
-    const elementId = await seedElement(store);
-    const result = await store.publishVersion({
-      elementId,
-      payload: STYLE_PAYLOAD,
-      schemaVersion: "1.0.0",
-      publishedBy: "vertrag",
-      parents: [{ parent_version_id: ABSENT_ID, relation: "derived_from" }]
-    });
-    kindIs(result, "error", "Publish mit unbekanntem Parent");
-  });
-  check("Veroeffentlichen", "ergibt mit derived_from einen linearen DAG", async (store) => {
-    const elementId = await seedElement(store);
-    const v1 = await seedVersion(store, elementId, STYLE_PAYLOAD);
-    const v2 = await seedVersion(store, elementId, STYLE_PAYLOAD_V2, [
-      { parent_version_id: v1.version_id, relation: "derived_from" }
-    ]);
-    const snapshot = await snapshotOf(store, elementId);
-    const dag = buildVersionDag(snapshot.versions);
-    deepEqual(dag.roots(), [v1.version_id], "Roots");
-    deepEqual(dag.heads(), [v2.version_id], "Heads");
-    equal(dag.hasFork(), false, "hasFork");
-  });
-  check("Veroeffentlichen", "ergibt ohne Parent zwei Heads \u2014 ein Fork wird nicht linearisiert", async (store) => {
-    const elementId = await seedElement(store);
-    await seedVersion(store, elementId, STYLE_PAYLOAD);
-    await seedVersion(store, elementId, STYLE_PAYLOAD_V2);
-    const snapshot = await snapshotOf(store, elementId);
-    const dag = buildVersionDag(snapshot.versions);
-    hasLength(dag.heads(), 2, "Heads");
-    equal(dag.hasFork(), true, "hasFork");
-    equal(
-      resolvePreferredHead({ dag, workingContextId: "ctx" }).resolution.kind,
-      "fork",
-      "Aufloesung ohne Auswahl"
-    );
-  });
-  check("Veroeffentlichen", "laesst eine veroeffentlichte Version unveraendert (D-02)", async (store) => {
-    const elementId = await seedElement(store);
-    const version = await seedVersion(store, elementId, STYLE_PAYLOAD);
-    await store.writeDraft({ elementId, payload: STYLE_PAYLOAD_V2, expectedRevision: 0 });
-    const snapshot = await snapshotOf(store, elementId);
-    hasLength(snapshot.versions, 1, "Versionen");
-    equal(snapshot.versions[0].version_id, version.version_id, "version_id");
-    deepEqual(snapshot.versions[0].payload, STYLE_PAYLOAD, "Payload der Version");
-  });
-  check("Veroeffentlichen", "liefert Versionen in Veroeffentlichungsreihenfolge (\xA74)", async (store) => {
-    const elementId = await seedElement(store);
-    const v1 = await seedVersion(store, elementId, STYLE_PAYLOAD);
-    const v2 = await seedVersion(store, elementId, STYLE_PAYLOAD_V2, [
-      { parent_version_id: v1.version_id, relation: "derived_from" }
-    ]);
-    const snapshot = await snapshotOf(store, elementId);
-    deepEqual(
-      snapshot.versions.map((v) => v.version_id),
-      [v1.version_id, v2.version_id],
-      "Reihenfolge der Versionen"
-    );
-  });
-  check(
-    "Preferred Head",
-    "setzt eine Auswahl und liefert sie zurueck",
-    async (store) => {
-      const elementId = await seedElement(store, "style", "A", "ctx");
-      const v1 = await seedVersion(store, elementId);
-      ok(
-        await store.setPreferredHead({
-          elementId,
-          contextId: "ctx",
-          versionId: v1.version_id,
-          expectedRevision: 0,
-          selectedBy: "vertrag"
-        }),
-        "setPreferredHead"
-      );
-      const snapshot = await snapshotOf(store, elementId);
-      const selection = snapshot.preferredHeads.find(
-        (eintrag) => eintrag.context_id === "ctx" && eintrag.version_id === v1.version_id
-      );
-      isTrue(!!selection, `Auswahl fehlt im gelesenen Stand: ${show(snapshot.preferredHeads)}`);
-      equal(selection.revision, 1, `Revision der Auswahl: ${show(snapshot.preferredHeads)}`);
-    },
-    "setPreferredHead"
-  );
-  check(
-    "Preferred Head",
-    "laesst die Auswahl mit der gelesenen Revision wechseln",
-    async (store) => {
-      const elementId = await seedElement(store, "style", "A", "ctx");
-      const v1 = await seedVersion(store, elementId);
-      const v2 = await seedVersion(store, elementId, STYLE_PAYLOAD_V2, [
-        { parent_version_id: v1.version_id, relation: "derived_from" }
-      ]);
-      ok(
-        await store.setPreferredHead({
-          elementId,
-          contextId: "ctx",
-          versionId: v1.version_id,
-          expectedRevision: 0,
-          selectedBy: "vertrag"
-        }),
-        "erste Auswahl"
-      );
-      const gelesen = await snapshotOf(store, elementId);
-      const aktuell = gelesen.preferredHeads.find((e) => e.context_id === "ctx");
-      ok(
-        await store.setPreferredHead({
-          elementId,
-          contextId: "ctx",
-          versionId: v2.version_id,
-          expectedRevision: aktuell?.revision ?? 0,
-          selectedBy: "vertrag"
-        }),
-        "zweite Auswahl mit gelesener Revision"
-      );
-      const danach = await snapshotOf(store, elementId);
-      const gewechselt = danach.preferredHeads.find((e) => e.context_id === "ctx");
-      equal(gewechselt?.version_id, v2.version_id, "Auswahl nach dem Wechsel");
-      equal(gewechselt?.revision, 2, "Revision nach dem Wechsel");
-    },
-    "setPreferredHead"
-  );
-  check(
-    "Preferred Head",
-    "verweigert eine fremde Version",
-    async (store) => {
-      const elementId = await seedElement(store);
-      const result = await store.setPreferredHead({
-        elementId,
-        contextId: "ctx",
-        versionId: ABSENT_ID,
-        expectedRevision: 0,
-        selectedBy: "vertrag"
-      });
-      kindIs(result, "error", "Auswahl auf fremde Version");
-    },
-    "setPreferredHead"
-  );
-  check(
-    "Preferred Head",
-    "lehnt eine veraltete Revision ab",
-    async (store) => {
-      const elementId = await seedElement(store);
-      const v1 = await seedVersion(store, elementId);
-      const input = {
-        elementId,
-        contextId: "ctx",
-        versionId: v1.version_id,
-        expectedRevision: 0,
-        selectedBy: "vertrag"
-      };
-      await store.setPreferredHead(input);
-      kindIs(await store.setPreferredHead(input), "conflict", "zweite Auswahl mit Revision 0");
-    },
-    "setPreferredHead"
-  );
-  check(
-    "Elementmetadaten D-35",
-    "aendert den Titel ohne neue Version",
-    async (store) => {
-      const elementId = await seedElement(store, "style", "Alt");
-      await seedVersion(store, elementId);
-      const revised = ok(
-        await store.reviseMetadata({ elementId, title: "Neu", expectedRevision: 1 }),
-        "reviseMetadata"
-      );
-      equal(revised.revision, 2, "Revision nach Umbenennung");
-      const snapshot = await snapshotOf(store, elementId);
-      equal(snapshot.metadata?.title, "Neu", "Titel");
-      hasLength(snapshot.versions, 1, "Versionen nach Umbenennung");
-    },
-    "reviseMetadata"
-  );
-  check(
-    "Elementmetadaten D-35",
-    "behaelt eine nicht mitgesendete Beschreibung (\xA78)",
-    async (store) => {
-      const element = ok(
-        await store.createElement({
-          type: "style",
-          title: "Alt",
-          description: "wichtige Notiz"
-        }),
-        "createElement mit Beschreibung"
-      );
-      ok(
-        await store.reviseMetadata({
-          elementId: element.element_id,
-          title: "Neu",
-          expectedRevision: 1
-        }),
-        "reviseMetadata ohne description"
-      );
-      const snapshot = await snapshotOf(store, element.element_id);
-      equal(snapshot.metadata?.title, "Neu", "Titel");
-      equal(snapshot.metadata?.description, "wichtige Notiz", "Beschreibung");
-    },
-    "reviseMetadata"
-  );
-  check(
-    "Elementmetadaten D-35",
-    "loescht die Beschreibung bei ausdruecklichem null (\xA78)",
-    async (store) => {
-      const element = ok(
-        await store.createElement({ type: "style", title: "Alt", description: "weg damit" }),
-        "createElement"
-      );
-      ok(
-        await store.reviseMetadata({
-          elementId: element.element_id,
-          title: "Alt",
-          description: null,
-          expectedRevision: 1
-        }),
-        "reviseMetadata mit description null"
-      );
-      const snapshot = await snapshotOf(store, element.element_id);
-      equal(snapshot.metadata?.description, null, "Beschreibung");
-    },
-    "reviseMetadata"
-  );
-  check(
-    "Elementmetadaten D-35",
-    "behaelt eine nicht mitgesendete locale (\xA78)",
-    async (store) => {
-      const element = ok(
-        await store.createElement({ type: "style", title: "A", locale: "en" }),
-        "createElement mit locale en"
-      );
-      ok(
-        await store.reviseMetadata({
-          elementId: element.element_id,
-          title: "B",
-          expectedRevision: 1
-        }),
-        "reviseMetadata ohne locale"
-      );
-      const snapshot = await snapshotOf(store, element.element_id);
-      equal(snapshot.metadata?.locale, "en", "locale");
-    },
-    "reviseMetadata"
-  );
-  check(
-    "Elementmetadaten D-35",
-    "lehnt eine veraltete Revision ab",
-    async (store) => {
-      const elementId = await seedElement(store, "style", "Alt");
-      await store.reviseMetadata({ elementId, title: "Neu", expectedRevision: 1 });
-      const stale = await store.reviseMetadata({
-        elementId,
-        title: "Noch neuer",
-        expectedRevision: 1
-      });
-      kindIs(stale, "conflict", "zweite Umbenennung mit Revision 1");
-    },
-    "reviseMetadata"
-  );
-  check(
-    "Stilllegen",
-    "ist idempotent \u2014 ein zweiter Aufruf aendert nichts (\xA79)",
-    async (store) => {
-      const elementId = await seedElement(store);
-      const erst = ok(await store.retireElement(elementId), "erstes retireElement");
-      const zweit = ok(await store.retireElement(elementId), "zweites retireElement");
-      equal(erst.retired, true, "retired nach dem ersten Aufruf");
-      equal(zweit.retired, true, "retired nach dem zweiten Aufruf");
-      deepEqual(zweit, erst, "Ergebnis des zweiten Aufrufs");
-    },
-    "retireElement"
-  );
-  check(
-    "Stilllegen",
-    "blendet aus, ohne zu loeschen",
-    async (store) => {
-      const elementId = await seedElement(store);
-      ok(await store.retireElement(elementId), "retireElement");
-      const visible = await store.listElements();
-      hasLength(visible.kind === "ok" ? visible.value : void 0, 0, "sichtbare Elemente");
-      const all = await store.listElements({ includeRetired: true });
-      hasLength(all.kind === "ok" ? all.value : void 0, 1, "Elemente inkl. stillgelegter");
-      const snapshot = await snapshotOf(store, elementId);
-      equal(snapshot.element.retired, true, "retired");
-    },
-    "retireElement"
-  );
-  return checks;
-}
+var _chunkQERFD7BYjs = require('./chunk-QERFD7BY.js');
+require('./chunk-FTLEDU6C.js');
 
 // src/lib/szenen/storeContractVitest.ts
+var _vitest = require('vitest');
 function describeElementStoreContract(name, harness) {
-  const missing = new Set(harness.optionalCommandsMissing ?? []);
-  const checks = elementStoreContractChecks();
+  const missing = new Set(_nullishCoalesce(harness.optionalCommandsMissing, () => ( [])));
+  const checks = _chunkQERFD7BYjs.elementStoreContractChecks.call(void 0, );
   const groups = [...new Set(checks.map((check) => check.group))];
-  (0, import_vitest.describe)(`Port-Vertrag: ${name}`, () => {
+  _vitest.describe.call(void 0, `Port-Vertrag: ${name}`, () => {
     for (const group of groups) {
-      (0, import_vitest.describe)(group, () => {
+      _vitest.describe.call(void 0, group, () => {
         for (const check of checks.filter((candidate) => candidate.group === group)) {
           const skip = check.requires !== void 0 && missing.has(check.requires);
-          import_vitest.it.skipIf(skip)(check.name, async () => {
+          _vitest.it.skipIf(skip)(check.name, async () => {
             await check.run(await harness.createStore());
           });
         }
@@ -1483,7 +22,6 @@ function describeElementStoreContract(name, harness) {
     }
   });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  describeElementStoreContract
-});
+
+
+exports.describeElementStoreContract = describeElementStoreContract;