@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-7UCY6DR5.js → chunk-JPWUZOMR.js}

@@ -11,7 +11,7 @@ import {
   PLAN_MODE_VALUES,
   PLAN_STEP_LINK_KIND_VALUES,
   PLAN_STEP_STATUS_VALUES
-} from "./chunk-KX62NMZC.js";
+} from "./chunk-D35WYXWC.js";
 
 // dist/sdk/cli-contracts/command-aliases.js
 var EXECUTABLE_COMMAND_ALIASES = {
@@ -5651,6 +5651,6 @@ export {
   PM_TOOL_PARAMETERS_SCHEMA,
   PM_PROVIDER_TOOL_PARAMETERS_SCHEMA
 };
-//# sourceMappingURL=chunk-7UCY6DR5.js.map
+//# sourceMappingURL=chunk-JPWUZOMR.js.map
 
 //# debugId=ebed3dd6-7ac3-5ba9-81af-461fa44a9c47

package/dist/cli-bundle/chunks/{chunk-FVNWHUME.js → chunk-K2L6FZBX.js}

@@ -1,22 +1,22 @@
 import {
-  resolveAuthor
-} from "./chunk-YRYYFGV3.js";
+  splitCommaList
+} from "./chunk-D6HZN36B.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
   looksLikeGenericKeyValueEntry,
   parseCsvKv
-} from "./chunk-D52ZN3BF.js";
+} from "./chunk-A5EQPNV7.js";
 import {
-  splitCommaList
-} from "./chunk-D6HZN36B.js";
+  resolveAuthor
+} from "./chunk-YRYYFGV3.js";
 import {
   getActiveExtensionRegistrations,
   locateItem,
   mutateItem,
   readLocatedItem,
   readSettings
-} from "./chunk-646MQXFW.js";
+} from "./chunk-RLLOZAM2.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -26,7 +26,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveWorkspaceRoot
-} from "./chunk-WACRQ26A.js";
+} from "./chunk-WCBB6VI3.js";
 
 // dist/sdk/linked-artifacts.js
 import fs from "node:fs/promises";
@@ -444,4 +444,4 @@ export {
   runLinkedArtifacts,
   renameArtifactsResultKey
 };
-//# sourceMappingURL=chunk-FVNWHUME.js.map
+//# sourceMappingURL=chunk-K2L6FZBX.js.map

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

@@ -0,0 +1,286 @@
+
+!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]="5638f886-de83-5daf-8c42-386c898c57c0")}catch(e){}}();
+import {
+  createRelationshipKindRegistry
+} from "./chunk-D35WYXWC.js";
+
+// dist/sdk/relationship-analytics.js
+function appendNeighbor(adjacency, source, target) {
+  adjacency.get(source).add(target);
+}
+function createAdjacency(nodes) {
+  return new Map(nodes.map((node) => [node, /* @__PURE__ */ new Set()]));
+}
+function sortComponents(components) {
+  for (const component of components)
+    component.sort();
+  return components.sort((left, right) => right.length - left.length || left[0].localeCompare(right[0]));
+}
+function stableJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => stableJsonValue(entry));
+  if (value === null || typeof value !== "object")
+    return value;
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function")
+    return stableJsonValue(toJSON.call(value));
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableJsonValue(entry)]));
+}
+function relationshipEdgeKey(edge) {
+  return JSON.stringify(stableJsonValue(edge));
+}
+function appendFinishingOrder(start, adjacency, visited, order) {
+  const stack = [{ id: start, expanded: false }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current.expanded) {
+      order.push(current.id);
+      continue;
+    }
+    if (visited.has(current.id))
+      continue;
+    visited.add(current.id);
+    stack.push({ id: current.id, expanded: true });
+    const neighbors = [...adjacency.get(current.id)].sort().reverse();
+    for (const neighbor of neighbors)
+      if (!visited.has(neighbor))
+        stack.push({ id: neighbor, expanded: false });
+  }
+}
+function computeFinishingOrder(nodes, adjacency) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of nodes)
+    if (!visited.has(start))
+      appendFinishingOrder(start, adjacency, visited, order);
+  return order;
+}
+function collectReverseComponents(order, reverse) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const start of [...order].reverse()) {
+    if (visited.has(start))
+      continue;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of reverse.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
+      }
+    }
+    components.push(component);
+  }
+  return sortComponents(components);
+}
+function stronglyConnectedComponents(nodes, adjacency) {
+  const reverse = createAdjacency(nodes);
+  for (const [source, targets] of adjacency)
+    for (const target of targets)
+      appendNeighbor(reverse, target, source);
+  return collectReverseComponents(computeFinishingOrder(nodes, adjacency), reverse);
+}
+function buildExecutionAdjacency(graph, registry) {
+  const adjacency = createAdjacency(graph.nodes());
+  for (const edge of graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!definition.ordering)
+      continue;
+    const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
+    appendNeighbor(adjacency, sourceFirst ? edge.source : edge.target, sourceFirst ? edge.target : edge.source);
+  }
+  return adjacency;
+}
+function topologicalLayers(nodes, adjacency) {
+  const indegree = new Map(nodes.map((node) => [node, 0]));
+  for (const targets of adjacency.values())
+    for (const target of targets)
+      indegree.set(target, indegree.get(target) + 1);
+  let frontier = nodes.filter((node) => indegree.get(node) === 0).sort();
+  const layers = [];
+  while (frontier.length > 0) {
+    layers.push(frontier);
+    const next = [];
+    for (const source of frontier) {
+      for (const target of adjacency.get(source)) {
+        const remaining = indegree.get(target) - 1;
+        indegree.set(target, remaining);
+        if (remaining === 0)
+          next.push(target);
+      }
+    }
+    frontier = next.sort();
+  }
+  return layers;
+}
+function longestPath(order, adjacency) {
+  const depth = new Map(order.map((node) => [node, 0]));
+  const parent = /* @__PURE__ */ new Map();
+  for (const source of order) {
+    for (const target of adjacency.get(source)) {
+      if (!depth.has(target))
+        continue;
+      const candidate = depth.get(source) + 1;
+      const currentParent = parent.get(target);
+      if (candidate > depth.get(target) || candidate === depth.get(target) && (currentParent === void 0 || source.localeCompare(currentParent) < 0)) {
+        depth.set(target, candidate);
+        parent.set(target, source);
+      }
+    }
+  }
+  const end = [...order].sort((left, right) => depth.get(right) - depth.get(left) || left.localeCompare(right))[0];
+  const path = end === void 0 ? [] : [end];
+  while (path[0] !== void 0 && parent.has(path[0]))
+    path.unshift(parent.get(path[0]));
+  return { depth: Object.fromEntries(depth), path };
+}
+function reconstructImpactPath(root, target, parents) {
+  const path = [target];
+  let cursor = target;
+  while (cursor !== root) {
+    cursor = parents.get(cursor);
+    path.push(cursor);
+  }
+  return path.reverse();
+}
+function analyzeRelationshipExecution(graph, options = {}) {
+  const registry = options.registry ?? createRelationshipKindRegistry();
+  const nodes = [...graph.nodes()];
+  const adjacency = buildExecutionAdjacency(graph, registry);
+  const layers = topologicalLayers(nodes, adjacency);
+  const order = layers.flat();
+  const acyclic = order.length === nodes.length;
+  const cycles = acyclic ? [] : stronglyConnectedComponents(nodes, adjacency).filter((component) => component.length > 1 || adjacency.get(component[0]).has(component[0]));
+  const longest = longestPath(order, adjacency);
+  return {
+    exact: true,
+    acyclic,
+    order,
+    layers,
+    frontier: layers[0] ?? [],
+    depth: longest.depth,
+    criticalPath: longest.path,
+    criticalPathLength: Math.max(0, longest.path.length - 1),
+    cycles,
+    provenance: { algorithm: "kahn-longest-path", edgeFamily: "ordering" }
+  };
+}
+function analyzeGraphImpact(graph, root, options = {}) {
+  const direction = options.direction ?? "outgoing";
+  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const queue = [{ id: root, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set([root]);
+  const parents = /* @__PURE__ */ new Map();
+  const affected = [];
+  let visitedNodes = 0;
+  let inspectedEdges = 0;
+  let truncated = false;
+  traversal: for (let index = 0; index < queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const current = queue[index];
+    visitedNodes += 1;
+    const adjacent = graph.adjacency(current.id, {
+      direction,
+      kinds: options.kinds,
+      signal: options.signal
+    });
+    inspectedEdges += adjacent.meta.inspectedEdges;
+    if (current.depth >= maxDepth) {
+      if (adjacent.value.some((id) => !seen.has(id)))
+        truncated = true;
+      continue;
+    }
+    for (const id of adjacent.value) {
+      if (seen.has(id))
+        continue;
+      if (affected.length >= limit) {
+        truncated = true;
+        break traversal;
+      }
+      seen.add(id);
+      parents.set(id, current.id);
+      const depth = current.depth + 1;
+      affected.push({
+        id,
+        distance: depth,
+        path: reconstructImpactPath(root, id, parents)
+      });
+      queue.push({ id, depth });
+    }
+  }
+  return {
+    root,
+    affected,
+    exact: true,
+    truncated,
+    cost: { visitedNodes, inspectedEdges }
+  };
+}
+function analyzeKnowledgeGraph(graph) {
+  const nodes = [...graph.nodes()];
+  const weak = createAdjacency(nodes);
+  const directed = createAdjacency(nodes);
+  for (const edge of graph.edges()) {
+    appendNeighbor(weak, edge.source, edge.target);
+    appendNeighbor(weak, edge.target, edge.source);
+    appendNeighbor(directed, edge.source, edge.target);
+  }
+  const components = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const start of nodes) {
+    if (visited.has(start))
+      continue;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of weak.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
+      }
+    }
+    components.push(component);
+  }
+  const degrees = nodes.map((id) => ({ id, degree: weak.get(id).size }));
+  const maximum = Math.max(0, ...degrees.map(({ degree }) => degree));
+  return {
+    components: sortComponents(components),
+    stronglyConnected: stronglyConnectedComponents(nodes, directed),
+    orphans: degrees.filter(({ degree }) => degree === 0).map(({ id }) => id),
+    hubs: degrees.filter(({ degree }) => degree > 0 && degree === maximum),
+    exact: true,
+    provenance: { algorithm: "component-degree", edgeFamily: "all" }
+  };
+}
+function compareRelationshipSnapshots(before, after) {
+  const earlier = new Map(before.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  const later = new Map(after.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  return {
+    fromVersion: before.version,
+    toVersion: after.version,
+    added: [...later].filter(([key]) => !earlier.has(key)).map(([, edge]) => edge),
+    removed: [...earlier].filter(([key]) => !later.has(key)).map(([, edge]) => edge),
+    unchangedCount: [...earlier.keys()].filter((key) => later.has(key)).length,
+    exact: true
+  };
+}
+
+export {
+  analyzeRelationshipExecution,
+  analyzeGraphImpact,
+  analyzeKnowledgeGraph,
+  compareRelationshipSnapshots
+};
+//# sourceMappingURL=chunk-KGPLSHJD.js.map
+
+//# debugId=5638f886-de83-5daf-8c42-386c898c57c0

package/dist/cli-bundle/chunks/chunk-KGPLSHJD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../sdk/relationship-analytics.ts"],"sourcesContent":["/**\n * @module sdk/relationship-analytics\n *\n * Provides exact, deterministic graph analytics with explicit semantics and\n * provenance suitable for planning, impact analysis, and context selection.\n */\nimport type { RelationshipSnapshot } from \"./relationship-history.js\";\nimport {\n  RelationshipGraph,\n  RelationshipKindRegistry,\n  createRelationshipKindRegistry,\n  type RelationshipEdge,\n  type RelationshipQueryOptions,\n} from \"./relationships.js\";\n\n/** Exact execution-graph analysis over registered ordering kinds. */\nexport interface RelationshipExecutionAnalysis {\n  /** Whether the result is exact rather than sampled or approximate. */\n  exact: true;\n  /** Whether the order-bearing graph is acyclic. */\n  acyclic: boolean;\n  /** Deterministic topological order for acyclic nodes. */\n  order: string[];\n  /** Parallelizable topological layers. */\n  layers: string[][];\n  /** Nodes with no prerequisites. */\n  frontier: string[];\n  /** Longest prerequisite distance for each acyclic node. */\n  depth: Record<string, number>;\n  /** Longest deterministic execution path. */\n  criticalPath: string[];\n  /** Edge count of the critical path. */\n  criticalPathLength: number;\n  /** Strongly connected order-bearing components that represent cycles. */\n  cycles: string[][];\n  /** Semantic provenance for the analysis. */\n  provenance: { algorithm: \"kahn-longest-path\"; edgeFamily: \"ordering\" };\n}\n\n/** One affected node with its exact shortest explanation path. */\nexport interface RelationshipImpactRow {\n  /** Affected node identifier. */\n  id: string;\n  /** Shortest relationship distance from the root. */\n  distance: number;\n  /** Exact path explaining why the node is affected. */\n  path: string[];\n}\n\n/** Bounded reverse- or forward-impact result. */\nexport interface RelationshipImpactAnalysis {\n  /** Impact origin. */\n  root: string;\n  /** Deterministic affected-node rows. */\n  affected: RelationshipImpactRow[];\n  /** Returned rows are exact even when the bounded result is incomplete. */\n  exact: true;\n  /** Whether configured traversal bounds omitted reachable work. */\n  truncated: boolean;\n  /** Query work retained for performance and explainability. */\n  cost: { visitedNodes: number; inspectedEdges: number };\n}\n\n/** Exact structural summary of the complete graph snapshot. */\nexport interface RelationshipKnowledgeAnalysis {\n  /** Weakly connected components, largest then lexicographic. */\n  components: string[][];\n  /** Strongly connected components over directed stored edges. */\n  stronglyConnected: string[][];\n  /** Nodes with no relationship edges. */\n  orphans: string[];\n  /** Maximum-degree nodes and their unique-neighbor degree. */\n  hubs: { id: string; degree: number }[];\n  /** Whether the result is exact. */\n  exact: true;\n  /** Semantic provenance for the analysis. */\n  provenance: { algorithm: \"component-degree\"; edgeFamily: \"all\" };\n}\n\n/** Edge-level delta between two immutable snapshots. */\nexport interface RelationshipSnapshotComparison {\n  /** Earlier snapshot version. */\n  fromVersion: number;\n  /** Later snapshot version. */\n  toVersion: number;\n  /** Edges introduced in the later snapshot. */\n  added: RelationshipEdge[];\n  /** Edges absent from the later snapshot. */\n  removed: RelationshipEdge[];\n  /** Number of byte-equivalent edges retained. */\n  unchangedCount: number;\n  /** Whether the comparison is exact. */\n  exact: true;\n}\n\n/** Registry override for custom domain semantics. */\nexport interface RelationshipAnalyticsOptions {\n  /** Registry used to interpret ordering direction and custom kinds. */\n  registry?: RelationshipKindRegistry;\n}\n\nfunction appendNeighbor(\n  adjacency: Map<string, Set<string>>,\n  source: string,\n  target: string,\n): void {\n  adjacency.get(source)!.add(target);\n}\n\nfunction createAdjacency(nodes: readonly string[]): Map<string, Set<string>> {\n  return new Map(nodes.map((node) => [node, new Set<string>()]));\n}\n\nfunction sortComponents(components: string[][]): string[][] {\n  for (const component of components) component.sort();\n  return components.sort(\n    (left, right) =>\n      right.length - left.length || left[0]!.localeCompare(right[0]!),\n  );\n}\n\nfunction stableJsonValue(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map((entry) => stableJsonValue(entry));\n  if (value === null || typeof value !== \"object\") return value;\n  const toJSON = (value as { toJSON?: (this: object) => unknown }).toJSON;\n  if (typeof toJSON === \"function\") return stableJsonValue(toJSON.call(value));\n  return Object.fromEntries(\n    Object.entries(value)\n      .sort(([left], [right]) => left.localeCompare(right))\n      .map(([key, entry]) => [key, stableJsonValue(entry)]),\n  );\n}\n\nfunction relationshipEdgeKey(edge: RelationshipEdge): string {\n  return JSON.stringify(stableJsonValue(edge));\n}\n\nfunction appendFinishingOrder(\n  start: string,\n  adjacency: ReadonlyMap<string, ReadonlySet<string>>,\n  visited: Set<string>,\n  order: string[],\n): void {\n  const stack = [{ id: start, expanded: false }];\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    if (current.expanded) {\n      order.push(current.id);\n      continue;\n    }\n    if (visited.has(current.id)) continue;\n    visited.add(current.id);\n    stack.push({ id: current.id, expanded: true });\n    const neighbors = [...adjacency.get(current.id)!].sort().reverse();\n    for (const neighbor of neighbors)\n      if (!visited.has(neighbor)) stack.push({ id: neighbor, expanded: false });\n  }\n}\n\nfunction computeFinishingOrder(\n  nodes: readonly string[],\n  adjacency: ReadonlyMap<string, ReadonlySet<string>>,\n): string[] {\n  const visited = new Set<string>();\n  const order: string[] = [];\n  for (const start of nodes)\n    if (!visited.has(start))\n      appendFinishingOrder(start, adjacency, visited, order);\n  return order;\n}\n\nfunction collectReverseComponents(\n  order: readonly string[],\n  reverse: ReadonlyMap<string, ReadonlySet<string>>,\n): string[][] {\n  const visited = new Set<string>();\n  const components: string[][] = [];\n  for (const start of [...order].reverse()) {\n    if (visited.has(start)) continue;\n    const component: string[] = [];\n    const stack = [start];\n    visited.add(start);\n    while (stack.length > 0) {\n      const current = stack.pop()!;\n      component.push(current);\n      for (const neighbor of reverse.get(current)!) {\n        if (visited.has(neighbor)) continue;\n        visited.add(neighbor);\n        stack.push(neighbor);\n      }\n    }\n    components.push(component);\n  }\n  return sortComponents(components);\n}\n\nfunction stronglyConnectedComponents(\n  nodes: readonly string[],\n  adjacency: ReadonlyMap<string, ReadonlySet<string>>,\n): string[][] {\n  const reverse = createAdjacency(nodes);\n  for (const [source, targets] of adjacency)\n    for (const target of targets) appendNeighbor(reverse, target, source);\n  return collectReverseComponents(\n    computeFinishingOrder(nodes, adjacency),\n    reverse,\n  );\n}\n\nfunction buildExecutionAdjacency(\n  graph: RelationshipGraph,\n  registry: RelationshipKindRegistry,\n): Map<string, Set<string>> {\n  const adjacency = createAdjacency(graph.nodes());\n  for (const edge of graph.edges()) {\n    const definition = registry.require(edge.kind);\n    if (!definition.ordering) continue;\n    // Legacy and JSON-parsed definitions may predate explicit precedence.\n    const sourceFirst =\n      (definition.precedence ?? \"source_before_target\") ===\n      \"source_before_target\";\n    appendNeighbor(\n      adjacency,\n      sourceFirst ? edge.source : edge.target,\n      sourceFirst ? edge.target : edge.source,\n    );\n  }\n  return adjacency;\n}\n\nfunction topologicalLayers(\n  nodes: readonly string[],\n  adjacency: ReadonlyMap<string, ReadonlySet<string>>,\n): string[][] {\n  const indegree = new Map(nodes.map((node) => [node, 0]));\n  for (const targets of adjacency.values())\n    for (const target of targets)\n      indegree.set(target, indegree.get(target)! + 1);\n  let frontier = nodes.filter((node) => indegree.get(node) === 0).sort();\n  const layers: string[][] = [];\n  while (frontier.length > 0) {\n    layers.push(frontier);\n    const next: string[] = [];\n    for (const source of frontier) {\n      for (const target of adjacency.get(source)!) {\n        const remaining = indegree.get(target)! - 1;\n        indegree.set(target, remaining);\n        if (remaining === 0) next.push(target);\n      }\n    }\n    frontier = next.sort();\n  }\n  return layers;\n}\n\nfunction longestPath(\n  order: readonly string[],\n  adjacency: ReadonlyMap<string, ReadonlySet<string>>,\n): { depth: Record<string, number>; path: string[] } {\n  const depth = new Map(order.map((node) => [node, 0]));\n  const parent = new Map<string, string>();\n  for (const source of order) {\n    for (const target of adjacency.get(source)!) {\n      if (!depth.has(target)) continue;\n      const candidate = depth.get(source)! + 1;\n      const currentParent = parent.get(target);\n      if (\n        candidate > depth.get(target)! ||\n        (candidate === depth.get(target)! &&\n          (currentParent === undefined ||\n            source.localeCompare(currentParent) < 0))\n      ) {\n        depth.set(target, candidate);\n        parent.set(target, source);\n      }\n    }\n  }\n  const end = [...order].sort(\n    (left, right) =>\n      depth.get(right)! - depth.get(left)! || left.localeCompare(right),\n  )[0];\n  const path = end === undefined ? [] : [end];\n  while (path[0] !== undefined && parent.has(path[0]!))\n    path.unshift(parent.get(path[0]!)!);\n  return { depth: Object.fromEntries(depth), path };\n}\n\nfunction reconstructImpactPath(\n  root: string,\n  target: string,\n  parents: ReadonlyMap<string, string>,\n): string[] {\n  const path = [target];\n  let cursor = target;\n  while (cursor !== root) {\n    cursor = parents.get(cursor)!;\n    path.push(cursor);\n  }\n  return path.reverse();\n}\n\n/** Analyze registered order-bearing relationships without treating associative cycles as blockers. */\nexport function analyzeRelationshipExecution(\n  graph: RelationshipGraph,\n  options: RelationshipAnalyticsOptions = {},\n): RelationshipExecutionAnalysis {\n  const registry = options.registry ?? createRelationshipKindRegistry();\n  const nodes = [...graph.nodes()];\n  const adjacency = buildExecutionAdjacency(graph, registry);\n  const layers = topologicalLayers(nodes, adjacency);\n  const order = layers.flat();\n  const acyclic = order.length === nodes.length;\n  const cycles = acyclic\n    ? []\n    : stronglyConnectedComponents(nodes, adjacency).filter(\n        (component) =>\n          component.length > 1 ||\n          adjacency.get(component[0]!)!.has(component[0]!),\n      );\n  const longest = longestPath(order, adjacency);\n  return {\n    exact: true,\n    acyclic,\n    order,\n    layers,\n    frontier: layers[0] ?? [],\n    depth: longest.depth,\n    criticalPath: longest.path,\n    criticalPathLength: Math.max(0, longest.path.length - 1),\n    cycles,\n    provenance: { algorithm: \"kahn-longest-path\", edgeFamily: \"ordering\" },\n  };\n}\n\n/** Compute bounded impact rows and exact shortest explanation paths. */\nexport function analyzeGraphImpact(\n  graph: RelationshipGraph,\n  root: string,\n  options: RelationshipQueryOptions = {},\n): RelationshipImpactAnalysis {\n  const direction = options.direction ?? \"outgoing\";\n  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;\n  const limit = options.limit ?? Number.POSITIVE_INFINITY;\n  const queue = [{ id: root, depth: 0 }];\n  const seen = new Set([root]);\n  const parents = new Map<string, string>();\n  const affected: RelationshipImpactRow[] = [];\n  let visitedNodes = 0;\n  let inspectedEdges = 0;\n  let truncated = false;\n  traversal: for (let index = 0; index < queue.length; index += 1) {\n    options.signal?.throwIfAborted();\n    const current = queue[index]!;\n    visitedNodes += 1;\n    const adjacent = graph.adjacency(current.id, {\n      direction,\n      kinds: options.kinds,\n      signal: options.signal,\n    });\n    inspectedEdges += adjacent.meta.inspectedEdges;\n    if (current.depth >= maxDepth) {\n      if (adjacent.value.some((id) => !seen.has(id))) truncated = true;\n      continue;\n    }\n    for (const id of adjacent.value) {\n      if (seen.has(id)) continue;\n      if (affected.length >= limit) {\n        truncated = true;\n        break traversal;\n      }\n      seen.add(id);\n      parents.set(id, current.id);\n      const depth = current.depth + 1;\n      affected.push({\n        id,\n        distance: depth,\n        path: reconstructImpactPath(root, id, parents),\n      });\n      queue.push({ id, depth });\n    }\n  }\n  return {\n    root,\n    affected,\n    exact: true,\n    truncated,\n    cost: { visitedNodes, inspectedEdges },\n  };\n}\n\n/** Analyze weak/strong components, isolates, and exact unique-neighbor hubs. */\nexport function analyzeKnowledgeGraph(\n  graph: RelationshipGraph,\n): RelationshipKnowledgeAnalysis {\n  const nodes = [...graph.nodes()];\n  const weak = createAdjacency(nodes);\n  const directed = createAdjacency(nodes);\n  for (const edge of graph.edges()) {\n    appendNeighbor(weak, edge.source, edge.target);\n    appendNeighbor(weak, edge.target, edge.source);\n    appendNeighbor(directed, edge.source, edge.target);\n  }\n  const components: string[][] = [];\n  const visited = new Set<string>();\n  for (const start of nodes) {\n    if (visited.has(start)) continue;\n    const component: string[] = [];\n    const stack = [start];\n    visited.add(start);\n    while (stack.length > 0) {\n      const current = stack.pop()!;\n      component.push(current);\n      for (const neighbor of weak.get(current)!) {\n        if (visited.has(neighbor)) continue;\n        visited.add(neighbor);\n        stack.push(neighbor);\n      }\n    }\n    components.push(component);\n  }\n  const degrees = nodes.map((id) => ({ id, degree: weak.get(id)!.size }));\n  const maximum = Math.max(0, ...degrees.map(({ degree }) => degree));\n  return {\n    components: sortComponents(components),\n    stronglyConnected: stronglyConnectedComponents(nodes, directed),\n    orphans: degrees.filter(({ degree }) => degree === 0).map(({ id }) => id),\n    hubs: degrees.filter(({ degree }) => degree > 0 && degree === maximum),\n    exact: true,\n    provenance: { algorithm: \"component-degree\", edgeFamily: \"all\" },\n  };\n}\n\n/** Compare two immutable relationship snapshots by full normalized edge value. */\nexport function compareRelationshipSnapshots(\n  before: RelationshipSnapshot,\n  after: RelationshipSnapshot,\n): RelationshipSnapshotComparison {\n  const earlier = new Map(\n    before.edges.map((edge) => [relationshipEdgeKey(edge), edge]),\n  );\n  const later = new Map(\n    after.edges.map((edge) => [relationshipEdgeKey(edge), edge]),\n  );\n  return {\n    fromVersion: before.version,\n    toVersion: after.version,\n    added: [...later]\n      .filter(([key]) => !earlier.has(key))\n      .map(([, edge]) => edge),\n    removed: [...earlier]\n      .filter(([key]) => !later.has(key))\n      .map(([, edge]) => edge),\n    unchangedCount: [...earlier.keys()].filter((key) => later.has(key)).length,\n    exact: true,\n  };\n}\n"],"names":[],"mappings":"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","debugId":"5638f886-de83-5daf-8c42-386c898c57c0"}

package/dist/cli-bundle/chunks/{chunk-YQEZWI3R.js → chunk-KZ5AC6B5.js}

@@ -1,13 +1,13 @@
 import {
   collectUsedExtensionCapabilities,
   normalizeExtensionName
-} from "./chunk-WACRQ26A.js";
+} from "./chunk-WCBB6VI3.js";
 
 // dist/core/extensions/activation-summary.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] = "5fe77bdc-8d36-559b-9e5f-51a3cd63cd9e");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "47bc7f94-775b-5e2c-85cf-ec263029ca56");
   } catch (e2) {
   }
 })();
@@ -30,6 +30,7 @@ function describeExtensionActivation(activation, options = {}) {
   const collect = (entries, identify) => sortUnique(entries.filter((entry) => matches(entry.name)).map(identify));
   const collectFlat = (entries, expand) => sortUnique(entries.filter((entry) => matches(entry.name)).flatMap(expand));
   const { registrations, commands, parsers, preflight, services, renderers, hooks } = activation;
+  const relationshipKinds = collectFlat(registrations.relationship_kinds ?? [], (entry) => entry.definitions.map((definition) => definition.kind));
   return {
     capabilities: collectUsedExtensionCapabilities(activation, options),
     commands: collect(registrations.commands, (entry) => entry.command),
@@ -39,6 +40,7 @@ function describeExtensionActivation(activation, options = {}) {
     flag_commands: collect(registrations.flags, (entry) => entry.target_command),
     item_types: collectFlat(registrations.item_types, (entry) => entry.types.map((type) => type.name)),
     item_fields: collectFlat(registrations.item_fields, (entry) => entry.fields.map((field) => field.name)),
+    ...relationshipKinds.length > 0 ? { relationship_kinds: relationshipKinds } : {},
     migrations: collectFlat(registrations.migrations, (entry) => typeof entry.definition.id === "string" ? [entry.definition.id] : []),
     profiles: collect(registrations.profiles, (entry) => entry.profile.name),
     importers: collect(registrations.importers, (entry) => entry.importer),
@@ -157,4 +159,4 @@ export {
   describeExtensionActivation,
   renderExtensionSurfaceMarkdown
 };
-//# sourceMappingURL=chunk-YQEZWI3R.js.map
+//# sourceMappingURL=chunk-KZ5AC6B5.js.map

package/dist/cli-bundle/chunks/chunk-KZ5AC6B5.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../core/extensions/activation-summary.ts", "../../../../../../../../core/extensions/activation-summary-markdown.ts"],
+  "sourcesContent": ["/**\n * @module core/extensions/activation-summary\n *\n * Enumerates *what* an extension activation registered, by name, in one pass.\n *\n * {@link ./extension-types.js#ExtensionActivationResult | `ExtensionActivationResult`}\n * already carries per-surface *counts* (`hook_counts`, `registration_counts`,\n * the various `*_count` fields), but answering \"what does this extension\n * register?\" otherwise means walking fifteen-plus sub-registries by hand\n * (`registrations.commands`/`flags`/`item_types`/`item_fields`/`migrations`/\n * `importers`/`exporters`/`search_providers`/`vector_store_adapters`,\n * `commands.overrides`/`handlers`, the `parsers`/`preflight`/`services`/\n * `renderers` override registries, and the five `hooks.*` arrays).\n *\n * {@link describeExtensionActivation} flattens all of them into one sorted,\n * deterministic {@link ExtensionActivationSummary} of identifiers — the\n * `describe` (enumerate-all) verb that complements the SDK's `assert*`\n * (verify-one) and `run*` (invoke-one) testing helpers. It serves two callers:\n *\n * - **Agents** get a single token-efficient view of an activation instead of\n *   traversing every registry (\"project management = context management\").\n * - **Package authors** can assert their *entire* registration surface in one\n *   `deepEqual` — a least-privilege \"I register exactly these surfaces and\n *   nothing more\" check, the positive counterpart to\n *   {@link ./capability-usage.js#reconcileExtensionCapabilityUsage}.\n */\nimport type {\n  ExtensionActivationResult,\n  ExtensionCapability,\n  ExtensionHookRegistry,\n  ExtensionServiceName,\n  OutputRendererFormat,\n} from \"./extension-types.js\";\nimport {\n  collectUsedExtensionCapabilities,\n  normalizeExtensionName,\n} from \"./capability-usage.js\";\n\n/**\n * Canonical lifecycle hook kinds paired with their {@link ExtensionHookRegistry}\n * field, ordered to match `ExtensionActivationResult.hook_counts` so a summary's\n * `hooks` list reads in the same stable order the runtime reports counts in.\n */\nconst HOOK_REGISTRY_FIELD_TO_KIND = [\n  [\"beforeCommand\", \"before_command\"],\n  [\"afterCommand\", \"after_command\"],\n  [\"onWrite\", \"on_write\"],\n  [\"onRead\", \"on_read\"],\n  [\"onIndex\", \"on_index\"],\n] as const satisfies ReadonlyArray<\n  readonly [keyof ExtensionHookRegistry, string]\n>;\n\n/**\n * Flat, name-level enumeration of every surface an activation registered.\n *\n * Arrays are de-duplicated for deterministic equality. Most are locale-sorted;\n * {@link ExtensionActivationSummary.hooks} is the exception — it is emitted in\n * canonical lifecycle order to mirror `ExtensionActivationResult.hook_counts`,\n * not alphabetically. The three command fields capture distinct dimensions and\n * can overlap: a command\n * registered via `api.registerCommand(definition)` appears in both\n * {@link ExtensionActivationSummary.commands} (its declared definition) and\n * {@link ExtensionActivationSummary.command_handlers} (its executable handler),\n * whereas a built-in command replaced via `api.registerCommand(name, override)`\n * appears only in {@link ExtensionActivationSummary.command_overrides}.\n */\nexport interface ExtensionActivationSummary {\n  /** Known capabilities the registered surfaces exercise (sorted, de-duplicated). */\n  capabilities: ExtensionCapability[];\n  /** Full command paths declared via `registerCommand`'s definition form. */\n  commands: string[];\n  /** Built-in command paths replaced by an `registerCommand(name, override)` handler. */\n  command_overrides: string[];\n  /**\n   * Full command paths backed by an extension-provided handler. A superset of\n   * {@link ExtensionActivationSummary.commands} that also includes the\n   * `<name> import`/`<name> export` paths synthesized for importers/exporters.\n   */\n  command_handlers: string[];\n  /** Lifecycle hook kinds with at least one registered hook (canonical order). */\n  hooks: string[];\n  /** Command paths that received extension-registered flags. */\n  flag_commands: string[];\n  /** Custom item-type names registered via `registerItemTypes`. */\n  item_types: string[];\n  /** Custom item-metadata field names registered via `registerItemFields`. */\n  item_fields: string[];\n  /** Custom relationship-kind names registered via `registerRelationshipKinds`. */\n  relationship_kinds?: string[];\n  /** Schema migration ids registered via `registerMigration` (id-less migrations are omitted — they carry no identifier). */\n  migrations: string[];\n  /** Project profile names registered via `registerProfile`. */\n  profiles: string[];\n  /** Importer names registered via `registerImporter`. */\n  importers: string[];\n  /** Exporter names registered via `registerExporter`. */\n  exporters: string[];\n  /** Search-provider names registered via `registerSearchProvider`. */\n  search_providers: string[];\n  /** Vector-store adapter names registered via `registerVectorStoreAdapter`. */\n  vector_store_adapters: string[];\n  /** Command paths with a parser override registered via `registerParser`. */\n  parser_overrides: string[];\n  /** Built-in service names overridden via `registerService`. */\n  service_overrides: ExtensionServiceName[];\n  /** Output formats with a renderer override registered via `registerRenderer`. */\n  renderer_overrides: OutputRendererFormat[];\n  /** Count of registered preflight overrides. The surface carries no per-entry identifier, so this is a `number` rather than `string[]` — the only numeric field in the summary. */\n  preflight_overrides: number;\n}\n\n/**\n * Options for {@link describeExtensionActivation}.\n */\nexport interface DescribeExtensionActivationOptions {\n  /**\n   * Restrict the summary to a single extension by name. Names are matched\n   * case-insensitively after trimming, mirroring\n   * {@link ./capability-usage.js#collectUsedExtensionCapabilities}. Omit to\n   * union across every extension in the activation result.\n   */\n  extensionName?: string;\n  /** Restrict the summary to a set of extension names. This supports package aliases that resolve to multiple extensions while keeping the historical single-name option intact. */\n  extensionNames?: readonly string[];\n}\n\n/**\n * Summarize, by name, every registration surface an activation exercised.\n *\n * Walks the same sub-registries the loader populates and the capability\n * reconciler attributes, returning a flat {@link ExtensionActivationSummary}\n * whose arrays are sorted and de-duplicated. With\n * {@link DescribeExtensionActivationOptions.extensionName} only the matching\n * extension's registrations contribute (across both layers); without it the\n * summary unions every extension in the activation. Failed activations register\n * nothing, so they contribute only an empty summary.\n */\nexport function describeExtensionActivation(\n  activation: ExtensionActivationResult,\n  options: DescribeExtensionActivationOptions = {},\n): ExtensionActivationSummary {\n  // Match both sides with the same normalizer collectUsedExtensionCapabilities\n  // uses for the `capabilities` field below, so a filtered summary's named\n  // surfaces and capabilities never disagree for a stored name with whitespace.\n  const filters = new Set<string>();\n  if (options.extensionName !== undefined) {\n    filters.add(normalizeExtensionName(options.extensionName));\n  }\n  for (const name of options.extensionNames ?? []) {\n    filters.add(normalizeExtensionName(name));\n  }\n  const matches = (name: string): boolean =>\n    filters.size === 0 || filters.has(normalizeExtensionName(name));\n  const collect = <TEntry extends { name: string }, TValue extends string>(\n    entries: readonly TEntry[],\n    identify: (entry: TEntry) => TValue,\n  ): TValue[] =>\n    sortUnique(entries.filter((entry) => matches(entry.name)).map(identify));\n  const collectFlat = <TEntry extends { name: string }>(\n    entries: readonly TEntry[],\n    expand: (entry: TEntry) => readonly string[],\n  ): string[] =>\n    sortUnique(entries.filter((entry) => matches(entry.name)).flatMap(expand));\n  const {\n    registrations,\n    commands,\n    parsers,\n    preflight,\n    services,\n    renderers,\n    hooks,\n  } = activation;\n  // Preserve compatibility with activation payloads produced before this registry existed.\n  const relationshipKinds = collectFlat(\n    registrations.relationship_kinds ?? [],\n    (entry) => entry.definitions.map((definition) => definition.kind),\n  );\n  return {\n    capabilities: collectUsedExtensionCapabilities(activation, options),\n    commands: collect(registrations.commands, (entry) => entry.command),\n    command_overrides: collect(commands.overrides, (entry) => entry.command),\n    command_handlers: collect(commands.handlers, (entry) => entry.command),\n    hooks: HOOK_REGISTRY_FIELD_TO_KIND.filter(([field]) =>\n      hooks[field].some((entry) => matches(entry.name)),\n    ).map(([, kind]) => kind),\n    flag_commands: collect(\n      registrations.flags,\n      (entry) => entry.target_command,\n    ),\n    item_types: collectFlat(registrations.item_types, (entry) =>\n      entry.types.map((type) => type.name),\n    ),\n    item_fields: collectFlat(registrations.item_fields, (entry) =>\n      entry.fields.map((field) => field.name),\n    ),\n    ...(relationshipKinds.length > 0\n      ? { relationship_kinds: relationshipKinds }\n      : {}),\n    migrations: collectFlat(registrations.migrations, (entry) =>\n      typeof entry.definition.id === \"string\" ? [entry.definition.id] : [],\n    ),\n    profiles: collect(registrations.profiles, (entry) => entry.profile.name),\n    importers: collect(registrations.importers, (entry) => entry.importer),\n    exporters: collect(registrations.exporters, (entry) => entry.exporter),\n    search_providers: collect(\n      registrations.search_providers,\n      (entry) => entry.definition.name,\n    ),\n    vector_store_adapters: collect(\n      registrations.vector_store_adapters,\n      (entry) => entry.definition.name,\n    ),\n    parser_overrides: collect(parsers.overrides, (entry) => entry.command),\n    service_overrides: collect(services.overrides, (entry) => entry.service),\n    renderer_overrides: collect(renderers.overrides, (entry) => entry.format),\n    preflight_overrides: preflight.overrides.filter((entry) =>\n      matches(entry.name),\n    ).length,\n  };\n}\n\nfunction sortUnique<TValue extends string>(\n  values: readonly TValue[],\n): TValue[] {\n  return [...new Set(values)].sort((left, right) => left.localeCompare(right));\n}\n", "/**\n * @module core/extensions/activation-summary-markdown\n *\n * Renders an {@link ExtensionActivationSummary} to a deterministic Markdown\n * reference document — the *render* leg that completes the `describe`\n * (enumerate-all) verb.\n *\n * {@link ./activation-summary.js#describeExtensionActivation | `describeExtensionActivation`}\n * (and its author-time twin\n * {@link ../../sdk/compose.js#describeExtensionBlueprint | `describeExtensionBlueprint`})\n * already answer \"what does this package register?\" as a structured summary, and\n * the `assert*`/`run*` testing helpers verify and invoke each surface. What was\n * missing is a way to turn that summary into human-readable docs: package\n * authors hand-wrote the README \"commands & capabilities\" reference, which\n * silently drifted from the surface the loader actually registers.\n *\n * {@link renderExtensionSurfaceMarkdown} closes that gap. It is a pure,\n * dependency-free projection of the summary, so an author can pipe\n * `describeExtensionBlueprint(blueprint)` straight into it during their build or\n * test step and embed the result in their README — a reference that can never\n * drift from the registered surface (\"project management = context management\").\n * The CLI's `pm extension|package describe --markdown` composes the same\n * primitive across every loaded extension.\n */\nimport type { ExtensionActivationSummary } from \"./activation-summary.js\";\n\n/**\n * The lowest and highest ATX heading levels Markdown supports, used to validate\n * {@link ExtensionSurfaceMarkdownOptions.headingLevel} and to clamp nested\n * section headings so a deep title never emits an invalid `#######` run.\n */\nconst MIN_HEADING_LEVEL = 1;\nconst MAX_HEADING_LEVEL = 6;\n\n/**\n * Options for {@link renderExtensionSurfaceMarkdown}.\n */\nexport interface ExtensionSurfaceMarkdownOptions {\n  /**\n   * Heading text for the document title. Defaults to `\"Extension surfaces\"`.\n   * The title always renders as an ATX heading at\n   * {@link ExtensionSurfaceMarkdownOptions.headingLevel}; per-surface sections\n   * render one level deeper.\n   */\n  title?: string;\n  /**\n   * ATX heading level for the title, an integer in `[1, 6]` (default `2`, i.e.\n   * `##`, so the document embeds cleanly under a `# Package` README heading).\n   * Section headings render at `headingLevel + 1`, clamped to `6`. Values\n   * outside `[1, 6]` throw a {@link RangeError}.\n   */\n  headingLevel?: number;\n  /** When `true`, render every surface section even when it has no entries (emitting `_None._` under the heading) and always emit the capabilities line. Defaults to `false`, which omits empty sections so the reference lists only what the package actually contributes. */\n  includeEmpty?: boolean;\n}\n\n/**\n * A surface section paired with the {@link ExtensionActivationSummary} field\n * whose identifiers populate it. Ordered for an author-facing reference:\n * commands first, then schema, then importers/exporters, retrieval, lifecycle\n * hooks, and finally the override surfaces. {@link ExtensionActivationSummary.command_handlers}\n * is intentionally omitted — it is a documented superset of `commands` plus the\n * synthesized `<name> import`/`<name> export` paths already covered by the\n * Importers and Exporters sections, so rendering it would duplicate information.\n */\nconst SURFACE_SECTIONS = [\n  [\"commands\", \"Commands\"],\n  [\"command_overrides\", \"Command overrides\"],\n  [\"flag_commands\", \"Flag commands\"],\n  [\"item_types\", \"Item types\"],\n  [\"item_fields\", \"Item fields\"],\n  [\"migrations\", \"Migrations\"],\n  [\"profiles\", \"Profiles\"],\n  [\"importers\", \"Importers\"],\n  [\"exporters\", \"Exporters\"],\n  [\"search_providers\", \"Search providers\"],\n  [\"vector_store_adapters\", \"Vector store adapters\"],\n  [\"hooks\", \"Lifecycle hooks\"],\n  [\"parser_overrides\", \"Parser overrides\"],\n  [\"service_overrides\", \"Service overrides\"],\n  [\"renderer_overrides\", \"Renderer overrides\"],\n] as const satisfies ReadonlyArray<\n  readonly [\n    {\n      [K in keyof ExtensionActivationSummary]: ExtensionActivationSummary[K] extends readonly string[]\n        ? K\n        : never;\n    }[keyof ExtensionActivationSummary],\n    string,\n  ]\n>;\n\n/** Repeat `#` `level` times to form an ATX heading prefix. */\nfunction headingPrefix(level: number): string {\n  return \"#\".repeat(level);\n}\n\n/** Render `value` as an inline Markdown code span. Backslash escapes do not work inside CommonMark code spans, so when `value` contains backticks the span is delimited by a run of backticks one longer than the longest internal run, and padded with a space when the value borders a backtick — the CommonMark rule for embedding literal backticks in a code span. */\nfunction code(value: string): string {\n  if (!value.includes(\"`\")) {\n    return `\\`${value}\\``;\n  }\n  let longestRun = 0;\n  let currentRun = 0;\n  for (const char of value) {\n    currentRun = char === \"`\" ? currentRun + 1 : 0;\n    longestRun = Math.max(longestRun, currentRun);\n  }\n  const fence = \"`\".repeat(longestRun + 1);\n  const pad = value.startsWith(\"`\") || value.endsWith(\"`\") ? \" \" : \"\";\n  return `${fence}${pad}${value}${pad}${fence}`;\n}\n\n/** Render the comma-separated capabilities summary line (or `_none registered_` when the activation exercised no known capability). */\nfunction renderCapabilitiesLine(capabilities: readonly string[]): string {\n  if (capabilities.length === 0) {\n    return \"Capabilities: _none registered_\";\n  }\n  return `Capabilities: ${capabilities.map(code).join(\", \")}`;\n}\n\n/**\n * Render one surface section as `heading` + a bullet per identifier, or, when\n * `entries` is empty, `heading` + `_None._`. Callers decide whether an empty\n * section is rendered at all via {@link ExtensionSurfaceMarkdownOptions.includeEmpty}.\n */\nfunction renderSection(\n  heading: string,\n  level: number,\n  entries: readonly string[],\n): string[] {\n  const lines = [`${headingPrefix(level)} ${heading}`, \"\"];\n  if (entries.length === 0) {\n    lines.push(\"_None._\", \"\");\n    return lines;\n  }\n  lines.push(...entries.map((entry) => `- ${code(entry)}`), \"\");\n  return lines;\n}\n\n/**\n * Render the preflight-overrides section: a count line when any are registered,\n * `_None._` when {@link ExtensionSurfaceMarkdownOptions.includeEmpty} forces the\n * empty section, or no lines at all otherwise. Preflight overrides carry no\n * per-entry identifier, so they have a bespoke renderer rather than reusing\n * {@link renderSection}.\n */\nfunction renderPreflightSection(\n  count: number,\n  level: number,\n  includeEmpty: boolean,\n): string[] {\n  if (count === 0 && !includeEmpty) {\n    return [];\n  }\n  return [\n    `${headingPrefix(level)} Preflight overrides`,\n    \"\",\n    count > 0\n      ? `- ${count} registered (this surface carries no per-entry identifier)`\n      : \"_None._\",\n    \"\",\n  ];\n}\n\n/**\n * Render an {@link ExtensionActivationSummary} as a deterministic Markdown\n * reference document.\n *\n * The output is a title heading, a one-line capabilities summary, and a section\n * per registered surface (commands, overrides, flags, item types/fields,\n * migrations, importers/exporters, search providers, vector adapters, lifecycle\n * hooks, and the parser/service/renderer override surfaces), followed by a\n * preflight-override count line when any are registered. Section order and\n * within-section identifier order both come straight from the summary, so the\n * same summary always renders byte-for-byte the same document.\n *\n * By default empty sections are omitted so the reference lists only what the\n * package contributes; set {@link ExtensionSurfaceMarkdownOptions.includeEmpty}\n * to render every section. A summary with no surfaces at all renders the title,\n * the capabilities line, and a `_This extension registers no surfaces._` note.\n *\n * @throws {RangeError} when `options.headingLevel` is not an integer in `[1, 6]`.\n */\nexport function renderExtensionSurfaceMarkdown(\n  summary: ExtensionActivationSummary,\n  options: ExtensionSurfaceMarkdownOptions = {},\n): string {\n  const titleLevel = options.headingLevel ?? 2;\n  if (\n    !Number.isInteger(titleLevel) ||\n    titleLevel < MIN_HEADING_LEVEL ||\n    titleLevel > MAX_HEADING_LEVEL\n  ) {\n    throw new RangeError(\n      `headingLevel must be an integer in [${MIN_HEADING_LEVEL}, ${MAX_HEADING_LEVEL}], received ${String(options.headingLevel)}`,\n    );\n  }\n  const sectionLevel = Math.min(titleLevel + 1, MAX_HEADING_LEVEL);\n  const includeEmpty = options.includeEmpty === true;\n  const title = options.title ?? \"Extension surfaces\";\n\n  const lines = [`${headingPrefix(titleLevel)} ${title}`, \"\"];\n  if (includeEmpty || summary.capabilities.length > 0) {\n    lines.push(renderCapabilitiesLine(summary.capabilities), \"\");\n  }\n\n  for (const [field, heading] of SURFACE_SECTIONS) {\n    const entries = summary[field];\n    if (entries.length === 0 && !includeEmpty) {\n      continue;\n    }\n    lines.push(...renderSection(heading, sectionLevel, entries));\n  }\n\n  lines.push(\n    ...renderPreflightSection(\n      summary.preflight_overrides,\n      sectionLevel,\n      includeEmpty,\n    ),\n  );\n\n  const hasAnySurface =\n    summary.preflight_overrides > 0 ||\n    SURFACE_SECTIONS.some(([field]) => summary[field].length > 0);\n  if (!hasAnySurface && !includeEmpty) {\n    lines.push(\"_This extension registers no surfaces._\", \"\");\n  }\n\n  return `${lines.join(\"\\n\").trimEnd()}\\n`;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cli-bundle/chunks/{chunk-X2MGQMZO.js → chunk-LT5UWU7H.js}

@@ -3,7 +3,7 @@
 import {
   renameArtifactsResultKey,
   runLinkedArtifacts
-} from "./chunk-H5IOT54C.js";
+} from "./chunk-VSQE43NO.js";
 
 // dist/sdk/docs.js
 async function runDocs(id, options, global) {
@@ -19,6 +19,6 @@ async function runDocs(id, options, global) {
 export {
   runDocs
 };
-//# sourceMappingURL=chunk-X2MGQMZO.js.map
+//# sourceMappingURL=chunk-LT5UWU7H.js.map
 
 //# debugId=db3e4dc9-8bda-5f4e-bf43-3c1ce147c9a2

package/dist/cli-bundle/chunks/{chunk-KH6QAHME.js → chunk-M4B4RK4J.js}

@@ -24,7 +24,7 @@ import {
   sha256Hex,
   stableStringify,
   toItemRecord
-} from "./chunk-P22HGFFI.js";
+} from "./chunk-QFG4MB7P.js";
 import {
   EXIT_CODE,
   ITEM_METADATA_KEY_ORDER,
@@ -37,7 +37,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   writeFileAtomic
-} from "./chunk-KX62NMZC.js";
+} from "./chunk-D35WYXWC.js";
 
 // dist/core/history/replay.js
 import jsonPatch from "fast-json-patch";
@@ -1038,6 +1038,6 @@ export {
   runHistoryRedact,
   _testOnly
 };
-//# sourceMappingURL=chunk-KH6QAHME.js.map
+//# sourceMappingURL=chunk-M4B4RK4J.js.map
 
 //# debugId=19224557-a97b-5405-9dc9-894cdbf821fc