@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.2

package/studio/server/views/session.ts

@@ -0,0 +1,166 @@
+import type {
+  StudioSchemaBundle,
+  ViewInfo,
+  ViewSessionResult,
+  ViewTargetCandidate,
+} from '../../shared/types'
+import type { StudioCliDecoder } from '../cli'
+
+import { decodeJsonObject, runStudioCliJson } from '../cli'
+import { activeInstanceName } from '../instances/active'
+import { rememberTarget } from './selection-repository'
+import { listViewTargets, viewDefinitionBindings } from './target'
+
+export { conciseCliFailure } from '../cli'
+
+interface AstraleResult<T> {
+  ok: boolean
+  data: T | null
+  detail: string
+}
+
+let viewSessionCommandTail: Promise<void> = Promise.resolve()
+
+export function viewSessionArgs(
+  origin: string,
+  slug: string,
+  instance: string,
+  targetRef?: string,
+): string[] {
+  const args = ['view', `/:${assertOrigin(origin)}:view.${assertViewSlug(slug)}`]
+  if (targetRef) args.push('--target', targetRef)
+  args.push('--no-open', '--json', '-i', instance)
+  return args
+}
+
+interface OpenedViewPayload {
+  session?: {
+    id?: string
+    pageUrl?: string
+    view?: { route?: { href?: string } }
+  }
+}
+
+function decodeOpenedViewPayload(value: unknown): OpenedViewPayload | null {
+  const payload = decodeJsonObject(value)
+  if (!payload) return null
+  const session = decodeJsonObject(payload.session)
+  if (!session) return null
+  const view = decodeJsonObject(session.view)
+  const route = decodeJsonObject(view?.route)
+  if (
+    typeof session.id !== 'string' ||
+    typeof session.pageUrl !== 'string' ||
+    typeof route?.href !== 'string'
+  ) {
+    return null
+  }
+  return {
+    session: {
+      id: session.id,
+      pageUrl: session.pageUrl,
+      view: { route: { href: route.href } },
+    },
+  }
+}
+
+export function readyViewSession(
+  opened: OpenedViewPayload | null,
+  target: ViewTargetCandidate | null,
+): Extract<ViewSessionResult, { status: 'ready' }> | null {
+  const session = opened?.session
+  const viewUrl = session?.view?.route?.href
+  if (!session?.id || !session.pageUrl || !viewUrl) return null
+  return {
+    status: 'ready',
+    sessionId: session.id,
+    pageUrl: session.pageUrl,
+    viewUrl,
+    target,
+  }
+}
+
+export async function launchViewSession(
+  root: string,
+  origin: string,
+  view: ViewInfo,
+  bundle: StudioSchemaBundle | null,
+  request: { targetId?: unknown },
+  timeoutMs: number,
+): Promise<ViewSessionResult> {
+  const instance = await activeInstanceName()
+  if (!instance) return { status: 'unavailable', reason: 'No active Astrale instance.' }
+
+  let target: ViewTargetCandidate | null = null
+  if (viewDefinitionBindings(origin, view, bundle).length > 0) {
+    const targetId = typeof request.targetId === 'string' ? request.targetId.trim() : ''
+    if (!targetId) return { status: 'unavailable', reason: 'Select a target before opening.' }
+    const targets = await listViewTargets(root, origin, view, bundle, instance, timeoutMs)
+    if (targets.status !== 'available') {
+      return { status: 'unavailable', reason: targets.reason ?? 'Targets could not be queried.' }
+    }
+    target = targets.items.find((item) => item.id === targetId) ?? null
+    if (!target) {
+      return {
+        status: 'unavailable',
+        reason: 'That target no longer exists or is no longer visible. Choose another target.',
+      }
+    }
+  }
+
+  const opened = await runViewSessionCommand<OpenedViewPayload>(
+    viewSessionArgs(origin, view.slug, instance, target?.ref),
+    Math.max(20_000, timeoutMs + 12_000),
+    decodeOpenedViewPayload,
+  )
+  const session = opened.ok ? readyViewSession(opened.data, target) : null
+  if (!session) {
+    return {
+      status: 'unavailable',
+      reason: opened.detail || '`astrale view` could not start the preview session.',
+    }
+  }
+
+  if (target) rememberTarget(root, instance, view.slug, target)
+  return session
+}
+
+export async function closeViewSession(sessionId: string): Promise<{ ok: true }> {
+  if (!/^v-[0-9a-f]+$/.test(sessionId)) return { ok: true }
+  await runViewSessionCommand(['view', '--close', sessionId, '--json'], 6000, decodeJsonObject)
+  return { ok: true }
+}
+
+function assertOrigin(value: string): string {
+  if (!/^[a-z0-9][a-z0-9.-]*$/i.test(value)) throw new Error(`Invalid domain origin: ${value}`)
+  return value
+}
+
+function assertViewSlug(value: string): string {
+  if (!/^[a-z][a-z0-9-]*$/.test(value)) throw new Error(`Invalid view slug: ${value}`)
+  return value
+}
+
+function runViewSessionCommand<T>(
+  args: string[],
+  timeoutMs: number,
+  decoder: StudioCliDecoder<T>,
+): Promise<AstraleResult<T>> {
+  const command = viewSessionCommandTail.then(
+    () => runAstraleJson(args, timeoutMs, decoder),
+    () => runAstraleJson(args, timeoutMs, decoder),
+  )
+  viewSessionCommandTail = command.then(
+    () => undefined,
+    () => undefined,
+  )
+  return command
+}
+
+async function runAstraleJson<T>(
+  args: string[],
+  timeoutMs: number,
+  decoder: StudioCliDecoder<T>,
+): Promise<AstraleResult<T>> {
+  return runStudioCliJson(args, decoder, { timeoutMs })
+}

package/studio/server/{state/views.test.ts → views/target.test.ts}

@@ -1,50 +1,10 @@
 import { describe, expect, test } from 'bun:test'
 
-import type {
-  RememberedViewTarget,
-  StudioSchemaBundle,
-  ViewInfo,
-  ViewTargetCandidate,
-} from '../../shared/types'
+import type { StudioSchemaBundle, ViewInfo } from '../../shared/types'
 
-import {
-  conciseCliFailure,
-  readyViewSession,
-  reconcileRememberedTarget,
-  targetDefinition,
-  targetFromRow,
-  viewDefinitionBindings,
-  viewSessionArgs,
-} from './views'
-
-describe('view session command', () => {
-  test('opens the installed ViewPath without rejected placement overrides', () => {
-    const args = viewSessionArgs('issues.astrale.ai', 'issue-detail', 'staging', '@issue-1')
-    expect(args).toEqual([
-      'view',
-      '/:issues.astrale.ai:view.issue-detail',
-      '--target',
-      '@issue-1',
-      '--no-open',
-      '--json',
-      '-i',
-      'staging',
-    ])
-    expect(args).not.toContain('--view-url')
-    expect(args).not.toContain('--handshake')
-  })
-
-  test('omits --target for a standalone view', () => {
-    expect(viewSessionArgs('issues.astrale.ai', 'dashboard', 'local')).toEqual([
-      'view',
-      '/:issues.astrale.ai:view.dashboard',
-      '--no-open',
-      '--json',
-      '-i',
-      'local',
-    ])
-  })
+import { targetDefinition, viewDefinitionBindings } from './target'
 
+describe('view target definitions', () => {
   test('preserves canonical interface View target coordinates', () => {
     const view = { slug: 'users', kind: 'unknown' } satisfies ViewInfo
     const bundle = {
@@ -63,11 +23,7 @@ describe('view session command', () => {
     } as unknown as StudioSchemaBundle
 
     expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
-      {
-        className: 'Identity',
-        classOrigin: 'kernel.astrale.ai',
-        kind: 'interface',
-      },
+      { className: 'Identity', classOrigin: 'kernel.astrale.ai', kind: 'interface' },
     ])
     expect(targetDefinition('Identity', 'kernel.astrale.ai', 'interface')).toBe(
       '/:kernel.astrale.ai:interface.Identity',
@@ -109,13 +65,8 @@ describe('view session command', () => {
   test('treats an exact Domain target as authoritative over legacy viewFor', () => {
     const view = { slug: 'home', kind: 'unknown', viewFor: 'User' } satisfies ViewInfo
     const bundle = {
-      ir: {
-        views: {
-          home: { name: 'home', auth: 'required', target: { kind: 'domain' } },
-        },
-      },
+      ir: { views: { home: { name: 'home', auth: 'required', target: { kind: 'domain' } } } },
     } as unknown as StudioSchemaBundle
-
     expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([])
   })
 
@@ -137,9 +88,7 @@ describe('view session command', () => {
             ref: { origin: 'shell.astrale.ai', kind: 'interface', name: 'Named' },
           },
         },
-        imports: {
-          Named: { origin: 'legacy.invalid', definition: 'class' },
-        },
+        imports: { Named: { origin: 'legacy.invalid', definition: 'class' } },
         importsByKey: {
           'directory.example.dev:interface.Named': {
             origin: 'directory.example.dev',
@@ -169,17 +118,10 @@ describe('view session command', () => {
         views: {},
         classes: {},
         interfaces: {},
-        imports: {
-          User: { origin: 'accounts.example.dev', definition: 'interface' },
-        },
-      },
-    } as unknown as StudioSchemaBundle
-    const exact = {
-      ir: {
-        ...legacy.ir,
-        importsByKey: {},
+        imports: { User: { origin: 'accounts.example.dev', definition: 'interface' } },
       },
     } as unknown as StudioSchemaBundle
+    const exact = { ir: { ...legacy.ir, importsByKey: {} } } as unknown as StudioSchemaBundle
 
     expect(viewDefinitionBindings('shell.astrale.ai', view, legacy)).toEqual([
       { className: 'User', classOrigin: 'accounts.example.dev', kind: 'interface' },
@@ -187,99 +129,6 @@ describe('view session command', () => {
     expect(viewDefinitionBindings('shell.astrale.ai', view, exact)).toEqual([])
   })
 
-  test('reads the verified placement URL from the current CLI session route', () => {
-    expect(
-      readyViewSession(
-        {
-          session: {
-            id: 'v-a1b2',
-            pageUrl: 'http://127.0.0.1:4419/s/nonce/',
-            view: { route: { href: 'https://issues.example/ui/issue' } },
-          },
-        },
-        null,
-      ),
-    ).toEqual({
-      status: 'ready',
-      sessionId: 'v-a1b2',
-      pageUrl: 'http://127.0.0.1:4419/s/nonce/',
-      viewUrl: 'https://issues.example/ui/issue',
-      target: null,
-    })
-    expect(
-      readyViewSession(
-        {
-          session: {
-            id: 'v-old',
-            pageUrl: 'http://127.0.0.1:4419/s/old/',
-            view: { url: 'https://legacy.invalid/view' },
-          },
-        } as never,
-        null,
-      ),
-    ).toBeNull()
-  })
-})
-
-test('reduces CLI stack output to the actionable kernel failure', () => {
-  expect(
-    conciseCliFailure(
-      `275 |   if (code === KERNEL_ERROR_CODES.INVALID_REQUEST)\n276 |\nPermissionDeniedError: Permission denied: READ on /:issues.astrale.ai:view.issue\n details: {\n  method: \"View:resolve\"\n}\n at mapServerError (errors.ts:280:61)\nBun v1.3.14`,
-    ),
-  ).toBe('PermissionDeniedError: Permission denied: READ on /:issues.astrale.ai:view.issue')
-})
-
-describe('target candidates', () => {
-  const remembered: RememberedViewTarget = {
-    id: 'gone-id',
-    className: 'Issue',
-    classOrigin: 'issues.astrale.ai',
-    label: 'Deleted issue',
-  }
-  const candidate: ViewTargetCandidate = {
-    id: 'live-id',
-    ref: '@live-id',
-    className: 'Issue',
-    classOrigin: 'issues.astrale.ai',
-    label: 'Live issue',
-  }
-
-  test('turns a missing remembered node into an explicit stale selection', () => {
-    expect(reconcileRememberedTarget(remembered, [candidate])).toEqual({
-      selected: null,
-      stale: remembered,
-    })
-    expect(reconcileRememberedTarget({ ...remembered, id: 'live-id' }, [candidate])).toEqual({
-      selected: candidate,
-      stale: null,
-    })
-  })
-
-  test('builds friendly candidates from generic qualified node properties', () => {
-    expect(
-      targetFromRow(
-        {
-          id: 'iss-1',
-          props: {
-            'kernel.astrale.ai:interface.Named.property.name': 'Broken authorization badge',
-            'kernel.astrale.ai:interface.Descriptable.property.description': 'Studio regression',
-            'kernel.astrale.ai:interface.Statused.property.status': 'open',
-          },
-        },
-        'Issue',
-        'issues.astrale.ai',
-      ),
-    ).toEqual({
-      id: 'iss-1',
-      ref: '@iss-1',
-      className: 'Issue',
-      classOrigin: 'issues.astrale.ai',
-      label: 'Broken authorization badge',
-      description: 'Studio regression',
-      status: 'open',
-    })
-  })
-
   test('addresses exact class instances through a canonical Definition source', () => {
     expect(targetDefinition('Issue', 'issues.astrale.ai')).toBe('/:issues.astrale.ai:class.Issue')
   })

package/studio/server/views/target.ts

@@ -0,0 +1,248 @@
+import type {
+  StudioSchemaBundle,
+  ViewInfo,
+  ViewTargetCandidate,
+  ViewTargetResult,
+} from '../../shared/types'
+import type { StudioCliDecoder } from '../cli'
+
+import { decodeJsonObject, runStudioCliJson } from '../cli'
+import { reconcileRememberedTarget, targetFromRow, type RawTargetRow } from './model'
+import { readRememberedTarget } from './selection-repository'
+
+const TARGET_LIMIT = 200
+
+interface AstraleResult<T> {
+  ok: boolean
+  data: T | null
+  detail: string
+}
+
+interface RawQueryResult {
+  graph?: { nodes?: RawTargetRow[] }
+}
+
+function decodeTargetRow(value: unknown): RawTargetRow | null {
+  const row = decodeJsonObject(value)
+  if (!row) return null
+  const props = decodeJsonObject(row.props)
+  return {
+    ...(typeof row.id === 'string' ? { id: row.id } : {}),
+    ...(props ? { props } : {}),
+  }
+}
+
+function decodeQueryResult(value: unknown): RawQueryResult | null {
+  const payload = decodeJsonObject(value)
+  const graph = decodeJsonObject(payload?.graph)
+  if (!graph || !Array.isArray(graph.nodes)) return null
+  const nodes = graph.nodes.map(decodeTargetRow).filter((row) => row !== null)
+  return { graph: { nodes } }
+}
+
+export async function listViewTargets(
+  root: string,
+  origin: string,
+  view: ViewInfo,
+  bundle: StudioSchemaBundle | null,
+  instance: string,
+  timeoutMs: number,
+): Promise<ViewTargetResult> {
+  const bindings = viewDefinitionBindings(origin, view, bundle)
+  if (bindings.length === 0) {
+    return {
+      status: 'available',
+      items: [],
+      selected: null,
+      stale: null,
+      truncated: false,
+    }
+  }
+
+  const queried = await Promise.all(
+    bindings.map(async (binding) => {
+      const definition = targetDefinition(binding.className, binding.classOrigin, binding.kind)
+      const result = await runAstraleJson<RawQueryResult>(
+        [
+          'query',
+          '--definition',
+          definition,
+          '--limit',
+          String(TARGET_LIMIT + 1),
+          '--json',
+          '-i',
+          instance,
+        ],
+        timeoutMs,
+        decodeQueryResult,
+      )
+      return { binding, result }
+    }),
+  )
+  const successes = queried.filter(
+    (item) => item.result.ok && Array.isArray(item.result.data?.graph?.nodes),
+  )
+  if (successes.length === 0) {
+    const reason = queried.map((item) => item.result.detail).find(Boolean)
+    return {
+      status: 'unavailable',
+      items: [],
+      selected: null,
+      stale: null,
+      truncated: false,
+      reason: reason || 'The active instance could not be queried for view targets.',
+    }
+  }
+
+  const byId = new Map<string, ViewTargetCandidate>()
+  let truncated = false
+  for (const { binding, result } of successes) {
+    const rows = result.data?.graph?.nodes ?? []
+    if (rows.length > TARGET_LIMIT) truncated = true
+    for (const row of rows.slice(0, TARGET_LIMIT)) {
+      const target = targetFromRow(row, binding.className, binding.classOrigin)
+      if (target) byId.set(target.id, target)
+    }
+  }
+  const items = [...byId.values()].sort(
+    (a, b) => a.label.localeCompare(b.label) || a.className.localeCompare(b.className),
+  )
+  const remembered = readRememberedTarget(root, instance, view.slug)
+  return {
+    status: 'available',
+    items,
+    ...reconcileRememberedTarget(remembered, items),
+    truncated,
+  }
+}
+
+export function targetDefinition(
+  className: string,
+  classOrigin: string,
+  kind: 'class' | 'interface' = 'class',
+): string {
+  return `/:${assertOrigin(classOrigin)}:${kind}.${assertSchemaName(className)}`
+}
+
+export interface ViewDefinitionBinding {
+  className: string
+  classOrigin: string
+  kind: 'class' | 'interface'
+}
+
+/** Preserve exact canonical View target coordinates; short-name anatomy is legacy-only. */
+export function viewDefinitionBindings(
+  origin: string,
+  view: ViewInfo,
+  bundle: StudioSchemaBundle | null,
+): ViewDefinitionBinding[] {
+  const target = bundle?.ir?.views?.[view.slug]?.target
+  if (target) {
+    if (target.kind === 'domain') return []
+    return uniqueViewBindings(
+      target.definitions
+        .filter(
+          (definition): definition is typeof definition & { kind: 'class' | 'interface' } =>
+            definition.kind === 'class' || definition.kind === 'interface',
+        )
+        .map((definition) => ({
+          className: definition.name,
+          classOrigin: definition.origin,
+          kind: definition.kind,
+        })),
+    )
+  }
+
+  const names = Array.isArray(view.viewFor) ? view.viewFor : view.viewFor ? [view.viewFor] : []
+  const ir = bundle?.ir
+  if (!ir) {
+    return uniqueViewBindings(
+      names.map((className) => ({ className, classOrigin: origin, kind: 'class' })),
+    )
+  }
+
+  return uniqueViewBindings(
+    names.flatMap((className) => {
+      const local: ViewDefinitionBinding[] = []
+      const localClass = ir.classes[className]
+      const localInterface = ir.interfaces[className]
+      if (localClass) {
+        local.push({
+          className,
+          classOrigin: localClass.ref?.origin ?? localClass.origin ?? ir.domain ?? origin,
+          kind: 'class',
+        })
+      }
+      if (localInterface) {
+        local.push({
+          className,
+          classOrigin: localInterface.ref?.origin ?? localInterface.origin ?? ir.domain ?? origin,
+          kind: 'interface',
+        })
+      }
+
+      if (ir.importsByKey !== undefined) {
+        const imported = Object.keys(ir.importsByKey).flatMap((key) => {
+          const binding = viewBindingFromDefinitionKey(key)
+          return binding?.className === className ? [binding] : []
+        })
+        return [...local, ...imported]
+      }
+
+      const legacy = ir.imports[className]
+      if (legacy) {
+        return [
+          ...local,
+          {
+            className,
+            classOrigin: legacy.origin,
+            kind: legacy.definition,
+          } satisfies ViewDefinitionBinding,
+        ]
+      }
+
+      return local.length > 0 ? local : [{ className, classOrigin: origin, kind: 'class' }]
+    }),
+  )
+}
+
+function viewBindingFromDefinitionKey(key: string): ViewDefinitionBinding | null {
+  const separator = key.lastIndexOf(':')
+  if (separator <= 0) return null
+  const classOrigin = key.slice(0, separator)
+  const ref = key.slice(separator + 1)
+  const match = /^(class|interface)\.([A-Za-z_$][\w$]*)$/.exec(ref)
+  if (!match) return null
+  return {
+    className: match[2]!,
+    classOrigin,
+    kind: match[1] as ViewDefinitionBinding['kind'],
+  }
+}
+
+function uniqueViewBindings(bindings: ViewDefinitionBinding[]): ViewDefinitionBinding[] {
+  const unique = new Map<string, ViewDefinitionBinding>()
+  for (const binding of bindings) {
+    const key = `${binding.classOrigin}:${binding.kind}.${binding.className}`
+    if (!unique.has(key)) unique.set(key, binding)
+  }
+  return [...unique.values()]
+}
+
+function assertOrigin(value: string): string {
+  if (!/^[a-z0-9][a-z0-9.-]*$/i.test(value)) throw new Error(`Invalid domain origin: ${value}`)
+  return value
+}
+
+function assertSchemaName(value: string): string {
+  if (!/^[A-Za-z_$][\w$]*$/.test(value)) throw new Error(`Invalid class name: ${value}`)
+  return value
+}
+
+async function runAstraleJson<T>(
+  args: string[],
+  timeoutMs: number,
+  decoder: StudioCliDecoder<T>,
+): Promise<AstraleResult<T>> {
+  return runStudioCliJson(args, decoder, { timeoutMs })
+}

package/studio/server/watch.ts

@@ -68,7 +68,7 @@ export function watchDomain(handle: DomainHandle): () => void {
       broadcast({
         type: 'schema-diff',
         domainId: handle.id,
-        schemaHash: b?.schemaHash ?? 'sha-none',
+        renderFingerprint: b?.renderFingerprint ?? 'sha-none',
       })
       broadcast({ type: 'anatomy-diff', domainId: handle.id })
     }, 150)

package/studio/server/workspace/catalog.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from 'bun:test'
+
+import { buildCatalog } from './catalog'
+
+test('workspace catalog contains only discovered domains and never simulated import authorities', () => {
+  const catalog = buildCatalog([
+    { origin: 'issues.example.dev', id: 'issues' },
+    { origin: 'billing.example.dev', id: 'billing-service' },
+  ])
+
+  expect(catalog.map(({ origin, kind }) => ({ origin, kind }))).toEqual([
+    { origin: 'kernel.astrale.ai', kind: 'kernel' },
+    { origin: 'issues.example.dev', kind: 'local' },
+    { origin: 'billing.example.dev', kind: 'local' },
+  ])
+  expect(catalog.some((entry) => entry.kind === 'external')).toBe(false)
+})

package/studio/server/workspace/catalog.ts

@@ -0,0 +1,43 @@
+/**
+ * Display metadata for domains Studio has actually discovered in its workspace.
+ * This is not an import registry or an authority for available domains. Until a
+ * real registry exists, it contains only the required Kernel and local workspace
+ * domains; Studio must not advertise simulated external services as importable.
+ */
+import type { DomainCatalogEntry } from '../../shared/types'
+
+const icon = (inner: string) =>
+  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`
+
+const HEXAGON = icon(
+  '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="m7.5 4.27 9 5.15"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/>',
+)
+const BOXES = icon(
+  '<path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z"/><path d="m7 16.5-4.74-2.85"/><path d="m7 16.5 5-3"/><path d="M7 16.5v5.17"/><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z"/><path d="m17 16.5-5-3"/><path d="m17 16.5 4.74-2.85"/><path d="M17 16.5v5.17"/><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z"/><path d="M12 8 7.26 5.15"/><path d="m12 8 4.74-2.85"/><path d="M12 13.5V8"/>',
+)
+const KERNEL: DomainCatalogEntry = {
+  origin: 'kernel.astrale.ai',
+  name: 'Kernel',
+  kind: 'kernel',
+  description: 'The typed graph every domain is built on.',
+  icon: HEXAGON,
+  required: true,
+}
+
+function humanize(slug: string): string {
+  return slug
+    .replace(/[-_]+/g, ' ')
+    .replace(/\b\w/g, (c) => c.toUpperCase())
+    .trim()
+}
+
+export function buildCatalog(locals: { origin: string; id: string }[]): DomainCatalogEntry[] {
+  const localEntries: DomainCatalogEntry[] = locals.map((d) => ({
+    origin: d.origin,
+    name: humanize(d.id),
+    kind: 'local',
+    description: 'A domain in this workspace.',
+    icon: BOXES,
+  }))
+  return [KERNEL, ...localEntries]
+}