@elevasis/ui 2.31.0 → 2.32.0

package/dist/chunk-WQPX44YM.js

@@ -0,0 +1,1626 @@
+import { SemanticIcon } from './chunk-UROTM5OR.js';
+import { buildOrganizationGraph, projectOrganizationSurfaces, getSortedSidebarEntries, getSystem } from './chunk-T35FWDAB.js';
+import { useMemo, useState, useRef, useEffect } from 'react';
+import { useTree, Text, Tree, UnstyledButton, Group, TextInput } from '@mantine/core';
+import { useClipboard } from '@mantine/hooks';
+import { IconChevronDown, IconChevronRight, IconX, IconSearch, IconCheck, IconCopy, IconStarFilled, IconStar } from '@tabler/icons-react';
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/organization-model/getSharedOrganizationGraph.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function getSharedOrganizationGraph(organizationModel) {
+  const cached = cache.get(organizationModel);
+  if (cached) return cached;
+  const graph = buildOrganizationGraph({ organizationModel });
+  cache.set(organizationModel, graph);
+  return graph;
+}
+
+// src/knowledge/iconTokens.ts
+var KNOWLEDGE_ICON_TOKEN_BY_KIND = {
+  playbook: "knowledge.playbook",
+  strategy: "knowledge.strategy",
+  reference: "knowledge.reference"
+};
+function getKnowledgeIconToken(node) {
+  return node.icon ?? KNOWLEDGE_ICON_TOKEN_BY_KIND[node.kind];
+}
+var useKnowledgeFavoritesStore = create()(
+  persist(
+    (set) => ({
+      favorites: {},
+      toggleFavorite: (entry) => set((state) => {
+        const next = { ...state.favorites };
+        if (next[entry.routeId]) {
+          delete next[entry.routeId];
+        } else {
+          next[entry.routeId] = { ...entry, addedAt: Date.now() };
+        }
+        return { favorites: next };
+      }),
+      removeFavorite: (routeId) => set((state) => {
+        if (!state.favorites[routeId]) return state;
+        const next = { ...state.favorites };
+        delete next[routeId];
+        return { favorites: next };
+      }),
+      clearFavorites: () => set({ favorites: {} })
+    }),
+    {
+      name: "elevasis-knowledge-favorites",
+      storage: createJSONStorage(() => localStorage),
+      version: 1
+    }
+  )
+);
+
+// src/knowledge/navigationProjection.ts
+function collectSurfaceIds(nodes) {
+  return getSortedSidebarEntries(nodes).flatMap(
+    ([id, node]) => node.type === "group" ? collectSurfaceIds(node.children) : [id]
+  );
+}
+function collectGroups(nodes, placement, groups = []) {
+  getSortedSidebarEntries(nodes).forEach(([id, node]) => {
+    if (node.type !== "group") return;
+    groups.push({
+      id,
+      label: node.label,
+      placement,
+      surfaceIds: collectSurfaceIds(node.children)
+    });
+    collectGroups(node.children, placement, groups);
+  });
+  return groups;
+}
+function projectNavigationSurfaces(model) {
+  return projectOrganizationSurfaces(model);
+}
+function projectNavigationGroups(model) {
+  return [
+    ...collectGroups(model.navigation.sidebar.primary, "primary"),
+    ...collectGroups(model.navigation.sidebar.bottom, "bottom")
+  ];
+}
+function toSemanticFallbackKind(kind) {
+  switch (kind) {
+    case "knowledge":
+    case "resource":
+    case "action":
+    case "entity":
+    case "event":
+    case "policy":
+      return kind;
+    case "system":
+      return "feature";
+    case "role":
+      return "unknown";
+    case "stage":
+      return "status";
+    case "organization":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+var QUICK_ACCESS_GROUP_KEY = "quick-access";
+var FAVORITE_PREFIX = "favorite:";
+var QUICK_ACCESS_GROUP_VALUE = `group:${QUICK_ACCESS_GROUP_KEY}`;
+var GROUP_ICON_TOKENS = {
+  [QUICK_ACCESS_GROUP_KEY]: "om.quick-access",
+  profile: "om.profile",
+  "business-model": "om.business-model",
+  systems: "om.systems",
+  graph: "om.graph",
+  "governance-wiring": "om.governance-wiring"
+};
+function findFavoritePathInTree(nodes, favorite) {
+  const matchesPrimary = (node) => {
+    if (favorite.kind === "knowledge") {
+      return node.nodeType === "leaf" && node.knowledgeNodeId === favorite.routeId;
+    }
+    if (favorite.kind === "graph") {
+      return node.graphNodeId === favorite.routeId;
+    }
+    return typeof node.value === "string" && node.value === favorite.routeId;
+  };
+  const matchesFallback = (node) => {
+    if (favorite.kind !== "knowledge") return false;
+    return node.nodeType === "item" && node.domainKey === "knowledge" && node.itemId === favorite.routeId;
+  };
+  function dfs(node, ancestors, match) {
+    if (node.value === QUICK_ACCESS_GROUP_VALUE) return void 0;
+    const value = typeof node.value === "string" ? node.value : "";
+    const path = [...ancestors, value];
+    if (match(node)) return path;
+    for (const child of node.children ?? []) {
+      const found = dfs(child, path, match);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  for (const root of nodes) {
+    const found = dfs(root, [], matchesPrimary);
+    if (found) return found;
+  }
+  for (const root of nodes) {
+    const found = dfs(root, [], matchesFallback);
+    if (found) return found;
+  }
+  return void 0;
+}
+var OM_TREE_GROUPS = [
+  { key: "profile", label: "Profile", domains: ["identity", "branding"] },
+  { key: "business-model", label: "Business Model", domains: ["customers", "offerings", "goals"] },
+  { key: "systems", label: "Systems", domains: ["systems", "sales", "prospecting", "projects"] },
+  { key: "graph", label: "Graph", domains: ["resources", "actions", "entities", "events", "stages", "knowledge"] },
+  { key: "governance-wiring", label: "Governance & Wiring", domains: ["roles", "policies", "statuses", "navigation"] }
+];
+var DOMAIN_PREFIX = "domain:";
+var GROUP_PREFIX = "group:";
+var ITEM_PREFIX = "item:";
+function domainKeyForKnowledgeTarget(targetKind) {
+  switch (targetKind) {
+    case "customer-segment":
+      return "customers";
+    case "offering":
+      return "offerings";
+    case "goal":
+      return "goals";
+    case "role":
+      return "roles";
+    default:
+      return void 0;
+  }
+}
+function graphNodeIdForKnowledgeTarget(targetKind, targetId) {
+  switch (targetKind) {
+    case "resource":
+    case "action":
+    case "entity":
+    case "event":
+    case "policy":
+    case "role":
+    case "knowledge":
+    case "system":
+    case "stage":
+      return `${targetKind}:${targetId}`;
+    default:
+      return void 0;
+  }
+}
+var GRAPH_RESOURCE_TYPE_ORDER = [
+  "workflow",
+  "agent",
+  "integration",
+  "script",
+  "external",
+  "trigger",
+  "human_checkpoint"
+];
+var GRAPH_RESOURCE_TYPE_LABELS = {
+  workflow: "Workflows",
+  agent: "Agents",
+  integration: "Integrations",
+  script: "Scripts",
+  external: "External",
+  trigger: "Triggers",
+  human_checkpoint: "Human Checkpoints"
+};
+var KNOWLEDGE_START_HERE_IDS = [
+  "knowledge.org-model-reference",
+  "knowledge.org-model-graph-contract",
+  "knowledge.org-model-actions",
+  "knowledge.org-model-entities",
+  "knowledge.org-model-events",
+  "knowledge.org-model-policies",
+  "knowledge.platform-command-view"
+];
+var SPINE_PREFIX = "spine:";
+var LEAF_PREFIX = "leaf:";
+var FOLDER_PREFIX = "folder:";
+var GROUP_THRESHOLD = 8;
+var SIDEBAR_TREE_ACCENT_COLOR = "var(--color-primary)";
+var DEFAULT_KNOWLEDGE_FACET_STATES = { knowledge: "include" };
+var FOLDER_ORDER = [
+  "campaigns",
+  "pipeline",
+  "targeting",
+  "channels",
+  "proof",
+  "references",
+  "playbooks",
+  "strategies"
+];
+var FOLDER_LABELS = {
+  campaigns: "Campaigns",
+  pipeline: "Pipeline",
+  targeting: "Targeting and Strategy",
+  channels: "Channels",
+  proof: "Proof",
+  references: "References",
+  playbooks: "Playbooks",
+  strategies: "Strategies"
+};
+var KNOWLEDGE_DOMAINS_WITH_PANELS = /* @__PURE__ */ new Set([
+  "identity",
+  "branding",
+  "customers",
+  "offerings",
+  "goals",
+  "roles",
+  "sales",
+  "prospecting",
+  "projects",
+  "statuses",
+  "navigation",
+  "policies"
+]);
+var FILTERABLE_DOMAIN_KEYS = /* @__PURE__ */ new Set(["customers", "offerings", "goals", "roles", "statuses", "policies"]);
+function shouldRouteItemToDomainPanel(domainKey) {
+  return FILTERABLE_DOMAIN_KEYS.has(domainKey);
+}
+function toBareGraphId(graphNodeId, kind) {
+  const prefix = `${kind}:`;
+  return graphNodeId.startsWith(prefix) ? graphNodeId.slice(prefix.length) : graphNodeId;
+}
+function topLevelGraphIds(allBareIds) {
+  return allBareIds.filter((id) => !id.includes("."));
+}
+function childGraphIds(allBareIds, parentId) {
+  const prefix = `${parentId}.`;
+  return allBareIds.filter((id) => id.startsWith(prefix) && !id.slice(prefix.length).includes("."));
+}
+function buildTreeContext(graph, knowledgeNodes) {
+  const knowledgeByGraphId = /* @__PURE__ */ new Map();
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    nodesById.set(node.id, node);
+    if (node.kind === "knowledge") {
+      knowledgeByGraphId.set(node.id, node.sourceId ?? node.id.replace(/^knowledge:/, ""));
+    }
+  }
+  const knowledgeById = new Map(knowledgeNodes.map((node) => [node.id, node]));
+  const governsRaw = /* @__PURE__ */ new Map();
+  const edgesBySource = /* @__PURE__ */ new Map();
+  const edgesByTarget = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const src = edgesBySource.get(edge.sourceId) ?? [];
+    src.push(edge);
+    edgesBySource.set(edge.sourceId, src);
+    const tgt = edgesByTarget.get(edge.targetId) ?? [];
+    tgt.push(edge);
+    edgesByTarget.set(edge.targetId, tgt);
+    if (edge.kind === "governs") {
+      const knowledgeId = knowledgeByGraphId.get(edge.sourceId);
+      const knowledgeNode = knowledgeId ? knowledgeById.get(knowledgeId) : void 0;
+      if (knowledgeNode) {
+        const bucket = governsRaw.get(edge.targetId) ?? [];
+        bucket.push(knowledgeNode);
+        governsRaw.set(edge.targetId, bucket);
+      }
+    }
+  }
+  const governsEdgesByTarget = /* @__PURE__ */ new Map();
+  for (const [targetId, nodes] of governsRaw) {
+    governsEdgesByTarget.set(
+      targetId,
+      nodes.sort((a, b) => a.title.localeCompare(b.title))
+    );
+  }
+  return { governsEdgesByTarget, nodesById, edgesBySource, edgesByTarget };
+}
+function getKnowledgeByTarget(knowledgeNodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of knowledgeNodes) {
+    for (const link of node.links) {
+      const graphNodeId = graphNodeIdForKnowledgeTarget(link.target.kind, link.target.id);
+      const domainKey = domainKeyForKnowledgeTarget(link.target.kind);
+      const targetKeys = [
+        graphNodeId,
+        domainKey ? `${domainKey}:${link.target.id}` : void 0,
+        domainKey ? domainKey : void 0
+      ].filter((key) => key !== void 0);
+      for (const targetKey of targetKeys) {
+        const bucket = map.get(targetKey) ?? [];
+        bucket.push(node);
+        map.set(targetKey, bucket);
+      }
+    }
+  }
+  return map;
+}
+function uniqueKnowledgeNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  return nodes.sort((left, right) => left.title.localeCompare(right.title)).filter((node) => {
+    if (seen.has(node.id)) return false;
+    seen.add(node.id);
+    return true;
+  });
+}
+function getTargetKnowledge(knowledgeByTarget, targetKey, facetStates) {
+  if (facetStates.knowledge === "exclude") return [];
+  return uniqueKnowledgeNodes(knowledgeByTarget.get(targetKey) ?? []);
+}
+function sortByOrderThenLabel(items, getLabel) {
+  return [...items].sort(
+    (left, right) => (left.order ?? 0) - (right.order ?? 0) || getLabel(left).localeCompare(getLabel(right))
+  );
+}
+function modelRecordValues(record, getLabel) {
+  return sortByOrderThenLabel(Object.values(record ?? {}), getLabel);
+}
+function spineNodeHasVisibleDescendant(bareId, allBareIds, spine, facetStates, ctx, organizationModel, cache2 = /* @__PURE__ */ new Map()) {
+  const cached = cache2.get(bareId);
+  if (cached !== void 0) return cached;
+  const graphNodeId = `${spine}:${bareId}`;
+  const hasContentChildren = spine === "system" && organizationModel !== void 0 && Object.keys(getSystem(organizationModel, bareId)?.content ?? {}).length > 0;
+  let result = hasContentChildren || facetStates.knowledge !== "exclude" && (ctx.governsEdgesByTarget.get(graphNodeId)?.length ?? 0) > 0 || getIncludedFacetNodes(graphNodeId, spine, facetStates, ctx).length > 0 || childGraphIds(allBareIds, bareId).some(
+    (childId) => spineNodeHasVisibleDescendant(childId, allBareIds, spine, facetStates, ctx, organizationModel, cache2)
+  );
+  cache2.set(bareId, result);
+  return result;
+}
+function buildSpineMetaMap(graph, spine) {
+  const map = {};
+  for (const node of graph.nodes) {
+    if (node.kind === spine) {
+      map[toBareGraphId(node.id, spine)] = { label: node.label, icon: node.icon, node };
+    }
+  }
+  return map;
+}
+function getKnowledgeReadCommand(nodeId) {
+  return `/knowledge read ${nodeId}`;
+}
+function getKnowledgeReadCommands(nodeIds) {
+  return [...new Set(nodeIds)].map(getKnowledgeReadCommand).join("\n");
+}
+function getKnowledgeReadSpineFolderCommand(spine, bareId) {
+  return `/knowledge read-folder ${spine}:${bareId}`;
+}
+function getKnowledgeReadTreeFolderCommand(treeValue) {
+  return `/knowledge read-folder ${treeValue}`;
+}
+function getKnowledgeDirectoryCommand(nodeIds, fallbackCommand) {
+  const command = getKnowledgeReadCommands(nodeIds ?? []);
+  return command || fallbackCommand;
+}
+function getKnowledgeFolderKey(node) {
+  const key = `${node.id} ${node.title}`.toLowerCase();
+  if (/\b(stage|booking|discovery|pipeline|communications?)\b/.test(key)) return "pipeline";
+  if (/\b(upwork scanning|youtube|obs|recording|reddit|social)\b/.test(key)) return "channels";
+  if (/\b(testimonials?|case stud|proof)\b/.test(key)) return "proof";
+  if (/\b(target|personalization|vertical|calibration|query|research|strategy)\b/.test(key)) return "targeting";
+  if (/\b(outreach|campaign|copy|handoff|bounce|reply|lead-gen playbook)\b/.test(key)) return "campaigns";
+  if (node.kind === "reference") return "references";
+  if (node.kind === "strategy") return "strategies";
+  return "playbooks";
+}
+function sortFolderKeys(left, right) {
+  const leftIndex = FOLDER_ORDER.indexOf(left);
+  const rightIndex = FOLDER_ORDER.indexOf(right);
+  if (leftIndex === -1 && rightIndex === -1) return left.localeCompare(right);
+  if (leftIndex === -1) return 1;
+  if (rightIndex === -1) return -1;
+  return leftIndex - rightIndex;
+}
+function createKnowledgeLeaf(graphNodeId, node) {
+  return {
+    value: `${LEAF_PREFIX}${graphNodeId}::${node.id}`,
+    label: node.title,
+    nodeType: "leaf",
+    knowledgeNodeId: node.id,
+    knowledgeNodeIds: [node.id]
+  };
+}
+function createKnowledgeLeaves(graphNodeId, nodes) {
+  if (nodes.length < GROUP_THRESHOLD) {
+    return nodes.map((node) => createKnowledgeLeaf(graphNodeId, node));
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const folderKey = getKnowledgeFolderKey(node);
+    const folderNodes = grouped.get(folderKey) ?? [];
+    folderNodes.push(node);
+    grouped.set(folderKey, folderNodes);
+  }
+  return [...grouped.entries()].sort(([left], [right]) => sortFolderKeys(left, right)).map(([folderKey, folderNodes]) => ({
+    value: `${FOLDER_PREFIX}${graphNodeId}::${folderKey}`,
+    label: FOLDER_LABELS[folderKey] ?? folderKey,
+    nodeType: "folder",
+    icon: "knowledge.playbook",
+    knowledgeNodeIds: folderNodes.map((node) => node.id),
+    children: folderNodes.map((node) => createKnowledgeLeaf(graphNodeId, node))
+  }));
+}
+function collectKnowledgeNodeIds(node) {
+  if (node.knowledgeNodeIds) return node.knowledgeNodeIds;
+  return (node.children ?? []).flatMap(collectKnowledgeNodeIds);
+}
+function createItemNode({
+  domainKey,
+  itemId,
+  label,
+  graphNodeId,
+  knowledgeNodes = [],
+  children = []
+}) {
+  const knowledgeLeaves = knowledgeNodes.length > 0 ? createKnowledgeLeaves(`${ITEM_PREFIX}${domainKey}:${itemId}`, knowledgeNodes) : [];
+  const allChildren = [...children, ...knowledgeLeaves];
+  return {
+    value: `${ITEM_PREFIX}${domainKey}:${itemId}`,
+    label,
+    nodeType: "item",
+    domainKey,
+    itemId,
+    graphNodeId,
+    knowledgeNodeIds: [...knowledgeNodes.map((node) => node.id), ...children.flatMap(collectKnowledgeNodeIds)],
+    children: allChildren.length > 0 ? allChildren : void 0
+  };
+}
+function createDomainNode({
+  domainKey,
+  label,
+  knowledgeNodes = [],
+  children = []
+}) {
+  const knowledgeLeaves = knowledgeNodes.length > 0 ? createKnowledgeLeaves(`${DOMAIN_PREFIX}${domainKey}`, knowledgeNodes) : [];
+  const allChildren = [...children, ...knowledgeLeaves];
+  return {
+    value: `${DOMAIN_PREFIX}${domainKey}`,
+    label,
+    nodeType: "domain",
+    domainKey,
+    knowledgeNodeIds: [...knowledgeNodes.map((node) => node.id), ...children.flatMap(collectKnowledgeNodeIds)],
+    children: allChildren.length > 0 ? allChildren : void 0
+  };
+}
+function createGroupNode({
+  groupKey,
+  label,
+  children
+}) {
+  return {
+    value: `${GROUP_PREFIX}${groupKey}`,
+    label,
+    nodeType: "group",
+    knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+    children: children.length > 0 ? children : void 0
+  };
+}
+function getIncludedFacetNodes(graphNodeId, spineKind, facetStates, ctx) {
+  const includedKinds = new Set(
+    Object.entries(facetStates).filter(([kind, state]) => state === "include" && kind !== "knowledge" && kind !== spineKind).map(([kind]) => kind)
+  );
+  if (includedKinds.size === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const nodes = [];
+  const outgoing = ctx.edgesBySource.get(graphNodeId) ?? [];
+  const incoming = ctx.edgesByTarget.get(graphNodeId) ?? [];
+  for (const edge of [...outgoing, ...incoming]) {
+    const relatedId = edge.sourceId === graphNodeId ? edge.targetId : edge.sourceId;
+    const relatedNode = ctx.nodesById.get(relatedId);
+    if (!relatedNode || !includedKinds.has(relatedNode.kind) || seen.has(relatedNode.id)) continue;
+    seen.add(relatedNode.id);
+    nodes.push(relatedNode);
+  }
+  return nodes.sort((left, right) => left.kind.localeCompare(right.kind) || left.label.localeCompare(right.label));
+}
+function createFacetGraphLeaves(nodes) {
+  return nodes.map((node) => ({
+    value: `graph:${node.id}`,
+    label: node.label,
+    nodeType: "graph",
+    icon: node.icon,
+    graphNodeId: node.id,
+    knowledgeNodeIds: []
+  }));
+}
+function createGraphNodeItem(node, domainKey) {
+  return createItemNode({
+    domainKey,
+    itemId: node.sourceId ?? node.id,
+    label: node.label,
+    graphNodeId: node.id
+  });
+}
+function createCollectionNode(parentKey, collectionKey, label, children) {
+  return {
+    value: `${FOLDER_PREFIX}${parentKey}:${collectionKey}`,
+    label,
+    nodeType: "folder",
+    knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+    children: children.length > 0 ? children : void 0
+  };
+}
+var CONTENT_META_KIND_ORDER = ["schema", "config", "knowledge"];
+function contentMetaKindSortKey(kind) {
+  const idx = CONTENT_META_KIND_ORDER.indexOf(kind);
+  return idx === -1 ? CONTENT_META_KIND_ORDER.length : idx;
+}
+function buildContentKindItems(systemPath, entries) {
+  return [...entries].sort(([, a], [, b]) => (a.order ?? 0) - (b.order ?? 0) || (a.label ?? "").localeCompare(b.label ?? "")).map(([localId, node]) => {
+    const qualifiedId = `${systemPath}:${localId}`;
+    return {
+      // Wave 5 will project content nodes into the graph; until then render as
+      // 'item' so the label appears without requiring a graph-node map lookup.
+      value: `${ITEM_PREFIX}content:${qualifiedId}`,
+      label: node.label ?? localId,
+      nodeType: "item",
+      domainKey: "content",
+      itemId: qualifiedId,
+      graphNodeId: `content-node:${qualifiedId}`,
+      knowledgeNodeIds: []
+    };
+  });
+}
+function buildContentSubgroup(bareId, organizationModel) {
+  if (!organizationModel) return [];
+  const system = getSystem(organizationModel, bareId);
+  const contentMap = system?.content;
+  if (!contentMap || Object.keys(contentMap).length === 0) return [];
+  const byMetaKind = /* @__PURE__ */ new Map();
+  for (const [localId, node] of Object.entries(contentMap)) {
+    const bucket = byMetaKind.get(node.kind) ?? [];
+    bucket.push([localId, node]);
+    byMetaKind.set(node.kind, bucket);
+  }
+  const kindFolders = [...byMetaKind.entries()].sort(([a], [b]) => contentMetaKindSortKey(a) - contentMetaKindSortKey(b) || a.localeCompare(b)).map(([metaKind, entries]) => {
+    const items = buildContentKindItems(bareId, entries);
+    return {
+      value: `${FOLDER_PREFIX}content:${bareId}:${metaKind}`,
+      label: metaKind.charAt(0).toUpperCase() + metaKind.slice(1),
+      nodeType: "folder",
+      knowledgeNodeIds: [],
+      children: items.length > 0 ? items : void 0
+    };
+  });
+  return [
+    {
+      value: `${FOLDER_PREFIX}content:${bareId}`,
+      label: "Content",
+      nodeType: "folder",
+      knowledgeNodeIds: [],
+      children: kindFolders.length > 0 ? kindFolders : void 0
+    }
+  ];
+}
+function buildSpineTreeNode(bareId, allBareIds, spineMetaMap, spine, facetStates, ctx, visibleSpineIds, organizationModel) {
+  const graphNodeId = `${spine}:${bareId}`;
+  const governing = facetStates.knowledge === "exclude" ? [] : ctx.governsEdgesByTarget.get(graphNodeId) ?? [];
+  const childIds = childGraphIds(allBareIds, bareId);
+  const contentChildren = spine === "system" ? buildContentSubgroup(bareId, organizationModel) : [];
+  const domainConfigChildren = [];
+  const childSpineNodes = childIds.filter((childId) => visibleSpineIds.has(childId)).map(
+    (childId) => buildSpineTreeNode(childId, allBareIds, spineMetaMap, spine, facetStates, ctx, visibleSpineIds, organizationModel)
+  );
+  const knowledgeLeaves = createKnowledgeLeaves(graphNodeId, governing);
+  const facetLeaves = createFacetGraphLeaves(getIncludedFacetNodes(graphNodeId, spine, facetStates, ctx));
+  const children = [...domainConfigChildren, ...contentChildren, ...childSpineNodes, ...knowledgeLeaves, ...facetLeaves];
+  const meta = spineMetaMap[bareId];
+  return {
+    value: `${SPINE_PREFIX}${spine}:${bareId}`,
+    label: meta?.label ?? bareId,
+    nodeType: "spine",
+    icon: meta?.icon,
+    graphNodeId,
+    knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+    children: children.length > 0 ? children : void 0
+  };
+}
+function getInitialExpandedState(nodes, omRooted) {
+  if (!omRooted) return {};
+  const systemsValue = `${GROUP_PREFIX}systems`;
+  const quickAccessValue = `${GROUP_PREFIX}${QUICK_ACCESS_GROUP_KEY}`;
+  const expanded = {};
+  for (const node of nodes) {
+    if (node.value === systemsValue) expanded[systemsValue] = true;
+    if (node.value === quickAccessValue) expanded[quickAccessValue] = true;
+  }
+  return expanded;
+}
+function buildProfileGroup(organizationModel, knowledgeByTarget, facetStates) {
+  return createGroupNode({
+    groupKey: "profile",
+    label: "Profile",
+    children: [
+      createDomainNode({
+        domainKey: "identity",
+        label: "Identity",
+        knowledgeNodes: getTargetKnowledge(knowledgeByTarget, "identity", facetStates)
+      }),
+      createDomainNode({
+        domainKey: "branding",
+        label: "Branding",
+        knowledgeNodes: getTargetKnowledge(knowledgeByTarget, "branding", facetStates)
+      })
+    ]
+  });
+}
+function buildBusinessModelGroup(organizationModel, knowledgeByTarget, facetStates) {
+  return createGroupNode({
+    groupKey: "business-model",
+    label: "Business Model",
+    children: [
+      createDomainNode({
+        domainKey: "customers",
+        label: "Customers",
+        children: modelRecordValues(organizationModel?.customers, (segment) => segment.name || segment.id).map(
+          (segment) => createItemNode({
+            domainKey: "customers",
+            itemId: segment.id,
+            label: segment.name || segment.id,
+            knowledgeNodes: getTargetKnowledge(knowledgeByTarget, `customers:${segment.id}`, facetStates)
+          })
+        )
+      }),
+      createDomainNode({
+        domainKey: "offerings",
+        label: "Offerings",
+        children: modelRecordValues(organizationModel?.offerings, (offering) => offering.name || offering.id).map(
+          (offering) => createItemNode({
+            domainKey: "offerings",
+            itemId: offering.id,
+            label: offering.name || offering.id,
+            knowledgeNodes: getTargetKnowledge(knowledgeByTarget, `offerings:${offering.id}`, facetStates)
+          })
+        )
+      }),
+      createDomainNode({
+        domainKey: "goals",
+        label: "Goals",
+        children: modelRecordValues(organizationModel?.goals, (goal) => goal.description || goal.id).map(
+          (goal) => createItemNode({
+            domainKey: "goals",
+            itemId: goal.id,
+            label: goal.description || goal.id,
+            knowledgeNodes: getTargetKnowledge(knowledgeByTarget, `goals:${goal.id}`, facetStates)
+          })
+        )
+      })
+    ]
+  });
+}
+function buildRolesDomain(graph, organizationModel, knowledgeByTarget, facetStates) {
+  const graphNodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const roleItems = modelRecordValues(organizationModel?.roles, (role) => role.title || role.id).map(
+    (role) => createItemNode({
+      domainKey: "roles",
+      itemId: role.id,
+      label: role.title || role.id,
+      graphNodeId: graphNodesById.get(`role:${role.id}`)?.id,
+      knowledgeNodes: getTargetKnowledge(knowledgeByTarget, `role:${role.id}`, facetStates)
+    })
+  );
+  return createDomainNode({ domainKey: "roles", label: "Roles", children: roleItems });
+}
+function buildSystemsGroup(graph, organizationModel, facetStates, ctx, visibleSpineIds) {
+  const spineMetaMap = buildSpineMetaMap(graph, "system");
+  const allBareIds = Object.keys(spineMetaMap);
+  const topIds = topLevelGraphIds(allBareIds);
+  const children = topIds.filter((bareId) => visibleSpineIds.has(bareId)).map(
+    (bareId) => buildSpineTreeNode(
+      bareId,
+      allBareIds,
+      spineMetaMap,
+      "system",
+      facetStates,
+      ctx,
+      visibleSpineIds,
+      organizationModel
+    )
+  );
+  return createGroupNode({ groupKey: "systems", label: "Systems", children });
+}
+function graphNodesByKind(graph, kind) {
+  return graph.nodes.filter((node) => node.kind === kind).sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id));
+}
+function buildGraphResourcesBranch(graph) {
+  const resources = graphNodesByKind(graph, "resource");
+  const children = GRAPH_RESOURCE_TYPE_ORDER.map((resourceType) => {
+    const resourceNodes = resources.filter((node) => node.resourceType === resourceType);
+    if (resourceNodes.length === 0) return void 0;
+    return createCollectionNode(
+      "graph:resources",
+      resourceType,
+      GRAPH_RESOURCE_TYPE_LABELS[resourceType],
+      resourceNodes.map((node) => createGraphNodeItem(node, "resources"))
+    );
+  }).filter((node) => node !== void 0);
+  const untypedResources = resources.filter((node) => node.resourceType === void 0);
+  if (untypedResources.length > 0) {
+    children.push(
+      createCollectionNode(
+        "graph:resources",
+        "unknown",
+        "Unclassified",
+        untypedResources.map((node) => createGraphNodeItem(node, "resources"))
+      )
+    );
+  }
+  return createDomainNode({ domainKey: "resources", label: "Resources", children });
+}
+function buildGraphKnowledgeBranch(graph, knowledgeNodes) {
+  const graphNodesBySourceId = new Map(
+    graph.nodes.filter((node) => node.kind === "knowledge").map((node) => [node.sourceId ?? node.id, node])
+  );
+  const knowledgeById = new Map(knowledgeNodes.map((node) => [node.id, node]));
+  const startHere = KNOWLEDGE_START_HERE_IDS.map((id) => knowledgeById.get(id)).filter(
+    (node) => node !== void 0
+  );
+  const startHereIds = new Set(startHere.map((node) => node.id));
+  const allKnowledge = [...knowledgeNodes].filter((node) => !startHereIds.has(node.id)).sort((left, right) => left.title.localeCompare(right.title));
+  const toKnowledgeItem = (node) => createItemNode({
+    domainKey: "knowledge",
+    itemId: node.id,
+    label: node.title,
+    graphNodeId: graphNodesBySourceId.get(node.id)?.id
+  });
+  return createDomainNode({
+    domainKey: "knowledge",
+    label: "Knowledge",
+    children: [
+      createCollectionNode("graph:knowledge", "start-here", "Start Here", startHere.map(toKnowledgeItem)),
+      createCollectionNode("graph:knowledge", "all", "All", allKnowledge.map(toKnowledgeItem))
+    ]
+  });
+}
+function buildGraphStagesBranch(graph) {
+  return createDomainNode({
+    domainKey: "stages",
+    label: "Stages",
+    children: graphNodesByKind(graph, "stage").map((node) => createGraphNodeItem(node, "stages"))
+  });
+}
+function buildGraphGroup(graph, knowledgeNodes) {
+  return createGroupNode({
+    groupKey: "graph",
+    label: "Graph",
+    children: [
+      buildGraphResourcesBranch(graph),
+      createDomainNode({
+        domainKey: "actions",
+        label: "Actions",
+        children: graphNodesByKind(graph, "action").map((node) => createGraphNodeItem(node, "actions"))
+      }),
+      createDomainNode({
+        domainKey: "entities",
+        label: "Entities",
+        children: graphNodesByKind(graph, "entity").map((node) => createGraphNodeItem(node, "entities"))
+      }),
+      createDomainNode({
+        domainKey: "events",
+        label: "Events",
+        children: graphNodesByKind(graph, "event").map((node) => createGraphNodeItem(node, "events"))
+      }),
+      buildGraphStagesBranch(graph),
+      buildGraphKnowledgeBranch(graph, knowledgeNodes)
+    ]
+  });
+}
+function buildGovernanceGroup(graph, organizationModel, knowledgeByTarget, facetStates) {
+  const graphNodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+  const policies = modelRecordValues(organizationModel?.policies, (policy) => policy.label || policy.id).map(
+    (policy) => createItemNode({
+      domainKey: "policies",
+      itemId: policy.id,
+      label: policy.label || policy.id,
+      graphNodeId: graphNodesById.get(`policy:${policy.id}`)?.id,
+      knowledgeNodes: getTargetKnowledge(knowledgeByTarget, `policy:${policy.id}`, facetStates)
+    })
+  );
+  const statusGroups = [];
+  const navigationSurfaces = (organizationModel ? projectNavigationSurfaces(organizationModel) : []).sort((left, right) => left.label.localeCompare(right.label)).map(
+    (surface) => createItemNode({
+      domainKey: "navigation",
+      itemId: surface.id,
+      label: surface.label
+    })
+  );
+  const rolesDomain = buildRolesDomain(graph, organizationModel, knowledgeByTarget, facetStates);
+  return createGroupNode({
+    groupKey: "governance-wiring",
+    label: "Governance & Wiring",
+    children: [
+      rolesDomain,
+      createDomainNode({ domainKey: "policies", label: "Policies", children: policies }),
+      createDomainNode({ domainKey: "statuses", label: "Statuses", children: statusGroups }),
+      createDomainNode({ domainKey: "navigation", label: "Navigation", children: navigationSurfaces })
+    ]
+  });
+}
+function computeVisibleSpineIds(allBareIds, spine, facetStates, ctx, organizationModel) {
+  const cache2 = /* @__PURE__ */ new Map();
+  const visible = /* @__PURE__ */ new Set();
+  for (const bareId of allBareIds) {
+    if (spineNodeHasVisibleDescendant(bareId, allBareIds, spine, facetStates, ctx, organizationModel, cache2)) {
+      visible.add(bareId);
+    }
+  }
+  return visible;
+}
+function buildOrgTreeNode(graph, knowledgeNodes, facetStates, organizationModel, favorites = []) {
+  const ctx = buildTreeContext(graph, knowledgeNodes);
+  const knowledgeByTarget = getKnowledgeByTarget(knowledgeNodes);
+  const spineMetaMap = buildSpineMetaMap(graph, "system");
+  const allBareIds = Object.keys(spineMetaMap);
+  const visibleSpineIds = computeVisibleSpineIds(allBareIds, "system", facetStates, ctx, organizationModel);
+  const omGroups = OM_TREE_GROUPS.map((group) => {
+    switch (group.key) {
+      case "profile":
+        return buildProfileGroup(organizationModel, knowledgeByTarget, facetStates);
+      case "business-model":
+        return buildBusinessModelGroup(organizationModel, knowledgeByTarget, facetStates);
+      case "systems":
+        return buildSystemsGroup(graph, organizationModel, facetStates, ctx, visibleSpineIds);
+      case "graph":
+        return buildGraphGroup(graph, knowledgeNodes);
+      case "governance-wiring":
+        return buildGovernanceGroup(graph, organizationModel, knowledgeByTarget, facetStates);
+      default:
+        return createGroupNode({ groupKey: group.key, label: group.label, children: [] });
+    }
+  });
+  const quickAccess = buildQuickAccessGroup(favorites, knowledgeNodes, graph);
+  return [quickAccess, ...omGroups];
+}
+function buildQuickAccessGroup(favorites, knowledgeNodes, graph) {
+  const knowledgeIds = new Set(knowledgeNodes.map((node) => node.id));
+  const graphIds = new Set(graph.nodes.map((node) => node.id));
+  const children = favorites.filter((favorite) => {
+    if (favorite.kind === "knowledge") return knowledgeIds.has(favorite.routeId);
+    if (favorite.kind === "graph") return graphIds.has(favorite.routeId);
+    return true;
+  }).map((favorite) => ({
+    value: `${FAVORITE_PREFIX}${favorite.routeId}`,
+    label: favorite.label,
+    nodeType: "favorite",
+    icon: favorite.iconToken,
+    favoriteRouteId: favorite.routeId,
+    favoriteKind: favorite.kind,
+    knowledgeNodeIds: []
+  }));
+  return {
+    value: `${GROUP_PREFIX}${QUICK_ACCESS_GROUP_KEY}`,
+    label: "Quick Access",
+    nodeType: "group",
+    knowledgeNodeIds: [],
+    children
+  };
+}
+function KnowledgeTree({
+  graph,
+  knowledgeNodes,
+  organizationModel,
+  onSelectNode,
+  onSelectGraphNode,
+  onSelectDomain,
+  onSelectGroup,
+  onSelectItem,
+  spine = "system",
+  omRooted = false,
+  facetStates = DEFAULT_KNOWLEDGE_FACET_STATES,
+  selectedNodeId
+}) {
+  const graphSpine = spine;
+  const favoritesMap = useKnowledgeFavoritesStore((state) => state.favorites);
+  const favorites = useMemo(
+    () => Object.values(favoritesMap).sort((left, right) => right.addedAt - left.addedAt),
+    [favoritesMap]
+  );
+  const treeData = useMemo(() => {
+    if (omRooted) {
+      return buildOrgTreeNode(graph, knowledgeNodes, facetStates, organizationModel, favorites);
+    }
+    const ctx = buildTreeContext(graph, knowledgeNodes);
+    const spineMetaMap = buildSpineMetaMap(graph, graphSpine);
+    const allBareIds = Object.keys(spineMetaMap);
+    const topIds = topLevelGraphIds(allBareIds);
+    const visibleSpineIds = computeVisibleSpineIds(allBareIds, graphSpine, facetStates, ctx, organizationModel);
+    return topIds.filter((bareId) => visibleSpineIds.has(bareId)).map(
+      (bareId) => buildSpineTreeNode(
+        bareId,
+        allBareIds,
+        spineMetaMap,
+        graphSpine,
+        facetStates,
+        ctx,
+        visibleSpineIds,
+        organizationModel
+      )
+    );
+  }, [facetStates, favorites, graph, graphSpine, knowledgeNodes, omRooted, organizationModel]);
+  const initialExpandedState = useMemo(() => getInitialExpandedState(treeData, omRooted), [treeData, omRooted]);
+  const treeController = useTree({ initialExpandedState });
+  const leafNodeMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const node of knowledgeNodes) {
+      map.set(node.id, node);
+    }
+    return map;
+  }, [knowledgeNodes]);
+  const graphNodeMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const graphNode of graph.nodes) {
+      map.set(graphNode.id, graphNode);
+    }
+    return map;
+  }, [graph]);
+  if (treeData.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", style: { padding: "var(--mantine-spacing-md)" }, children: omRooted ? "No OM domains in model." : `No ${spine} spine nodes in graph.` });
+  }
+  return /* @__PURE__ */ jsx(
+    Tree,
+    {
+      data: treeData,
+      tree: treeController,
+      style: { padding: "var(--mantine-spacing-xs)" },
+      renderNode: ({ node, expanded, hasChildren, elementProps }) => {
+        const value = node.value;
+        const typedNode = node;
+        const decoratedElementProps = {
+          ...elementProps,
+          "data-tree-row-value": typeof value === "string" ? value : void 0
+        };
+        if (typedNode.nodeType === "group") {
+          const groupKey = typeof value === "string" ? value.slice(GROUP_PREFIX.length) : "";
+          const isActive2 = selectedNodeId === value;
+          const isQuickAccess = groupKey === QUICK_ACCESS_GROUP_KEY;
+          return /* @__PURE__ */ jsx(
+            DirectoryRow,
+            {
+              elementProps: decoratedElementProps,
+              expanded,
+              hasChildren,
+              label: String(node.label),
+              iconToken: GROUP_ICON_TOKENS[groupKey] ?? typedNode.icon,
+              command: isQuickAccess ? "" : getKnowledgeDirectoryCommand(
+                typedNode.knowledgeNodeIds,
+                getKnowledgeReadTreeFolderCommand(`${GROUP_PREFIX}${groupKey}`)
+              ),
+              isActive: isActive2,
+              fallbackKind: "organization",
+              uppercase: true,
+              onSelectGraphNode: isQuickAccess ? void 0 : onSelectGroup ? () => onSelectGroup(groupKey) : void 0,
+              favorite: isQuickAccess ? void 0 : {
+                routeId: `${GROUP_PREFIX}${groupKey}`,
+                label: String(node.label),
+                kind: "group",
+                iconToken: typedNode.icon
+              }
+            }
+          );
+        }
+        if (typedNode.nodeType === "favorite" && typedNode.favoriteRouteId && typedNode.favoriteKind) {
+          const routeId = typedNode.favoriteRouteId;
+          const favoriteKind = typedNode.favoriteKind;
+          return /* @__PURE__ */ jsx(
+            FavoriteRow,
+            {
+              elementProps: decoratedElementProps,
+              label: String(node.label),
+              routeId,
+              kind: favoriteKind,
+              iconToken: typedNode.icon,
+              onActivate: () => {
+                dispatchFavoriteSelection(routeId, favoriteKind, typedNode, {
+                  onSelectNode,
+                  onSelectGraphNode,
+                  onSelectGroup,
+                  onSelectDomain,
+                  onSelectItem,
+                  leafNodeMap,
+                  graphNodeMap
+                });
+                focusFavoriteInTree(treeData, treeController, { routeId, kind: favoriteKind });
+              }
+            }
+          );
+        }
+        if (typedNode.nodeType === "domain" && typedNode.domainKey) {
+          const domainKey = typedNode.domainKey;
+          const isActive2 = selectedNodeId === `${DOMAIN_PREFIX}${domainKey}`;
+          return /* @__PURE__ */ jsx(
+            DirectoryRow,
+            {
+              elementProps: decoratedElementProps,
+              expanded,
+              hasChildren,
+              label: String(node.label),
+              iconToken: void 0,
+              command: getKnowledgeDirectoryCommand(
+                typedNode.knowledgeNodeIds,
+                getKnowledgeReadTreeFolderCommand(`${DOMAIN_PREFIX}${domainKey}`)
+              ),
+              isActive: isActive2,
+              fallbackKind: "organization",
+              uppercase: true,
+              onSelectGraphNode: onSelectDomain ? () => onSelectDomain(domainKey) : void 0,
+              favorite: {
+                routeId: `${DOMAIN_PREFIX}${domainKey}`,
+                label: String(node.label),
+                kind: "domain"
+              }
+            }
+          );
+        }
+        if (typedNode.nodeType === "item" && typedNode.domainKey && typedNode.itemId) {
+          const graphNode2 = typedNode.graphNodeId ? graphNodeMap.get(typedNode.graphNodeId) : void 0;
+          const itemRouteId = `${ITEM_PREFIX}${typedNode.domainKey}:${typedNode.itemId}`;
+          const routeToDomainPanel = shouldRouteItemToDomainPanel(typedNode.domainKey);
+          const fallbackCommand = graphNode2?.kind === "knowledge" && graphNode2.sourceId ? getKnowledgeReadCommand(graphNode2.sourceId) : graphNode2 ? getKnowledgeReadTreeFolderCommand(`graph:${graphNode2.id}`) : getKnowledgeReadTreeFolderCommand(itemRouteId);
+          const isActive2 = selectedNodeId !== void 0 && (selectedNodeId === itemRouteId || selectedNodeId === typedNode.itemId || selectedNodeId === typedNode.graphNodeId || graphNode2 !== void 0 && (selectedNodeId === graphNode2.id || selectedNodeId === graphNode2.sourceId));
+          return /* @__PURE__ */ jsx(
+            DirectoryRow,
+            {
+              elementProps: decoratedElementProps,
+              expanded,
+              hasChildren,
+              label: String(node.label),
+              iconToken: typedNode.icon ?? graphNode2?.icon,
+              command: getKnowledgeDirectoryCommand(typedNode.knowledgeNodeIds, fallbackCommand),
+              isActive: isActive2,
+              fallbackKind: graphNode2?.kind ?? "organization",
+              onSelectGraphNode: routeToDomainPanel && onSelectItem ? () => onSelectItem(typedNode.domainKey ?? "", typedNode.itemId ?? "") : graphNode2 ? () => onSelectGraphNode?.(graphNode2) : onSelectItem ? () => onSelectItem(typedNode.domainKey ?? "", typedNode.itemId ?? "") : void 0,
+              favorite: {
+                routeId: itemRouteId,
+                label: String(node.label),
+                kind: "item",
+                iconToken: typedNode.icon ?? graphNode2?.icon
+              }
+            }
+          );
+        }
+        if (typeof value === "string" && value.startsWith(LEAF_PREFIX)) {
+          const knowledgeNodeId = value.split("::").at(-1);
+          const knowledgeNode = knowledgeNodeId ? leafNodeMap.get(knowledgeNodeId) : void 0;
+          if (!knowledgeNode) return null;
+          return /* @__PURE__ */ jsx(
+            KnowledgeLeafRow,
+            {
+              elementProps: decoratedElementProps,
+              knowledgeNode,
+              isActive: knowledgeNode.id === selectedNodeId,
+              onSelectNode
+            }
+          );
+        }
+        if (typeof value === "string" && value.startsWith(FOLDER_PREFIX)) {
+          return /* @__PURE__ */ jsx(
+            DirectoryRow,
+            {
+              elementProps: decoratedElementProps,
+              expanded,
+              hasChildren,
+              label: String(node.label),
+              iconToken: typedNode.icon,
+              command: getKnowledgeDirectoryCommand(
+                typedNode.knowledgeNodeIds,
+                getKnowledgeReadTreeFolderCommand(String(value))
+              ),
+              isActive: false
+            }
+          );
+        }
+        if (typedNode.nodeType === "graph" && typedNode.graphNodeId) {
+          const graphNode2 = graphNodeMap.get(typedNode.graphNodeId);
+          if (!graphNode2) return null;
+          const isActive2 = selectedNodeId !== void 0 && (selectedNodeId === graphNode2.id || selectedNodeId === graphNode2.sourceId);
+          return /* @__PURE__ */ jsx(
+            DirectoryRow,
+            {
+              elementProps: decoratedElementProps,
+              expanded,
+              hasChildren,
+              label: String(node.label),
+              iconToken: typedNode.icon,
+              command: getKnowledgeReadTreeFolderCommand(`graph:${graphNode2.id}`),
+              isActive: isActive2,
+              fallbackKind: graphNode2.kind,
+              onSelectGraphNode: () => onSelectGraphNode?.(graphNode2),
+              favorite: {
+                routeId: graphNode2.id,
+                label: graphNode2.label,
+                kind: "graph",
+                iconToken: typedNode.icon ?? graphNode2.icon
+              }
+            }
+          );
+        }
+        const graphNodeId = typedNode.graphNodeId ?? String(value).replace(SPINE_PREFIX, "");
+        const graphNode = graphNodeMap.get(graphNodeId);
+        const isActive = selectedNodeId !== void 0 && graphNode !== void 0 && (selectedNodeId === graphNode.id || selectedNodeId === graphNode.sourceId || selectedNodeId === graphNodeId);
+        return /* @__PURE__ */ jsx(
+          DirectoryRow,
+          {
+            elementProps: decoratedElementProps,
+            expanded,
+            hasChildren,
+            label: String(node.label),
+            iconToken: typedNode.icon,
+            command: graphSpine ? getKnowledgeReadSpineFolderCommand(graphSpine, graphNode?.sourceId ?? graphNodeId) : "",
+            isActive,
+            fallbackKind: graphNode?.kind ?? "system",
+            uppercase: true,
+            onSelectGraphNode: graphNode ? () => onSelectGraphNode?.(graphNode) : void 0,
+            favorite: graphNode ? {
+              routeId: graphNode.id,
+              label: graphNode.label,
+              kind: "graph",
+              iconToken: typedNode.icon ?? graphNode.icon
+            } : void 0
+          }
+        );
+      }
+    }
+  );
+}
+function FavoriteStarControl({ routeId, label, kind, iconToken, hovered }) {
+  const isFavorited = useKnowledgeFavoritesStore((state) => Boolean(state.favorites[routeId]));
+  const toggleFavorite = useKnowledgeFavoritesStore((state) => state.toggleFavorite);
+  const visible = hovered || isFavorited;
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      role: "button",
+      tabIndex: visible ? 0 : -1,
+      "aria-hidden": !visible,
+      "aria-pressed": isFavorited,
+      "aria-label": isFavorited ? `Unfavorite ${label}` : `Favorite ${label}`,
+      onClick: (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        toggleFavorite({ routeId, label, kind, iconToken });
+      },
+      onKeyDown: (event) => {
+        if (event.key !== "Enter" && event.key !== " ") return;
+        event.preventDefault();
+        event.stopPropagation();
+        toggleFavorite({ routeId, label, kind, iconToken });
+      },
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center",
+        width: 22,
+        height: 22,
+        flexShrink: 0,
+        opacity: visible ? 1 : 0,
+        pointerEvents: visible ? "auto" : "none",
+        color: isFavorited ? "var(--mantine-color-yellow-5)" : "var(--color-text-subtle)",
+        transition: "opacity 120ms ease, color 120ms ease"
+      },
+      children: isFavorited ? /* @__PURE__ */ jsx(IconStarFilled, { size: 14 }) : /* @__PURE__ */ jsx(IconStar, { size: 14 })
+    }
+  );
+}
+function focusFavoriteInTree(treeData, controller, favorite) {
+  const path = findFavoritePathInTree(treeData, favorite);
+  if (!path || path.length === 0) return;
+  for (let i = 0; i < path.length - 1; i++) {
+    controller.expand(path[i]);
+  }
+  const targetValue = path[path.length - 1];
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  const escape = (raw) => typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(raw) : raw.replace(/"/g, '\\"');
+  window.requestAnimationFrame(() => {
+    window.requestAnimationFrame(() => {
+      const el = document.querySelector(`[data-tree-row-value="${escape(targetValue)}"]`);
+      if (el instanceof HTMLElement) {
+        el.scrollIntoView({ behavior: "smooth", block: "center" });
+      }
+    });
+  });
+}
+function dispatchFavoriteSelection(routeId, kind, typedNode, ctx) {
+  if (kind === "group" && routeId.startsWith(GROUP_PREFIX)) {
+    ctx.onSelectGroup?.(routeId.slice(GROUP_PREFIX.length));
+    return;
+  }
+  if (kind === "domain" && routeId.startsWith(DOMAIN_PREFIX)) {
+    ctx.onSelectDomain?.(routeId.slice(DOMAIN_PREFIX.length));
+    return;
+  }
+  if (kind === "item" && routeId.startsWith(ITEM_PREFIX)) {
+    const rest = routeId.slice(ITEM_PREFIX.length);
+    const sepIndex = rest.indexOf(":");
+    if (sepIndex > 0) {
+      ctx.onSelectItem?.(rest.slice(0, sepIndex), rest.slice(sepIndex + 1));
+    }
+    return;
+  }
+  if (kind === "graph") {
+    const graphNode = ctx.graphNodeMap.get(routeId);
+    if (graphNode) ctx.onSelectGraphNode?.(graphNode);
+    return;
+  }
+  if (kind === "knowledge") {
+    const knowledgeNode = ctx.leafNodeMap.get(routeId);
+    if (knowledgeNode) ctx.onSelectNode(knowledgeNode);
+  }
+}
+function FavoriteRow({ elementProps, label, routeId, kind, iconToken, onActivate }) {
+  const [hovered, setHovered] = useState(false);
+  return /* @__PURE__ */ jsx(
+    UnstyledButton,
+    {
+      ...elementProps,
+      onMouseEnter: (event) => {
+        elementProps.onMouseEnter?.(event);
+        setHovered(true);
+      },
+      onMouseLeave: (event) => {
+        elementProps.onMouseLeave?.(event);
+        setHovered(false);
+      },
+      onClick: () => onActivate(),
+      style: {
+        ...elementProps.style ?? {},
+        padding: "5px 8px 5px 24px",
+        borderRadius: "var(--mantine-radius-sm)",
+        backgroundColor: hovered ? "var(--color-surface-hover)" : "transparent",
+        width: "100%",
+        textAlign: "left",
+        display: "block"
+      },
+      children: /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "nowrap", children: [
+        /* @__PURE__ */ jsx(
+          SemanticIcon,
+          {
+            token: iconToken,
+            fallbackKind: kind === "knowledge" ? "knowledge" : "unknown",
+            size: 15,
+            style: { color: SIDEBAR_TREE_ACCENT_COLOR }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            size: "sm",
+            c: hovered ? "var(--color-text)" : void 0,
+            style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TrailingCopySlot,
+          {
+            command: "",
+            label: "",
+            showCopy: false,
+            favorite: { routeId, label, kind, iconToken },
+            hovered
+          }
+        )
+      ] })
+    }
+  );
+}
+function CopyCommandControl({ command, label, visible }) {
+  const clipboard = useClipboard({ timeout: 1500 });
+  if (!command) return null;
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      role: "button",
+      tabIndex: visible ? 0 : -1,
+      "aria-hidden": !visible,
+      "aria-label": label,
+      onClick: (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        clipboard.copy(command);
+      },
+      onKeyDown: (event) => {
+        if (event.key !== "Enter" && event.key !== " ") return;
+        event.preventDefault();
+        event.stopPropagation();
+        clipboard.copy(command);
+      },
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "center",
+        width: 22,
+        height: 22,
+        flexShrink: 0,
+        opacity: visible ? 1 : 0,
+        pointerEvents: visible ? "auto" : "none",
+        color: clipboard.copied ? "var(--color-primary)" : "var(--color-text-subtle)",
+        transition: "opacity 120ms ease, color 120ms ease"
+      },
+      children: clipboard.copied ? /* @__PURE__ */ jsx(IconCheck, { size: 14 }) : /* @__PURE__ */ jsx(IconCopy, { size: 14 })
+    }
+  );
+}
+function KnowledgeLeafRow({ elementProps, knowledgeNode, isActive, onSelectNode }) {
+  const [hovered, setHovered] = useState(false);
+  return /* @__PURE__ */ jsx(
+    UnstyledButton,
+    {
+      ...elementProps,
+      onMouseEnter: (event) => {
+        elementProps.onMouseEnter?.(event);
+        setHovered(true);
+      },
+      onMouseLeave: (event) => {
+        elementProps.onMouseLeave?.(event);
+        setHovered(false);
+      },
+      onClick: () => onSelectNode(knowledgeNode),
+      style: {
+        ...elementProps.style ?? {},
+        padding: "5px 8px 5px 24px",
+        borderRadius: "var(--mantine-radius-sm)",
+        backgroundColor: isActive ? "color-mix(in srgb, var(--color-primary) 10%, transparent)" : hovered ? "var(--color-surface-hover)" : "transparent",
+        width: "100%",
+        textAlign: "left",
+        display: "block"
+      },
+      children: /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "nowrap", children: [
+        /* @__PURE__ */ jsx(
+          SemanticIcon,
+          {
+            token: getKnowledgeIconToken(knowledgeNode),
+            fallbackKind: knowledgeNode.kind,
+            size: 15,
+            style: { color: SIDEBAR_TREE_ACCENT_COLOR }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            size: "sm",
+            c: isActive ? "var(--color-primary)" : hovered ? "var(--color-text)" : void 0,
+            fw: isActive ? 600 : 400,
+            style: { flex: 1, minWidth: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+            children: knowledgeNode.title
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TrailingCopySlot,
+          {
+            command: getKnowledgeReadCommand(knowledgeNode.id),
+            label: "Copy knowledge command",
+            showCopy: hovered,
+            favorite: {
+              routeId: knowledgeNode.id,
+              label: knowledgeNode.title,
+              kind: "knowledge",
+              iconToken: getKnowledgeIconToken(knowledgeNode)
+            },
+            hovered
+          }
+        )
+      ] })
+    }
+  );
+}
+function DirectoryRow({
+  elementProps,
+  expanded,
+  hasChildren,
+  label,
+  iconToken,
+  command,
+  isActive,
+  fallbackKind = "system",
+  uppercase = false,
+  onSelectGraphNode,
+  favorite
+}) {
+  const [hovered, setHovered] = useState(false);
+  return /* @__PURE__ */ jsxs(
+    Group,
+    {
+      ...elementProps,
+      gap: "xs",
+      onMouseEnter: (event) => {
+        elementProps.onMouseEnter?.(event);
+        setHovered(true);
+      },
+      onMouseLeave: (event) => {
+        elementProps.onMouseLeave?.(event);
+        setHovered(false);
+      },
+      onClick: (event) => {
+        if (onSelectGraphNode) {
+          if (isActive && expanded) {
+            elementProps.onClick?.(event);
+          } else {
+            if (!expanded) elementProps.onClick?.(event);
+            onSelectGraphNode();
+          }
+        } else {
+          elementProps.onClick?.(event);
+        }
+      },
+      style: {
+        ...elementProps.style ?? {},
+        padding: "4px 8px",
+        borderRadius: "var(--mantine-radius-sm)",
+        backgroundColor: isActive ? "color-mix(in srgb, var(--color-primary) 10%, transparent)" : hovered ? "var(--color-surface-hover)" : "transparent",
+        cursor: onSelectGraphNode || hasChildren ? "pointer" : "default",
+        userSelect: "none"
+      },
+      children: [
+        hasChildren ? /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": "true",
+            style: {
+              display: "inline-flex",
+              alignItems: "center",
+              justifyContent: "center",
+              width: 12,
+              height: 12,
+              color: SIDEBAR_TREE_ACCENT_COLOR,
+              flexShrink: 0
+            },
+            children: expanded ? /* @__PURE__ */ jsx(IconChevronDown, { size: 12, stroke: 2 }) : /* @__PURE__ */ jsx(IconChevronRight, { size: 12, stroke: 2 })
+          }
+        ) : /* @__PURE__ */ jsx(Text, { size: "xs", style: { width: 12, flexShrink: 0 } }),
+        /* @__PURE__ */ jsx(
+          SemanticIcon,
+          {
+            token: iconToken,
+            fallbackKind: fallbackKind !== void 0 ? toSemanticFallbackKind(fallbackKind) : "unknown",
+            size: 14,
+            style: { color: SIDEBAR_TREE_ACCENT_COLOR }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            size: "sm",
+            fw: isActive ? 700 : 600,
+            tt: uppercase ? "uppercase" : void 0,
+            c: isActive ? "var(--color-primary)" : hovered ? "var(--color-text)" : void 0,
+            style: {
+              letterSpacing: uppercase ? "0.05em" : 0,
+              flex: 1,
+              minWidth: 0,
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap"
+            },
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TrailingCopySlot,
+          {
+            command,
+            label: "Copy folder knowledge commands",
+            showCopy: hovered,
+            favorite,
+            hovered
+          }
+        )
+      ]
+    }
+  );
+}
+function TrailingCopySlot({ command, label, showCopy, favorite, hovered }) {
+  const isFavorited = useKnowledgeFavoritesStore(
+    (state) => favorite ? Boolean(state.favorites[favorite.routeId]) : false
+  );
+  const favoriteVisible = Boolean(favorite) && (hovered || isFavorited);
+  const copyVisible = showCopy && Boolean(command);
+  if (!favoriteVisible && !copyVisible) return null;
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        justifyContent: "flex-end",
+        gap: 2,
+        height: 22,
+        flexShrink: 0
+      },
+      children: [
+        copyVisible ? /* @__PURE__ */ jsx(CopyCommandControl, { command, label, visible: true }) : null,
+        favoriteVisible && favorite ? /* @__PURE__ */ jsx(
+          FavoriteStarControl,
+          {
+            routeId: favorite.routeId,
+            label: favorite.label,
+            kind: favorite.kind,
+            iconToken: favorite.iconToken,
+            hovered: true
+          }
+        ) : null
+      ]
+    }
+  );
+}
+var indexPromise = null;
+function loadSearchIndex() {
+  if (!indexPromise) {
+    indexPromise = import('./knowledge-search-index-5KYPO746.js').then(
+      (mod) => buildSearchIndex(mod.default ?? mod)
+    );
+  }
+  return indexPromise;
+}
+function buildSearchIndex(entries) {
+  return {
+    search(query) {
+      if (!query.trim()) return [];
+      const q = query.trim().toLowerCase();
+      const scored = [];
+      for (const entry of entries) {
+        let score = 0;
+        if (entry.title.toLowerCase().includes(q)) score += 3;
+        if (entry.summary.toLowerCase().includes(q)) score += 2;
+        if (entry.bodyText.toLowerCase().includes(q)) score += 1;
+        if (score > 0) scored.push({ id: entry.id, score });
+      }
+      return scored.sort((a, b) => b.score - a.score).map((s) => s.id);
+    }
+  };
+}
+function KnowledgeSearchBar({
+  knowledgeNodes,
+  onResults,
+  placeholder = "Search knowledge\u2026"
+}) {
+  const [query, setQuery] = useState("");
+  const indexRef = useRef(null);
+  const nodeMapRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const node of knowledgeNodes) map.set(node.id, node);
+    nodeMapRef.current = map;
+  }, [knowledgeNodes]);
+  const handleChange = (value) => {
+    setQuery(value);
+    if (!value.trim()) {
+      onResults(null);
+      return;
+    }
+    if (indexRef.current) {
+      runSearch(value, indexRef.current);
+      return;
+    }
+    void loadSearchIndex().then((index) => {
+      indexRef.current = index;
+      if (query.trim() || value.trim()) runSearch(value, index);
+    });
+  };
+  function runSearch(value, index) {
+    const ids = index.search(value);
+    const hits = ids.flatMap((id) => {
+      const node = nodeMapRef.current.get(id);
+      return node ? [node] : [];
+    });
+    onResults(hits);
+  }
+  const handleClear = () => {
+    setQuery("");
+    onResults(null);
+  };
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      value: query,
+      onChange: (e) => handleChange(e.currentTarget.value),
+      placeholder,
+      leftSection: /* @__PURE__ */ jsx(IconSearch, { size: 16 }),
+      rightSection: query ? /* @__PURE__ */ jsx(IconX, { size: 14, style: { cursor: "pointer", color: "var(--color-text-subtle)" }, onClick: handleClear }) : null,
+      styles: {
+        input: {
+          backgroundColor: "var(--color-surface)",
+          borderColor: "var(--color-border)",
+          color: "var(--color-text)"
+        }
+      }
+    }
+  );
+}
+
+export { KNOWLEDGE_DOMAINS_WITH_PANELS, KNOWLEDGE_ICON_TOKEN_BY_KIND, KnowledgeSearchBar, KnowledgeTree, OM_TREE_GROUPS, getKnowledgeIconToken, getSharedOrganizationGraph, projectNavigationGroups, projectNavigationSurfaces };