@elevasis/ui 2.31.0 → 2.33.0

package/dist/chunk-YAQ25UNM.js

@@ -0,0 +1,2126 @@
+import { SemanticIcon } from './chunk-DWXDNT7P.js';
+import { buildOrganizationGraph, projectOrganizationSurfaces, compileOrganizationOntology, getSortedSidebarEntries, parseOntologyId, getSystem, resolveSystemConfig } from './chunk-GNRMB6DC.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: "playbook",
+  strategy: "strategy",
+  reference: "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")
+  ];
+}
+
+// src/knowledge/ontologyProjection.ts
+var DOMAIN_LABELS = {
+  "ontology-objects": "Objects",
+  "ontology-links": "Links",
+  "ontology-actions": "Actions",
+  "ontology-catalogs": "Catalogs",
+  "ontology-events": "Events",
+  "ontology-interfaces": "Interfaces",
+  "ontology-value-types": "Value Types",
+  "ontology-properties": "Shared Properties",
+  "ontology-groups": "Groups",
+  "ontology-surfaces": "Surfaces",
+  "ontology-resources": "Resources"
+};
+function titleFromId(id) {
+  const localId = id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id;
+  return localId.replace(/[-_.]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function isLegacyBridgeRecord(record) {
+  return typeof record["legacyEntityId"] === "string" || typeof record["legacyActionId"] === "string" || typeof record["legacyContentId"] === "string";
+}
+function ontologyItem(id, record, fallbackKind) {
+  let parsed;
+  try {
+    parsed = parseOntologyId(id);
+  } catch {
+    parsed = void 0;
+  }
+  const ownerSystemId = typeof record["ownerSystemId"] === "string" ? record["ownerSystemId"] : parsed?.isGlobal === false ? parsed.scope : void 0;
+  const meta = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (["id", "label", "description", "ownerSystemId", "aliases"].includes(key)) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      meta[key] = value;
+    }
+  }
+  return {
+    id,
+    label: typeof record["label"] === "string" ? record["label"] : titleFromId(id),
+    description: typeof record["description"] === "string" ? record["description"] : void 0,
+    kind: parsed?.kind ?? fallbackKind,
+    ownerSystemId,
+    source: isLegacyBridgeRecord(record) ? "legacy-bridge" : "ontology",
+    meta
+  };
+}
+function sortItems(items) {
+  return [...items].sort(
+    (left, right) => (left.ownerSystemId ?? "").localeCompare(right.ownerSystemId ?? "") || left.label.localeCompare(right.label) || left.id.localeCompare(right.id)
+  );
+}
+function resourceDescription(resource) {
+  return resource.codeRefs.find((codeRef) => codeRef.description !== void 0)?.description;
+}
+function getKnowledgeOntologyProjection(model) {
+  const compiled = compileOrganizationOntology(model);
+  return {
+    objects: sortItems(
+      Object.entries(compiled.ontology.objectTypes).map(
+        ([id, record]) => ontologyItem(id, record, "object")
+      )
+    ),
+    links: sortItems(
+      Object.entries(compiled.ontology.linkTypes).map(
+        ([id, record]) => ontologyItem(id, record, "link")
+      )
+    ),
+    actions: sortItems(
+      Object.entries(compiled.ontology.actionTypes).map(
+        ([id, record]) => ontologyItem(id, record, "action")
+      )
+    ),
+    catalogs: sortItems(
+      Object.entries(compiled.ontology.catalogTypes).map(
+        ([id, record]) => ontologyItem(id, record, "catalog")
+      )
+    ),
+    events: sortItems(
+      Object.entries(compiled.ontology.eventTypes).map(
+        ([id, record]) => ontologyItem(id, record, "event")
+      )
+    ),
+    interfaces: sortItems(
+      Object.entries(compiled.ontology.interfaceTypes).map(
+        ([id, record]) => ontologyItem(id, record, "interface")
+      )
+    ),
+    valueTypes: sortItems(
+      Object.entries(compiled.ontology.valueTypes).map(
+        ([id, record]) => ontologyItem(id, record, "value-type")
+      )
+    ),
+    properties: sortItems(
+      Object.entries(compiled.ontology.sharedProperties).map(
+        ([id, record]) => ontologyItem(id, record, "property")
+      )
+    ),
+    groups: sortItems(
+      Object.entries(compiled.ontology.groups).map(
+        ([id, record]) => ontologyItem(id, record, "group")
+      )
+    ),
+    surfaces: sortItems(
+      Object.entries(compiled.ontology.surfaces).map(
+        ([id, record]) => ontologyItem(id, record, "surface")
+      )
+    ),
+    resources: sortItems(
+      Object.values(model.resources ?? {}).map((resource) => ({
+        id: resource.id,
+        label: resource.id,
+        description: resourceDescription(resource),
+        kind: "resource",
+        ownerSystemId: resource.systemPath,
+        source: "resource",
+        meta: { type: resource.kind, status: resource.status }
+      }))
+    ),
+    diagnosticsCount: compiled.diagnostics.length
+  };
+}
+function getOntologyItemsForDomain(projection, domainKey) {
+  switch (domainKey) {
+    case "ontology-objects":
+      return projection.objects;
+    case "ontology-links":
+      return projection.links;
+    case "ontology-actions":
+      return projection.actions;
+    case "ontology-catalogs":
+      return projection.catalogs;
+    case "ontology-events":
+      return projection.events;
+    case "ontology-interfaces":
+      return projection.interfaces;
+    case "ontology-value-types":
+      return projection.valueTypes;
+    case "ontology-properties":
+      return projection.properties;
+    case "ontology-groups":
+      return projection.groups;
+    case "ontology-surfaces":
+      return projection.surfaces;
+    case "ontology-resources":
+      return projection.resources;
+    default:
+      return [];
+  }
+}
+function getPrimaryOntologyItemsForDomain(projection, domainKey) {
+  return getOntologyItemsForDomain(projection, domainKey).filter((item) => item.source !== "legacy-bridge");
+}
+function getOntologyDomainLabel(domainKey) {
+  return DOMAIN_LABELS[domainKey] ?? "Ontology";
+}
+
+// src/knowledge/knowledgeCopyCommands.ts
+function stripGraphKindPrefix(id, kind) {
+  const prefix = `${kind}:`;
+  return id.startsWith(prefix) ? id.slice(prefix.length) : id;
+}
+function normalizeKnowledgeNodeId(nodeId) {
+  return nodeId.startsWith("knowledge:") ? nodeId.slice("knowledge:".length) : nodeId;
+}
+function getKnowledgeNodeReadCommand(nodeId) {
+  return `/knowledge read ${normalizeKnowledgeNodeId(nodeId)}`;
+}
+function getKnowledgeNodeReadCommands(nodeIds) {
+  return [...new Set(nodeIds)].map(getKnowledgeNodeReadCommand).join("\n");
+}
+function getKnowledgeFolderCommand(kind, id) {
+  return `/knowledge read-folder ${kind}:${id}`;
+}
+function getKnowledgeTreeFolderCommand(treeValue) {
+  return `/knowledge read-folder ${treeValue}`;
+}
+function getKnowledgeDomainFolderCommand(domainKey) {
+  return getKnowledgeFolderCommand("domain", domainKey);
+}
+function getKnowledgeGraphFolderCommand(graphNodeId) {
+  return getKnowledgeFolderCommand("graph", graphNodeId);
+}
+function getKnowledgeSpineFolderCommand(spine, id) {
+  const bareId = stripGraphKindPrefix(id, spine);
+  if (spine === "system") return getKnowledgeFolderCommand("system", bareId);
+  if (spine === "ontology") return getKnowledgeFolderCommand("ontology", bareId);
+  return getKnowledgeGraphFolderCommand(`${spine}:${bareId}`);
+}
+function getKnowledgeGraphNodeCommand(node) {
+  if (node.kind === "knowledge") {
+    return getKnowledgeNodeReadCommand(node.sourceId ?? node.id);
+  }
+  if (node.kind === "system") {
+    return getKnowledgeFolderCommand("system", node.sourceId ?? stripGraphKindPrefix(node.id, "system"));
+  }
+  if (node.kind === "ontology") {
+    return getKnowledgeFolderCommand("ontology", node.sourceId ?? stripGraphKindPrefix(node.id, "ontology"));
+  }
+  return getKnowledgeGraphFolderCommand(node.id);
+}
+function graphKindToFallbackToken(kind) {
+  switch (kind) {
+    case "knowledge":
+      return "reference";
+    case "resource":
+      return "workflow";
+    case "action":
+      return "view";
+    case "entity":
+    case "event":
+      return "database";
+    case "policy":
+      return "shield";
+    case "system":
+      return "operations";
+    case "role":
+      return "user";
+    case "stage":
+      return "pending";
+    case "organization":
+      return "building";
+    default:
+      return "info";
+  }
+}
+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",
+  resources: "resources",
+  knowledge: "knowledge",
+  navigation: "view",
+  "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: "Ontology",
+    domains: [
+      "ontology-objects",
+      "ontology-links",
+      "ontology-actions",
+      "ontology-catalogs",
+      "ontology-events",
+      "ontology-interfaces",
+      "ontology-value-types",
+      "ontology-properties",
+      "ontology-groups",
+      "ontology-surfaces"
+    ]
+  },
+  { key: "resources", label: "Resources", domains: ["resources"] },
+  { key: "knowledge", label: "Knowledge", domains: ["knowledge"] },
+  { key: "navigation", label: "Navigation", domains: ["navigation"] },
+  { key: "governance-wiring", label: "Governance", domains: ["roles", "policies"] }
+];
+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 "ontology":
+    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 CORE_ONTOLOGY_DOMAIN_KEYS = [
+  "ontology-objects",
+  "ontology-links",
+  "ontology-actions",
+  "ontology-catalogs",
+  "ontology-events",
+  "ontology-surfaces"
+];
+var OPTIONAL_ONTOLOGY_DOMAIN_KEYS = [
+  "ontology-interfaces",
+  "ontology-value-types",
+  "ontology-properties",
+  "ontology-groups"
+];
+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",
+  "navigation",
+  "policies",
+  "ontology-objects",
+  "ontology-links",
+  "ontology-actions",
+  "ontology-catalogs",
+  "ontology-events",
+  "ontology-interfaces",
+  "ontology-value-types",
+  "ontology-properties",
+  "ontology-groups",
+  "ontology-surfaces"
+]);
+var FILTERABLE_DOMAIN_KEYS = /* @__PURE__ */ new Set(["customers", "offerings", "goals", "roles", "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 hasSystemModelChildren = spine === "system" && [
+    ...buildOntologySubgroup(bareId, organizationModel),
+    ...buildSystemResourcesSubgroup(bareId, ctx),
+    ...buildSystemConfigSubgroup(bareId, organizationModel),
+    ...buildSystemGovernanceSubgroup(bareId, organizationModel)
+  ].length > 0;
+  let result = hasSystemModelChildren || 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 getKnowledgeDirectoryCommand(nodeIds, fallbackCommand) {
+  const command = getKnowledgeNodeReadCommands(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 formatTreeLabel(value) {
+  const spaced = value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._/-]+/g, " ").trim();
+  if (!spaced) return value;
+  return spaced.split(/\s+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function treeValueSegment(value) {
+  return value.replace(/[^A-Za-z0-9_.-]/g, "-");
+}
+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: "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
+  };
+}
+function buildOntologySubgroup(bareId, organizationModel) {
+  if (!organizationModel) return [];
+  const projection = getKnowledgeOntologyProjection(organizationModel);
+  const domainKeys = [...CORE_ONTOLOGY_DOMAIN_KEYS, ...OPTIONAL_ONTOLOGY_DOMAIN_KEYS];
+  const domainFolders = domainKeys.map((domainKey) => {
+    const items = getPrimaryOntologyItemsForDomain(projection, domainKey).filter(
+      (item) => item.ownerSystemId === bareId
+    );
+    if (items.length === 0) return void 0;
+    return {
+      value: `${FOLDER_PREFIX}ontology:${bareId}:${domainKey}`,
+      label: getOntologyDomainLabel(domainKey),
+      nodeType: "folder",
+      knowledgeNodeIds: [],
+      children: items.map(
+        (item) => createItemNode({
+          domainKey,
+          itemId: item.id,
+          label: item.label,
+          graphNodeId: item.kind === "resource" ? `resource:${item.id}` : `ontology:${item.id}`
+        })
+      )
+    };
+  }).filter((node) => node !== void 0);
+  if (domainFolders.length === 0) return [];
+  return [
+    {
+      value: `${FOLDER_PREFIX}ontology:${bareId}`,
+      label: "Ontology",
+      nodeType: "folder",
+      knowledgeNodeIds: [],
+      children: domainFolders
+    }
+  ];
+}
+function buildSystemResourcesSubgroup(bareId, ctx) {
+  const graphNodeId = `system:${bareId}`;
+  const resourceNodes = (ctx.edgesBySource.get(graphNodeId) ?? []).filter((edge) => edge.kind === "contains").map((edge) => ctx.nodesById.get(edge.targetId)).filter((node) => node?.kind === "resource").sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id));
+  if (resourceNodes.length === 0) return [];
+  const children = GRAPH_RESOURCE_TYPE_ORDER.map((resourceType) => {
+    const typedResources = resourceNodes.filter((node) => node.resourceType === resourceType);
+    if (typedResources.length === 0) return void 0;
+    return createCollectionNode(
+      `system:${bareId}:resources`,
+      resourceType,
+      GRAPH_RESOURCE_TYPE_LABELS[resourceType],
+      typedResources.map((node) => createGraphNodeItem(node, "resources"))
+    );
+  }).filter((node) => node !== void 0);
+  const unclassifiedResources = resourceNodes.filter((node) => node.resourceType === void 0);
+  if (unclassifiedResources.length > 0) {
+    children.push(
+      createCollectionNode(
+        `system:${bareId}:resources`,
+        "unknown",
+        "Unclassified",
+        unclassifiedResources.map((node) => createGraphNodeItem(node, "resources"))
+      )
+    );
+  }
+  return [
+    {
+      value: `${FOLDER_PREFIX}resources:${bareId}`,
+      label: "Resources",
+      nodeType: "folder",
+      icon: "workflow",
+      knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+      children
+    }
+  ];
+}
+function buildSystemConfigSubgroup(bareId, organizationModel) {
+  if (!organizationModel) return [];
+  const system = getSystem(organizationModel, bareId);
+  if (!system) return [];
+  const config = resolveSystemConfig(organizationModel, bareId);
+  const configKeys = Object.keys(config).sort((left, right) => left.localeCompare(right));
+  const children = [];
+  if (configKeys.length > 0) {
+    children.push({
+      value: `${FOLDER_PREFIX}config:${bareId}:defaults`,
+      label: "Defaults",
+      nodeType: "folder",
+      icon: "settings",
+      knowledgeNodeIds: [],
+      children: configKeys.map((key) => ({
+        value: `${FOLDER_PREFIX}config:${bareId}:defaults:${treeValueSegment(key)}`,
+        label: formatTreeLabel(key),
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      }))
+    });
+  }
+  const hasUiConfig = system.ui !== void 0 || system.path !== void 0 || system.icon !== void 0 || system.uiPosition !== void 0 || system.enabled !== void 0 || system.devOnly !== void 0 || system.requiresAdmin !== void 0;
+  if (hasUiConfig) {
+    const uiChildren = [];
+    if (system.ui?.path !== void 0 || system.path !== void 0) {
+      uiChildren.push({
+        value: `${FOLDER_PREFIX}config:${bareId}:ui:path`,
+        label: "Path",
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      });
+    }
+    if ((system.ui?.surfaces.length ?? 0) > 0) {
+      uiChildren.push({
+        value: `${FOLDER_PREFIX}config:${bareId}:ui:surfaces`,
+        label: "Surfaces",
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      });
+    }
+    if (system.ui?.icon !== void 0 || system.icon !== void 0) {
+      uiChildren.push({
+        value: `${FOLDER_PREFIX}config:${bareId}:ui:icon`,
+        label: "Icon",
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      });
+    }
+    if (system.uiPosition !== void 0) {
+      uiChildren.push({
+        value: `${FOLDER_PREFIX}config:${bareId}:ui:placement`,
+        label: "Placement",
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      });
+    }
+    if (system.enabled !== void 0 || system.devOnly !== void 0 || system.requiresAdmin !== void 0) {
+      uiChildren.push({
+        value: `${FOLDER_PREFIX}config:${bareId}:ui:access`,
+        label: "Access",
+        nodeType: "folder",
+        knowledgeNodeIds: []
+      });
+    }
+    children.push({
+      value: `${FOLDER_PREFIX}config:${bareId}:ui`,
+      label: "UI",
+      nodeType: "folder",
+      icon: "view",
+      knowledgeNodeIds: [],
+      children: uiChildren.length > 0 ? uiChildren : void 0
+    });
+  }
+  if (children.length === 0) return [];
+  return [
+    {
+      value: `${FOLDER_PREFIX}config:${bareId}`,
+      label: "Config",
+      nodeType: "folder",
+      icon: "settings",
+      knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+      children
+    }
+  ];
+}
+function buildSystemKnowledgeSubgroup(graphNodeId, governing) {
+  if (governing.length === 0) return [];
+  const children = createKnowledgeLeaves(graphNodeId, governing);
+  return [
+    {
+      value: `${FOLDER_PREFIX}knowledge:${graphNodeId}`,
+      label: "Knowledge",
+      nodeType: "folder",
+      icon: "reference",
+      knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+      children
+    }
+  ];
+}
+function buildSystemGovernanceSubgroup(bareId, organizationModel) {
+  if (!organizationModel) return [];
+  const system = getSystem(organizationModel, bareId);
+  if (!system) return [];
+  const roleIds = /* @__PURE__ */ new Set();
+  if (system.responsibleRoleId !== void 0) roleIds.add(system.responsibleRoleId);
+  for (const role of Object.values(organizationModel.roles ?? {})) {
+    if (role.responsibleFor?.includes(bareId)) roleIds.add(role.id);
+  }
+  const policyIds = new Set(system.policies ?? []);
+  for (const policy of Object.values(organizationModel.policies ?? {})) {
+    if (policy.appliesTo.systemIds.includes(bareId)) policyIds.add(policy.id);
+  }
+  const roles = Object.values(organizationModel.roles ?? {}).filter((role) => roleIds.has(role.id)).sort((left, right) => (left.order ?? 0) - (right.order ?? 0) || left.title.localeCompare(right.title));
+  const policies = Object.values(organizationModel.policies ?? {}).filter((policy) => policyIds.has(policy.id)).sort((left, right) => (left.order ?? 0) - (right.order ?? 0) || left.label.localeCompare(right.label));
+  const children = [];
+  if (roles.length > 0) {
+    children.push(
+      createCollectionNode(
+        `governance:${bareId}`,
+        "roles",
+        roles.length === 1 ? "Responsible Role" : "Responsible Roles",
+        roles.map(
+          (role) => createItemNode({
+            domainKey: "roles",
+            itemId: role.id,
+            label: role.title,
+            graphNodeId: `role:${role.id}`
+          })
+        )
+      )
+    );
+  }
+  if (policies.length > 0) {
+    children.push(
+      createCollectionNode(
+        `governance:${bareId}`,
+        "policies",
+        "Policies",
+        policies.map(
+          (policy) => createItemNode({
+            domainKey: "policies",
+            itemId: policy.id,
+            label: policy.label,
+            graphNodeId: `policy:${policy.id}`
+          })
+        )
+      )
+    );
+  }
+  if (children.length === 0) return [];
+  return [
+    {
+      value: `${FOLDER_PREFIX}governance:${bareId}`,
+      label: "Governance",
+      nodeType: "folder",
+      icon: "shield",
+      knowledgeNodeIds: children.flatMap(collectKnowledgeNodeIds),
+      children
+    }
+  ];
+}
+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 systemModelChildren = spine === "system" ? [
+    ...buildOntologySubgroup(bareId, organizationModel),
+    ...buildSystemResourcesSubgroup(bareId, ctx),
+    ...buildSystemConfigSubgroup(bareId, organizationModel),
+    ...buildSystemKnowledgeSubgroup(graphNodeId, governing),
+    ...buildSystemGovernanceSubgroup(bareId, organizationModel)
+  ] : [];
+  const childSpineNodes = childIds.filter((childId) => visibleSpineIds.has(childId)).map(
+    (childId) => buildSpineTreeNode(childId, allBareIds, spineMetaMap, spine, facetStates, ctx, visibleSpineIds, organizationModel)
+  );
+  const knowledgeLeaves = spine === "system" ? [] : createKnowledgeLeaves(graphNodeId, governing);
+  const facetLeaves = createFacetGraphLeaves(getIncludedFacetNodes(graphNodeId, spine, facetStates, ctx));
+  const children = [...systemModelChildren, ...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 buildOntologyBranch(organizationModel, domainKey) {
+  if (!organizationModel) return void 0;
+  const projection = getKnowledgeOntologyProjection(organizationModel);
+  const items = getPrimaryOntologyItemsForDomain(projection, domainKey);
+  if (items.length === 0) return void 0;
+  return createDomainNode({
+    domainKey,
+    label: getOntologyDomainLabel(domainKey),
+    children: items.map(
+      (item) => createItemNode({
+        domainKey,
+        itemId: item.id,
+        label: item.label,
+        children: [
+          {
+            value: `${FOLDER_PREFIX}${domainKey}:${item.id}:owner`,
+            label: item.ownerSystemId ?? "global",
+            nodeType: "folder",
+            icon: item.kind === "resource" ? "workflow" : "info",
+            knowledgeNodeIds: []
+          }
+        ]
+      })
+    )
+  });
+}
+function buildGraphGroup(organizationModel) {
+  const ontologyDomains = [...CORE_ONTOLOGY_DOMAIN_KEYS, ...OPTIONAL_ONTOLOGY_DOMAIN_KEYS].map((domainKey) => buildOntologyBranch(organizationModel, domainKey)).filter((node) => node !== void 0);
+  return createGroupNode({
+    groupKey: "graph",
+    label: "Ontology",
+    children: ontologyDomains
+  });
+}
+function buildResourcesGroup(graph) {
+  const resourceNodes = graph.nodes.filter((node) => node.kind === "resource").sort(
+    (left, right) => (left.resourceType ?? "").localeCompare(right.resourceType ?? "") || left.label.localeCompare(right.label) || left.id.localeCompare(right.id)
+  );
+  const children = GRAPH_RESOURCE_TYPE_ORDER.map((resourceType) => {
+    const typedResources = resourceNodes.filter((node) => node.resourceType === resourceType);
+    if (typedResources.length === 0) return void 0;
+    return createCollectionNode(
+      "resources",
+      resourceType,
+      GRAPH_RESOURCE_TYPE_LABELS[resourceType],
+      typedResources.map((node) => createGraphNodeItem(node, "resources"))
+    );
+  }).filter((node) => node !== void 0);
+  const orderedTypes = new Set(GRAPH_RESOURCE_TYPE_ORDER);
+  const otherResources = resourceNodes.filter(
+    (node) => node.resourceType === void 0 || !orderedTypes.has(node.resourceType)
+  );
+  if (otherResources.length > 0) {
+    children.push(
+      createCollectionNode(
+        "resources",
+        "other",
+        "Other",
+        otherResources.map((node) => createGraphNodeItem(node, "resources"))
+      )
+    );
+  }
+  return createGroupNode({
+    groupKey: "resources",
+    label: "Resources",
+    children
+  });
+}
+function formatOntologyKnowledgeTargetLabel(targetId, organizationModel) {
+  if (organizationModel) {
+    const projection = getKnowledgeOntologyProjection(organizationModel);
+    for (const domainKey of [...CORE_ONTOLOGY_DOMAIN_KEYS, ...OPTIONAL_ONTOLOGY_DOMAIN_KEYS]) {
+      const item = getPrimaryOntologyItemsForDomain(projection, domainKey).find((candidate) => candidate.id === targetId);
+      if (item) return item.label;
+    }
+  }
+  return formatTreeLabel(targetId.includes("/") ? targetId.slice(targetId.lastIndexOf("/") + 1) : targetId);
+}
+function createKnowledgeCollection(parentKey, collectionKey, label, nodes) {
+  return createCollectionNode(parentKey, collectionKey, label, createKnowledgeLeaves(`knowledge:${collectionKey}`, nodes));
+}
+function buildKnowledgeTargetCollections(knowledgeNodes, targetKind, parentKey, collectionLabel, formatTargetLabel) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const node of knowledgeNodes) {
+    for (const link of node.links) {
+      if (link.target.kind !== targetKind) continue;
+      const bucket = grouped.get(link.target.id) ?? [];
+      bucket.push(node);
+      grouped.set(link.target.id, bucket);
+    }
+  }
+  const children = [...grouped.entries()].sort(([left], [right]) => formatTargetLabel(left).localeCompare(formatTargetLabel(right))).map(
+    ([targetId, nodes]) => createCollectionNode(
+      `${parentKey}:${collectionKeyForTarget(targetKind)}`,
+      treeValueSegment(targetId),
+      formatTargetLabel(targetId),
+      uniqueKnowledgeNodes(nodes).map((node) => createKnowledgeLeaf(`knowledge:${targetKind}:${targetId}`, node))
+    )
+  );
+  if (children.length === 0) return void 0;
+  return createCollectionNode(parentKey, collectionKeyForTarget(targetKind), collectionLabel, children);
+}
+function collectionKeyForTarget(targetKind) {
+  return targetKind === "system" ? "by-system" : "by-ontology";
+}
+function buildKnowledgeGroup(graph, knowledgeNodes, organizationModel) {
+  const systemLabels = new Map(
+    graph.nodes.filter((node) => node.kind === "system").map((node) => [node.sourceId ?? node.id.replace(/^system:/, ""), node.label])
+  );
+  const sortedKnowledgeNodes = uniqueKnowledgeNodes(knowledgeNodes);
+  const startHereNodes = sortedKnowledgeNodes.filter((node) => KNOWLEDGE_START_HERE_IDS.includes(node.id));
+  const startHereIds = new Set(startHereNodes.map((node) => node.id));
+  const allNodes = sortedKnowledgeNodes.filter((node) => !startHereIds.has(node.id));
+  const children = [];
+  if (startHereNodes.length > 0) {
+    children.push(createKnowledgeCollection("knowledge", "start-here", "Start Here", startHereNodes));
+  }
+  if (allNodes.length > 0) {
+    children.push(createKnowledgeCollection("knowledge", "all", "All", allNodes));
+  }
+  const bySystem = buildKnowledgeTargetCollections(
+    sortedKnowledgeNodes,
+    "system",
+    "knowledge",
+    "By System",
+    (targetId) => systemLabels.get(targetId) ?? formatTreeLabel(targetId)
+  );
+  if (bySystem) children.push(bySystem);
+  const byOntology = buildKnowledgeTargetCollections(
+    sortedKnowledgeNodes,
+    "ontology",
+    "knowledge",
+    "By Ontology",
+    (targetId) => formatOntologyKnowledgeTargetLabel(targetId, organizationModel)
+  );
+  if (byOntology) children.push(byOntology);
+  return createGroupNode({
+    groupKey: "knowledge",
+    label: "Knowledge",
+    children
+  });
+}
+function buildNavigationGroup(organizationModel) {
+  const navigationSurfaces = (organizationModel ? projectNavigationSurfaces(organizationModel) : []).sort((left, right) => left.label.localeCompare(right.label)).map(
+    (surface) => createItemNode({
+      domainKey: "navigation",
+      itemId: surface.id,
+      label: surface.label
+    })
+  );
+  return createGroupNode({
+    groupKey: "navigation",
+    label: "Navigation",
+    children: [createDomainNode({ domainKey: "navigation", label: "Surfaces", children: navigationSurfaces })]
+  });
+}
+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 rolesDomain = buildRolesDomain(graph, organizationModel, knowledgeByTarget, facetStates);
+  return createGroupNode({
+    groupKey: "governance-wiring",
+    label: "Governance",
+    children: [
+      rolesDomain,
+      createDomainNode({ domainKey: "policies", label: "Policies", children: policies })
+    ]
+  });
+}
+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(organizationModel);
+      case "resources":
+        return buildResourcesGroup(graph);
+      case "knowledge":
+        return buildKnowledgeGroup(graph, knowledgeNodes, organizationModel);
+      case "navigation":
+        return buildNavigationGroup(organizationModel);
+      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,
+                getKnowledgeTreeFolderCommand(`${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,
+                getKnowledgeTreeFolderCommand(`${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 ? getKnowledgeNodeReadCommand(graphNode2.sourceId) : graphNode2 ? getKnowledgeGraphFolderCommand(graphNode2.id) : getKnowledgeTreeFolderCommand(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,
+                getKnowledgeTreeFolderCommand(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: getKnowledgeGraphFolderCommand(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 ? getKnowledgeSpineFolderCommand(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 ?? (kind === "knowledge" ? "reference" : "info"),
+            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) ?? "reference",
+            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: getKnowledgeNodeReadCommand(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 !== void 0 ? graphKindToFallbackToken(fallbackKind) : "info"),
+            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-P7PR626V.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, getKnowledgeDomainFolderCommand, getKnowledgeGraphNodeCommand, getKnowledgeIconToken, getKnowledgeNodeReadCommand, getKnowledgeOntologyProjection, getKnowledgeTreeFolderCommand, getOntologyDomainLabel, getPrimaryOntologyItemsForDomain, getSharedOrganizationGraph, projectNavigationGroups, projectNavigationSurfaces };