@unbrained/pm-cli 2026.7.18 → 2026.7.19

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

@@ -1,662 +0,0 @@
-// dist/sdk/relationships.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]="8145f80d-99b5-53e4-a519-54b4549dca6c")}catch(e){}}();
-var BUILTIN_RELATIONSHIP_KINDS = [
-  {
-    kind: "blocked_by",
-    direction: "directed",
-    inverse: "blocks",
-    ordering: true,
-    precedence: "target_before_source",
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "persistent",
-    aliases: ["depends_on"],
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "blocks",
-    direction: "directed",
-    inverse: "blocked_by",
-    ordering: true,
-    precedence: "source_before_target",
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "persistent",
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "parent",
-    direction: "directed",
-    inverse: "child",
-    ordering: false,
-    hierarchy: true,
-    hierarchyDirection: "target_parent",
-    outgoing: "one",
-    incoming: "many",
-    lifecycle: "supersedable",
-    aliases: ["child_of", "epic"],
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "child",
-    direction: "directed",
-    inverse: "parent",
-    ordering: false,
-    hierarchy: true,
-    hierarchyDirection: "source_parent",
-    outgoing: "many",
-    incoming: "one",
-    lifecycle: "supersedable",
-    aliases: ["parent_child", "task"],
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "related",
-    direction: "undirected",
-    ordering: false,
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "persistent",
-    aliases: ["related_to"],
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "discovered_from",
-    direction: "directed",
-    ordering: false,
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "persistent",
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "incident_from",
-    direction: "directed",
-    ordering: false,
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "persistent",
-    compatibilityVersion: 1,
-    allowSelf: false
-  },
-  {
-    kind: "supersedes",
-    direction: "directed",
-    ordering: false,
-    hierarchy: false,
-    outgoing: "many",
-    incoming: "many",
-    lifecycle: "supersedable",
-    compatibilityVersion: 1,
-    allowSelf: false
-  }
-];
-function normalizeKind(kind) {
-  return kind.trim().toLowerCase().replaceAll("-", "_");
-}
-function normalizeInverseKind(inverse) {
-  if (inverse === void 0)
-    return void 0;
-  const normalized = normalizeKind(inverse);
-  if (!/^[a-z][a-z0-9_]*$/.test(normalized))
-    throw new TypeError(`Invalid inverse relationship kind: ${inverse}`);
-  return normalized;
-}
-function freezeValue(value, visited = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value !== "object")
-    return value;
-  if (visited.has(value))
-    return value;
-  visited.add(value);
-  if (Array.isArray(value)) {
-    for (const entry of value)
-      freezeValue(entry, visited);
-    return Object.freeze(value);
-  }
-  for (const entry of Object.values(value))
-    freezeValue(entry, visited);
-  return Object.freeze(value);
-}
-function assertRelationshipPrecedence(definition, kind) {
-  if (definition.precedence !== void 0 && definition.precedence !== "source_before_target" && definition.precedence !== "target_before_source")
-    throw new TypeError(`Invalid relationship precedence for ${kind}`);
-  if (!definition.ordering && definition.precedence !== void 0)
-    throw new TypeError(`Non-ordering relationship kind cannot declare precedence: ${kind}`);
-}
-function assertRelationshipHierarchyDirection(definition, kind) {
-  if (definition.hierarchyDirection !== void 0 && definition.hierarchyDirection !== "source_parent" && definition.hierarchyDirection !== "target_parent")
-    throw new TypeError(`Invalid relationship hierarchy direction for ${kind}`);
-  if (!definition.hierarchy && definition.hierarchyDirection !== void 0)
-    throw new TypeError(`Non-hierarchy relationship kind cannot declare hierarchy direction: ${kind}`);
-}
-var RelationshipKindRegistry = class {
-  #definitions = /* @__PURE__ */ new Map();
-  #aliases = /* @__PURE__ */ new Map();
-  /** Create a registry initialized with the stable built-in ontology by default. */
-  constructor(definitions = BUILTIN_RELATIONSHIP_KINDS) {
-    for (const definition of definitions)
-      this.register(definition);
-  }
-  /** Register one definition after validating its identifier, version, and aliases. */
-  register(definition) {
-    const kind = normalizeKind(definition.kind);
-    if (!/^[a-z][a-z0-9_]*$/.test(kind))
-      throw new TypeError(`Invalid relationship kind: ${definition.kind}`);
-    if (!Number.isInteger(definition.compatibilityVersion) || definition.compatibilityVersion < 1)
-      throw new TypeError(`Invalid compatibility version for ${kind}`);
-    assertRelationshipPrecedence(definition, kind);
-    assertRelationshipHierarchyDirection(definition, kind);
-    if (this.#definitions.has(kind) || this.#aliases.has(kind))
-      throw new TypeError(`Relationship kind already registered: ${kind}`);
-    const inverse = normalizeInverseKind(definition.inverse);
-    const aliases = [
-      ...new Set((definition.aliases ?? []).map(normalizeKind))
-    ].sort();
-    for (const alias of aliases) {
-      if (!/^[a-z][a-z0-9_]*$/.test(alias))
-        throw new TypeError(`Invalid relationship alias: ${alias}`);
-      if (alias === kind || this.#definitions.has(alias) || this.#aliases.has(alias))
-        throw new TypeError(`Relationship alias already registered: ${alias}`);
-    }
-    const normalized = Object.freeze({
-      ...definition,
-      kind,
-      inverse,
-      aliases: Object.freeze(aliases),
-      payloadSchema: definition.payloadSchema ? freezeValue(structuredClone(definition.payloadSchema)) : void 0
-    });
-    this.#definitions.set(kind, normalized);
-    for (const alias of aliases)
-      this.#aliases.set(alias, kind);
-    return this;
-  }
-  /** Resolve a canonical kind or compatibility alias. */
-  resolve(kind) {
-    if (typeof kind !== "string")
-      return void 0;
-    const normalized = normalizeKind(kind);
-    return this.#definitions.get(this.#aliases.get(normalized) ?? normalized);
-  }
-  /** Resolve a kind or throw a precise error suitable for command adapters. */
-  require(kind) {
-    const definition = this.resolve(kind);
-    if (!definition)
-      throw new TypeError(`Unknown relationship kind: ${kind}`);
-    return definition;
-  }
-  /** Return a deterministic immutable registry snapshot. */
-  list() {
-    return Object.freeze([...this.#definitions.values()].sort((left, right) => left.kind.localeCompare(right.kind)));
-  }
-};
-function createRelationshipKindRegistry() {
-  return new RelationshipKindRegistry();
-}
-var defaultRegistry = createRelationshipKindRegistry();
-function isOrderingRelationshipKind(kind, registry = defaultRegistry) {
-  return registry.resolve(kind)?.ordering === true;
-}
-function compareEdges(left, right) {
-  return left.source.localeCompare(right.source) || left.target.localeCompare(right.target) || left.kind.localeCompare(right.kind);
-}
-function normalizeRelationshipEdge(candidate, nodes, registry) {
-  const source = typeof candidate.source === "string" ? candidate.source.trim() : "";
-  const target = typeof candidate.target === "string" ? candidate.target.trim() : "";
-  const definition = registry.require(candidate.kind);
-  if (!nodes.has(source) || !nodes.has(target))
-    throw new TypeError(`Relationship endpoint not found: ${source} -> ${target}`);
-  if (source === target && !definition.allowSelf)
-    throw new TypeError(`Self relationship is not allowed for ${definition.kind}`);
-  const edge = Object.freeze({
-    ...candidate,
-    source,
-    target,
-    kind: definition.kind
-  });
-  const endpoints = definition.direction === "undirected" ? [source, target].sort().join("\0") : `${source}\0${target}`;
-  return { edge, identity: `${definition.kind}\0${endpoints}` };
-}
-function appendIndexedEdge(index, node, edge) {
-  const indexed = index.get(node);
-  if (indexed)
-    indexed.push(edge);
-  else
-    index.set(node, [edge]);
-}
-function normalizeNodeId(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function resolveExistingNodeId(value, ids) {
-  const id = normalizeNodeId(value);
-  return id && ids.has(id) ? id : void 0;
-}
-function reconstructPath(source, target, parents) {
-  const path = [target];
-  let cursor = target;
-  while (cursor !== source) {
-    cursor = parents.get(cursor);
-    path.push(cursor);
-  }
-  return path.reverse();
-}
-var RelationshipGraph = class _RelationshipGraph {
-  #registry;
-  #nodes;
-  #nodeSnapshot;
-  #edges;
-  #outgoing = /* @__PURE__ */ new Map();
-  #incoming = /* @__PURE__ */ new Map();
-  /** Validate and index nodes and edges without reading tracker storage. */
-  constructor(nodes, edges, registry = defaultRegistry) {
-    this.#registry = registry;
-    this.#nodes = new Set([...nodes].filter((id) => typeof id === "string").map((id) => id.trim()).filter(Boolean));
-    this.#nodeSnapshot = Object.freeze([...this.#nodes].sort());
-    const deduped = /* @__PURE__ */ new Map();
-    for (const candidate of edges) {
-      const { edge, identity } = normalizeRelationshipEdge(candidate, this.#nodes, registry);
-      deduped.set(identity, edge);
-    }
-    this.#edges = Object.freeze([...deduped.values()].sort(compareEdges));
-    for (const edge of this.#edges) {
-      appendIndexedEdge(this.#outgoing, edge.source, edge);
-      appendIndexedEdge(this.#incoming, edge.target, edge);
-      if (registry.require(edge.kind).direction === "undirected") {
-        appendIndexedEdge(this.#outgoing, edge.target, edge);
-        appendIndexedEdge(this.#incoming, edge.source, edge);
-      }
-    }
-  }
-  /** Build the graph directly from item metadata, including hierarchy and legacy blocker fields. */
-  static fromItems(items, registry = defaultRegistry) {
-    const ids = new Set(items.map((item) => normalizeNodeId(item.id)).filter(Boolean));
-    const edges = [];
-    for (const item of items) {
-      const source = normalizeNodeId(item.id);
-      if (!source)
-        continue;
-      const parent = resolveExistingNodeId(item.parent, ids);
-      if (parent)
-        edges.push({ source, target: parent, kind: "parent" });
-      const blockedBy = resolveExistingNodeId(item.blocked_by, ids);
-      if (blockedBy)
-        edges.push({
-          source,
-          target: blockedBy,
-          kind: "blocked_by"
-        });
-      for (const dependency of item.dependencies ?? []) {
-        const dependencyId = resolveExistingNodeId(dependency.id, ids);
-        if (dependencyId && registry.resolve(dependency.kind))
-          edges.push({
-            source,
-            target: dependencyId,
-            kind: dependency.kind,
-            createdAt: dependency.created_at,
-            author: dependency.author
-          });
-      }
-    }
-    return new _RelationshipGraph(ids, edges, registry);
-  }
-  /** Return the deterministic immutable edge snapshot. */
-  edges() {
-    return this.#edges;
-  }
-  /** Return the deterministic immutable edges incident to one node. */
-  incidentEdges(id) {
-    this.#assertNode(id);
-    const outgoing = this.#outgoing.get(id) ?? [];
-    const incoming = this.#incoming.get(id) ?? [];
-    if (outgoing.length === 0)
-      return Object.freeze([...incoming]);
-    if (incoming.length === 0)
-      return Object.freeze([...outgoing]);
-    const edges = [];
-    let outgoingIndex = 0;
-    let incomingIndex = 0;
-    while (outgoingIndex < outgoing.length || incomingIndex < incoming.length) {
-      const outgoingEdge = outgoing[outgoingIndex];
-      const incomingEdge = incoming[incomingIndex];
-      const edge = outgoingEdge === void 0 ? incomingEdge : incomingEdge === void 0 || compareEdges(outgoingEdge, incomingEdge) <= 0 ? outgoingEdge : incomingEdge;
-      if (edges.at(-1) !== edge)
-        edges.push(edge);
-      if (outgoingEdge === edge)
-        outgoingIndex += 1;
-      if (incomingEdge === edge)
-        incomingIndex += 1;
-    }
-    return Object.freeze(edges);
-  }
-  /** Return the deterministic immutable node snapshot. */
-  nodes() {
-    return this.#nodeSnapshot;
-  }
-  /** Report whether an identifier names an indexed node. */
-  hasNode(id) {
-    return this.#nodes.has(id);
-  }
-  /** Return the registry that interprets this graph's relationship kinds. */
-  registry() {
-    return this.#registry;
-  }
-  #assertNode(id) {
-    if (!this.#nodes.has(id))
-      throw new TypeError(`Relationship node not found: ${id}`);
-  }
-  #matchesKinds(edge, kinds) {
-    if (!kinds)
-      return true;
-    const definition = this.#registry.require(edge.kind);
-    return kinds.has(edge.kind) || definition.inverse !== void 0 && kinds.has(definition.inverse);
-  }
-  #neighbors(id, direction, kinds) {
-    const candidates = [
-      ...direction === "incoming" ? [] : this.#outgoing.get(id) ?? [],
-      ...direction === "outgoing" ? [] : this.#incoming.get(id) ?? []
-    ];
-    return [...new Set(candidates)].filter((edge) => this.#matchesKinds(edge, kinds)).map((edge) => ({
-      id: edge.source === id ? edge.target : edge.source,
-      edge
-    })).sort((left, right) => left.id.localeCompare(right.id) || compareEdges(left.edge, right.edge));
-  }
-  /** Return one-hop adjacent node identifiers. */
-  adjacency(id, options = {}) {
-    this.#assertNode(id);
-    options.signal?.throwIfAborted();
-    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
-    const rows = this.#neighbors(id, options.direction ?? "outgoing", kinds);
-    const limit = options.limit ?? Number.POSITIVE_INFINITY;
-    const uniqueNeighbors = [...new Set(rows.map((row) => row.id))];
-    const value = uniqueNeighbors.slice(0, limit);
-    return {
-      value,
-      meta: {
-        visitedNodes: 1,
-        inspectedEdges: rows.length,
-        truncated: value.length < uniqueNeighbors.length,
-        nextCursor: value.at(-1)
-      }
-    };
-  }
-  /** Return deterministic one-hop neighbor rows paired with each connecting edge. */
-  neighborEdges(id, options = {}) {
-    this.#assertNode(id);
-    options.signal?.throwIfAborted();
-    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
-    const rows = this.#neighbors(id, options.direction ?? "outgoing", kinds);
-    const limit = options.limit ?? Number.POSITIVE_INFINITY;
-    const value = rows.slice(0, limit);
-    return {
-      value,
-      meta: {
-        visitedNodes: 1,
-        inspectedEdges: rows.length,
-        truncated: value.length < rows.length,
-        nextCursor: value.at(-1)?.id
-      }
-    };
-  }
-  /** Return bounded transitive closure in breadth-first discovery order. */
-  closure(id, options = {}) {
-    this.#assertNode(id);
-    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
-    const direction = options.direction ?? "outgoing";
-    const limit = options.limit ?? Number.POSITIVE_INFINITY;
-    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
-    const seen = /* @__PURE__ */ new Set([id]);
-    const value = [];
-    const queue = [{ id, depth: 0 }];
-    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 neighbors = this.#neighbors(current.id, direction, kinds);
-      inspectedEdges += neighbors.length;
-      if (current.depth >= maxDepth) {
-        if (neighbors.some((neighbor) => !seen.has(neighbor.id)))
-          truncated = true;
-        continue;
-      }
-      for (const neighbor of neighbors) {
-        if (seen.has(neighbor.id))
-          continue;
-        if (value.length >= limit) {
-          truncated = true;
-          break traversal;
-        }
-        seen.add(neighbor.id);
-        value.push(neighbor.id);
-        queue.push({ id: neighbor.id, depth: current.depth + 1 });
-      }
-    }
-    return {
-      value,
-      meta: {
-        visitedNodes,
-        inspectedEdges,
-        truncated,
-        nextCursor: value.at(-1)
-      }
-    };
-  }
-  /** Return a deterministic shortest path, or an empty array when disconnected. */
-  shortestPath(source, target, options = {}) {
-    this.#assertNode(source);
-    this.#assertNode(target);
-    if (source === target)
-      return {
-        value: [source],
-        meta: { visitedNodes: 1, inspectedEdges: 0, truncated: false }
-      };
-    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
-    const direction = options.direction ?? "outgoing";
-    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
-    const queue = [{ id: source, depth: 0 }];
-    const parents = /* @__PURE__ */ new Map();
-    const seen = /* @__PURE__ */ new Set([source]);
-    let visitedNodes = 0;
-    let inspectedEdges = 0;
-    let truncated = false;
-    for (let index = 0; index < queue.length; index += 1) {
-      options.signal?.throwIfAborted();
-      const current = queue[index];
-      visitedNodes += 1;
-      const neighbors = this.#neighbors(current.id, direction, kinds);
-      inspectedEdges += neighbors.length;
-      if (current.depth >= maxDepth) {
-        if (neighbors.some((neighbor) => !seen.has(neighbor.id)))
-          truncated = true;
-        continue;
-      }
-      for (const neighbor of neighbors) {
-        if (seen.has(neighbor.id))
-          continue;
-        parents.set(neighbor.id, current.id);
-        if (neighbor.id === target)
-          return {
-            value: reconstructPath(source, target, parents),
-            meta: { visitedNodes, inspectedEdges, truncated: false }
-          };
-        seen.add(neighbor.id);
-        queue.push({ id: neighbor.id, depth: current.depth + 1 });
-      }
-    }
-    return {
-      value: [],
-      meta: { visitedNodes, inspectedEdges, truncated }
-    };
-  }
-  /** Return the induced subgraph over a bounded closure including the root. */
-  subgraph(id, options = {}) {
-    const closure = this.closure(id, options);
-    const nodes = [id, ...closure.value].sort();
-    const included = new Set(nodes);
-    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
-    const edges = /* @__PURE__ */ new Set();
-    for (const node of nodes) {
-      for (const edge of this.#outgoing.get(node) ?? []) {
-        if (included.has(edge.source) && included.has(edge.target) && this.#matchesKinds(edge, kinds))
-          edges.add(edge);
-      }
-    }
-    return {
-      value: {
-        nodes,
-        edges: [...edges].sort(compareEdges)
-      },
-      meta: closure.meta
-    };
-  }
-};
-function dependencyToRelationship(source, dependency, registry = defaultRegistry) {
-  return {
-    source,
-    target: dependency.id,
-    kind: registry.require(dependency.kind).kind,
-    createdAt: dependency.created_at,
-    author: dependency.author
-  };
-}
-
-// dist/sdk/graph/assembly.js
-function normalizeDependencyReferenceTarget(target) {
-  if (typeof target !== "string")
-    return void 0;
-  const normalized = target.trim();
-  if (!normalized || ["none", "null", "n/a", "na"].includes(normalized.toLowerCase()))
-    return void 0;
-  return normalized;
-}
-function normalizeDependencyGraphTarget(target) {
-  const normalized = normalizeDependencyReferenceTarget(target);
-  return normalized?.toLowerCase() === "no-active-blocker" ? void 0 : normalized;
-}
-function collectDanglingDependencyReferences(items, isTerminal = (status) => status === "closed" || status === "canceled") {
-  const safeItems = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0);
-  const knownIds = new Set(safeItems.map((item) => item.id.trim().toLowerCase()));
-  const rows = /* @__PURE__ */ new Map();
-  const addReference = (item, target, kind, source) => {
-    const normalized = normalizeDependencyReferenceTarget(target);
-    if (!normalized || knownIds.has(normalized.toLowerCase())) {
-      return;
-    }
-    const row = {
-      holder_id: item.id.trim(),
-      target_id: normalized,
-      kind,
-      source,
-      holder_status: item.status,
-      legacy_terminal: isTerminal(item.status),
-      no_active_blocker_sentinel: normalized.toLowerCase() === "no-active-blocker"
-    };
-    rows.set(`${row.holder_id}::${row.target_id}::${row.kind}::${row.source}`, row);
-  };
-  for (const item of safeItems) {
-    addReference(item, item.parent, "parent", "parent");
-    addReference(item, item.blocked_by, "blocked_by", "blocked_by");
-    for (const dependency of item.dependencies ?? []) {
-      if (typeof dependency !== "object" || dependency === null) {
-        continue;
-      }
-      const legacyDependency = dependency;
-      addReference(item, legacyDependency.id, typeof legacyDependency.kind === "string" ? legacyDependency.kind : "related", "dependency");
-    }
-  }
-  const sorted = [...rows.values()].sort((left, right) => left.holder_id.localeCompare(right.holder_id) || left.target_id.localeCompare(right.target_id) || left.kind.localeCompare(right.kind) || left.source.localeCompare(right.source));
-  const legacyTerminal = sorted.filter((row) => row.legacy_terminal);
-  return {
-    active: sorted.filter((row) => !row.legacy_terminal),
-    legacy_terminal: legacyTerminal,
-    no_active_blocker_sentinels: sorted.filter((row) => row.no_active_blocker_sentinel)
-  };
-}
-function collectMissingDependencyTargetIds(dangling) {
-  const targets = /* @__PURE__ */ new Map();
-  for (const reference of [...dangling.active, ...dangling.legacy_terminal]) {
-    if (reference.no_active_blocker_sentinel)
-      continue;
-    const target = reference.target_id.trim();
-    const key = target.toLowerCase();
-    if (!targets.has(key))
-      targets.set(key, target);
-  }
-  return [...targets.values()].sort((left, right) => left.localeCompare(right));
-}
-function assembleWorkspaceRelationshipGraph(items, isTerminal, registry) {
-  const safeItems = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0);
-  const canonicalIds = new Map(safeItems.map((item) => [item.id.trim().toLowerCase(), item.id.trim()]));
-  const dangling = collectDanglingDependencyReferences(safeItems, isTerminal);
-  const missingIds = collectMissingDependencyTargetIds(dangling);
-  for (const id of missingIds)
-    canonicalIds.set(id.toLowerCase(), id);
-  const graphItems = safeItems.map((item) => {
-    const parent = normalizeDependencyGraphTarget(item.parent);
-    const blocker = normalizeDependencyGraphTarget(item.blocked_by);
-    const dependencies = (item.dependencies ?? []).flatMap((rawDependency) => {
-      if (typeof rawDependency !== "object" || rawDependency === null)
-        return [];
-      const dependency = rawDependency;
-      const target = normalizeDependencyGraphTarget(dependency.id);
-      if (!target)
-        return [];
-      return [
-        {
-          id: canonicalIds.get(target.toLowerCase()),
-          kind: typeof dependency.kind === "string" ? dependency.kind : "related"
-        }
-      ];
-    });
-    return {
-      id: item.id.trim(),
-      ...parent ? { parent: canonicalIds.get(parent.toLowerCase()) } : {},
-      ...blocker ? { blocked_by: canonicalIds.get(blocker.toLowerCase()) } : {},
-      dependencies
-    };
-  });
-  return {
-    graph: RelationshipGraph.fromItems([...graphItems, ...missingIds.map((id) => ({ id }))], registry),
-    details: [
-      ...safeItems.map((item) => ({
-        id: item.id.trim(),
-        title: item.title,
-        status: item.status
-      })),
-      ...missingIds.map((id) => ({
-        id,
-        title: `[missing] ${id}`,
-        status: "missing"
-      }))
-    ],
-    missingIdSet: new Set(missingIds.map((id) => id.toLowerCase())),
-    dangling
-  };
-}
-
-export {
-  RelationshipKindRegistry,
-  createRelationshipKindRegistry,
-  isOrderingRelationshipKind,
-  RelationshipGraph,
-  dependencyToRelationship,
-  collectDanglingDependencyReferences,
-  collectMissingDependencyTargetIds,
-  assembleWorkspaceRelationshipGraph
-};
-//# sourceMappingURL=chunk-L5BTTDU5.js.map
-
-//# debugId=8145f80d-99b5-53e4-a519-54b4549dca6c