@elevasis/core 0.21.0 → 0.23.0

package/src/knowledge/format.ts

@@ -1,4 +1,4 @@
-import type { OrgKnowledgeNode } from '../organization-model/domains/knowledge'
+import type { OrgKnowledgeNode } from '../organization-model/domains/knowledge'
 import type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 // ---------------------------------------------------------------------------
@@ -9,7 +9,7 @@ import type { KnowledgeMount, ParsedKnowledgePath } from './queries'
  * Renders a list of `OrgKnowledgeNode` results as a human-friendly text table.
  *
  * Output format (one row per node):
- *   `<kind>  <id>  <title>  —  <summary (truncated to 80 chars)>`
+ *   `<kind>  <id>  <title>  —  <summary (truncated to 80 chars)>`
  *
  * Returns `"(no results)"` when the array is empty.
  */
@@ -26,7 +26,7 @@ export function formatText(results: OrgKnowledgeNode[]): string {
 
   const rows = results.map((n) => {
     const summary = n.summary.length > 80 ? n.summary.slice(0, 77) + '...' : n.summary
-    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  —  ${summary}`
+    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  —  ${summary}`
   })
 
   return [header, divider, ...rows].join('\n')
@@ -41,10 +41,10 @@ export function formatText(results: OrgKnowledgeNode[]): string {
  *
  * Shape: `{ path, mount, args, results }`
  *
- * - `path`    — the original path string passed to `parsePath`
- * - `mount`   — the resolved mount axis
- * - `args`    — the parsed arguments array
- * - `results` — the query results (array of `OrgKnowledgeNode` or string IDs)
+ * - `path`    — the original path string passed to `parsePath`
+ * - `mount`   — the resolved mount axis
+ * - `args`    — the parsed arguments array
+ * - `results` — the query results (array of `OrgKnowledgeNode` or string IDs)
  */
 export interface KnowledgeJsonEnvelope {
   path: string
@@ -57,10 +57,10 @@ export interface KnowledgeJsonEnvelope {
  * Formats query results as a wrapped JSON envelope string.
  *
  * The envelope shape is `{ path, mount, args, results }`.  This is intentionally
- * NOT flat `{ results }` — consumers (agent skills, jq pipelines) need the
+ * NOT flat `{ results }` — consumers (agent skills, jq pipelines) need the
  * mount + args to know how to interpret the results array.
  *
- * @param input.path    - The original path string (e.g. `"/by-feature/sales.crm"`).
+ * @param input.path    - The original path string (e.g. `"/by-system/sales.crm"`).
  * @param input.mount   - The resolved mount axis.
  * @param input.args    - The parsed argument array.
  * @param input.results - The query results.
@@ -97,3 +97,4 @@ export function formatIdsOnly(results: OrgKnowledgeNode[] | string[]): string {
   const ids = results.map((r) => (typeof r === 'string' ? r : r.id))
   return ids.join('\n')
 }
+

package/src/knowledge/index.ts

@@ -1,4 +1,4 @@
-export { byFeature, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
 export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 export { formatText, formatJson, formatIdsOnly } from './format'

package/src/knowledge/published.ts

@@ -1,4 +1,4 @@
-export { byFeature, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
 export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
 
 export { formatText, formatJson, formatIdsOnly } from './format'

package/src/knowledge/queries.ts

@@ -1,4 +1,4 @@
-import type { OrganizationGraph } from '../organization-model/graph/types'
+import type { OrganizationGraph } from '../organization-model/graph/types'
 import type { OrgKnowledgeKind, OrgKnowledgeNode } from '../organization-model/domains/knowledge'
 
 // ---------------------------------------------------------------------------
@@ -35,17 +35,17 @@ function buildKnowledgeSourceIdMap(graph: OrganizationGraph): Map<string, string
 
 /**
  * Returns all knowledge nodes whose `governs` edges point to the given
- * featureId (graph node ID: `feature:<featureId>`).
+ * systemId (graph node ID: `system:<systemId>`).
  *
  * @param graph   - The built OrganizationGraph.
- * @param featureId - The dotted feature id (e.g. `sales.crm`).
+ * @param systemId - The dotted system id (e.g. `sales.crm`).
  */
-export function byFeature(
+export function bySystem(
   graph: OrganizationGraph,
-  featureId: string,
+  systemId: string,
   knowledgeNodes: OrgKnowledgeNode[]
 ): OrgKnowledgeNode[] {
-  const targetGraphNodeId = `feature:${featureId}`
+  const targetGraphNodeId = `system:${systemId}`
 
   // Find all knowledge graph node IDs that have a `governs` edge to the target
   const governingKnowledgeNodeIds = new Set<string>()
@@ -107,7 +107,7 @@ export function byOwner(
  * @param graph    - The built OrganizationGraph.
  * @param nodeId   - The OM knowledge node id (e.g. `knowledge.outreach-playbook`).
  *                   Also accepts the graph node ID format (`knowledge:knowledge.outreach-playbook`).
- * @returns Array of target graph node IDs (e.g. `['feature:sales.crm', ...]`).
+ * @returns Array of target graph node IDs (e.g. `['system:sales.crm', ...]`).
  */
 export function governs(graph: OrganizationGraph, nodeId: string): string[] {
   const graphNodeId = nodeId.startsWith('knowledge:') ? nodeId : toGraphNodeId(nodeId)
@@ -126,16 +126,16 @@ export function governs(graph: OrganizationGraph, nodeId: string): string[] {
  * (incoming `governs` edges pointing to `nodeId`).
  *
  * @param graph   - The built OrganizationGraph.
- * @param nodeId  - The target graph node ID (e.g. `feature:sales.crm`) or a
- *                  bare feature id (e.g. `sales.crm` — will be prefixed with `feature:`).
+ * @param nodeId  - The target graph node ID (e.g. `system:sales.crm`) or a
+ *                  bare system id (e.g. `sales.crm` — will be prefixed with `system:`).
  * @returns Array of source graph node IDs (e.g. `['knowledge:knowledge.outreach-playbook', ...]`).
  */
 export function governedBy(graph: OrganizationGraph, nodeId: string): string[] {
-  // Accept both `feature:sales.crm` and bare `sales.crm`
+  // Accept both `system:sales.crm` and bare `sales.crm`
   const targetId =
-    nodeId.startsWith('feature:') || nodeId.startsWith('knowledge:') || nodeId.startsWith('resource:')
+    nodeId.startsWith('system:') || nodeId.startsWith('knowledge:') || nodeId.startsWith('resource:')
       ? nodeId
-      : `feature:${nodeId}`
+      : `system:${nodeId}`
 
   const results: string[] = []
   for (const edge of graph.edges) {
@@ -151,7 +151,7 @@ export function governedBy(graph: OrganizationGraph, nodeId: string): string[] {
 // ---------------------------------------------------------------------------
 
 /** The recognized mount axes for Knowledge Map paths. */
-export type KnowledgeMount = 'by-feature' | 'by-kind' | 'by-owner' | 'graph' | 'node'
+export type KnowledgeMount = 'by-system' | 'by-kind' | 'by-owner' | 'graph' | 'node'
 
 /**
  * The result of parsing a Knowledge Map path string.
@@ -159,7 +159,7 @@ export type KnowledgeMount = 'by-feature' | 'by-kind' | 'by-owner' | 'graph' | '
  * Shape: `{ mount: KnowledgeMount, args: string[] }`
  *
  * Per-mount arg arrays:
- * - `by-feature`: `[featureId]`  (e.g. `['sales.crm']`)
+ * - `by-system`:  `[systemId]`   (e.g. `['sales.crm']`)
  * - `by-kind`:    `[kind]`       (e.g. `['playbook']`)
  * - `by-owner`:   `[ownerId]`    (e.g. `['role.ops-lead']`)
  * - `graph`:      `[nodeId, verb]` where verb is `'governs'` or `'governed-by'`
@@ -174,12 +174,12 @@ export interface ParsedKnowledgePath {
  * Parses a Knowledge Map path string into a `{ mount, args }` descriptor.
  *
  * Supported path patterns:
- *   `/by-feature/<featureId>`         → `{ mount: 'by-feature', args: ['<featureId>'] }`
- *   `/by-kind/<kind>`                 → `{ mount: 'by-kind',    args: ['<kind>'] }`
- *   `/by-owner/<ownerId>`             → `{ mount: 'by-owner',   args: ['<ownerId>'] }`
- *   `/graph/<nodeId>/governs`         → `{ mount: 'graph',      args: ['<nodeId>', 'governs'] }`
- *   `/graph/<nodeId>/governed-by`     → `{ mount: 'graph',      args: ['<nodeId>', 'governed-by'] }`
- *   `/<nodeId>`                       → `{ mount: 'node',       args: ['<nodeId>'] }`
+ *   `/by-system/<systemId>`           -> `{ mount: 'by-system', args: ['<systemId>'] }`
+ *   `/by-kind/<kind>`                 → `{ mount: 'by-kind',    args: ['<kind>'] }`
+ *   `/by-owner/<ownerId>`             → `{ mount: 'by-owner',   args: ['<ownerId>'] }`
+ *   `/graph/<nodeId>/governs`         → `{ mount: 'graph',      args: ['<nodeId>', 'governs'] }`
+ *   `/graph/<nodeId>/governed-by`     → `{ mount: 'graph',      args: ['<nodeId>', 'governed-by'] }`
+ *   `/<nodeId>`                       → `{ mount: 'node',       args: ['<nodeId>'] }`
  *
  * The path MUST start with `/`.  Trailing slashes are stripped before parsing.
  *
@@ -205,12 +205,12 @@ export function parsePath(pathString: string): ParsedKnowledgePath {
 
   const [first, ...rest] = segments
 
-  // /by-feature/<featureId>
-  if (first === 'by-feature') {
+  // /by-system/<systemId>
+  if (first === 'by-system') {
     if (rest.length === 0) {
-      throw new Error(`parsePath: /by-feature requires a featureId argument, got: "${pathString}"`)
+      throw new Error(`parsePath: /by-system requires a systemId argument, got: "${pathString}"`)
     }
-    return { mount: 'by-feature', args: [rest.join('/')] }
+    return { mount: 'by-system', args: [rest.join('/')] }
   }
 
   // /by-kind/<kind>
@@ -251,6 +251,7 @@ export function parsePath(pathString: string): ParsedKnowledgePath {
   }
 
   throw new Error(
-    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-feature/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
+    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-system/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
   )
 }
+

package/src/organization-model/README.md

@@ -1,20 +1,19 @@
 # Organization Model
 
-The organization model is the published semantic contract that maps a tenant's product shape to flat feature hierarchy, shell navigation, business semantics, and graph bindings.
+The organization model is the published semantic contract that maps a tenant's System hierarchy, shell navigation, business semantics, resource governance, and graph bindings.
 
-Use this module when resolving or validating an organization's contract before wiring UI shells, routing, feature gates, or domain-specific capability checks.
+Use this module when resolving or validating an organization's contract before wiring UI shells, routing, system gates, or domain-specific capability checks.
 
 ## Published Exports
 
 The public entry point exposes:
 
 - `OrganizationModelSchema`
-- `FeatureSchema`
 - `DEFAULT_ORGANIZATION_MODEL`
 - `defineOrganizationModel`
 - `resolveOrganizationModel`
 - `createFoundationOrganizationModel`
-- node ID and feature helper types
+- node ID and System helper types
 - `OrganizationModel` and supporting domain types
 
 Import it from the published subpath:
@@ -36,8 +35,8 @@ The model is versioned and currently validates against `version: 1`.
 Top-level fields:
 
 - `version`
+- `domainMetadata`
 - `branding`
-- `features`
 - `navigation`
 - `sales`
 - `prospecting`
@@ -47,35 +46,83 @@ Top-level fields:
 - `offerings`
 - `roles`
 - `goals`
+- `systems`
+- `resources`
+- `capabilities`
+- `policies`
 - `statuses`
-- `operations`
+- `knowledge`
 
-Resources bind to the graph from deployment metadata through `links` and `category`.
+The pure collection domains are id-keyed maps: `systems`, `roles`, `goals`, `customers`, `offerings`, `resources`, `capabilities`, `policies`, and `statuses`. The map key must match the entry `id`. Entries carry `order` for deterministic ordered views; use `listDomain(record)` when order matters.
 
-## Feature Set
+Resource identity is authored in `resources`. Runtime workflows, agents, integrations, and scripts import those descriptors, derive `resourceId` and kind from them, and attach executable behavior in operations code.
 
-Feature hierarchy is authored as a flat array. Dotted IDs define parent/child relationships:
+## System Set
+
+System hierarchy is authored as an id-keyed `systems` map. Dotted IDs and `parentSystemId` define parent/child relationships:
 
 ```ts
-features: [
-  { id: 'dashboard', label: 'Dashboard', enabled: true, path: '/', uiPosition: 'sidebar-primary' },
-  { id: 'sales', label: 'Sales', enabled: true, uiPosition: 'sidebar-primary' },
-  { id: 'sales.crm', label: 'CRM', enabled: true, path: '/crm' },
-  { id: 'operations.resources', label: 'Resources', enabled: true, path: '/operations/resources' }
-]
+systems: {
+  dashboard: { id: 'dashboard', order: 10, label: 'Dashboard', lifecycle: 'active' },
+  sales: { id: 'sales', order: 20, label: 'Sales', lifecycle: 'active' },
+  clients: { id: 'clients', order: 30, label: 'Clients', lifecycle: 'active' },
+  projects: { id: 'projects', order: 40, label: 'Projects', lifecycle: 'active' }
+}
 ```
 
-Containers omit `path`; leaves provide `path`. `uiPosition`, `requiresAdmin`, and `devOnly` inherit from ancestors.
-Development-only features remain in the contract with `enabled: true` and `devOnly: true`; shell consumers hide them and guard their paths outside development mode.
+Systems describe semantic ownership, hierarchy, lifecycle, access, and governance. Sidebar presentation is authored separately under `navigation.sidebar`; UI-backed Systems may still provide `ui.path` for route matching during the migration, but they do not author composed surface lists. Lifecycle values such as `active`, `beta`, `deprecated`, and `archived` replace the old feature enabled/dev-only split.
+
+## Sidebar Navigation
+
+Shell navigation is authored as a recursive sidebar tree:
+
+```ts
+navigation: {
+  sidebar: {
+    primary: {
+      dashboard: {
+        type: 'surface',
+        order: 10,
+        label: 'Dashboard',
+        path: '/',
+        surfaceType: 'dashboard',
+        targets: { systems: ['dashboard'] }
+      },
+      business: {
+        type: 'group',
+        order: 20,
+        label: 'Business',
+        children: {
+          clients: {
+            type: 'surface',
+            order: 20,
+            label: 'Clients',
+            path: '/clients',
+            surfaceType: 'list',
+            targets: { systems: ['clients'] }
+          }
+        }
+      }
+    },
+    bottom: {}
+  }
+}
+```
+
+Routeable sidebar leaves are projected into flat semantic surface DTOs by `projectOrganizationSurfaces(model)`. Do not author top-level `surfaces` or `navigationGroups` fields on `OrganizationModel`.
 
 ## Graph IDs
 
 Cross-collection links use kind-prefixed IDs:
 
-- `feature:sales.crm`
+- `system:sales.crm`
 - `integration:instantly`
 - `resource:lead-import`
-- `capability:operations.queue.review`
+- `action:operations.queue.review`
+
+## Resource Descriptors
+
+The OM Resources domain is governance-only. Descriptors declare canonical `id`, required `systemPath`, governance `status`, and optional role ownership. `DeploymentSpec` remains the runtime/deploy assembly around those descriptors, not a second resource identity catalog.
 
 ## Resolution Semantics
 
@@ -83,20 +130,20 @@ Cross-collection links use kind-prefixed IDs:
 - `resolveOrganizationModel()` deep-merges a partial override into the default model, then validates it.
 - `createFoundationOrganizationModel()` resolves the canonical model and returns UI-facing helper outputs.
 - Plain objects merge recursively.
+- Id-keyed domain maps merge additively by key.
 - Arrays replace the default value.
 - Missing fields fall back to `DEFAULT_ORGANIZATION_MODEL`.
 
 ## Referential Integrity
 
-- Feature IDs must be unique.
-- Child feature IDs require ancestor feature nodes.
-- Container features omit `path`.
-- Leaf features provide `path`.
-- Resource links are validated against graph node IDs during registry registration.
+- System IDs must be unique.
+- Child System IDs require valid ancestors or `parentSystemId` links.
+- Systems with UI provide `ui.path`.
+- Systems, resources, roles, knowledge nodes, and goals must resolve their declared cross-references.
 
 ## Practical Guidance
 
 - Use `resolveOrganizationModel()` when you need a runtime-safe model.
 - Use `defineOrganizationModel()` when authoring static overrides.
-- Keep feature IDs stable because shell routing, gating, breadcrumbs, and docs depend on them.
-- Put semantic resource relationships on resource metadata, not on feature nodes.
+- Keep System IDs stable because shell routing, gating, breadcrumbs, and docs depend on them.
+- Put resource identity and governance in `resources`; attach executable behavior in operations.

package/src/organization-model/__tests__/content-kinds-registry.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest'
+import {
+  CONTENT_KIND_REGISTRY,
+  defineContentType,
+  lookupContentType,
+  pipelineKind,
+  stageKind,
+  templateKind,
+  templateStepKind,
+  statusFlowKind,
+  statusKind,
+  configKvKind
+} from '../content-kinds/index'
+import type { ContentTypeDefinition, ContentTypeKey } from '../content-kinds/types'
+
+// ---------------------------------------------------------------------------
+// CONTENT_KIND_REGISTRY shape (D8: static object literal)
+// ---------------------------------------------------------------------------
+
+describe('CONTENT_KIND_REGISTRY', () => {
+  it('contains all 7 expected keys', () => {
+    const expectedKeys: ContentTypeKey[] = [
+      'schema:pipeline',
+      'schema:stage',
+      'schema:template',
+      'schema:template-step',
+      'schema:status-flow',
+      'schema:status',
+      'config:kv'
+    ]
+    for (const key of expectedKeys) {
+      expect(CONTENT_KIND_REGISTRY).toHaveProperty(key)
+    }
+  })
+
+  it('maps schema:pipeline to the pipelineKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:pipeline']).toBe(pipelineKind)
+  })
+
+  it('maps schema:stage to the stageKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:stage']).toBe(stageKind)
+  })
+
+  it('maps schema:template to the templateKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:template']).toBe(templateKind)
+  })
+
+  it('maps schema:template-step to the templateStepKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:template-step']).toBe(templateStepKind)
+  })
+
+  it('maps schema:status-flow to the statusFlowKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:status-flow']).toBe(statusFlowKind)
+  })
+
+  it('maps schema:status to the statusKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:status']).toBe(statusKind)
+  })
+
+  it('maps config:kv to the configKvKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['config:kv']).toBe(configKvKind)
+  })
+
+  it('has exactly 7 keys (no extra unintended entries)', () => {
+    expect(Object.keys(CONTENT_KIND_REGISTRY)).toHaveLength(7)
+  })
+
+  it('every entry has kind, type, payloadSchema, label, and description fields', () => {
+    for (const [key, def] of Object.entries(CONTENT_KIND_REGISTRY)) {
+      expect(def).toHaveProperty('kind')
+      expect(def).toHaveProperty('type')
+      expect(def).toHaveProperty('payloadSchema')
+      expect(typeof def.kind).toBe('string')
+      expect(typeof def.type).toBe('string')
+      expect(def.label).toBeTruthy()
+      expect(def.description).toBeTruthy()
+      // key must equal kind:type
+      expect(key).toBe(`${def.kind}:${def.type}`)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parentTypes constraint
+// ---------------------------------------------------------------------------
+
+describe('parentTypes constraints', () => {
+  it('schema:pipeline has empty parentTypes (top-level, no parent required)', () => {
+    expect(pipelineKind.parentTypes).toEqual([])
+  })
+
+  it('schema:stage parentTypes is ["schema:pipeline"]', () => {
+    expect(stageKind.parentTypes).toEqual(['schema:pipeline'])
+  })
+
+  it('schema:template has empty parentTypes', () => {
+    expect(templateKind.parentTypes).toEqual([])
+  })
+
+  it('schema:template-step parentTypes is ["schema:template"]', () => {
+    expect(templateStepKind.parentTypes).toEqual(['schema:template'])
+  })
+
+  it('schema:status-flow has empty parentTypes', () => {
+    expect(statusFlowKind.parentTypes).toEqual([])
+  })
+
+  it('schema:status parentTypes is ["schema:status-flow"]', () => {
+    expect(statusKind.parentTypes).toEqual(['schema:status-flow'])
+  })
+
+  it('config:kv has empty parentTypes', () => {
+    expect(configKvKind.parentTypes).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// lookupContentType
+// ---------------------------------------------------------------------------
+
+describe('lookupContentType', () => {
+  it('returns the correct definition for schema:pipeline', () => {
+    const def = lookupContentType('schema', 'pipeline')
+    expect(def).toBe(pipelineKind)
+  })
+
+  it('returns the correct definition for schema:stage', () => {
+    const def = lookupContentType('schema', 'stage')
+    expect(def).toBe(stageKind)
+  })
+
+  it('returns the correct definition for config:kv', () => {
+    const def = lookupContentType('config', 'kv')
+    expect(def).toBe(configKvKind)
+  })
+
+  it('returns undefined for an unregistered kind (D2: not an error)', () => {
+    const def = lookupContentType('tenant', 'custom-thing')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for unknown kind with valid type', () => {
+    const def = lookupContentType('unknown', 'pipeline')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for valid kind with unknown type', () => {
+    const def = lookupContentType('schema', 'not-a-real-type')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for empty kind string', () => {
+    const def = lookupContentType('', 'pipeline')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for empty type string', () => {
+    const def = lookupContentType('schema', '')
+    expect(def).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// defineContentType (identity factory, L16)
+// ---------------------------------------------------------------------------
+
+describe('defineContentType', () => {
+  it('is an identity function — returns the same object reference', () => {
+    const def: ContentTypeDefinition<{ name: string }> = {
+      kind: 'tenant',
+      type: 'custom',
+      payloadSchema: { safeParse: () => ({ success: true, data: { name: 'x' } }) } as unknown as ContentTypeDefinition<{
+        name: string
+      }>['payloadSchema'],
+      label: 'Custom',
+      description: 'A tenant-defined type.',
+      parentTypes: []
+    }
+    const result = defineContentType(def)
+    expect(result).toBe(def)
+  })
+
+  it('does NOT mutate the input definition', () => {
+    const def: ContentTypeDefinition<unknown> = {
+      kind: 'schema',
+      type: 'pipeline',
+      payloadSchema: {
+        safeParse: () => ({ success: true, data: {} })
+      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
+      parentTypes: []
+    }
+    const original = { ...def }
+    defineContentType(def)
+    expect(def).toEqual(original)
+  })
+
+  it('does NOT register the definition globally (no side-effects on CONTENT_KIND_REGISTRY)', () => {
+    const tenantKey = 'tenant:my-new-type'
+    defineContentType({
+      kind: 'tenant',
+      type: 'my-new-type',
+      payloadSchema: {
+        safeParse: () => ({ success: true, data: {} })
+      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
+      parentTypes: []
+    })
+    // After calling defineContentType, the registry must remain unchanged (D8: static)
+    expect(CONTENT_KIND_REGISTRY).not.toHaveProperty(tenantKey)
+  })
+})