@elevasis/core 0.36.0 → 0.37.0

package/dist/test-utils/index.d.ts

@@ -4046,6 +4046,84 @@ declare const OrganizationModelSchema: z.ZodObject<{
             primary: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<SidebarNode, unknown, z.core.$ZodTypeInternals<SidebarNode, unknown>>>>;
             bottom: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<SidebarNode, unknown, z.core.$ZodTypeInternals<SidebarNode, unknown>>>>;
         }, z.core.$strip>>;
+        topbar: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            tooltip: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                message: "message";
+                error: "error";
+                agent: "agent";
+                workflow: "workflow";
+                "google-sheets": "google-sheets";
+                dashboard: "dashboard";
+                calendar: "calendar";
+                sales: "sales";
+                crm: "crm";
+                "lead-gen": "lead-gen";
+                projects: "projects";
+                clients: "clients";
+                operations: "operations";
+                monitoring: "monitoring";
+                knowledge: "knowledge";
+                settings: "settings";
+                admin: "admin";
+                archive: "archive";
+                business: "business";
+                finance: "finance";
+                platform: "platform";
+                seo: "seo";
+                playbook: "playbook";
+                strategy: "strategy";
+                reference: "reference";
+                integration: "integration";
+                database: "database";
+                user: "user";
+                team: "team";
+                gmail: "gmail";
+                attio: "attio";
+                overview: "overview";
+                "command-view": "command-view";
+                "command-queue": "command-queue";
+                pipeline: "pipeline";
+                lists: "lists";
+                resources: "resources";
+                approve: "approve";
+                reject: "reject";
+                retry: "retry";
+                edit: "edit";
+                view: "view";
+                launch: "launch";
+                "message-plus": "message-plus";
+                escalate: "escalate";
+                promote: "promote";
+                submit: "submit";
+                email: "email";
+                success: "success";
+                warning: "warning";
+                info: "info";
+                pending: "pending";
+                bolt: "bolt";
+                building: "building";
+                briefcase: "briefcase";
+                apps: "apps";
+                graph: "graph";
+                shield: "shield";
+                users: "users";
+                "chart-bar": "chart-bar";
+                search: "search";
+            }>, z.ZodString]>>;
+            order: z.ZodOptional<z.ZodNumber>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            devOnly: z.ZodOptional<z.ZodBoolean>;
+            requiresAdmin: z.ZodOptional<z.ZodBoolean>;
+            targets: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+                systems: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+                entities: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+                resources: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+                actions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     identity: z.ZodDefault<z.ZodObject<{
         mission: z.ZodDefault<z.ZodString>;
@@ -4714,6 +4792,7 @@ declare const OrganizationModelSchema: z.ZodObject<{
             edit: "edit";
             view: "view";
             launch: "launch";
+            "message-plus": "message-plus";
             escalate: "escalate";
             promote: "promote";
             submit: "submit";

package/dist/test-utils/index.js

@@ -19817,6 +19817,7 @@ var ORGANIZATION_MODEL_ICON_TOKENS = [
   "view",
   "launch",
   "message",
+  "message-plus",
   "escalate",
   "promote",
   "submit",
@@ -20001,9 +20002,22 @@ var SidebarNavigationSchema = z.object({
   primary: SidebarSectionSchema,
   bottom: SidebarSectionSchema
 }).default({ primary: {}, bottom: {} });
+var TopbarActionNodeSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  tooltip: DescriptionSchema.optional(),
+  icon: IconNameSchema.optional(),
+  order: z.number().int().optional(),
+  enabled: z.boolean().default(true),
+  devOnly: z.boolean().optional(),
+  requiresAdmin: z.boolean().optional(),
+  targets: SidebarSurfaceTargetsSchema.optional()
+});
+var TopbarSectionSchema = z.record(z.string(), TopbarActionNodeSchema).default({});
 var OrganizationModelNavigationSchema = z.object({
-  sidebar: SidebarNavigationSchema
-}).default({ sidebar: { primary: {}, bottom: {} } });
+  sidebar: SidebarNavigationSchema,
+  topbar: TopbarSectionSchema
+}).default({ sidebar: { primary: {}, bottom: {} }, topbar: {} });
 z.object({
   id: ModelIdSchema,
   label: LabelSchema,
@@ -21608,7 +21622,8 @@ var DEFAULT_ORGANIZATION_MODEL_NAVIGATION = {
   sidebar: {
     primary: {},
     bottom: {}
-  }
+  },
+  topbar: {}
 };
 var DEFAULT_ORGANIZATION_MODEL = {
   version: 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,

package/src/_gen/__tests__/__snapshots__/contracts.md.snap

@@ -135,6 +135,18 @@ export type OrganizationModelSidebarSurfaceNode = Extract<OrganizationModelSideb
 export type OrganizationModelSidebarGroupNode = Extract<OrganizationModelSidebarNode, { type: 'group' }>
 ```
 
+### `OrganizationModelTopbarActionNode`
+
+```typescript
+export type OrganizationModelTopbarActionNode = z.infer<typeof TopbarActionNodeSchema>
+```
+
+### `OrganizationModelTopbarSection`
+
+```typescript
+export type OrganizationModelTopbarSection = z.infer<typeof TopbarSectionSchema>
+```
+
 ### `OrganizationModelTechStackEntry`
 
 ```typescript
@@ -845,6 +857,57 @@ export interface ShellRuntime {
 }
 ```
 
+### `ResolvedTopbarAction`
+
+```typescript
+/**
+ * A resolved topbar action — the OM node after gating/filtering, with icon resolved
+ * from the semantic icon registry. Passed to `TopbarActionModule.render`.
+ */
+export interface ResolvedTopbarAction {
+  id: string
+  label: string
+  tooltip?: string
+  icon: TablerIconComponent
+  order: number
+}
+```
+
+### `TopbarActionModule`
+
+```typescript
+/**
+ * A topbar action module — binds a registry key to UI behavior (a render callback).
+ * The key must match `navigation.topbar[id]`. The OM supplies data + visibility;
+ * the module supplies behavior.
+ */
+export interface TopbarActionModule {
+  /** Stable key that matches the `id` of a `navigation.topbar` node. */
+  key: string
+  /** Render the topbar action. Receives the resolved OM node (icon pre-resolved). */
+  render: (ctx: { node: ResolvedTopbarAction }) => ReactNode
+}
+```
+
+### `ResolvedTopbarActionEntry`
+
+```typescript
+/** A joined entry emitted by `getTopbarActions`: resolved OM node + module behavior. */
+export interface ResolvedTopbarActionEntry {
+  node: ResolvedTopbarAction
+  render: TopbarActionModule['render']
+}
+```
+
+### `TopbarActionsProjectionOptions`
+
+```typescript
+export interface TopbarActionsProjectionOptions {
+  isPlatformAdmin?: boolean
+  isDev?: boolean
+}
+```
+
 ### `OrganizationGraphSystemBridge`
 
 ```typescript
@@ -868,6 +931,8 @@ export interface OrganizationGraphContextValue {
 ```typescript
 export interface ElevasisSystemsProviderProps {
   systems?: SystemModule[]
+  /** Registered topbar action modules. OM node presence controls visibility; module supplies behavior. */
+  topbarActions?: TopbarActionModule[]
   organizationModel?: ElevasisOrganizationModel
   timeRange?: TimeRange
   operationsApiUrl?: string
@@ -886,6 +951,8 @@ export interface ElevasisSystemsContextValue {
   shellModel: ResolvedShellModel
   shellRuntime: ShellRuntime
   getSidebarLinks: (options?: ShellSidebarProjectionOptions) => ShellSidebarLinkGroup[]
+  /** Returns the list of topbar actions visible to the current user, in order. */
+  getTopbarActions: (options?: TopbarActionsProjectionOptions) => ResolvedTopbarActionEntry[]
   enabledResolvedSystems: ResolvedSystemModule[]
   resolvedSystems: ResolvedSystemModule[]
   organizationGraph: OrganizationGraphContextValue

package/src/organization-model/__tests__/domains/navigation-topbar.test.ts

@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest'
+import {
+  OrganizationModelNavigationSchema,
+  TopbarActionNodeSchema,
+  TopbarSectionSchema
+} from '../../domains/navigation'
+import { OrganizationModelSchema } from '../../schema'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMinimalSystems() {
+  return {
+    dashboard: {
+      id: 'dashboard',
+      order: 10,
+      label: 'Dashboard',
+      enabled: true,
+      lifecycle: 'active' as const,
+      path: '/'
+    }
+  }
+}
+
+function makeMinimalModel(overrides: Record<string, unknown> = {}) {
+  return {
+    version: 1,
+    branding: { organizationName: 'Test', productName: 'Test OS', shortName: 'Test' },
+    systems: makeMinimalSystems(),
+    entities: {},
+    actions: {},
+    ...overrides
+  }
+}
+
+// ---------------------------------------------------------------------------
+// TopbarActionNodeSchema
+// ---------------------------------------------------------------------------
+
+describe('TopbarActionNodeSchema — leaf node shape', () => {
+  it('accepts a minimal node (id + label + enabled default)', () => {
+    const result = TopbarActionNodeSchema.safeParse({
+      id: 'request',
+      label: 'Request a feature or report an issue'
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.enabled).toBe(true)
+    }
+  })
+
+  it('accepts a fully populated node', () => {
+    const result = TopbarActionNodeSchema.safeParse({
+      id: 'request',
+      label: 'Request a feature or report an issue',
+      tooltip: 'Request a feature or report an issue',
+      icon: 'message-plus',
+      order: 10,
+      enabled: true,
+      devOnly: false,
+      requiresAdmin: false,
+      targets: { systems: ['monitoring'], actions: [] }
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults enabled to true when omitted', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'docs', label: 'Docs' })
+
+    expect(result.enabled).toBe(true)
+  })
+
+  it('accepts enabled: false to mark an item as hidden', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'docs', label: 'Docs', enabled: false })
+
+    expect(result.enabled).toBe(false)
+  })
+
+  it('accepts optional devOnly flag', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'devtools', label: 'Dev Tools', devOnly: true })
+
+    expect(result.devOnly).toBe(true)
+  })
+
+  it('accepts optional requiresAdmin flag', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'admin-panel', label: 'Admin Panel', requiresAdmin: true })
+
+    expect(result.requiresAdmin).toBe(true)
+  })
+
+  it('rejects a node missing id', () => {
+    const result = TopbarActionNodeSchema.safeParse({ label: 'No Id' })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a node missing label', () => {
+    const result = TopbarActionNodeSchema.safeParse({ id: 'no-label' })
+
+    expect(result.success).toBe(false)
+  })
+
+  it('does NOT have a path field (leaf, not a route)', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'request', label: 'Request' })
+
+    expect('path' in result).toBe(false)
+  })
+
+  it('does NOT have a surfaceType field (closed enum untouched)', () => {
+    const result = TopbarActionNodeSchema.parse({ id: 'request', label: 'Request' })
+
+    expect('surfaceType' in result).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// TopbarSectionSchema
+// ---------------------------------------------------------------------------
+
+describe('TopbarSectionSchema — flat map of topbar action nodes', () => {
+  it('defaults to an empty record', () => {
+    const result = TopbarSectionSchema.parse(undefined)
+
+    expect(result).toEqual({})
+  })
+
+  it('accepts a populated map', () => {
+    const result = TopbarSectionSchema.safeParse({
+      request: { id: 'request', label: 'Request' },
+      docs: { id: 'docs', label: 'Docs', icon: 'knowledge' }
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(Object.keys(result.data)).toEqual(['request', 'docs'])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OrganizationModelNavigationSchema — topbar field added
+// ---------------------------------------------------------------------------
+
+describe('OrganizationModelNavigationSchema — topbar region', () => {
+  it('defaults topbar to an empty record', () => {
+    const result = OrganizationModelNavigationSchema.parse({})
+
+    expect(result.topbar).toEqual({})
+  })
+
+  it('retains existing sidebar defaults (regression: append only, sidebar untouched)', () => {
+    const result = OrganizationModelNavigationSchema.parse({})
+
+    expect(result.sidebar.primary).toEqual({})
+    expect(result.sidebar.bottom).toEqual({})
+  })
+
+  it('accepts topbar nodes alongside sidebar', () => {
+    const result = OrganizationModelNavigationSchema.safeParse({
+      sidebar: { primary: {}, bottom: {} },
+      topbar: {
+        request: {
+          id: 'request',
+          label: 'Request a feature or report an issue',
+          tooltip: 'Request a feature or report an issue',
+          icon: 'message-plus',
+          order: 10,
+          enabled: true
+        }
+      }
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.topbar['request']?.id).toBe('request')
+      expect(result.data.topbar['request']?.icon).toBe('message-plus')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OrganizationModelSchema — navigation.topbar propagates through full schema
+// ---------------------------------------------------------------------------
+
+describe('OrganizationModelSchema — navigation.topbar contract', () => {
+  it('accepts a model with topbar declared', () => {
+    const result = OrganizationModelSchema.safeParse(
+      makeMinimalModel({
+        navigation: {
+          topbar: {
+            request: {
+              id: 'request',
+              label: 'Request a feature or report an issue',
+              tooltip: 'Request a feature or report an issue',
+              icon: 'message-plus',
+              order: 10,
+              enabled: true
+            }
+          }
+        }
+      })
+    )
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.navigation.topbar['request']?.id).toBe('request')
+    }
+  })
+
+  it('defaults navigation.topbar to empty when navigation is omitted', () => {
+    const result = OrganizationModelSchema.safeParse(makeMinimalModel())
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.navigation.topbar).toEqual({})
+    }
+  })
+
+  it('defaults navigation.topbar to empty when only sidebar is provided', () => {
+    const result = OrganizationModelSchema.safeParse(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              dashboard: {
+                type: 'surface',
+                label: 'Dashboard',
+                path: '/',
+                surfaceType: 'dashboard',
+                order: 10
+              }
+            },
+            bottom: {}
+          }
+        }
+      })
+    )
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.navigation.topbar).toEqual({})
+    }
+  })
+
+  it('coexists with sidebar — both sections independently populated', () => {
+    const result = OrganizationModelSchema.safeParse(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              dashboard: {
+                type: 'surface',
+                label: 'Dashboard',
+                path: '/',
+                surfaceType: 'dashboard',
+                order: 10
+              }
+            },
+            bottom: {}
+          },
+          topbar: {
+            request: {
+              id: 'request',
+              label: 'Request',
+              order: 10,
+              enabled: true
+            }
+          }
+        }
+      })
+    )
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.navigation.sidebar.primary['dashboard']?.label).toBe('Dashboard')
+      expect(result.data.navigation.topbar['request']?.label).toBe('Request')
+    }
+  })
+})

package/src/organization-model/defaults.ts

@@ -37,7 +37,8 @@ const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: OrganizationModelNavigation = {
   sidebar: {
     primary: {},
     bottom: {}
-  }
+  },
+  topbar: {}
 }
 
 export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {