@elevasis/core 0.23.0 → 0.24.1

package/src/organization-model/__tests__/lookup-helpers.test.ts

@@ -1,438 +1,438 @@
-/**
- * lookup-helpers.test.ts
- *
- * Tests for the Wave 1B recursive system-tree helpers:
- *   getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent
- *
- * NOTE: getSystem / getSystemAncestors / getContent / resolveSystemContent walk
- * systems via the `subsystems` nesting field (per the Wave 1B docstrings). The
- * `model.systems` map holds TOP-LEVEL systems only; nested systems live in
- * `parent.subsystems.<childKey>`. Fixtures must author hierarchies via
- * `subsystems`, not via flat dot-notation keys in `model.systems`.
- */
-import { describe, expect, it } from 'vitest'
-import { resolveOrganizationModel } from '../resolve'
-import { getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent } from '../helpers'
-import type { OrganizationModel } from '../types'
-
-// ---------------------------------------------------------------------------
-// Minimal model factory — uses `subsystems` nesting so Wave 1B helpers work
-// ---------------------------------------------------------------------------
-
-/**
- * Build a minimal valid model with a 3-level nested system tree:
- *   root (top-level, no content)
- *   └── mid  (subsystem of root, has content)
- *       └── leaf (subsystem of mid, has content)
- */
-function makeNestedModel(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      root: {
-        id: 'root',
-        order: 10,
-        label: 'Root',
-        enabled: true,
-        path: '/root',
-        subsystems: {
-          mid: {
-            id: 'mid',
-            order: 20,
-            label: 'Mid',
-            enabled: true,
-            path: '/root/mid',
-            content: {
-              'mid-pipeline': {
-                kind: 'schema',
-                type: 'pipeline',
-                label: 'Mid Pipeline',
-                data: { entityId: 'crm.deal' }
-              }
-            },
-            subsystems: {
-              leaf: {
-                id: 'leaf',
-                order: 30,
-                label: 'Leaf',
-                enabled: true,
-                path: '/root/mid/leaf',
-                content: {
-                  'leaf-config': {
-                    kind: 'config',
-                    type: 'kv',
-                    label: 'Leaf Config',
-                    data: { entries: { timeout: 5000 } }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-}
-
-/**
- * Build a model where 'ancestor' has content and 'ancestor.child' (in subsystems)
- * overrides one localId while inheriting the other.
- */
-function makeInheritanceModel(): OrganizationModel {
-  return resolveOrganizationModel({
-    systems: {
-      ancestor: {
-        id: 'ancestor',
-        order: 10,
-        label: 'Ancestor',
-        enabled: true,
-        path: '/ancestor',
-        content: {
-          shared: {
-            kind: 'config',
-            type: 'kv',
-            label: 'Shared Config',
-            order: 10,
-            data: { entries: { globalFlag: true } }
-          },
-          'ancestor-only': {
-            kind: 'config',
-            type: 'kv',
-            label: 'Ancestor Only',
-            order: 20,
-            data: { entries: { ancestorProp: 'yes' } }
-          }
-        },
-        subsystems: {
-          child: {
-            id: 'child',
-            order: 20,
-            label: 'Child',
-            enabled: true,
-            path: '/ancestor/child',
-            content: {
-              // 'shared' localId shadows the ancestor's 'shared' — override
-              shared: {
-                kind: 'config',
-                type: 'kv',
-                label: 'Child Override Config',
-                order: 10,
-                data: { entries: { localFlag: false } }
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-}
-
-// ---------------------------------------------------------------------------
-// getSystem
-// ---------------------------------------------------------------------------
-
-describe('getSystem', () => {
-  it('returns a root-level system by single-segment path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Root')
-  })
-
-  it('returns a 2-level nested system by dot-separated path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Mid')
-  })
-
-  it('returns a 3-level nested system by dot-separated path', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid.leaf')
-    expect(sys).toBeDefined()
-    expect(sys?.label).toBe('Leaf')
-  })
-
-  it('returns undefined for an unknown top-level segment', () => {
-    const model = makeNestedModel()
-    expect(getSystem(model, 'nonexistent')).toBeUndefined()
-  })
-
-  it('returns undefined when a middle segment is missing', () => {
-    const model = makeNestedModel()
-    expect(getSystem(model, 'root.missing.leaf')).toBeUndefined()
-  })
-
-  it('returns undefined for a path that is too deep (past a leaf)', () => {
-    const model = makeNestedModel()
-    // 'leaf' has no subsystems, so 'root.mid.leaf.deeper' must return undefined
-    expect(getSystem(model, 'root.mid.leaf.deeper')).toBeUndefined()
-  })
-
-  it('returns the content map for a system that has content', () => {
-    const model = makeNestedModel()
-    const sys = getSystem(model, 'root.mid')
-    expect(sys?.content).toBeDefined()
-    expect(Object.keys(sys?.content ?? {})).toContain('mid-pipeline')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getSystemAncestors
-// ---------------------------------------------------------------------------
-
-describe('getSystemAncestors', () => {
-  it('returns [root] for a single-segment path (root-first order)', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root')
-    expect(ancestors).toHaveLength(1)
-    expect(ancestors[0]?.label).toBe('Root')
-  })
-
-  it('returns [root, mid] for a 2-level path', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root.mid')
-    expect(ancestors).toHaveLength(2)
-    expect(ancestors[0]?.label).toBe('Root')
-    expect(ancestors[1]?.label).toBe('Mid')
-  })
-
-  it('returns [root, mid, leaf] for a 3-level path', () => {
-    const model = makeNestedModel()
-    const ancestors = getSystemAncestors(model, 'root.mid.leaf')
-    expect(ancestors).toHaveLength(3)
-    expect(ancestors[0]?.label).toBe('Root')
-    expect(ancestors[1]?.label).toBe('Mid')
-    expect(ancestors[2]?.label).toBe('Leaf')
-  })
-
-  it('returns empty array when the path does not resolve', () => {
-    const model = makeNestedModel()
-    expect(getSystemAncestors(model, 'does.not.exist')).toEqual([])
-  })
-
-  it('returns empty array when the first segment is unknown', () => {
-    const model = makeNestedModel()
-    expect(getSystemAncestors(model, 'unknown.mid')).toEqual([])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// listAllSystems
-// ---------------------------------------------------------------------------
-
-describe('listAllSystems', () => {
-  it('enumerates root-level systems from the default model', () => {
-    const model = resolveOrganizationModel()
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    // Default model has 'sales', 'dashboard', etc. as top-level systems
-    expect(paths.some((p) => p === 'sales')).toBe(true)
-    expect(paths.some((p) => p === 'dashboard')).toBe(true)
-  })
-
-  it('enumerates nested systems via subsystems when they exist', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    expect(paths).toContain('root')
-    expect(paths).toContain('root.mid')
-    expect(paths).toContain('root.mid.leaf')
-  })
-
-  it('returns pre-order DFS order (parent before children)', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    const rootIdx = all.findIndex((e) => e.path === 'root')
-    const midIdx = all.findIndex((e) => e.path === 'root.mid')
-    const leafIdx = all.findIndex((e) => e.path === 'root.mid.leaf')
-    expect(rootIdx).toBeGreaterThanOrEqual(0)
-    expect(midIdx).toBeGreaterThanOrEqual(0)
-    expect(leafIdx).toBeGreaterThanOrEqual(0)
-    expect(rootIdx).toBeLessThan(midIdx)
-    expect(midIdx).toBeLessThan(leafIdx)
-  })
-
-  it('each entry has a non-empty string path and an object system', () => {
-    const model = makeNestedModel()
-    const all = listAllSystems(model)
-    for (const entry of all) {
-      expect(typeof entry.path).toBe('string')
-      expect(entry.path.length).toBeGreaterThan(0)
-      expect(typeof entry.system).toBe('object')
-      expect(entry.system).not.toBeNull()
-    }
-  })
-
-  it('flat model (no subsystems) returns only top-level systems', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        lone: { id: 'lone', order: 10, label: 'Lone', enabled: true, path: '/lone' }
-      }
-    })
-    const all = listAllSystems(model)
-    const paths = all.map((e) => e.path)
-    expect(paths).toContain('lone')
-    // Should not contain any path with a dot from 'lone'
-    expect(paths.filter((p) => p.startsWith('lone.')).length).toBe(0)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// getContent
-// ---------------------------------------------------------------------------
-
-describe('getContent', () => {
-  it('resolves a content node by qualified id for a 2-level path', () => {
-    const model = makeNestedModel()
-    const node = getContent(model, 'root.mid:mid-pipeline')
-    expect(node).toBeDefined()
-    expect(node?.label).toBe('Mid Pipeline')
-    expect(node?.kind).toBe('schema')
-    expect(node?.type).toBe('pipeline')
-  })
-
-  it('resolves a leaf system content node by 3-level qualified id', () => {
-    const model = makeNestedModel()
-    const node = getContent(model, 'root.mid.leaf:leaf-config')
-    expect(node).toBeDefined()
-    expect(node?.label).toBe('Leaf Config')
-    expect(node?.kind).toBe('config')
-    expect(node?.type).toBe('kv')
-  })
-
-  it('returns undefined for an unknown local-id within a valid system', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid:does-not-exist')).toBeUndefined()
-  })
-
-  it('returns undefined for an unknown system path', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'ghost:some-node')).toBeUndefined()
-  })
-
-  it('returns undefined for a qualified id with no colon separator', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid')).toBeUndefined()
-  })
-
-  it('returns undefined when the system path segment is empty (colon at start)', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, ':local-id')).toBeUndefined()
-  })
-
-  it('returns undefined when the local-id is empty (colon at end)', () => {
-    const model = makeNestedModel()
-    expect(getContent(model, 'root.mid:')).toBeUndefined()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// resolveSystemContent — own, inherited, and override-by-localId
-// ---------------------------------------------------------------------------
-
-describe('resolveSystemContent', () => {
-  it('returns empty own and inherited for a system with no content and no ancestor content', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        bare: { id: 'bare', order: 10, label: 'Bare', enabled: true, path: '/bare' }
-      }
-    })
-    const result = resolveSystemContent(model, 'bare')
-    expect(result.own).toEqual({})
-    expect(result.inherited).toEqual([])
-  })
-
-  it('returns empty own and inherited for an unknown system path', () => {
-    const model = makeNestedModel()
-    const result = resolveSystemContent(model, 'nonexistent')
-    expect(result.own).toEqual({})
-    expect(result.inherited).toEqual([])
-  })
-
-  it('returns only own content for a system whose ancestor has no content', () => {
-    const model = makeNestedModel()
-    // 'root' has no content, so 'root.mid' inherits nothing
-    const result = resolveSystemContent(model, 'root.mid')
-    expect(Object.keys(result.own)).toContain('mid-pipeline')
-    expect(result.inherited).toHaveLength(0)
-  })
-
-  it('own section contains only the direct content of the queried system', () => {
-    const model = makeInheritanceModel()
-    // 'ancestor.child' path = 'ancestor.child' using subsystems nesting
-    const result = resolveSystemContent(model, 'ancestor.child')
-    expect(Object.keys(result.own)).toContain('shared')
-    expect(Object.keys(result.own)).not.toContain('ancestor-only')
-  })
-
-  it('inherited section contains ancestor content not shadowed by own', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    const inheritedIds = result.inherited.map((e) => e.localId)
-    expect(inheritedIds).toContain('ancestor-only')
-  })
-
-  it('override-by-localId: shadowed ancestor entry does NOT appear in inherited', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    // 'shared' is in both ancestor and child; child's own shadows it
-    const inheritedIds = result.inherited.map((e) => e.localId)
-    expect(inheritedIds).not.toContain('shared')
-  })
-
-  it('inherited entries carry fromPath pointing to the source ancestor system', () => {
-    const model = makeInheritanceModel()
-    const result = resolveSystemContent(model, 'ancestor.child')
-    const ancestorEntry = result.inherited.find((e) => e.localId === 'ancestor-only')
-    expect(ancestorEntry).toBeDefined()
-    expect(ancestorEntry?.fromPath).toBe('ancestor')
-  })
-
-  it('inherited entries appear in root-first display order (shallower before deeper)', () => {
-    // 3-level chain: gp → parent → child
-    // gp has 'gp-node', parent has 'p-node', child has own content
-    const model = resolveOrganizationModel({
-      systems: {
-        gp: {
-          id: 'gp',
-          order: 10,
-          label: 'Grandparent',
-          enabled: true,
-          path: '/gp',
-          content: {
-            'gp-node': { kind: 'config', type: 'kv', label: 'GP Node', data: { entries: { a: 1 } } }
-          },
-          subsystems: {
-            parent: {
-              id: 'parent',
-              order: 20,
-              label: 'Parent',
-              enabled: true,
-              path: '/gp/parent',
-              content: {
-                'p-node': { kind: 'config', type: 'kv', label: 'P Node', data: { entries: { b: 2 } } }
-              },
-              subsystems: {
-                child: {
-                  id: 'child',
-                  order: 30,
-                  label: 'Child',
-                  enabled: true,
-                  path: '/gp/parent/child'
-                }
-              }
-            }
-          }
-        }
-      }
-    })
-    const result = resolveSystemContent(model, 'gp.parent.child')
-    const fromPaths = result.inherited.map((e) => e.fromPath)
-    const gpIdx = fromPaths.indexOf('gp')
-    const pIdx = fromPaths.indexOf('gp.parent')
-    expect(gpIdx).toBeGreaterThanOrEqual(0)
-    expect(pIdx).toBeGreaterThanOrEqual(0)
-    // Shallow ancestor (gp) must appear before deeper ancestor (gp.parent)
-    expect(gpIdx).toBeLessThan(pIdx)
-  })
-})
+/**
+ * lookup-helpers.test.ts
+ *
+ * Tests for the Wave 1B recursive system-tree helpers:
+ *   getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent
+ *
+ * NOTE: getSystem / getSystemAncestors / getContent / resolveSystemContent walk
+ * systems via the `subsystems` nesting field (per the Wave 1B docstrings). The
+ * `model.systems` map holds TOP-LEVEL systems only; nested systems live in
+ * `parent.subsystems.<childKey>`. Fixtures must author hierarchies via
+ * `subsystems`, not via flat dot-notation keys in `model.systems`.
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveOrganizationModel } from '../resolve'
+import { getSystem, getSystemAncestors, listAllSystems, getContent, resolveSystemContent } from '../helpers'
+import type { OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Minimal model factory — uses `subsystems` nesting so Wave 1B helpers work
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal valid model with a 3-level nested system tree:
+ *   root (top-level, no content)
+ *   └── mid  (subsystem of root, has content)
+ *       └── leaf (subsystem of mid, has content)
+ */
+function makeNestedModel(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      root: {
+        id: 'root',
+        order: 10,
+        label: 'Root',
+        enabled: true,
+        path: '/root',
+        subsystems: {
+          mid: {
+            id: 'mid',
+            order: 20,
+            label: 'Mid',
+            enabled: true,
+            path: '/root/mid',
+            content: {
+              'mid-pipeline': {
+                kind: 'schema',
+                type: 'pipeline',
+                label: 'Mid Pipeline',
+                data: { entityId: 'crm.deal' }
+              }
+            },
+            subsystems: {
+              leaf: {
+                id: 'leaf',
+                order: 30,
+                label: 'Leaf',
+                enabled: true,
+                path: '/root/mid/leaf',
+                content: {
+                  'leaf-config': {
+                    kind: 'config',
+                    type: 'kv',
+                    label: 'Leaf Config',
+                    data: { entries: { timeout: 5000 } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+/**
+ * Build a model where 'ancestor' has content and 'ancestor.child' (in subsystems)
+ * overrides one localId while inheriting the other.
+ */
+function makeInheritanceModel(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      ancestor: {
+        id: 'ancestor',
+        order: 10,
+        label: 'Ancestor',
+        enabled: true,
+        path: '/ancestor',
+        content: {
+          shared: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Shared Config',
+            order: 10,
+            data: { entries: { globalFlag: true } }
+          },
+          'ancestor-only': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Ancestor Only',
+            order: 20,
+            data: { entries: { ancestorProp: 'yes' } }
+          }
+        },
+        subsystems: {
+          child: {
+            id: 'child',
+            order: 20,
+            label: 'Child',
+            enabled: true,
+            path: '/ancestor/child',
+            content: {
+              // 'shared' localId shadows the ancestor's 'shared' — override
+              shared: {
+                kind: 'config',
+                type: 'kv',
+                label: 'Child Override Config',
+                order: 10,
+                data: { entries: { localFlag: false } }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+}
+
+// ---------------------------------------------------------------------------
+// getSystem
+// ---------------------------------------------------------------------------
+
+describe('getSystem', () => {
+  it('returns a root-level system by single-segment path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Root')
+  })
+
+  it('returns a 2-level nested system by dot-separated path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Mid')
+  })
+
+  it('returns a 3-level nested system by dot-separated path', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid.leaf')
+    expect(sys).toBeDefined()
+    expect(sys?.label).toBe('Leaf')
+  })
+
+  it('returns undefined for an unknown top-level segment', () => {
+    const model = makeNestedModel()
+    expect(getSystem(model, 'nonexistent')).toBeUndefined()
+  })
+
+  it('returns undefined when a middle segment is missing', () => {
+    const model = makeNestedModel()
+    expect(getSystem(model, 'root.missing.leaf')).toBeUndefined()
+  })
+
+  it('returns undefined for a path that is too deep (past a leaf)', () => {
+    const model = makeNestedModel()
+    // 'leaf' has no subsystems, so 'root.mid.leaf.deeper' must return undefined
+    expect(getSystem(model, 'root.mid.leaf.deeper')).toBeUndefined()
+  })
+
+  it('returns the content map for a system that has content', () => {
+    const model = makeNestedModel()
+    const sys = getSystem(model, 'root.mid')
+    expect(sys?.content).toBeDefined()
+    expect(Object.keys(sys?.content ?? {})).toContain('mid-pipeline')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getSystemAncestors
+// ---------------------------------------------------------------------------
+
+describe('getSystemAncestors', () => {
+  it('returns [root] for a single-segment path (root-first order)', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root')
+    expect(ancestors).toHaveLength(1)
+    expect(ancestors[0]?.label).toBe('Root')
+  })
+
+  it('returns [root, mid] for a 2-level path', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root.mid')
+    expect(ancestors).toHaveLength(2)
+    expect(ancestors[0]?.label).toBe('Root')
+    expect(ancestors[1]?.label).toBe('Mid')
+  })
+
+  it('returns [root, mid, leaf] for a 3-level path', () => {
+    const model = makeNestedModel()
+    const ancestors = getSystemAncestors(model, 'root.mid.leaf')
+    expect(ancestors).toHaveLength(3)
+    expect(ancestors[0]?.label).toBe('Root')
+    expect(ancestors[1]?.label).toBe('Mid')
+    expect(ancestors[2]?.label).toBe('Leaf')
+  })
+
+  it('returns empty array when the path does not resolve', () => {
+    const model = makeNestedModel()
+    expect(getSystemAncestors(model, 'does.not.exist')).toEqual([])
+  })
+
+  it('returns empty array when the first segment is unknown', () => {
+    const model = makeNestedModel()
+    expect(getSystemAncestors(model, 'unknown.mid')).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listAllSystems
+// ---------------------------------------------------------------------------
+
+describe('listAllSystems', () => {
+  it('enumerates root-level systems from the default model', () => {
+    const model = resolveOrganizationModel()
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    // Default model has 'sales', 'dashboard', etc. as top-level systems
+    expect(paths.some((p) => p === 'sales')).toBe(true)
+    expect(paths.some((p) => p === 'dashboard')).toBe(true)
+  })
+
+  it('enumerates nested systems via subsystems when they exist', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    expect(paths).toContain('root')
+    expect(paths).toContain('root.mid')
+    expect(paths).toContain('root.mid.leaf')
+  })
+
+  it('returns pre-order DFS order (parent before children)', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    const rootIdx = all.findIndex((e) => e.path === 'root')
+    const midIdx = all.findIndex((e) => e.path === 'root.mid')
+    const leafIdx = all.findIndex((e) => e.path === 'root.mid.leaf')
+    expect(rootIdx).toBeGreaterThanOrEqual(0)
+    expect(midIdx).toBeGreaterThanOrEqual(0)
+    expect(leafIdx).toBeGreaterThanOrEqual(0)
+    expect(rootIdx).toBeLessThan(midIdx)
+    expect(midIdx).toBeLessThan(leafIdx)
+  })
+
+  it('each entry has a non-empty string path and an object system', () => {
+    const model = makeNestedModel()
+    const all = listAllSystems(model)
+    for (const entry of all) {
+      expect(typeof entry.path).toBe('string')
+      expect(entry.path.length).toBeGreaterThan(0)
+      expect(typeof entry.system).toBe('object')
+      expect(entry.system).not.toBeNull()
+    }
+  })
+
+  it('flat model (no subsystems) returns only top-level systems', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        lone: { id: 'lone', order: 10, label: 'Lone', enabled: true, path: '/lone' }
+      }
+    })
+    const all = listAllSystems(model)
+    const paths = all.map((e) => e.path)
+    expect(paths).toContain('lone')
+    // Should not contain any path with a dot from 'lone'
+    expect(paths.filter((p) => p.startsWith('lone.')).length).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getContent
+// ---------------------------------------------------------------------------
+
+describe('getContent', () => {
+  it('resolves a content node by qualified id for a 2-level path', () => {
+    const model = makeNestedModel()
+    const node = getContent(model, 'root.mid:mid-pipeline')
+    expect(node).toBeDefined()
+    expect(node?.label).toBe('Mid Pipeline')
+    expect(node?.kind).toBe('schema')
+    expect(node?.type).toBe('pipeline')
+  })
+
+  it('resolves a leaf system content node by 3-level qualified id', () => {
+    const model = makeNestedModel()
+    const node = getContent(model, 'root.mid.leaf:leaf-config')
+    expect(node).toBeDefined()
+    expect(node?.label).toBe('Leaf Config')
+    expect(node?.kind).toBe('config')
+    expect(node?.type).toBe('kv')
+  })
+
+  it('returns undefined for an unknown local-id within a valid system', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid:does-not-exist')).toBeUndefined()
+  })
+
+  it('returns undefined for an unknown system path', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'ghost:some-node')).toBeUndefined()
+  })
+
+  it('returns undefined for a qualified id with no colon separator', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid')).toBeUndefined()
+  })
+
+  it('returns undefined when the system path segment is empty (colon at start)', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, ':local-id')).toBeUndefined()
+  })
+
+  it('returns undefined when the local-id is empty (colon at end)', () => {
+    const model = makeNestedModel()
+    expect(getContent(model, 'root.mid:')).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveSystemContent — own, inherited, and override-by-localId
+// ---------------------------------------------------------------------------
+
+describe('resolveSystemContent', () => {
+  it('returns empty own and inherited for a system with no content and no ancestor content', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        bare: { id: 'bare', order: 10, label: 'Bare', enabled: true, path: '/bare' }
+      }
+    })
+    const result = resolveSystemContent(model, 'bare')
+    expect(result.own).toEqual({})
+    expect(result.inherited).toEqual([])
+  })
+
+  it('returns empty own and inherited for an unknown system path', () => {
+    const model = makeNestedModel()
+    const result = resolveSystemContent(model, 'nonexistent')
+    expect(result.own).toEqual({})
+    expect(result.inherited).toEqual([])
+  })
+
+  it('returns only own content for a system whose ancestor has no content', () => {
+    const model = makeNestedModel()
+    // 'root' has no content, so 'root.mid' inherits nothing
+    const result = resolveSystemContent(model, 'root.mid')
+    expect(Object.keys(result.own)).toContain('mid-pipeline')
+    expect(result.inherited).toHaveLength(0)
+  })
+
+  it('own section contains only the direct content of the queried system', () => {
+    const model = makeInheritanceModel()
+    // 'ancestor.child' path = 'ancestor.child' using subsystems nesting
+    const result = resolveSystemContent(model, 'ancestor.child')
+    expect(Object.keys(result.own)).toContain('shared')
+    expect(Object.keys(result.own)).not.toContain('ancestor-only')
+  })
+
+  it('inherited section contains ancestor content not shadowed by own', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    const inheritedIds = result.inherited.map((e) => e.localId)
+    expect(inheritedIds).toContain('ancestor-only')
+  })
+
+  it('override-by-localId: shadowed ancestor entry does NOT appear in inherited', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    // 'shared' is in both ancestor and child; child's own shadows it
+    const inheritedIds = result.inherited.map((e) => e.localId)
+    expect(inheritedIds).not.toContain('shared')
+  })
+
+  it('inherited entries carry fromPath pointing to the source ancestor system', () => {
+    const model = makeInheritanceModel()
+    const result = resolveSystemContent(model, 'ancestor.child')
+    const ancestorEntry = result.inherited.find((e) => e.localId === 'ancestor-only')
+    expect(ancestorEntry).toBeDefined()
+    expect(ancestorEntry?.fromPath).toBe('ancestor')
+  })
+
+  it('inherited entries appear in root-first display order (shallower before deeper)', () => {
+    // 3-level chain: gp → parent → child
+    // gp has 'gp-node', parent has 'p-node', child has own content
+    const model = resolveOrganizationModel({
+      systems: {
+        gp: {
+          id: 'gp',
+          order: 10,
+          label: 'Grandparent',
+          enabled: true,
+          path: '/gp',
+          content: {
+            'gp-node': { kind: 'config', type: 'kv', label: 'GP Node', data: { entries: { a: 1 } } }
+          },
+          subsystems: {
+            parent: {
+              id: 'parent',
+              order: 20,
+              label: 'Parent',
+              enabled: true,
+              path: '/gp/parent',
+              content: {
+                'p-node': { kind: 'config', type: 'kv', label: 'P Node', data: { entries: { b: 2 } } }
+              },
+              subsystems: {
+                child: {
+                  id: 'child',
+                  order: 30,
+                  label: 'Child',
+                  enabled: true,
+                  path: '/gp/parent/child'
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+    const result = resolveSystemContent(model, 'gp.parent.child')
+    const fromPaths = result.inherited.map((e) => e.fromPath)
+    const gpIdx = fromPaths.indexOf('gp')
+    const pIdx = fromPaths.indexOf('gp.parent')
+    expect(gpIdx).toBeGreaterThanOrEqual(0)
+    expect(pIdx).toBeGreaterThanOrEqual(0)
+    // Shallow ancestor (gp) must appear before deeper ancestor (gp.parent)
+    expect(gpIdx).toBeLessThan(pIdx)
+  })
+})