@astrale-os/cli 0.4.0-alpha.13

package/studio/server/introspect/overlay.ts

@@ -0,0 +1,57 @@
+/**
+ * overlay.ts — the Studio overlay over the DSL IR. Computes what the IR cannot
+ * carry. The imports split + requires/postInstall are done here (pure / light
+ * static parse). handlerLinks, sourceSpans (+JSDoc) and annotations are filled
+ * by a ts-morph pass over schema/*.ts, domain.ts and runtime/index.ts.
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import type { CrossDomainImport, SchemaIR, SchemaOverlay } from '../../shared/types'
+
+import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
+
+export interface OverlayArgs {
+  ir: SchemaIR | null
+  domainRoot: string
+  schemaDir: string
+}
+
+export function buildOverlay({ ir, domainRoot, schemaDir }: OverlayArgs): SchemaOverlay {
+  const origin = ir?.domain ?? ''
+  const mixins: CrossDomainImport[] = []
+  const crossDomainImports: CrossDomainImport[] = []
+  for (const [name, d] of Object.entries(ir?.imports ?? {})) {
+    const entry: CrossDomainImport = { name, origin: d.origin, definition: d.definition }
+    if (d.origin === 'kernel.astrale.ai') mixins.push(entry)
+    else crossDomainImports.push(entry)
+  }
+
+  const { requires, postInstall } = parseDomainTs(domainRoot, origin)
+
+  return {
+    origin,
+    requires,
+    crossDomainImports,
+    mixins,
+    postInstall,
+    handlerLinks: buildHandlerLinks({ ir, domainRoot }),
+    sourceSpans: buildSourceSpans({ ir, schemaDir }),
+    annotations: buildSchemaAnnotations({ ir }),
+  }
+}
+
+function parseDomainTs(root: string, origin: string): { requires: string[]; postInstall?: string } {
+  const f = join(root, 'domain.ts')
+  let requires: string[] = []
+  let postInstall: string | undefined
+  if (existsSync(f)) {
+    const src = readFileSync(f, 'utf8')
+    const rm = src.match(/requires\s*:\s*\[([^\]]*)\]/)
+    if (rm) requires = [...rm[1].matchAll(/['"`]([^'"`]+)['"`]/g)].map((x) => x[1])
+    const pm = src.match(/postInstall\s*:\s*[`'"]([^`'"]+)[`'"]/)
+    if (pm)
+      postInstall = pm[1].replace(/\$\{schema\.domain\}/g, origin).replace(/\$\{[^}]+\}/g, origin)
+  }
+  return { requires, postInstall }
+}

package/studio/server/introspect/runtime.ts

@@ -0,0 +1,99 @@
+/**
+ * runtime.ts — the introspection driver. Spawns the Bun extractor island in a
+ * short-lived subprocess (cwd = domain dir so the domain's own node_modules
+ * resolve the @astrale-os/* packages), with a hard timeout. Returns the raw
+ * SchemaIR or an error render-state — never throws.
+ */
+import type { IrInterface, SchemaIR, StudioCore } from '../../shared/types'
+
+const EXTRACTOR = new URL('./extractor.ts', import.meta.url).pathname
+const CORE_EXTRACTOR = new URL('./core-extractor.ts', import.meta.url).pathname
+
+export interface RuntimeExtractResult {
+  ok: boolean
+  ir: SchemaIR | null
+  /** member bodies of imported (kernel + cross-domain) interfaces, by name */
+  importedInterfaces?: Record<string, IrInterface>
+  error?: { message: string }
+}
+
+export async function runtimeExtract(
+  schemaIndexPath: string,
+  domainDir: string,
+  timeoutMs = 20000,
+): Promise<RuntimeExtractResult> {
+  try {
+    const proc = Bun.spawn(['bun', 'run', EXTRACTOR, schemaIndexPath, domainDir], {
+      cwd: domainDir,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const timer = setTimeout(() => proc.kill(9), timeoutMs)
+    const out = await new Response(proc.stdout).text()
+    await proc.exited
+    clearTimeout(timer)
+
+    if (!out.trim()) {
+      const err = await new Response(proc.stderr).text()
+      return {
+        ok: false,
+        ir: null,
+        error: { message: err.trim() || 'extractor produced no output' },
+      }
+    }
+    const parsed = JSON.parse(out)
+    if (!parsed.ok)
+      return { ok: false, ir: null, error: parsed.error ?? { message: 'extraction failed' } }
+    return {
+      ok: true,
+      ir: parsed.ir as SchemaIR,
+      importedInterfaces: (parsed.importedInterfaces ?? {}) as Record<string, IrInterface>,
+    }
+  } catch (e: any) {
+    return { ok: false, ir: null, error: { message: String(e?.message ?? e) } }
+  }
+}
+
+export interface CoreExtractResult {
+  ok: boolean
+  /** the resolved core graph, or null when the domain defines no core */
+  core: Pick<StudioCore, 'domain' | 'nodes' | 'edges'> | null
+  error?: { message: string }
+}
+
+/**
+ * Spawn the core-extractor island over a domain's `domain.ts` (cwd = domainDir),
+ * with a hard timeout. Returns the resolved core graph or an error — never throws.
+ */
+export async function coreExtract(
+  domainFile: string,
+  domainDir: string,
+  timeoutMs = 20000,
+): Promise<CoreExtractResult> {
+  try {
+    const proc = Bun.spawn(['bun', 'run', CORE_EXTRACTOR, domainFile, domainDir], {
+      cwd: domainDir,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const timer = setTimeout(() => proc.kill(9), timeoutMs)
+    const out = await new Response(proc.stdout).text()
+    await proc.exited
+    clearTimeout(timer)
+
+    if (!out.trim()) {
+      const err = await new Response(proc.stderr).text()
+      return {
+        ok: false,
+        core: null,
+        error: { message: err.trim() || 'core extractor produced no output' },
+      }
+    }
+    const parsed = JSON.parse(out)
+    if (!parsed.ok)
+      return { ok: false, core: null, error: parsed.error ?? { message: 'core extraction failed' } }
+    return { ok: true, core: (parsed.core ?? null) as CoreExtractResult['core'] }
+  } catch (e: any) {
+    return { ok: false, core: null, error: { message: String(e?.message ?? e) } }
+  }
+}

package/studio/server/introspect/schema-refs.ts

@@ -0,0 +1,46 @@
+import type { StudioSchemaBundle } from '../../shared/types'
+
+/**
+ * schema-refs.ts — enumerate every SCHEMA anchor ref a bundle can target, derived
+ * from the IR (the authority), NOT from `overlay.sourceSpans`.
+ *
+ * Source spans are a best-effort ts-morph source-location index: they cover only
+ * locally-authored members and only the declaration helpers the parser recognises.
+ * Using their keys as the set of "valid" targets falsely orphans real, commentable
+ * targets — most notably INHERITED members surfaced in the detail pane's Inherited
+ * section (kernel mixins / cross-domain interfaces, e.g. `interface.Named.property.name`),
+ * which live in another package and so have no local span. This walks the IR
+ * instead, mirroring exactly the refs the detail pane stamps.
+ */
+export function schemaRefs(bundle: StudioSchemaBundle): string[] {
+  const ir = bundle.ir
+  if (!ir) return []
+  const refs = new Set<string>()
+  const addMember = (
+    base: string,
+    properties: Record<string, unknown> | undefined,
+    methods: Record<string, unknown> | undefined,
+  ) => {
+    refs.add(base)
+    for (const p of Object.keys(properties ?? {})) refs.add(`${base}.property.${p}`)
+    for (const m of Object.keys(methods ?? {})) refs.add(`${base}.method.${m}`)
+  }
+
+  for (const [name, iface] of Object.entries(ir.interfaces))
+    addMember(`interface.${name}`, iface.properties, iface.methods)
+
+  for (const [name, cls] of Object.entries(ir.classes)) {
+    const ns = cls.type === 'edge' ? 'edge' : 'class'
+    addMember(`${ns}.${name}`, cls.properties, cls.methods)
+    if (cls.type === 'edge')
+      for (const ep of cls.endpoints ?? [])
+        if (ep.name) refs.add(`edge.${name}.endpoint.${ep.name}`)
+  }
+
+  // Imported interfaces (kernel mixins + cross-domain) are rendered — and so are
+  // commentable — in the Inherited section, keyed under the `interface.` namespace.
+  for (const [name, iface] of Object.entries(bundle.importedInterfaces ?? {}))
+    addMember(`interface.${name}`, iface.properties, iface.methods)
+
+  return [...refs]
+}

package/studio/server/lifecycle.ts

@@ -0,0 +1,38 @@
+import type { DomainHandle } from './domain'
+
+/**
+ * lifecycle.ts — bring a single domain online: prepare its `.domain-studio` dir,
+ * warm its bundle, seed the baseline, and start watching its files. Used by BOTH
+ * the startup scan (index.ts) and the live workspace watcher (workspace-watch.ts),
+ * so a domain added while the studio is running boots in exactly the same way as
+ * one present at launch.
+ */
+import { getBundle } from './cache'
+import { captureBaseline, hashAnatomyFiles, loadBaseline } from './state/baseline'
+import { initDotDir } from './state/store'
+import { watchDomain } from './watch'
+
+export interface BootedDomain {
+  origin: string
+  depsInstalled: boolean
+  /** stops the domain's file watcher */
+  stop: () => void
+}
+
+/** Initialize + start watching one domain. Returns its origin + a stop handle. */
+export async function bootDomain(handle: DomainHandle): Promise<BootedDomain> {
+  initDotDir(handle.root)
+  const bundle = await getBundle(handle.id)
+  if (!loadBaseline(handle.root))
+    captureBaseline(
+      handle.root,
+      bundle?.ir ?? null,
+      hashAnatomyFiles(handle.root, handle.schemaDirName),
+    )
+  const stop = watchDomain(handle)
+  return {
+    origin: bundle?.overlay.origin ?? handle.id,
+    depsInstalled: !!bundle?.depsInstalled,
+    stop,
+  }
+}

package/studio/server/sse.ts

@@ -0,0 +1,57 @@
+/**
+ * sse.ts — a tiny server-sent-events hub. One-directional server→client; the
+ * studio is read-only so the client never pushes here (it uses POST).
+ */
+import type { StudioEvent } from '../shared/types'
+
+const encoder = new TextEncoder()
+const clients = new Map<number, ReadableStreamDefaultController<Uint8Array>>()
+let nextId = 1
+
+export function sseResponse(domains: string[]): Response {
+  let id = 0
+  let keepalive: ReturnType<typeof setInterval> | undefined
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      id = nextId++
+      clients.set(id, controller)
+      controller.enqueue(encoder.encode(frame({ type: 'hello', domains })))
+      // keepalive comment every 20s — long agent turns can go minutes between
+      // events; without this the connection is idle and gets dropped.
+      keepalive = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(': keepalive\n\n'))
+        } catch {
+          clearInterval(keepalive)
+          clients.delete(id)
+        }
+      }, 20_000)
+    },
+    cancel() {
+      clearInterval(keepalive)
+      clients.delete(id)
+    },
+  })
+  return new Response(stream, {
+    headers: {
+      'content-type': 'text/event-stream',
+      'cache-control': 'no-cache, no-transform',
+      connection: 'keep-alive',
+    },
+  })
+}
+
+export function broadcast(event: StudioEvent): void {
+  const payload = encoder.encode(frame(event))
+  for (const [id, c] of clients) {
+    try {
+      c.enqueue(payload)
+    } catch {
+      clients.delete(id)
+    }
+  }
+}
+
+function frame(event: StudioEvent): string {
+  return `data: ${JSON.stringify(event)}\n\n`
+}

package/studio/server/state/baseline.ts

@@ -0,0 +1,211 @@
+/**
+ * baseline.ts — the PRIMARY change tracker. On first launch we capture a
+ * snapshot (the schema IR + a content hash of the "anatomy + schema fileset")
+ * under `.domain-studio/.cache/baseline/`. Subsequent runs diff the live state
+ * against that baseline to compute a ChangeSet. Git (git.ts) only enriches when
+ * a real repo is present; the fixtures are not repos, so baseline stands alone.
+ *
+ * Layout under `.cache/baseline/`:
+ *   ir.json     — the captured SchemaIR (or null)
+ *   files.json  — { [relpathFromRoot]: sha256 }
+ *   meta.json   — { capturedAt }
+ */
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+
+import type { ChangeSet, FileChange, SchemaChange, SchemaIR } from '../../shared/types'
+
+import { classify, diffSchemas } from '../introspect/diff'
+import { detectGit, gitDiff } from './git'
+import { readJson, writeJson } from './store'
+
+const BASE = '.cache/baseline'
+
+/** Directories to never descend into when hashing the fileset. */
+const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.domain-studio', '.git'])
+
+/**
+ * The "anatomy + schema fileset": directories walked recursively + standalone
+ * files. The schema dir is injected per-domain (its name is configurable), so it
+ * is NOT listed here — see hashAnatomyFiles. Everything else is a fixed contract.
+ */
+export const ANATOMY_GLOBS = {
+  dirs: ['runtime', 'views', 'functions', 'client/src'],
+  files: ['domain.ts', 'deps.ts', 'env.ts', 'package.json', 'astrale.config.ts'],
+} as const
+
+function sha256(buf: Buffer): string {
+  return createHash('sha256').update(buf).digest('hex')
+}
+
+/** Recursively collect file paths under `dir` (absolute), skipping SKIP_DIRS. */
+function walkFiles(dir: string, out: string[]): void {
+  let entries: string[]
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return
+  }
+  for (const e of entries) {
+    if (SKIP_DIRS.has(e)) continue
+    const full = join(dir, e)
+    let st
+    try {
+      st = statSync(full)
+    } catch {
+      continue
+    }
+    if (st.isDirectory()) walkFiles(full, out)
+    else if (st.isFile()) out.push(full)
+  }
+}
+
+/**
+ * Hash (sha256) every file in the anatomy + schema fileset. Keys are paths
+ * relative to `root`, forward-slashed. Missing dirs/files are silently skipped.
+ */
+export function hashAnatomyFiles(root: string, schemaDirName: string): Record<string, string> {
+  const r = resolve(root)
+  const absFiles: string[] = []
+
+  // Schema dir (configurable name) + the fixed anatomy dirs.
+  for (const d of [schemaDirName, ...ANATOMY_GLOBS.dirs]) {
+    const abs = join(r, d)
+    if (existsSync(abs)) {
+      let st
+      try {
+        st = statSync(abs)
+      } catch {
+        st = null
+      }
+      if (st?.isDirectory()) walkFiles(abs, absFiles)
+      else if (st?.isFile()) absFiles.push(abs)
+    }
+  }
+
+  // Standalone files.
+  for (const f of ANATOMY_GLOBS.files) {
+    const abs = join(r, f)
+    if (existsSync(abs)) {
+      try {
+        if (statSync(abs).isFile()) absFiles.push(abs)
+      } catch {
+        /* skip */
+      }
+    }
+  }
+
+  const hashes: Record<string, string> = {}
+  for (const abs of absFiles) {
+    let buf: Buffer
+    try {
+      buf = readFileSync(abs)
+    } catch {
+      continue
+    }
+    const key = relative(r, abs).split('\\').join('/')
+    hashes[key] = sha256(buf)
+  }
+  return hashes
+}
+
+export interface Baseline {
+  ir: SchemaIR | null
+  files: Record<string, string>
+  capturedAt?: string
+}
+
+/** Persist a baseline snapshot under `.cache/baseline/`. All writes go through the store. */
+export function captureBaseline(
+  root: string,
+  ir: SchemaIR | null,
+  fileHashes: Record<string, string>,
+): void {
+  writeJson(root, `${BASE}/ir.json`, ir)
+  writeJson(root, `${BASE}/files.json`, fileHashes)
+  writeJson(root, `${BASE}/meta.json`, { capturedAt: new Date().toISOString() })
+}
+
+/** Load a previously-captured baseline, or null if none exists. Never throws. */
+export function loadBaseline(root: string): Baseline | null {
+  const irPath = join(resolve(root), '.domain-studio', BASE, 'meta.json')
+  if (!existsSync(irPath)) return null
+  const ir = readJson<SchemaIR | null>(root, `${BASE}/ir.json`, null)
+  const files = readJson<Record<string, string>>(root, `${BASE}/files.json`, {})
+  const meta = readJson<{ capturedAt?: string }>(root, `${BASE}/meta.json`, {})
+  return { ir, files, capturedAt: meta.capturedAt }
+}
+
+/** Compare two file-hash maps into added/modified/removed FileChange[]. */
+function diffFiles(prev: Record<string, string>, next: Record<string, string>): FileChange[] {
+  const out: FileChange[] = []
+  for (const file of Object.keys(next)) {
+    if (!(file in prev)) out.push({ file, status: 'added' })
+    else if (prev[file] !== next[file]) out.push({ file, status: 'modified' })
+  }
+  for (const file of Object.keys(prev)) {
+    if (!(file in next)) out.push({ file, status: 'removed' })
+  }
+  out.sort((a, b) => a.file.localeCompare(b.file))
+  return out
+}
+
+/** A compact human-readable summary of schema changes (baseline source fallback for diff text). */
+function summarizeSchemaChanges(changes: SchemaChange[]): string {
+  if (changes.length === 0) return 'No schema changes.'
+  return changes
+    .map((c) => {
+      const flag = c.breaking ? 'breaking' : 'additive'
+      const detail = c.detail ? `: ${c.detail}` : ''
+      return `${c.kind} ${c.target}${detail} (${flag})`
+    })
+    .join('\n')
+}
+
+/**
+ * Compute the live ChangeSet against the captured baseline. On first launch
+ * (no baseline yet) this returns an empty, 'none' ChangeSet with
+ * hasBaseline:false so the UI shows "no changes" and the caller can then
+ * capture an initial baseline.
+ */
+export function computeChanges(
+  root: string,
+  currentIr: SchemaIR | null,
+  currentFiles: Record<string, string>,
+  opts: { schemaDirName: string },
+): ChangeSet {
+  const { hasGit } = detectGit(root)
+  const source: ChangeSet['source'] = hasGit ? 'git' : 'baseline'
+  const baseline = loadBaseline(root)
+
+  if (!baseline) {
+    return {
+      source,
+      hasGit,
+      hasBaseline: false,
+      schemaChanges: [],
+      fileChanges: [],
+      classification: 'none',
+    }
+  }
+
+  const schemaChanges = diffSchemas(baseline.ir ?? null, currentIr)
+  const classification = classify(schemaChanges)
+  const fileChanges = diffFiles(baseline.files ?? {}, currentFiles)
+
+  const schemaDiffText = hasGit
+    ? (gitDiff(root, opts.schemaDirName) ?? undefined)
+    : summarizeSchemaChanges(schemaChanges)
+
+  return {
+    source,
+    hasGit,
+    hasBaseline: true,
+    schemaChanges,
+    fileChanges,
+    schemaDiffText,
+    classification,
+    baselineCapturedAt: baseline.capturedAt,
+  }
+}

package/studio/server/state/catalog.ts

@@ -0,0 +1,117 @@
+/**
+ * catalog.ts — the domain catalog for the canvas "Import a domain" picker. It merges:
+ *   - the kernel (always present + required),
+ *   - the LOCAL domains detected in this workspace,
+ *   - a curated set of FAKED external service domains (placeholders until a real
+ *     registry exists).
+ * Each entry carries a lucide-style SVG icon + a one-line description.
+ */
+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 BELL = icon(
+  '<path d="M10.268 21a2 2 0 0 0 3.464 0"/><path d="M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326"/>',
+)
+const CARD = icon(
+  '<rect width="20" height="14" x="2" y="5" rx="2"/><line x1="2" x2="22" y1="10" y2="10"/>',
+)
+const USERS = icon(
+  '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
+)
+const CHART = icon(
+  '<line x1="12" x2="12" y1="20" y2="10"/><line x1="18" x2="18" y1="20" y2="4"/><line x1="6" x2="6" y1="20" y2="16"/>',
+)
+const SEARCH = icon('<circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/>')
+const DRIVE = icon(
+  '<line x1="22" x2="2" y1="12" y2="12"/><path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"/><line x1="6" x2="6.01" y1="16" y2="16"/><line x1="10" x2="10.01" y1="16" y2="16"/>',
+)
+const SPARKLES = icon(
+  '<path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"/>',
+)
+
+const KERNEL: DomainCatalogEntry = {
+  origin: 'kernel.astrale.ai',
+  name: 'Kernel',
+  kind: 'kernel',
+  description: 'The typed graph every domain is built on.',
+  icon: HEXAGON,
+  required: true,
+}
+
+const EXTERNAL: DomainCatalogEntry[] = [
+  {
+    origin: 'notifications.astrale.ai',
+    name: 'Notifications',
+    kind: 'external',
+    description: 'Email, push & SMS delivery.',
+    icon: BELL,
+  },
+  {
+    origin: 'payments.astrale.ai',
+    name: 'Payments',
+    kind: 'external',
+    description: 'Charges, subscriptions & invoices.',
+    icon: CARD,
+  },
+  {
+    origin: 'identity.astrale.ai',
+    name: 'Identity',
+    kind: 'external',
+    description: 'SSO, directory sync & users.',
+    icon: USERS,
+  },
+  {
+    origin: 'analytics.astrale.ai',
+    name: 'Analytics',
+    kind: 'external',
+    description: 'Events, funnels & dashboards.',
+    icon: CHART,
+  },
+  {
+    origin: 'search.astrale.ai',
+    name: 'Search',
+    kind: 'external',
+    description: 'Full-text & vector search.',
+    icon: SEARCH,
+  },
+  {
+    origin: 'storage.astrale.ai',
+    name: 'Storage',
+    kind: 'external',
+    description: 'Files, blobs & a CDN.',
+    icon: DRIVE,
+  },
+  {
+    origin: 'ai.astrale.ai',
+    name: 'AI Gateway',
+    kind: 'external',
+    description: 'LLM routing & embeddings.',
+    icon: SPARKLES,
+  },
+]
+
+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, ...EXTERNAL]
+}