@muonroi/ui-engine-rule-components 0.1.21 → 0.1.23

package/dist/flow-D-0MTYCm.js

@@ -0,0 +1,510 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+class g {
+  constructor(i) {
+    this._map = /* @__PURE__ */ new Map(), this._roundAverageSize = !1, this.totalSize = 0, (i == null ? void 0 : i.roundAverageSize) === !0 && (this._roundAverageSize = !0);
+  }
+  set(i, t) {
+    const s = this._map.get(i) || 0;
+    this._map.set(i, t), this.totalSize += t - s;
+  }
+  get averageSize() {
+    if (this._map.size > 0) {
+      const i = this.totalSize / this._map.size;
+      return this._roundAverageSize ? Math.round(i) : i;
+    }
+    return 0;
+  }
+  getSize(i) {
+    return this._map.get(i);
+  }
+  clear() {
+    this._map.clear(), this.totalSize = 0;
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+function f(o) {
+  return o === "horizontal" ? "width" : "height";
+}
+class d {
+  _getDefaultConfig() {
+    return {
+      direction: "vertical"
+    };
+  }
+  constructor(i, t) {
+    this._latestCoords = { left: 0, top: 0 }, this._direction = null, this._viewportSize = { width: 0, height: 0 }, this.totalScrollSize = { width: 0, height: 0 }, this.offsetWithinScroller = { left: 0, top: 0 }, this._pendingReflow = !1, this._pendingLayoutUpdate = !1, this._pin = null, this._firstVisible = 0, this._lastVisible = 0, this._physicalMin = 0, this._physicalMax = 0, this._first = -1, this._last = -1, this._sizeDim = "height", this._secondarySizeDim = "width", this._positionDim = "top", this._secondaryPositionDim = "left", this._scrollPosition = 0, this._scrollError = 0, this._items = [], this._scrollSize = 1, this._overhang = 1e3, this._hostSink = i, Promise.resolve().then(() => this.config = t || this._getDefaultConfig());
+  }
+  set config(i) {
+    Object.assign(this, Object.assign({}, this._getDefaultConfig(), i));
+  }
+  get config() {
+    return {
+      direction: this.direction
+    };
+  }
+  /**
+   * Maximum index of children + 1, to help estimate total height of the scroll
+   * space.
+   */
+  get items() {
+    return this._items;
+  }
+  set items(i) {
+    this._setItems(i);
+  }
+  _setItems(i) {
+    i !== this._items && (this._items = i, this._scheduleReflow());
+  }
+  /**
+   * Primary scrolling direction.
+   */
+  get direction() {
+    return this._direction;
+  }
+  set direction(i) {
+    i = i === "horizontal" ? i : "vertical", i !== this._direction && (this._direction = i, this._sizeDim = i === "horizontal" ? "width" : "height", this._secondarySizeDim = i === "horizontal" ? "height" : "width", this._positionDim = i === "horizontal" ? "left" : "top", this._secondaryPositionDim = i === "horizontal" ? "top" : "left", this._triggerReflow());
+  }
+  /**
+   * Height and width of the viewport.
+   */
+  get viewportSize() {
+    return this._viewportSize;
+  }
+  set viewportSize(i) {
+    const { _viewDim1: t, _viewDim2: s } = this;
+    Object.assign(this._viewportSize, i), s !== this._viewDim2 ? this._scheduleLayoutUpdate() : t !== this._viewDim1 && this._checkThresholds();
+  }
+  /**
+   * Scroll offset of the viewport.
+   */
+  get viewportScroll() {
+    return this._latestCoords;
+  }
+  set viewportScroll(i) {
+    Object.assign(this._latestCoords, i);
+    const t = this._scrollPosition;
+    this._scrollPosition = this._latestCoords[this._positionDim], Math.abs(t - this._scrollPosition) >= 1 && this._checkThresholds();
+  }
+  /**
+   * Perform a reflow if one has been scheduled.
+   */
+  reflowIfNeeded(i = !1) {
+    (i || this._pendingReflow) && (this._pendingReflow = !1, this._reflow());
+  }
+  set pin(i) {
+    this._pin = i, this._triggerReflow();
+  }
+  get pin() {
+    if (this._pin !== null) {
+      const { index: i, block: t } = this._pin;
+      return {
+        index: Math.max(0, Math.min(i, this.items.length - 1)),
+        block: t
+      };
+    }
+    return null;
+  }
+  _clampScrollPosition(i) {
+    return Math.max(-this.offsetWithinScroller[this._positionDim], Math.min(i, this.totalScrollSize[f(this.direction)] - this._viewDim1));
+  }
+  unpin() {
+    this._pin !== null && (this._sendUnpinnedMessage(), this._pin = null);
+  }
+  _updateLayout() {
+  }
+  // protected _viewDim2Changed(): void {
+  //   this._scheduleLayoutUpdate();
+  // }
+  /**
+   * The height or width of the viewport, whichever corresponds to the scrolling direction.
+   */
+  get _viewDim1() {
+    return this._viewportSize[this._sizeDim];
+  }
+  /**
+   * The height or width of the viewport, whichever does NOT correspond to the scrolling direction.
+   */
+  get _viewDim2() {
+    return this._viewportSize[this._secondarySizeDim];
+  }
+  _scheduleReflow() {
+    this._pendingReflow = !0;
+  }
+  _scheduleLayoutUpdate() {
+    this._pendingLayoutUpdate = !0, this._scheduleReflow();
+  }
+  // For triggering a reflow based on incoming changes to
+  // the layout config.
+  _triggerReflow() {
+    this._scheduleLayoutUpdate(), Promise.resolve().then(() => this.reflowIfNeeded());
+  }
+  _reflow() {
+    this._pendingLayoutUpdate && (this._updateLayout(), this._pendingLayoutUpdate = !1), this._updateScrollSize(), this._setPositionFromPin(), this._getActiveItems(), this._updateVisibleIndices(), this._sendStateChangedMessage();
+  }
+  /**
+   * If we are supposed to be pinned to a particular
+   * item or set of coordinates, we set `_scrollPosition`
+   * accordingly and adjust `_scrollError` as needed
+   * so that the virtualizer can keep the scroll
+   * position in the DOM in sync
+   */
+  _setPositionFromPin() {
+    if (this.pin !== null) {
+      const i = this._scrollPosition, { index: t, block: s } = this.pin;
+      this._scrollPosition = this._calculateScrollIntoViewPosition({
+        index: t,
+        block: s || "start"
+      }) - this.offsetWithinScroller[this._positionDim], this._scrollError = i - this._scrollPosition;
+    }
+  }
+  /**
+   * Calculate the coordinates to scroll to, given
+   * a request to scroll to the element at a specific
+   * index.
+   *
+   * Supports the same positioning options (`start`,
+   * `center`, `end`, `nearest`) as the standard
+   * `Element.scrollIntoView()` method, but currently
+   * only considers the provided value in the `block`
+   * dimension, since we don't yet have any layouts
+   * that support virtualization in two dimensions.
+   */
+  _calculateScrollIntoViewPosition(i) {
+    const { block: t } = i, s = Math.min(this.items.length, Math.max(0, i.index)), h = this._getItemPosition(s)[this._positionDim];
+    let n = h;
+    if (t !== "start") {
+      const l = this._getItemSize(s)[this._sizeDim];
+      if (t === "center")
+        n = h - 0.5 * this._viewDim1 + 0.5 * l;
+      else {
+        const e = h - this._viewDim1 + l;
+        if (t === "end")
+          n = e;
+        else {
+          const r = this._scrollPosition;
+          n = Math.abs(r - h) < Math.abs(r - e) ? h : e;
+        }
+      }
+    }
+    return n += this.offsetWithinScroller[this._positionDim], this._clampScrollPosition(n);
+  }
+  getScrollIntoViewCoordinates(i) {
+    return {
+      [this._positionDim]: this._calculateScrollIntoViewPosition(i)
+    };
+  }
+  _sendUnpinnedMessage() {
+    this._hostSink({
+      type: "unpinned"
+    });
+  }
+  _sendVisibilityChangedMessage() {
+    this._hostSink({
+      type: "visibilityChanged",
+      firstVisible: this._firstVisible,
+      lastVisible: this._lastVisible
+    });
+  }
+  _sendStateChangedMessage() {
+    const i = /* @__PURE__ */ new Map();
+    if (this._first !== -1 && this._last !== -1)
+      for (let s = this._first; s <= this._last; s++)
+        i.set(s, this._getItemPosition(s));
+    const t = {
+      type: "stateChanged",
+      scrollSize: {
+        [this._sizeDim]: this._scrollSize,
+        [this._secondarySizeDim]: null
+      },
+      range: {
+        first: this._first,
+        last: this._last,
+        firstVisible: this._firstVisible,
+        lastVisible: this._lastVisible
+      },
+      childPositions: i
+    };
+    this._scrollError && (t.scrollError = {
+      [this._positionDim]: this._scrollError,
+      [this._secondaryPositionDim]: 0
+    }, this._scrollError = 0), this._hostSink(t);
+  }
+  /**
+   * Number of items to display.
+   */
+  get _num() {
+    return this._first === -1 || this._last === -1 ? 0 : this._last - this._first + 1;
+  }
+  _checkThresholds() {
+    if (this._viewDim1 === 0 && this._num > 0 || this._pin !== null)
+      this._scheduleReflow();
+    else {
+      const i = Math.max(0, this._scrollPosition - this._overhang), t = Math.min(this._scrollSize, this._scrollPosition + this._viewDim1 + this._overhang);
+      this._physicalMin > i || this._physicalMax < t ? this._scheduleReflow() : this._updateVisibleIndices({ emit: !0 });
+    }
+  }
+  /**
+   * Find the indices of the first and last items to intersect the viewport.
+   * Emit a visibleindiceschange event when either index changes.
+   */
+  _updateVisibleIndices(i) {
+    if (this._first === -1 || this._last === -1)
+      return;
+    let t = this._first;
+    for (; t < this._last && Math.round(this._getItemPosition(t)[this._positionDim] + this._getItemSize(t)[this._sizeDim]) <= Math.round(this._scrollPosition); )
+      t++;
+    let s = this._last;
+    for (; s > this._first && Math.round(this._getItemPosition(s)[this._positionDim]) >= Math.round(this._scrollPosition + this._viewDim1); )
+      s--;
+    (t !== this._firstVisible || s !== this._lastVisible) && (this._firstVisible = t, this._lastVisible = s, i && i.emit && this._sendVisibilityChangedMessage());
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+function m(o) {
+  return o === "horizontal" ? "marginLeft" : "marginTop";
+}
+function u(o) {
+  return o === "horizontal" ? "marginRight" : "marginBottom";
+}
+function S(o) {
+  return o === "horizontal" ? "xOffset" : "yOffset";
+}
+function z(o, i) {
+  const t = [o, i].sort();
+  return t[1] <= 0 ? Math.min(...t) : t[0] >= 0 ? Math.max(...t) : t[0] + t[1];
+}
+class p {
+  constructor() {
+    this._childSizeCache = new g(), this._marginSizeCache = new g(), this._metricsCache = /* @__PURE__ */ new Map();
+  }
+  update(i, t) {
+    var h, n;
+    const s = /* @__PURE__ */ new Set();
+    Object.keys(i).forEach((l) => {
+      const e = Number(l);
+      this._metricsCache.set(e, i[e]), this._childSizeCache.set(e, i[e][f(t)]), s.add(e), s.add(e + 1);
+    });
+    for (const l of s) {
+      const e = ((h = this._metricsCache.get(l)) == null ? void 0 : h[m(t)]) || 0, r = ((n = this._metricsCache.get(l - 1)) == null ? void 0 : n[u(t)]) || 0;
+      this._marginSizeCache.set(l, z(e, r));
+    }
+  }
+  get averageChildSize() {
+    return this._childSizeCache.averageSize;
+  }
+  get totalChildSize() {
+    return this._childSizeCache.totalSize;
+  }
+  get averageMarginSize() {
+    return this._marginSizeCache.averageSize;
+  }
+  get totalMarginSize() {
+    return this._marginSizeCache.totalSize;
+  }
+  getLeadingMarginValue(i, t) {
+    var s;
+    return ((s = this._metricsCache.get(i)) == null ? void 0 : s[m(t)]) || 0;
+  }
+  getChildSize(i) {
+    return this._childSizeCache.getSize(i);
+  }
+  getMarginSize(i) {
+    return this._marginSizeCache.getSize(i);
+  }
+  clear() {
+    this._childSizeCache.clear(), this._marginSizeCache.clear(), this._metricsCache.clear();
+  }
+}
+class M extends d {
+  constructor() {
+    super(...arguments), this._itemSize = { width: 100, height: 100 }, this._physicalItems = /* @__PURE__ */ new Map(), this._newPhysicalItems = /* @__PURE__ */ new Map(), this._metricsCache = new p(), this._anchorIdx = null, this._anchorPos = null, this._stable = !0, this._measureChildren = !0, this._estimate = !0;
+  }
+  // protected _defaultConfig: BaseLayoutConfig = Object.assign({}, super._defaultConfig, {
+  // })
+  // constructor(config: Layout1dConfig) {
+  //   super(config);
+  // }
+  get measureChildren() {
+    return this._measureChildren;
+  }
+  /**
+   * Determine the average size of all children represented in the sizes
+   * argument.
+   */
+  updateItemSizes(i) {
+    this._metricsCache.update(i, this.direction), this._scheduleReflow();
+  }
+  /**
+   * Set the average item size based on the total length and number of children
+   * in range.
+   */
+  // _updateItemSize() {
+  //   // Keep integer values.
+  //   this._itemSize[this._sizeDim] = this._metricsCache.averageChildSize;
+  // }
+  _getPhysicalItem(i) {
+    return this._newPhysicalItems.get(i) ?? this._physicalItems.get(i);
+  }
+  _getSize(i) {
+    return this._getPhysicalItem(i) && this._metricsCache.getChildSize(i);
+  }
+  _getAverageSize() {
+    return this._metricsCache.averageChildSize || this._itemSize[this._sizeDim];
+  }
+  _estimatePosition(i) {
+    const t = this._metricsCache;
+    if (this._first === -1 || this._last === -1)
+      return t.averageMarginSize + i * (t.averageMarginSize + this._getAverageSize());
+    if (i < this._first) {
+      const s = this._first - i;
+      return this._getPhysicalItem(this._first).pos - (t.getMarginSize(this._first - 1) || t.averageMarginSize) - (s * t.averageChildSize + (s - 1) * t.averageMarginSize);
+    } else {
+      const s = i - this._last;
+      return this._getPhysicalItem(this._last).pos + (t.getChildSize(this._last) || t.averageChildSize) + (t.getMarginSize(this._last) || t.averageMarginSize) + s * (t.averageChildSize + t.averageMarginSize);
+    }
+  }
+  /**
+   * Returns the position in the scrolling direction of the item at idx.
+   * Estimates it if the item at idx is not in the DOM.
+   */
+  _getPosition(i) {
+    const t = this._getPhysicalItem(i), { averageMarginSize: s } = this._metricsCache;
+    return i === 0 ? this._metricsCache.getMarginSize(0) ?? s : t ? t.pos : this._estimatePosition(i);
+  }
+  _calculateAnchor(i, t) {
+    return i <= 0 ? 0 : t > this._scrollSize - this._viewDim1 ? this.items.length - 1 : Math.max(0, Math.min(this.items.length - 1, Math.floor((i + t) / 2 / this._delta)));
+  }
+  _getAnchor(i, t) {
+    if (this._physicalItems.size === 0)
+      return this._calculateAnchor(i, t);
+    if (this._first < 0)
+      return this._calculateAnchor(i, t);
+    if (this._last < 0)
+      return this._calculateAnchor(i, t);
+    const s = this._getPhysicalItem(this._first), h = this._getPhysicalItem(this._last), n = s.pos;
+    if (h.pos + this._metricsCache.getChildSize(this._last) < i)
+      return this._calculateAnchor(i, t);
+    if (n > t)
+      return this._calculateAnchor(i, t);
+    let r = this._firstVisible - 1, a = -1 / 0;
+    for (; a < i; )
+      a = this._getPhysicalItem(++r).pos + this._metricsCache.getChildSize(r);
+    return r;
+  }
+  /**
+   * Updates _first and _last based on items that should be in the current
+   * viewed range.
+   */
+  _getActiveItems() {
+    this._viewDim1 === 0 || this.items.length === 0 ? this._clearItems() : this._getItems();
+  }
+  /**
+   * Sets the range to empty.
+   */
+  _clearItems() {
+    this._first = -1, this._last = -1, this._physicalMin = 0, this._physicalMax = 0;
+    const i = this._newPhysicalItems;
+    this._newPhysicalItems = this._physicalItems, this._newPhysicalItems.clear(), this._physicalItems = i, this._stable = !0;
+  }
+  /*
+   * Updates _first and _last based on items that should be in the given range.
+   */
+  _getItems() {
+    const i = this._newPhysicalItems;
+    this._stable = !0;
+    let t, s;
+    if (this.pin !== null) {
+      const { index: a } = this.pin;
+      this._anchorIdx = a, this._anchorPos = this._getPosition(a);
+    }
+    if (t = this._scrollPosition - this._overhang, s = this._scrollPosition + this._viewDim1 + this._overhang, s < 0 || t > this._scrollSize) {
+      this._clearItems();
+      return;
+    }
+    (this._anchorIdx === null || this._anchorPos === null) && (this._anchorIdx = this._getAnchor(t, s), this._anchorPos = this._getPosition(this._anchorIdx));
+    let h = this._getSize(this._anchorIdx);
+    h === void 0 && (this._stable = !1, h = this._getAverageSize());
+    const n = this._metricsCache.getMarginSize(this._anchorIdx) ?? this._metricsCache.averageMarginSize, l = this._metricsCache.getMarginSize(this._anchorIdx + 1) ?? this._metricsCache.averageMarginSize;
+    this._anchorIdx === 0 && (this._anchorPos = n), this._anchorIdx === this.items.length - 1 && (this._anchorPos = this._scrollSize - l - h);
+    let e = 0;
+    for (this._anchorPos + h + l < t && (e = t - (this._anchorPos + h + l)), this._anchorPos - n > s && (e = s - (this._anchorPos - n)), e && (this._scrollPosition -= e, t -= e, s -= e, this._scrollError += e), i.set(this._anchorIdx, { pos: this._anchorPos, size: h }), this._first = this._last = this._anchorIdx, this._physicalMin = this._anchorPos - n, this._physicalMax = this._anchorPos + h + l; this._physicalMin > t && this._first > 0; ) {
+      let a = this._getSize(--this._first);
+      a === void 0 && (this._stable = !1, a = this._getAverageSize());
+      let _ = this._metricsCache.getMarginSize(this._first);
+      _ === void 0 && (this._stable = !1, _ = this._metricsCache.averageMarginSize), this._physicalMin -= a;
+      const c = this._physicalMin;
+      if (i.set(this._first, { pos: c, size: a }), this._physicalMin -= _, this._stable === !1 && this._estimate === !1)
+        break;
+    }
+    for (; this._physicalMax < s && this._last < this.items.length - 1; ) {
+      let a = this._getSize(++this._last);
+      a === void 0 && (this._stable = !1, a = this._getAverageSize());
+      let _ = this._metricsCache.getMarginSize(this._last);
+      _ === void 0 && (this._stable = !1, _ = this._metricsCache.averageMarginSize);
+      const c = this._physicalMax;
+      if (i.set(this._last, { pos: c, size: a }), this._physicalMax += a + _, !this._stable && !this._estimate)
+        break;
+    }
+    const r = this._calculateError();
+    r && (this._physicalMin -= r, this._physicalMax -= r, this._anchorPos -= r, this._scrollPosition -= r, i.forEach((a) => a.pos -= r), this._scrollError += r), this._stable && (this._newPhysicalItems = this._physicalItems, this._newPhysicalItems.clear(), this._physicalItems = i);
+  }
+  _calculateError() {
+    return this._first === 0 ? this._physicalMin : this._physicalMin <= 0 ? this._physicalMin - this._first * this._delta : this._last === this.items.length - 1 ? this._physicalMax - this._scrollSize : this._physicalMax >= this._scrollSize ? this._physicalMax - this._scrollSize + (this.items.length - 1 - this._last) * this._delta : 0;
+  }
+  _reflow() {
+    const { _first: i, _last: t } = this;
+    super._reflow(), (this._first === -1 && this._last == -1 || this._first === i && this._last === t) && this._resetReflowState();
+  }
+  _resetReflowState() {
+    this._anchorIdx = null, this._anchorPos = null, this._stable = !0;
+  }
+  _updateScrollSize() {
+    const { averageMarginSize: i } = this._metricsCache;
+    this._scrollSize = Math.max(1, this.items.length * (i + this._getAverageSize()) + i);
+  }
+  /**
+   * Returns the average size (precise or estimated) of an item in the scrolling direction,
+   * including any surrounding space.
+   */
+  get _delta() {
+    const { averageMarginSize: i } = this._metricsCache;
+    return this._getAverageSize() + i;
+  }
+  /**
+   * Returns the top and left positioning of the item at idx.
+   */
+  _getItemPosition(i) {
+    return {
+      [this._positionDim]: this._getPosition(i),
+      [this._secondaryPositionDim]: 0,
+      [S(this.direction)]: -(this._metricsCache.getLeadingMarginValue(i, this.direction) ?? this._metricsCache.averageMarginSize)
+    };
+  }
+  /**
+   * Returns the height and width of the item at idx.
+   */
+  _getItemSize(i) {
+    return {
+      [this._sizeDim]: this._getSize(i) || this._getAverageSize(),
+      [this._secondarySizeDim]: this._itemSize[this._secondarySizeDim]
+    };
+  }
+  _viewDim2Changed() {
+    this._metricsCache.clear(), this._scheduleReflow();
+  }
+}
+export {
+  M as FlowLayout
+};

package/dist/models/living-docs-models.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Traceability.Models.TestCoverageState
+ *
+ * Serialized by NAME (JsonStringEnumConverter) — MUST be a string union, never an ordinal.
+ * Do NOT compare against integers: compare against "UnitTestLinked" | "DryRunExampleOnly" | "None".
+ */
+export type TestCoverageState = "UnitTestLinked" | "DryRunExampleOnly" | "None";
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Models.FactRef
+ */
+export interface FactRef {
+    name: string;
+    label: string;
+    dataType: string;
+    description?: string | null;
+}
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Models.DecisionNarrative
+ * One section of the living doc — one rule node's BA-readable description.
+ */
+export interface DecisionNarrative {
+    nodeId: string;
+    title: string;
+    inputs: FactRef[];
+    outputs: FactRef[];
+    logicProse: string;
+    sourceKind: string;
+}
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Models.Coverage
+ */
+export interface Coverage {
+    unitTestLinkedCount: number;
+    dryRunExampleCount: number;
+    noCoverageCount: number;
+    totalNodes: number;
+}
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Models.LivingDoc
+ *
+ * The top-level response from GET /api/v1/living-docs/{workflow}/{version}.
+ * Provenance: drift-proofing covers rule-logic layer only (C-04).
+ */
+export interface LivingDocModel {
+    workflow: string;
+    version: number;
+    tenantId: string;
+    generatedAt: string;
+    generatedFromVersionHash: string;
+    sections: DecisionNarrative[];
+    factDictionary: FactRef[];
+    coverage: Coverage;
+}
+/**
+ * Mirrors C# TestCoverageInfo (inner object in TraceabilityMatrixRow + ImpactRow).
+ *
+ * Authoritative shape from plan-01 serialized ImpactListResponse:
+ *   { state, exampleId?, unitTestCode? }
+ * DRIFT FIX: replaced stale { linkedTestIds?, exampleCount? } with correct fields.
+ */
+export interface TestCoverageInfo {
+    state: TestCoverageState;
+    exampleId?: string | null;
+    unitTestCode?: string | null;
+}
+/**
+ * Mirrors C# RequirementRef (inner object in TraceabilityMatrixRow + ImpactRow).
+ *
+ * Authoritative shape from plan-01 serialized ImpactListResponse:
+ *   { id, title, sourceRef?, approver? }
+ * DRIFT FIX: replaced stale { requirementId, title?, source? } with correct camelCase fields.
+ * approver is required for the D-05 Approver column.
+ */
+export interface RequirementRef {
+    id: string;
+    title?: string | null;
+    sourceRef?: string | null;
+    approver?: string | null;
+}
+/**
+ * Mirrors C# DecisionTableCellInfo (optional inner object in TraceabilityMatrixRow).
+ *
+ * DRIFT FIX: replaced stale { columnCount, rowCount, hitPolicy } with full 5-field shape.
+ */
+export interface DecisionTableCellInfo {
+    tableId: string;
+    hitPolicy: string;
+    inputColumnCount: number;
+    outputColumnCount: number;
+    rowCount: number;
+}
+/**
+ * One row in the impact list (D-05 columns).
+ * Mirrors C# ImpactRow (ImpactListResponse.cs).
+ */
+export interface ImpactRow {
+    nodeId: string;
+    title: string;
+    /** RequirementRef MUST carry approver after the drift fix above. */
+    requirements: RequirementRef[];
+    /** Three-state coverage. DryRunExampleOnly is NEVER "covered" (C-01). */
+    testCoverage: TestCoverageInfo;
+    /** "allow→block" | "block→allow" | "none" (Unicode → U+2192) */
+    impactType: string;
+}
+/**
+ * One UAT checklist case (D-02 — grouped under a UatRuleGroup).
+ * Mirrors C# UatCase (ImpactListResponse.cs).
+ */
+export interface UatCase {
+    exampleId: string;
+    expectedOutcome: "allow" | "block";
+    /** Three-state; DryRunExampleOnly is NEVER badge--success (C-01). */
+    coverageBadge: TestCoverageState;
+}
+/**
+ * Top-level impact list response.
+ * Mirrors C# ImpactListResponse (ImpactListResponse.cs).
+ * Authoritative JSON shape confirmed in plan-01 SUMMARY §ImpactListResponse JSON Shape.
+ */
+export interface ImpactListResponse {
+    workflow: string;
+    fromVersion: number;
+    toVersion: number;
+    rows: ImpactRow[];
+    uatChecklist: {
+        nodeId: string;
+        title: string;
+        cases: UatCase[];
+    }[];
+}
+/**
+ * Mirrors the C# record: Muonroi.ControlPlane.Api.LivingDocs.Traceability.Models.TraceabilityMatrixRow
+ *
+ * One row in the traceability matrix — one rule node mapped to its requirements + test coverage.
+ * Consumed from GET /api/v1/traceability/{workflow}/{version}.
+ */
+export interface TraceabilityMatrixRow {
+    nodeId: string;
+    title: string;
+    nodeType: string;
+    requirements: RequirementRef[];
+    testCoverage: TestCoverageInfo;
+    decisionTable?: DecisionTableCellInfo | null;
+}
+//# sourceMappingURL=living-docs-models.d.ts.map

package/dist/models/living-docs-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"living-docs-models.d.ts","sourceRoot":"","sources":["../../src/models/living-docs-models.ts"],"names":[],"mappings":"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"}