@unbrained/pm-cli 2026.7.20 → 2026.7.21

package/dist/cli-bundle/chunks/chunk-PWDEHT3L.js

@@ -0,0 +1,991 @@
+// dist/sdk/graph/traversal.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8b7a0e24-8ead-5b79-a83b-6d2bb32f807f");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_MAX_PATHS = 5;
+var DEFAULT_MAX_VISITED_PATHS = 1e4;
+var DEFAULT_PATH_MAX_DEPTH = 8;
+function assertPathBound(name, value) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0)
+    throw new TypeError(`Invalid path ${name} bound: ${String(value)}`);
+}
+function hierarchyParentEndpoint(edge, definition) {
+  return definition.hierarchyDirection === "target_parent" ? edge.target : edge.source;
+}
+function orderingPredecessorEndpoint(edge, definition) {
+  return (definition.precedence ?? "source_before_target") === "target_before_source" ? edge.target : edge.source;
+}
+function orientOrderingEdge(edge, definition) {
+  const predecessor = orderingPredecessorEndpoint(edge, definition);
+  return {
+    predecessor,
+    successor: predecessor === edge.source ? edge.target : edge.source
+  };
+}
+function resolveFamilyKinds(graph, kinds, family) {
+  if (kinds === void 0)
+    return void 0;
+  const registry = graph.registry();
+  const resolved = /* @__PURE__ */ new Set();
+  for (const kind of kinds) {
+    const definition = registry.require(kind);
+    if (!definition[family])
+      throw new TypeError(`Relationship kind ${definition.kind} is not a ${family} kind`);
+    resolved.add(definition.kind);
+  }
+  return resolved;
+}
+function expandSemanticNeighbors(graph, nodeId, familyKinds, family, matches) {
+  const registry = graph.registry();
+  const rows = graph.neighborEdges(nodeId, {
+    direction: "both",
+    ...familyKinds === void 0 ? {} : { kinds: [...familyKinds] }
+  });
+  const neighbors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows.value) {
+    const definition = registry.require(row.edge.kind);
+    if (!definition[family])
+      continue;
+    if (!matches(row, definition, nodeId))
+      continue;
+    if (seen.has(row.id))
+      continue;
+    seen.add(row.id);
+    neighbors.push(row.id);
+  }
+  return { neighbors, inspectedEdges: rows.meta.inspectedEdges };
+}
+function appendSemanticExpansion(expansion, currentDepth, maxDepth, limit, after, state) {
+  if (currentDepth >= maxDepth) {
+    if (expansion.neighbors.some((neighbor) => !state.seen.has(neighbor)))
+      state.truncated = true;
+    return false;
+  }
+  for (const neighbor of expansion.neighbors) {
+    if (state.seen.has(neighbor))
+      continue;
+    state.seen.add(neighbor);
+    state.queue.push({ id: neighbor, depth: currentDepth + 1 });
+    if (!state.resumed) {
+      if (neighbor === after)
+        state.resumed = true;
+      continue;
+    }
+    if (state.value.length >= limit) {
+      state.truncated = true;
+      return true;
+    }
+    state.value.push(neighbor);
+  }
+  return false;
+}
+function boundedSemanticWalk(graph, start, options, family, matches) {
+  if (!graph.hasNode(start))
+    throw new TypeError(`Relationship node not found: ${start}`);
+  const familyKinds = resolveFamilyKinds(graph, options.kinds, family);
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+  const after = options.after;
+  const state = {
+    seen: /* @__PURE__ */ new Set([start]),
+    value: [],
+    queue: [{ id: start, depth: 0 }],
+    resumed: after === void 0,
+    truncated: false
+  };
+  let visitedNodes = 0;
+  let inspectedEdges = 0;
+  for (let index = 0; index < state.queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const current = state.queue[index];
+    visitedNodes += 1;
+    const expansion = expandSemanticNeighbors(graph, current.id, familyKinds, family, matches);
+    inspectedEdges += expansion.inspectedEdges;
+    if (appendSemanticExpansion(expansion, current.depth, maxDepth, limit, after, state))
+      break;
+  }
+  if (!state.resumed)
+    throw new TypeError(`Traversal cursor not found in sequence: ${after}`);
+  return {
+    value: state.value,
+    meta: {
+      visitedNodes,
+      inspectedEdges,
+      truncated: state.truncated,
+      nextCursor: state.value.at(-1)
+    }
+  };
+}
+function assertPathEndpoint(graph, id) {
+  if (!graph.hasNode(id))
+    throw new TypeError(`Relationship node not found: ${id}`);
+}
+function readPathContinuations(graph, partial, options, direction, state) {
+  const rows = graph.neighborEdges(partial.nodes.at(-1), {
+    direction,
+    ...options.kinds === void 0 ? {} : { kinds: options.kinds }
+  });
+  state.inspectedEdges += rows.meta.inspectedEdges;
+  return rows.value.filter((row) => !partial.nodeSet.has(row.id));
+}
+function expandPartialPath(graph, partial, target, options, direction, probeLimit, state) {
+  for (const row of readPathContinuations(graph, partial, options, direction, state)) {
+    const nodes = [...partial.nodes, row.id];
+    const nodeSet = new Set(partial.nodeSet).add(row.id);
+    const edges = [...partial.edges, row.edge];
+    if (row.id === target) {
+      state.value.push({ nodes, edges, length: edges.length });
+      if (state.value.length >= probeLimit)
+        return true;
+    } else {
+      state.queue.push({ nodes, nodeSet, edges });
+    }
+  }
+  return false;
+}
+function hierarchyAncestors(graph, id, options = {}) {
+  return boundedSemanticWalk(graph, id, options, "hierarchy", (row, definition) => hierarchyParentEndpoint(row.edge, definition) === row.id);
+}
+function hierarchyDescendants(graph, id, options = {}) {
+  return boundedSemanticWalk(graph, id, options, "hierarchy", (row, definition, nodeId) => hierarchyParentEndpoint(row.edge, definition) === nodeId);
+}
+function orderingPredecessors(graph, id, options = {}) {
+  return boundedSemanticWalk(graph, id, options, "ordering", (row, definition) => orderingPredecessorEndpoint(row.edge, definition) === row.id);
+}
+function orderingSuccessors(graph, id, options = {}) {
+  return boundedSemanticWalk(graph, id, options, "ordering", (row, definition, nodeId) => orderingPredecessorEndpoint(row.edge, definition) === nodeId);
+}
+function enumerateNonZeroRelationshipPaths(graph, source, target, options, maxPaths, maxVisitedPaths, maxDepth, direction) {
+  const state = {
+    value: [],
+    queue: [{ nodes: [source], nodeSet: /* @__PURE__ */ new Set([source]), edges: [] }],
+    inspectedEdges: 0
+  };
+  let visitedNodes = 0;
+  let truncated = false;
+  const probeLimit = maxPaths + 1;
+  for (let index = 0; index < state.queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    if (state.value.length >= probeLimit || visitedNodes >= maxVisitedPaths) {
+      truncated = true;
+      break;
+    }
+    const partial = state.queue[index];
+    visitedNodes += 1;
+    if (partial.edges.length >= maxDepth) {
+      if (readPathContinuations(graph, partial, options, direction, state).length > 0)
+        truncated = true;
+      continue;
+    }
+    if (expandPartialPath(graph, partial, target, options, direction, probeLimit, state)) {
+      truncated = true;
+      break;
+    }
+  }
+  return {
+    value: state.value.slice(0, maxPaths),
+    meta: { visitedNodes, inspectedEdges: state.inspectedEdges, truncated }
+  };
+}
+function enumerateRelationshipPaths(graph, source, target, options = {}) {
+  assertPathEndpoint(graph, source);
+  assertPathEndpoint(graph, target);
+  const maxPaths = options.maxPaths ?? DEFAULT_MAX_PATHS;
+  const maxVisitedPaths = options.maxVisitedPaths ?? DEFAULT_MAX_VISITED_PATHS;
+  const maxDepth = options.maxDepth ?? DEFAULT_PATH_MAX_DEPTH;
+  assertPathBound("maxPaths", maxPaths);
+  assertPathBound("maxVisitedPaths", maxVisitedPaths);
+  assertPathBound("maxDepth", maxDepth);
+  const direction = options.direction ?? "outgoing";
+  options.signal?.throwIfAborted();
+  for (const kind of options.kinds ?? [])
+    graph.registry().require(kind);
+  if (source === target) {
+    if (maxPaths === 0) {
+      return {
+        value: [],
+        meta: { visitedNodes: 1, inspectedEdges: 0, truncated: true }
+      };
+    }
+    return {
+      value: [{ nodes: [source], edges: [], length: 0 }],
+      meta: { visitedNodes: 1, inspectedEdges: 0, truncated: false }
+    };
+  }
+  return enumerateNonZeroRelationshipPaths(graph, source, target, options, maxPaths, maxVisitedPaths, maxDepth, direction);
+}
+
+// dist/sdk/graph/analytics.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e7884ad6-98e5-5ed6-93a0-ffba254fe174");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_MAX_ITERATIONS = 16;
+var DEFAULT_MIN_COMMUNITY_SIZE = 2;
+var DEFAULT_REDUNDANCY_MAX_DEPTH = 8;
+function assertPositiveBound(name, value) {
+  if (!Number.isInteger(value) || value < 1)
+    throw new TypeError(`Invalid ${name} bound: ${String(value)}`);
+}
+function forEachMatchedRelationshipEdge(graph, kinds, visit) {
+  const registry = graph.registry();
+  const wanted = kinds === void 0 ? void 0 : new Set(kinds.map((kind) => registry.require(kind).kind));
+  for (const edge of graph.edges()) {
+    if (edge.source === edge.target)
+      continue;
+    const definition = registry.require(edge.kind);
+    if (wanted !== void 0 && !(wanted.has(definition.kind) || definition.inverse !== void 0 && wanted.has(definition.inverse)))
+      continue;
+    visit(edge, definition);
+  }
+}
+function buildUndirectedAdjacency(graph, kinds) {
+  const adjacency = /* @__PURE__ */ new Map();
+  forEachMatchedRelationshipEdge(graph, kinds, (edge) => {
+    appendAdjacency(adjacency, edge.source, edge.target);
+    appendAdjacency(adjacency, edge.target, edge.source);
+  });
+  for (const neighbors of adjacency.values())
+    neighbors.sort();
+  return adjacency;
+}
+function appendAdjacency(adjacency, from, to) {
+  const neighbors = adjacency.get(from);
+  if (neighbors === void 0)
+    adjacency.set(from, [to]);
+  else
+    neighbors.push(to);
+}
+function dominantNeighborLabel(neighbors, labels) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const neighbor of neighbors) {
+    const label = labels.get(neighbor);
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  }
+  let best;
+  let bestCount = 0;
+  for (const [label, count] of counts) {
+    if (count > bestCount || count === bestCount && label < best) {
+      best = label;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function collectCommunities(labels, minSize) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [id, label] of labels) {
+    const members = groups.get(label);
+    if (members === void 0)
+      groups.set(label, [id]);
+    else
+      members.push(id);
+  }
+  const communities = [];
+  for (const members of groups.values()) {
+    if (members.length < minSize)
+      continue;
+    members.sort();
+    communities.push({
+      representative: members[0],
+      size: members.length,
+      members
+    });
+  }
+  return communities.sort((left, right) => right.size - left.size || left.representative.localeCompare(right.representative));
+}
+function detectRelationshipCommunities(graph, options = {}) {
+  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const minSize = options.minSize ?? DEFAULT_MIN_COMMUNITY_SIZE;
+  assertPositiveBound("maxIterations", maxIterations);
+  assertPositiveBound("minSize", minSize);
+  const adjacency = buildUndirectedAdjacency(graph, options.kinds);
+  const nodes = graph.nodes();
+  const labels = new Map(nodes.map((id) => [id, id]));
+  let iterations = 0;
+  let converged = false;
+  let visitedNodes = 0;
+  let inspectedEdges = 0;
+  while (iterations < maxIterations && !converged) {
+    options.signal?.throwIfAborted();
+    iterations += 1;
+    converged = true;
+    for (const id of nodes) {
+      visitedNodes += 1;
+      const neighbors = adjacency.get(id);
+      if (neighbors === void 0)
+        continue;
+      inspectedEdges += neighbors.length;
+      const dominant = dominantNeighborLabel(neighbors, labels);
+      if (dominant !== labels.get(id)) {
+        labels.set(id, dominant);
+        converged = false;
+      }
+    }
+  }
+  return {
+    value: {
+      communities: collectCommunities(labels, minSize),
+      iterations,
+      converged
+    },
+    meta: { visitedNodes, inspectedEdges, truncated: !converged }
+  };
+}
+function isTransitiveKind(definition) {
+  return definition.direction === "directed" && (definition.ordering || definition.hierarchy);
+}
+function transitiveFamilyKey(definition) {
+  return definition.inverse !== void 0 && definition.inverse < definition.kind ? definition.inverse : definition.kind;
+}
+function orientTransitiveEdge(edge, definition) {
+  const head = definition.hierarchy ? hierarchyParentEndpoint(edge, definition) : edge.source === orderingPredecessorEndpoint(edge, definition) ? edge.target : edge.source;
+  return head === edge.target ? { from: edge.source, to: edge.target } : { from: edge.target, to: edge.source };
+}
+function resolveRedundancyFamilies(graph, kinds) {
+  if (kinds === void 0)
+    return void 0;
+  const registry = graph.registry();
+  const families = /* @__PURE__ */ new Set();
+  for (const kind of kinds) {
+    const definition = registry.require(kind);
+    if (!isTransitiveKind(definition))
+      throw new TypeError(`Relationship kind ${definition.kind} is not a directed ordering or hierarchy kind`);
+    families.add(transitiveFamilyKey(definition));
+  }
+  return families;
+}
+function collectTransitiveFamilies(graph, wanted) {
+  const registry = graph.registry();
+  const families = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!isTransitiveKind(definition))
+      continue;
+    const key = transitiveFamilyKey(definition);
+    if (wanted !== void 0 && !wanted.has(key))
+      continue;
+    const oriented = orientTransitiveEdge(edge, definition);
+    if (oriented.from === oriented.to)
+      continue;
+    let family = families.get(key);
+    if (family === void 0) {
+      family = { adjacency: /* @__PURE__ */ new Map(), records: [] };
+      families.set(key, family);
+    }
+    const targets = family.adjacency.get(oriented.from);
+    if (targets === void 0)
+      family.adjacency.set(oriented.from, /* @__PURE__ */ new Set([oriented.to]));
+    else
+      targets.add(oriented.to);
+    family.records.push({ ...oriented, edge });
+  }
+  return families;
+}
+function sortedFamilyAdjacency(family) {
+  const sorted = /* @__PURE__ */ new Map();
+  for (const [from, targets] of family.adjacency)
+    sorted.set(from, [...targets].sort());
+  return sorted;
+}
+function reconstructWitness(parents, from, tail, head) {
+  const witness = [head];
+  for (let node = tail; node !== from; node = parents.get(node))
+    witness.push(node);
+  witness.push(from);
+  return witness.reverse();
+}
+function expandWitnessFrontier(adjacency, record, current, parents, queue, cost) {
+  for (const next of adjacency.get(current.id) ?? []) {
+    cost.inspectedEdges += 1;
+    if (current.depth === 0 && next === record.to)
+      continue;
+    if (parents.has(next))
+      continue;
+    parents.set(next, current.id);
+    if (next === record.to)
+      return reconstructWitness(parents, record.from, current.id, next);
+    queue.push({ id: next, depth: current.depth + 1 });
+  }
+  return void 0;
+}
+function findWitnessPath(adjacency, record, maxDepth, cost) {
+  const parents = /* @__PURE__ */ new Map([[record.from, record.from]]);
+  const queue = [{ id: record.from, depth: 0 }];
+  for (let index = 0; index < queue.length; index += 1) {
+    const current = queue[index];
+    cost.visitedNodes += 1;
+    if (current.depth >= maxDepth)
+      continue;
+    const witness = expandWitnessFrontier(adjacency, record, current, parents, queue, cost);
+    if (witness !== void 0)
+      return witness;
+  }
+  return void 0;
+}
+function findRedundantRelationshipEdges(graph, options = {}) {
+  const maxDepth = options.maxDepth ?? DEFAULT_REDUNDANCY_MAX_DEPTH;
+  assertPositiveBound("maxDepth", maxDepth);
+  if (options.limit !== void 0)
+    assertPositiveBound("limit", options.limit);
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const wanted = resolveRedundancyFamilies(graph, options.kinds);
+  const families = collectTransitiveFamilies(graph, wanted);
+  const value = [];
+  const cost = { visitedNodes: 0, inspectedEdges: 0 };
+  let truncated = false;
+  scan: for (const key of [...families.keys()].sort()) {
+    const family = families.get(key);
+    const adjacency = sortedFamilyAdjacency(family);
+    for (const record of family.records) {
+      options.signal?.throwIfAborted();
+      const witness = findWitnessPath(adjacency, record, maxDepth, cost);
+      if (witness === void 0)
+        continue;
+      if (value.length >= limit) {
+        truncated = true;
+        break scan;
+      }
+      value.push({ edge: record.edge, witness });
+    }
+  }
+  return {
+    value,
+    meta: {
+      visitedNodes: cost.visitedNodes,
+      inspectedEdges: cost.inspectedEdges,
+      truncated
+    }
+  };
+}
+function expandReachableNode(id, depth, rows, maxDepth, state) {
+  const nextSet = /* @__PURE__ */ new Set();
+  const nexts = [];
+  for (const row of rows) {
+    if (row.id === id || nextSet.has(row.id))
+      continue;
+    if (!state.seen.has(row.id)) {
+      if (depth >= maxDepth) {
+        state.truncated = true;
+        continue;
+      }
+      state.seen.add(row.id);
+      state.queue.push({ id: row.id, depth: depth + 1 });
+    }
+    nextSet.add(row.id);
+    nexts.push(row.id);
+    let incoming = state.predecessors.get(row.id);
+    if (incoming === void 0) {
+      incoming = /* @__PURE__ */ new Set();
+      state.predecessors.set(row.id, incoming);
+    }
+    incoming.add(id);
+  }
+  return nexts;
+}
+function indexReachableSubgraph(graph, root, options) {
+  const direction = options.direction ?? "outgoing";
+  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+  const order = [];
+  const successors = /* @__PURE__ */ new Map();
+  const state = {
+    seen: /* @__PURE__ */ new Set([root]),
+    queue: [{ id: root, depth: 0 }],
+    predecessors: /* @__PURE__ */ new Map(),
+    truncated: false
+  };
+  let inspectedEdges = 0;
+  for (let index = 0; index < state.queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const { id, depth } = state.queue[index];
+    order.push(id);
+    const rows = graph.neighborEdges(id, {
+      direction,
+      ...options.kinds === void 0 ? {} : { kinds: options.kinds }
+    });
+    inspectedEdges += rows.meta.inspectedEdges;
+    successors.set(id, expandReachableNode(id, depth, rows.value, maxDepth, state));
+  }
+  return {
+    order,
+    successors,
+    predecessors: state.predecessors,
+    inspectedEdges,
+    truncated: state.truncated
+  };
+}
+function reversePostorder(subgraph, root) {
+  const postorder = [];
+  const visited = /* @__PURE__ */ new Set([root]);
+  const stack = [{ id: root, index: 0 }];
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    const nexts = subgraph.successors.get(frame.id);
+    if (frame.index < nexts.length) {
+      const next = nexts[frame.index];
+      frame.index += 1;
+      if (!visited.has(next)) {
+        visited.add(next);
+        stack.push({ id: next, index: 0 });
+      }
+    } else {
+      postorder.push(frame.id);
+      stack.pop();
+    }
+  }
+  return postorder.reverse();
+}
+function intersectDominators(left, right, idom, ordinal) {
+  let first = left;
+  let second = right;
+  while (first !== second) {
+    while (ordinal.get(first) > ordinal.get(second))
+      first = idom.get(first);
+    while (ordinal.get(second) > ordinal.get(first))
+      second = idom.get(second);
+  }
+  return first;
+}
+function dominatorCandidate(predecessors, idom, ordinal) {
+  let candidate;
+  for (const pred of [...predecessors].sort()) {
+    if (!idom.has(pred))
+      continue;
+    candidate = candidate === void 0 ? pred : intersectDominators(candidate, pred, idom, ordinal);
+  }
+  return candidate;
+}
+function solveImmediateDominators(subgraph, root, order, ordinal, signal) {
+  const idom = /* @__PURE__ */ new Map([[root, root]]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const id of order) {
+      signal?.throwIfAborted();
+      if (id === root)
+        continue;
+      const candidate = dominatorCandidate(subgraph.predecessors.get(id), idom, ordinal);
+      if (candidate !== void 0 && idom.get(id) !== candidate) {
+        idom.set(id, candidate);
+        changed = true;
+      }
+    }
+  }
+  return idom;
+}
+function computeRelationshipDominators(graph, root, options = {}) {
+  if (!graph.hasNode(root))
+    throw new TypeError(`Relationship node not found: ${root}`);
+  if (options.maxDepth !== void 0 && (!Number.isInteger(options.maxDepth) || options.maxDepth < 0))
+    throw new TypeError(`Invalid maxDepth bound: ${String(options.maxDepth)}`);
+  const subgraph = indexReachableSubgraph(graph, root, options);
+  const order = reversePostorder(subgraph, root);
+  const ordinal = new Map(order.map((id, index) => [id, index]));
+  const idom = solveImmediateDominators(subgraph, root, order, ordinal, options.signal);
+  const subtreeSizes = new Map(order.map((id) => [id, 1]));
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const id = order[index];
+    if (id === root)
+      continue;
+    const parent = idom.get(id);
+    subtreeSizes.set(parent, subtreeSizes.get(parent) + subtreeSizes.get(id));
+  }
+  const rows = order.filter((id) => id !== root).map((id) => ({
+    id,
+    idom: idom.get(id),
+    dominatedCount: subtreeSizes.get(id) - 1
+  })).sort((left, right) => right.dominatedCount - left.dominatedCount || left.id.localeCompare(right.id));
+  return {
+    value: { root, reachableCount: subgraph.order.length, rows },
+    meta: {
+      visitedNodes: subgraph.order.length,
+      inspectedEdges: subgraph.inspectedEdges,
+      truncated: subgraph.truncated
+    }
+  };
+}
+
+// dist/sdk/graph/governance.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "4b36a9d4-2621-5560-831f-7fd026072cf1");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_MAX_SAMPLE_SIZE = 25;
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+function buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation) {
+  const sorted = [...subjects].sort((left, right) => left.localeCompare(right));
+  return {
+    code,
+    severity,
+    policy,
+    message: describe(sorted.length),
+    count: sorted.length,
+    sample: sorted.slice(0, maxSampleSize),
+    sample_truncated: sorted.length > maxSampleSize,
+    remediation
+  };
+}
+function buildOrderingAdjacency(assembly) {
+  const registry = assembly.graph.registry();
+  const successors = /* @__PURE__ */ new Map();
+  for (const edge of assembly.graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!definition.ordering)
+      continue;
+    const [predecessor, successor] = (definition.precedence ?? "source_before_target") === "target_before_source" ? [edge.target, edge.source] : [edge.source, edge.target];
+    const adjacent = successors.get(predecessor);
+    if (adjacent)
+      adjacent.push(successor);
+    else
+      successors.set(predecessor, [successor]);
+  }
+  for (const adjacent of successors.values())
+    adjacent.sort((left, right) => left.localeCompare(right));
+  return successors;
+}
+function registerTarjanNode(node, state) {
+  state.indexes.set(node, state.nextIndex);
+  state.lowLinks.set(node, state.nextIndex);
+  state.nextIndex += 1;
+  state.stack.push(node);
+  state.onStack.add(node);
+}
+function visitNextTarjanNeighbor(frame, frames, successors, state) {
+  const neighbors = successors.get(frame.node) ?? [];
+  if (frame.neighborIndex >= neighbors.length)
+    return false;
+  const neighbor = neighbors[frame.neighborIndex];
+  frame.neighborIndex += 1;
+  if (!state.indexes.has(neighbor)) {
+    registerTarjanNode(neighbor, state);
+    frames.push({ node: neighbor, neighborIndex: 0 });
+  } else if (state.onStack.has(neighbor)) {
+    state.lowLinks.set(frame.node, Math.min(state.lowLinks.get(frame.node), state.indexes.get(neighbor)));
+  }
+  return true;
+}
+function completeTarjanFrame(frame, frames, successors, state) {
+  frames.pop();
+  const parent = frames.at(-1);
+  if (parent)
+    state.lowLinks.set(parent.node, Math.min(state.lowLinks.get(parent.node), state.lowLinks.get(frame.node)));
+  if (state.lowLinks.get(frame.node) !== state.indexes.get(frame.node))
+    return;
+  const component = [];
+  while (true) {
+    const member = state.stack.pop();
+    state.onStack.delete(member);
+    component.push(member);
+    if (member === frame.node)
+      break;
+  }
+  if (component.length > 1 || component.length === 1 && successors.get(component[0])?.includes(component[0]))
+    state.components.push(component.sort((left, right) => left.localeCompare(right)));
+}
+function collectOrderingCycles(successors) {
+  const state = {
+    indexes: /* @__PURE__ */ new Map(),
+    lowLinks: /* @__PURE__ */ new Map(),
+    onStack: /* @__PURE__ */ new Set(),
+    stack: [],
+    components: [],
+    nextIndex: 0
+  };
+  const roots = [...successors.keys()].sort((left, right) => left.localeCompare(right));
+  for (const root of roots) {
+    if (state.indexes.has(root))
+      continue;
+    const frames = [{ node: root, neighborIndex: 0 }];
+    registerTarjanNode(root, state);
+    while (frames.length > 0) {
+      const frame = frames.at(-1);
+      if (visitNextTarjanNeighbor(frame, frames, successors, state))
+        continue;
+      completeTarjanFrame(frame, frames, successors, state);
+    }
+  }
+  return state.components.sort((left, right) => left[0].localeCompare(right[0]));
+}
+function formatDanglingReference(reference) {
+  return `${reference.holder_id} -> ${reference.target_id} (${reference.kind})`;
+}
+function appendFinding(findings, subjects, maxSampleSize, code, severity, policy, describe, remediation) {
+  if (subjects.length === 0)
+    return;
+  findings.push(buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation));
+}
+function collectIntegrityFindings(assembly, isTerminal, maxSampleSize) {
+  const findings = [];
+  const references = [
+    ...assembly.dangling.active,
+    ...assembly.dangling.legacy_terminal
+  ].filter((reference) => !reference.no_active_blocker_sentinel);
+  appendFinding(findings, references.filter((reference) => !isTerminal(reference.holder_status)).map(formatDanglingReference), maxSampleSize, "missing_reference_active", "error", "Active items must not reference absent targets; missing prerequisites distort scheduling.", (count) => `${count} active dangling reference(s) to absent items`, "Restore or re-create the referenced item, or remove/retype the reference on the holder.");
+  appendFinding(findings, references.filter((reference) => isTerminal(reference.holder_status)).map(formatDanglingReference), maxSampleSize, "missing_reference_terminal", "info", "Terminal items may retain historical references, but absent targets remain unexplainable context.", (count) => `${count} terminal dangling reference(s) to absent items`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
+  appendFinding(findings, assembly.dangling.no_active_blocker_sentinels.map(formatDanglingReference), maxSampleSize, "legacy_no_blocker_sentinel", "info", "The pre-structured-dependency no-active-blocker sentinel is retired; real edges carry blocker state.", (count) => `${count} legacy no-active-blocker sentinel reference(s)`, "Delete the sentinel reference; blocker state is derived from blocked_by edges.");
+  return findings;
+}
+function isActiveAuditMember(member, nodeStates) {
+  const state = nodeStates.get(member);
+  if (!state)
+    return true;
+  return !state.terminal;
+}
+function collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize) {
+  const findings = [];
+  const orderingAdjacency = buildOrderingAdjacency(assembly);
+  for (const cycle of collectOrderingCycles(orderingAdjacency)) {
+    const active = cycle.some((member) => isActiveAuditMember(member, nodeStates));
+    findings.push(active ? buildFinding("ordering_cycle", "error", "Order-bearing relationship kinds must stay acyclic; a cycle makes every member unschedulable.", (count) => `execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Remove or retype one ordering edge inside the cycle, or split the work so precedence is linear.") : buildFinding("legacy_ordering_cycle", "info", "Ordering cycles between exclusively terminal items are historical contradictions with no scheduling effect.", (count) => `terminal-only execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Leave as history debt, or clean up in a dedicated changelog-safe closed-item batch; never repair closed items ad hoc."));
+  }
+  const predecessorsByNode = /* @__PURE__ */ new Map();
+  for (const [predecessor, adjacent] of orderingAdjacency)
+    for (const successor of adjacent) {
+      const predecessors = predecessorsByNode.get(successor);
+      if (predecessors)
+        predecessors.push(predecessor);
+      else
+        predecessorsByNode.set(successor, [predecessor]);
+    }
+  const staleLifecycleBlocks = [...nodeStates.values()].filter((state) => !state.missing && !state.terminal && isBlocked(state.status) && !(predecessorsByNode.get(state.id) ?? []).some((predecessor) => {
+    const predecessorState = nodeStates.get(predecessor);
+    return predecessorState === void 0 || !predecessorState.terminal;
+  })).map((state) => state.id);
+  appendFinding(findings, staleLifecycleBlocks, maxSampleSize, "stale_lifecycle_block", "warning", "A blocked lifecycle status must be backed by at least one open ordering predecessor.", (count) => `${count} status-blocked item(s) with no open blocker edge`, "Re-open the missing prerequisite as an edge, or move the item back to an active status.");
+  return findings;
+}
+function formatDuplicateEdgeGroup(group) {
+  const kinds = group.edges.map((edge) => edge.kind).sort((left, right) => left.localeCompare(right));
+  return `${group.from} -> ${group.to} (${kinds.join(" + ")})`;
+}
+function collectDuplicateRelationshipEdgeGroups(assembly) {
+  const registry = assembly.graph.registry();
+  const groups = /* @__PURE__ */ new Map();
+  for (const edge of assembly.graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!isTransitiveKind(definition))
+      continue;
+    const oriented = orientTransitiveEdge(edge, definition);
+    if (oriented.from === oriented.to)
+      continue;
+    const key = `${transitiveFamilyKey(definition)}::${oriented.from}::${oriented.to}`;
+    const group = groups.get(key);
+    if (group)
+      group.edges.push(edge);
+    else
+      groups.set(key, { ...oriented, edges: [edge] });
+  }
+  const duplicated = [...groups.values()].filter((group) => group.edges.length >= 2);
+  for (const group of duplicated)
+    group.edges.sort((left, right) => left.kind.localeCompare(right.kind));
+  return duplicated.sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to));
+}
+function collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize) {
+  const active = [];
+  const legacy = [];
+  for (const group of collectDuplicateRelationshipEdgeGroups(assembly)) {
+    const subjects = isActiveAuditMember(group.from, nodeStates) || isActiveAuditMember(group.to, nodeStates) ? active : legacy;
+    subjects.push(formatDuplicateEdgeGroup(group));
+  }
+  const findings = [];
+  appendFinding(findings, active, maxSampleSize, "duplicate_edge", "info", "One semantic relationship should be stored once; parallel same-family spellings (reciprocal inverse pairs included) add no information and skew degree metrics.", (count) => `${count} duplicated relationship(s) between active endpoints`, "Remove all but one stored spelling of the relationship; keep the canonical direction the holder declared first.");
+  appendFinding(findings, legacy, maxSampleSize, "legacy_duplicate_edge", "info", "Duplicated spellings between exclusively terminal items are historical noise with no scheduling effect.", (count) => `${count} duplicated relationship(s) between terminal endpoints`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
+  return findings;
+}
+function collectDuplicateRowFindings(assembly, maxSampleSize) {
+  const active = [];
+  const legacy = [];
+  for (const row of assembly.duplicateRows ?? []) {
+    (row.legacy_terminal ? legacy : active).push(`${row.holder_id} -> ${row.target_id} (${row.kind} x${row.occurrences})`);
+  }
+  const findings = [];
+  appendFinding(findings, active, maxSampleSize, "duplicate_dependency_row", "warning", "One dependency row must be stored once per holder; identical repeated rows are a storage-layer defect invisible to the assembled graph.", (count) => `${count} exactly duplicated stored dependency row(s) on active holder(s)`, "Remove the repeated rows so the dependency is stored exactly once; graph semantics are unchanged.");
+  appendFinding(findings, legacy, maxSampleSize, "legacy_duplicate_dependency_row", "info", "Identical repeated dependency rows on terminal holders are historical storage noise with no scheduling effect.", (count) => `${count} exactly duplicated stored dependency row(s) on terminal holder(s)`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
+  return findings;
+}
+function tallyActiveCoverageNode(tallies, state, degree, exemptIsolates, isolateExemptTypes) {
+  tallies.active += 1;
+  const typeKey = state.type ?? "(untyped)";
+  let typeProfile = tallies.byType.get(typeKey);
+  if (!typeProfile) {
+    typeProfile = { active: 0, isolated: 0, degree_leq_one: 0 };
+    tallies.byType.set(typeKey, typeProfile);
+  }
+  typeProfile.active += 1;
+  if (degree > 1)
+    return;
+  tallies.degreeLeqOne += 1;
+  typeProfile.degree_leq_one += 1;
+  if (degree === 0) {
+    tallies.isolated += 1;
+    typeProfile.isolated += 1;
+  }
+  if (exemptIsolates.has(state.id.toLowerCase()) || isolateExemptTypes.has(typeKey.toLowerCase()))
+    return;
+  if (degree === 0)
+    tallies.isolates.push(state.id);
+  else
+    tallies.sparse.push(state.id);
+}
+function collectCoverageReport(assembly, nodeStates, exemptIsolates, isolateExemptTypes, maxSampleSize, edgesByKind) {
+  const tallies = {
+    active: 0,
+    missing: 0,
+    isolated: 0,
+    degreeLeqOne: 0,
+    isolates: [],
+    sparse: [],
+    byType: /* @__PURE__ */ new Map()
+  };
+  for (const id of assembly.graph.nodes()) {
+    const state = nodeStates.get(id);
+    if (!state)
+      continue;
+    if (state.missing) {
+      tallies.missing += 1;
+      continue;
+    }
+    if (state.terminal)
+      continue;
+    tallyActiveCoverageNode(tallies, state, assembly.graph.incidentEdges(id).length, exemptIsolates, isolateExemptTypes);
+  }
+  const { isolates, sparse } = tallies;
+  const findings = [];
+  appendFinding(findings, isolates, maxSampleSize, "isolated_active_node", "warning", "Active work should be reachable from the graph unless explicitly declared a valid isolate.", (count) => `${count} active item(s) with no relationships`, "Link the item to its parent, prerequisite, or origin \u2014 or register it as an exempt isolate.");
+  appendFinding(findings, sparse, maxSampleSize, "sparse_active_node", "info", "Active items with a single edge often miss an honest semantic partner; sparse is not automatically defective.", (count) => `${count} active item(s) with exactly one relationship`, "Investigate for an honest second edge (story->task, defect family, cross-epic complement); do not fabricate one.");
+  return {
+    findings,
+    profile: {
+      nodes: assembly.graph.nodes().length,
+      edges: assembly.graph.edges().length,
+      edges_by_kind: Object.fromEntries(Object.entries(edgesByKind).sort(([left], [right]) => left.localeCompare(right))),
+      active_nodes: tallies.active,
+      missing_nodes: tallies.missing,
+      isolated_active_nodes: tallies.isolated,
+      degree_leq_one_active_nodes: tallies.degreeLeqOne,
+      coverage_by_type: Object.fromEntries([...tallies.byType.entries()].sort(([left], [right]) => left < right ? -1 : 1))
+    }
+  };
+}
+function auditWorkspaceRelationshipGraph(assembly, options = {}) {
+  const isTerminal = options.isTerminal ?? ((status) => status === "closed" || status === "canceled");
+  const isBlocked = options.isBlocked ?? ((status) => status === "blocked");
+  const maxSampleSize = options.maxSampleSize ?? DEFAULT_MAX_SAMPLE_SIZE;
+  if (!Number.isInteger(maxSampleSize) || maxSampleSize < 1)
+    throw new TypeError(`Invalid audit sample bound: ${String(options.maxSampleSize)}`);
+  const exemptIsolates = new Set((options.exemptIsolates ?? []).filter((id) => typeof id === "string").map((id) => id.trim().toLowerCase()));
+  const isolateExemptTypes = new Set((options.isolateExemptTypes ?? []).filter((type) => typeof type === "string").map((type) => type.trim().toLowerCase()));
+  const nodeStates = new Map(assembly.details.map((detail) => [
+    detail.id,
+    {
+      id: detail.id,
+      status: detail.status,
+      missing: assembly.missingIdSet.has(detail.id.toLowerCase()),
+      terminal: isTerminal(detail.status),
+      ...detail.type === void 0 ? {} : { type: detail.type }
+    }
+  ]));
+  options.signal?.throwIfAborted();
+  const edgesByKind = {};
+  for (const edge of assembly.graph.edges())
+    edgesByKind[edge.kind] = (edgesByKind[edge.kind] ?? 0) + 1;
+  const findings = collectIntegrityFindings(assembly, isTerminal, maxSampleSize);
+  options.signal?.throwIfAborted();
+  findings.push(...collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize));
+  options.signal?.throwIfAborted();
+  findings.push(...collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize), ...collectDuplicateRowFindings(assembly, maxSampleSize));
+  options.signal?.throwIfAborted();
+  const coverage = collectCoverageReport(assembly, nodeStates, exemptIsolates, isolateExemptTypes, maxSampleSize, edgesByKind);
+  findings.push(...coverage.findings);
+  findings.sort((left, right) => SEVERITY_RANK[left.severity] - SEVERITY_RANK[right.severity] || left.code.localeCompare(right.code) || left.sample[0].localeCompare(right.sample[0]));
+  return {
+    findings,
+    profile: coverage.profile
+  };
+}
+function diffCountRecords(baseline, current) {
+  const keys = [
+    .../* @__PURE__ */ new Set([...Object.keys(baseline), ...Object.keys(current)])
+  ].sort();
+  const deltas = {};
+  for (const key of keys) {
+    const delta = (current[key] ?? 0) - (baseline[key] ?? 0);
+    if (delta !== 0)
+      deltas[key] = delta;
+  }
+  return deltas;
+}
+function readSnapshotCoverageByType(snapshot) {
+  return snapshot.profile.coverage_by_type ?? {};
+}
+function diffRelationshipAuditSnapshots(baseline, current) {
+  const coverageByType = {};
+  const baselineCoverageByType = readSnapshotCoverageByType(baseline);
+  const currentCoverageByType = readSnapshotCoverageByType(current);
+  const typeKeys = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(baselineCoverageByType),
+      ...Object.keys(currentCoverageByType)
+    ])
+  ].sort();
+  for (const type of typeKeys) {
+    const before = baselineCoverageByType[type];
+    const after = currentCoverageByType[type];
+    const delta = {
+      active: (after?.active ?? 0) - (before?.active ?? 0),
+      isolated: (after?.isolated ?? 0) - (before?.isolated ?? 0),
+      degree_leq_one: (after?.degree_leq_one ?? 0) - (before?.degree_leq_one ?? 0)
+    };
+    if (Object.values(delta).some((value) => value !== 0))
+      coverageByType[type] = delta;
+  }
+  return {
+    baseline_saved_at: baseline.saved_at,
+    same_snapshot: baseline.fingerprint === current.fingerprint,
+    affected_subjects_by_code: diffCountRecords(baseline.affected_subjects_by_code, current.affected_subjects_by_code),
+    profile: {
+      nodes: current.profile.nodes - baseline.profile.nodes,
+      edges: current.profile.edges - baseline.profile.edges,
+      active_nodes: current.profile.active_nodes - baseline.profile.active_nodes,
+      missing_nodes: current.profile.missing_nodes - baseline.profile.missing_nodes,
+      isolated_active_nodes: current.profile.isolated_active_nodes - baseline.profile.isolated_active_nodes,
+      degree_leq_one_active_nodes: current.profile.degree_leq_one_active_nodes - baseline.profile.degree_leq_one_active_nodes,
+      edges_by_kind: diffCountRecords(baseline.profile.edges_by_kind, current.profile.edges_by_kind),
+      coverage_by_type: coverageByType
+    }
+  };
+}
+
+export {
+  orientOrderingEdge,
+  hierarchyAncestors,
+  hierarchyDescendants,
+  orderingPredecessors,
+  orderingSuccessors,
+  enumerateRelationshipPaths,
+  forEachMatchedRelationshipEdge,
+  detectRelationshipCommunities,
+  findRedundantRelationshipEdges,
+  computeRelationshipDominators,
+  collectOrderingCycles,
+  formatDuplicateEdgeGroup,
+  collectDuplicateRelationshipEdgeGroups,
+  auditWorkspaceRelationshipGraph,
+  diffRelationshipAuditSnapshots
+};
+//# sourceMappingURL=chunk-PWDEHT3L.js.map