@elevasis/ui 2.32.0 → 2.33.0

package/dist/{chunk-WQPX44YM.js → chunk-YAQ25UNM.js}

@@ -1,5 +1,5 @@
-import { SemanticIcon } from './chunk-UROTM5OR.js';
-import { buildOrganizationGraph, projectOrganizationSurfaces, getSortedSidebarEntries, getSystem } from './chunk-T35FWDAB.js';
+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';
@@ -20,9 +20,9 @@ function getSharedOrganizationGraph(organizationModel) {
 
 // src/knowledge/iconTokens.ts
 var KNOWLEDGE_ICON_TOKEN_BY_KIND = {
-  playbook: "knowledge.playbook",
-  strategy: "knowledge.strategy",
-  reference: "knowledge.reference"
+  playbook: "playbook",
+  strategy: "strategy",
+  reference: "reference"
 };
 function getKnowledgeIconToken(node) {
   return node.icon ?? KNOWLEDGE_ICON_TOKEN_BY_KIND[node.kind];
@@ -84,25 +84,230 @@ function projectNavigationGroups(model) {
     ...collectGroups(model.navigation.sidebar.bottom, "bottom")
   ];
 }
-function toSemanticFallbackKind(kind) {
+
+// 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 kind;
+      return "shield";
     case "system":
-      return "feature";
+      return "operations";
     case "role":
-      return "unknown";
+      return "user";
     case "stage":
-      return "status";
+      return "pending";
     case "organization":
-      return "unknown";
+      return "building";
     default:
-      return "unknown";
+      return "info";
   }
 }
 var QUICK_ACCESS_GROUP_KEY = "quick-access";
@@ -114,6 +319,9 @@ var GROUP_ICON_TOKENS = {
   "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) {
@@ -155,8 +363,26 @@ 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"] }
+  {
+    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:";
@@ -184,6 +410,7 @@ function graphNodeIdForKnowledgeTarget(targetKind, targetId) {
     case "policy":
     case "role":
     case "knowledge":
+    case "ontology":
     case "system":
     case "stage":
       return `${targetKind}:${targetId}`;
@@ -209,6 +436,20 @@ var GRAPH_RESOURCE_TYPE_LABELS = {
   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",
@@ -254,11 +495,20 @@ var KNOWLEDGE_DOMAINS_WITH_PANELS = /* @__PURE__ */ new Set([
   "sales",
   "prospecting",
   "projects",
-  "statuses",
   "navigation",
-  "policies"
+  "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", "statuses", "policies"]);
+var FILTERABLE_DOMAIN_KEYS = /* @__PURE__ */ new Set(["customers", "offerings", "goals", "roles", "policies"]);
 function shouldRouteItemToDomainPanel(domainKey) {
   return FILTERABLE_DOMAIN_KEYS.has(domainKey);
 }
@@ -356,8 +606,13 @@ function spineNodeHasVisibleDescendant(bareId, allBareIds, spine, facetStates, c
   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(
+  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);
@@ -372,20 +627,8 @@ function buildSpineMetaMap(graph, spine) {
   }
   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 ?? []);
+  const command = getKnowledgeNodeReadCommands(nodeIds ?? []);
   return command || fallbackCommand;
 }
 function getKnowledgeFolderKey(node) {
@@ -407,6 +650,14 @@ function sortFolderKeys(left, right) {
   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}`,
@@ -431,7 +682,7 @@ function createKnowledgeLeaves(graphNodeId, nodes) {
     value: `${FOLDER_PREFIX}${graphNodeId}::${folderKey}`,
     label: FOLDER_LABELS[folderKey] ?? folderKey,
     nodeType: "folder",
-    icon: "knowledge.playbook",
+    icon: "playbook",
     knowledgeNodeIds: folderNodes.map((node) => node.id),
     children: folderNodes.map((node) => createKnowledgeLeaf(graphNodeId, node))
   }));
@@ -536,55 +787,236 @@ function createCollectionNode(parentKey, collectionKey, label, children) {
     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}`;
+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 {
-      // 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: []
+      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 buildContentSubgroup(bareId, organizationModel) {
+function buildSystemConfigSubgroup(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);
+  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 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),
+  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: items.length > 0 ? items : void 0
-    };
-  });
+      children: uiChildren.length > 0 ? uiChildren : void 0
+    });
+  }
+  if (children.length === 0) return [];
   return [
     {
-      value: `${FOLDER_PREFIX}content:${bareId}`,
-      label: "Content",
+      value: `${FOLDER_PREFIX}config:${bareId}`,
+      label: "Config",
       nodeType: "folder",
-      knowledgeNodeIds: [],
-      children: kindFolders.length > 0 ? kindFolders : void 0
+      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
     }
   ];
 }
@@ -592,14 +1024,19 @@ function buildSpineTreeNode(bareId, allBareIds, spineMetaMap, spine, facetStates
   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 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 = createKnowledgeLeaves(graphNodeId, governing);
+  const knowledgeLeaves = spine === "system" ? [] : createKnowledgeLeaves(graphNodeId, governing);
   const facetLeaves = createFacetGraphLeaves(getIncludedFacetNodes(graphNodeId, spine, facetStates, ctx));
-  const children = [...domainConfigChildren, ...contentChildren, ...childSpineNodes, ...knowledgeLeaves, ...facetLeaves];
+  const children = [...systemModelChildren, ...childSpineNodes, ...knowledgeLeaves, ...facetLeaves];
   const meta = spineMetaMap[bareId];
   return {
     value: `${SPINE_PREFIX}${spine}:${bareId}`,
@@ -715,90 +1152,160 @@ function buildSystemsGroup(graph, organizationModel, facetStates, ctx, visibleSp
   );
   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 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 buildGraphResourcesBranch(graph) {
-  const resources = graphNodesByKind(graph, "resource");
+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 resourceNodes = resources.filter((node) => node.resourceType === resourceType);
-    if (resourceNodes.length === 0) return void 0;
+    const typedResources = resourceNodes.filter((node) => node.resourceType === resourceType);
+    if (typedResources.length === 0) return void 0;
     return createCollectionNode(
-      "graph:resources",
+      "resources",
       resourceType,
       GRAPH_RESOURCE_TYPE_LABELS[resourceType],
-      resourceNodes.map((node) => createGraphNodeItem(node, "resources"))
+      typedResources.map((node) => createGraphNodeItem(node, "resources"))
     );
   }).filter((node) => node !== void 0);
-  const untypedResources = resources.filter((node) => node.resourceType === void 0);
-  if (untypedResources.length > 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(
-        "graph:resources",
-        "unknown",
-        "Unclassified",
-        untypedResources.map((node) => createGraphNodeItem(node, "resources"))
+        "resources",
+        "other",
+        "Other",
+        otherResources.map((node) => createGraphNodeItem(node, "resources"))
       )
     );
   }
-  return createDomainNode({ domainKey: "resources", label: "Resources", children });
+  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 buildGraphKnowledgeBranch(graph, knowledgeNodes) {
-  const graphNodesBySourceId = new Map(
-    graph.nodes.filter((node) => node.kind === "knowledge").map((node) => [node.sourceId ?? node.id, node])
+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))
+    )
   );
-  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
+  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 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",
+  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: [
-      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"))
+    children
   });
 }
-function buildGraphGroup(graph, knowledgeNodes) {
+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: "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)
-    ]
+    groupKey: "navigation",
+    label: "Navigation",
+    children: [createDomainNode({ domainKey: "navigation", label: "Surfaces", children: navigationSurfaces })]
   });
 }
 function buildGovernanceGroup(graph, organizationModel, knowledgeByTarget, facetStates) {
@@ -812,23 +1319,13 @@ function buildGovernanceGroup(graph, organizationModel, knowledgeByTarget, facet
       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",
+    label: "Governance",
     children: [
       rolesDomain,
-      createDomainNode({ domainKey: "policies", label: "Policies", children: policies }),
-      createDomainNode({ domainKey: "statuses", label: "Statuses", children: statusGroups }),
-      createDomainNode({ domainKey: "navigation", label: "Navigation", children: navigationSurfaces })
+      createDomainNode({ domainKey: "policies", label: "Policies", children: policies })
     ]
   });
 }
@@ -857,7 +1354,13 @@ function buildOrgTreeNode(graph, knowledgeNodes, facetStates, organizationModel,
       case "systems":
         return buildSystemsGroup(graph, organizationModel, facetStates, ctx, visibleSpineIds);
       case "graph":
-        return buildGraphGroup(graph, knowledgeNodes);
+        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:
@@ -979,7 +1482,7 @@ function KnowledgeTree({
               iconToken: GROUP_ICON_TOKENS[groupKey] ?? typedNode.icon,
               command: isQuickAccess ? "" : getKnowledgeDirectoryCommand(
                 typedNode.knowledgeNodeIds,
-                getKnowledgeReadTreeFolderCommand(`${GROUP_PREFIX}${groupKey}`)
+                getKnowledgeTreeFolderCommand(`${GROUP_PREFIX}${groupKey}`)
               ),
               isActive: isActive2,
               fallbackKind: "organization",
@@ -1033,7 +1536,7 @@ function KnowledgeTree({
               iconToken: void 0,
               command: getKnowledgeDirectoryCommand(
                 typedNode.knowledgeNodeIds,
-                getKnowledgeReadTreeFolderCommand(`${DOMAIN_PREFIX}${domainKey}`)
+                getKnowledgeTreeFolderCommand(`${DOMAIN_PREFIX}${domainKey}`)
               ),
               isActive: isActive2,
               fallbackKind: "organization",
@@ -1051,7 +1554,7 @@ function KnowledgeTree({
           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 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,
@@ -1099,7 +1602,7 @@ function KnowledgeTree({
               iconToken: typedNode.icon,
               command: getKnowledgeDirectoryCommand(
                 typedNode.knowledgeNodeIds,
-                getKnowledgeReadTreeFolderCommand(String(value))
+                getKnowledgeTreeFolderCommand(String(value))
               ),
               isActive: false
             }
@@ -1117,7 +1620,7 @@ function KnowledgeTree({
               hasChildren,
               label: String(node.label),
               iconToken: typedNode.icon,
-              command: getKnowledgeReadTreeFolderCommand(`graph:${graphNode2.id}`),
+              command: getKnowledgeGraphFolderCommand(graphNode2.id),
               isActive: isActive2,
               fallbackKind: graphNode2.kind,
               onSelectGraphNode: () => onSelectGraphNode?.(graphNode2),
@@ -1141,7 +1644,7 @@ function KnowledgeTree({
             hasChildren,
             label: String(node.label),
             iconToken: typedNode.icon,
-            command: graphSpine ? getKnowledgeReadSpineFolderCommand(graphSpine, graphNode?.sourceId ?? graphNodeId) : "",
+            command: graphSpine ? getKnowledgeSpineFolderCommand(graphSpine, graphNode?.sourceId ?? graphNodeId) : "",
             isActive,
             fallbackKind: graphNode?.kind ?? "system",
             uppercase: true,
@@ -1270,8 +1773,7 @@ function FavoriteRow({ elementProps, label, routeId, kind, iconToken, onActivate
         /* @__PURE__ */ jsx(
           SemanticIcon,
           {
-            token: iconToken,
-            fallbackKind: kind === "knowledge" ? "knowledge" : "unknown",
+            token: iconToken ?? (kind === "knowledge" ? "reference" : "info"),
             size: 15,
             style: { color: SIDEBAR_TREE_ACCENT_COLOR }
           }
@@ -1364,8 +1866,7 @@ function KnowledgeLeafRow({ elementProps, knowledgeNode, isActive, onSelectNode
         /* @__PURE__ */ jsx(
           SemanticIcon,
           {
-            token: getKnowledgeIconToken(knowledgeNode),
-            fallbackKind: knowledgeNode.kind,
+            token: getKnowledgeIconToken(knowledgeNode) ?? "reference",
             size: 15,
             style: { color: SIDEBAR_TREE_ACCENT_COLOR }
           }
@@ -1383,7 +1884,7 @@ function KnowledgeLeafRow({ elementProps, knowledgeNode, isActive, onSelectNode
         /* @__PURE__ */ jsx(
           TrailingCopySlot,
           {
-            command: getKnowledgeReadCommand(knowledgeNode.id),
+            command: getKnowledgeNodeReadCommand(knowledgeNode.id),
             label: "Copy knowledge command",
             showCopy: hovered,
             favorite: {
@@ -1466,8 +1967,7 @@ function DirectoryRow({
         /* @__PURE__ */ jsx(
           SemanticIcon,
           {
-            token: iconToken,
-            fallbackKind: fallbackKind !== void 0 ? toSemanticFallbackKind(fallbackKind) : "unknown",
+            token: iconToken ?? (fallbackKind !== void 0 ? graphKindToFallbackToken(fallbackKind) : "info"),
             size: 14,
             style: { color: SIDEBAR_TREE_ACCENT_COLOR }
           }
@@ -1541,7 +2041,7 @@ function TrailingCopySlot({ command, label, showCopy, favorite, hovered }) {
 var indexPromise = null;
 function loadSearchIndex() {
   if (!indexPromise) {
-    indexPromise = import('./knowledge-search-index-5KYPO746.js').then(
+    indexPromise = import('./knowledge-search-index-P7PR626V.js').then(
       (mod) => buildSearchIndex(mod.default ?? mod)
     );
   }
@@ -1623,4 +2123,4 @@ function KnowledgeSearchBar({
   );
 }
 
-export { KNOWLEDGE_DOMAINS_WITH_PANELS, KNOWLEDGE_ICON_TOKEN_BY_KIND, KnowledgeSearchBar, KnowledgeTree, OM_TREE_GROUPS, getKnowledgeIconToken, getSharedOrganizationGraph, projectNavigationGroups, projectNavigationSurfaces };
+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 };