@astrale-os/cli 0.8.0-alpha.0 → 0.8.1-alpha.2

package/src/admin/catalog/__tests__/client.test.ts

@@ -0,0 +1,171 @@
+import type { DomainBinding } from '@astrale-os/kernel-client/domain'
+import type { Node } from '@astrale-os/sdk/graph/node'
+import type { QueryAST } from '@astrale-os/sdk/query'
+
+import { ClassPath } from '@astrale-os/sdk/graph/class'
+import { NodeId } from '@astrale-os/sdk/graph/node'
+import { Path } from '@astrale-os/sdk/graph/path'
+import { describe, expect, mock, test } from 'bun:test'
+
+import type { AdminGraphApi } from '../../graph'
+
+import { connectAdminCatalog } from '../client'
+
+function definition(name: string) {
+  return {
+    name,
+    $: {
+      method(method: string) {
+        return { owner: name, name: method }
+      },
+      property(property: string) {
+        return { key: property }
+      },
+    },
+  }
+}
+
+function domainNode(id: string, origin: string): Node {
+  return {
+    id: NodeId(id),
+    class: ClassPath.from('admin.astrale.ai', 'Domain'),
+    props: {
+      origin,
+      name: origin.split('.')[0]!,
+      discoveryUrl: `https://${origin}`,
+      createdAt: '2026-08-12T00:00:00.000Z',
+      updatedAt: '2026-08-12T00:00:00.000Z',
+    } as never,
+  }
+}
+
+function fixture(input: {
+  domains?: readonly Node[]
+  defaults?: readonly Node[]
+  invoke?: (method: { owner: string; name: string }, receiver: unknown, value: unknown) => unknown
+}) {
+  const Domain = definition('Domain')
+  const Fleet = definition('Fleet')
+  const invoke = mock(async (method: unknown, receiver: unknown, value: unknown) =>
+    input.invoke?.(method as { owner: string; name: string }, receiver, value),
+  )
+  const binding = {
+    $: {
+      publication: { origin: 'admin.astrale.ai' },
+      origin: 'admin.astrale.ai',
+      class(name: string) {
+        if (name === 'Domain') return Domain
+        if (name === 'Fleet') return Fleet
+        throw new Error(`Unexpected class ${name}`)
+      },
+      core: { nodes: { fleet: { path: Path.id(NodeId('fleet')) } } },
+      invoke,
+    },
+  } as unknown as DomainBinding
+  const query = mock(async (_ast: QueryAST) => ({
+    result: {
+      kind: 'nodes' as const,
+      nodes: (input.domains ?? []).map((value) => ({ kind: 'value' as const, value })),
+    },
+    page: {},
+  }))
+  const defaultNodes = input.defaults ?? []
+  const neighbors = mock(async () => ({
+    nodes: defaultNodes,
+    first: defaultNodes[0] ?? null,
+    graph: { nodes: defaultNodes, edges: [] },
+    cursor: null,
+    collect: async () => ({ nodes: defaultNodes, cursor: null }),
+  }))
+  const graph = { query, neighbors } as unknown as AdminGraphApi
+  return {
+    invoke,
+    connect: () =>
+      connectAdminCatalog(
+        { session: {} as never, graph },
+        {
+          bind: async () => binding,
+          operationId: (kind) => `cli.domain.${kind}:test`,
+        },
+      ),
+  }
+}
+
+function summary(origin: string) {
+  return {
+    id: '@crm-domain',
+    origin,
+    name: 'crm',
+    discoveryUrl: `https://${origin}`,
+    createdAt: '2026-08-12T00:00:00.000Z',
+    updatedAt: '2026-08-12T00:00:00.000Z',
+  }
+}
+
+describe('V2 Admin Domain catalog adapter', () => {
+  test('lists Domain nodes through GraphApi and joins the Fleet default relation', async () => {
+    const crm = domainNode('crm-domain', 'crm.acme.dev')
+    const notes = domainNode('notes-domain', 'notes.acme.dev')
+    const api = await fixture({ domains: [crm, notes], defaults: [crm] }).connect()
+
+    await expect(api.list()).resolves.toEqual([
+      expect.objectContaining({
+        id: '@crm-domain',
+        origin: 'crm.acme.dev',
+        installByDefault: true,
+      }),
+      expect.objectContaining({ id: '@notes-domain', origin: 'notes.acme.dev' }),
+    ])
+  })
+
+  test('publishes through Fleet then configures the Domain default explicitly', async () => {
+    const contract = fixture({ invoke: () => summary('crm.acme.dev') })
+    const api = await contract.connect()
+
+    await expect(
+      api.publish({
+        origin: 'crm.acme.dev',
+        name: 'crm',
+        url: 'https://crm.acme.dev',
+        installByDefault: true,
+      }),
+    ).resolves.toMatchObject({ changed: true, isNew: true, entry: { installByDefault: true } })
+    expect(
+      contract.invoke.mock.calls.map(([method, receiver, value]) => ({
+        method,
+        receiver: String(receiver),
+        value,
+      })),
+    ).toEqual([
+      {
+        method: { owner: 'Fleet', name: 'publishDomain' },
+        receiver: '@fleet',
+        value: {
+          operationId: 'cli.domain.publish:test',
+          origin: 'crm.acme.dev',
+          name: 'crm',
+          discoveryUrl: 'https://crm.acme.dev',
+        },
+      },
+      {
+        method: { owner: 'Domain', name: 'configureDefault' },
+        receiver: '@crm-domain',
+        value: {
+          operationId: 'cli.domain.configure-default:test',
+          enabled: true,
+        },
+      },
+    ])
+  })
+
+  test('does not invoke a receiver when the catalog record is already current', async () => {
+    const crm = domainNode('crm-domain', 'crm.acme.dev')
+    const contract = fixture({ domains: [crm] })
+    const api = await contract.connect()
+
+    await expect(
+      api.publish({ origin: 'crm.acme.dev', name: 'crm', url: 'https://crm.acme.dev' }),
+    ).resolves.toMatchObject({ changed: false, isNew: false })
+    expect(contract.invoke).not.toHaveBeenCalled()
+  })
+})

package/src/admin/catalog/client.ts

@@ -0,0 +1,214 @@
+import type { DomainBinding } from '@astrale-os/kernel-client/domain'
+import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { Node } from '@astrale-os/sdk/graph/node'
+
+import { bind } from '@astrale-os/kernel-client/domain'
+import { Path } from '@astrale-os/sdk/graph/path'
+import { Query } from '@astrale-os/sdk/query'
+
+import { readAllNodes, type AdminGraphApi } from '../graph'
+import {
+  AdminDomainNotFoundError,
+  type DomainInfo,
+  type PublishDomainInput,
+  type PublishDomainResult,
+} from './model'
+
+const ADMIN_ORIGIN = 'admin.astrale.ai'
+const PAGE_SIZE = 256
+const MAXIMUM_DOMAINS = 10_000
+const MAXIMUM_PAGES = Math.ceil(MAXIMUM_DOMAINS / PAGE_SIZE) + 1
+const DomainRef = Object.freeze({ origin: ADMIN_ORIGIN, kind: 'class' as const, name: 'Domain' })
+const fleetInstallsByDefault = Object.freeze({
+  origin: ADMIN_ORIGIN,
+  kind: 'class' as const,
+  name: 'fleet_installs_domain_by_default',
+})
+
+export interface AdminCatalogContext {
+  readonly session: ClientSession
+  readonly graph: AdminGraphApi
+}
+
+export interface AdminCatalogApi {
+  list(): Promise<DomainInfo[]>
+  require(identifier: string): Promise<DomainInfo>
+  publish(input: PublishDomainInput): Promise<PublishDomainResult>
+}
+
+export interface AdminCatalogDependencies {
+  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
+  readonly operationId?: (kind: 'publish' | 'configure-default') => string
+}
+
+/** Bind the discovered Admin revision and expose its Domain catalog journey. */
+export async function connectAdminCatalog(
+  context: AdminCatalogContext,
+  dependencies: AdminCatalogDependencies = {},
+): Promise<AdminCatalogApi> {
+  const binding = await (dependencies.bind ?? bindInstalledAdmin)(context.session)
+  if (binding.$.publication?.origin !== ADMIN_ORIGIN || binding.$.origin !== ADMIN_ORIGIN) {
+    throw new TypeError('Configured Admin target does not serve the Admin Domain.')
+  }
+  const Domain = binding.$.class('Domain')
+  const Fleet = binding.$.class('Fleet')
+  const fleet = binding.$.core.nodes.fleet?.path
+  if (fleet === undefined) throw new TypeError('Admin Domain has no singleton Fleet receiver.')
+  const operationId = dependencies.operationId ?? defaultOperationId
+
+  const list = async (): Promise<DomainInfo[]> => {
+    const [nodes, defaultsPage] = await Promise.all([
+      readAllNodes(
+        context.graph,
+        Query.from({ kind: 'node', definitions: [DomainRef] }).select({
+          kind: 'nodes',
+          projection: { kind: 'value' },
+        }),
+        {
+          label: 'Admin Domain catalog',
+          maximum: MAXIMUM_DOMAINS,
+          maximumPages: MAXIMUM_PAGES,
+        },
+      ),
+      context.graph.neighbors(fleet, fleetInstallsByDefault, {
+        direction: 'outgoing',
+        page: { size: PAGE_SIZE },
+      }),
+    ])
+    const defaults = await defaultsPage.collect({ maximumPages: MAXIMUM_PAGES })
+    if (defaults.cursor !== null)
+      throw new TypeError('Admin default Domain catalog exceeded its bound.')
+    const defaultIds = new Set(defaults.nodes.map((node) => String(node.id)))
+    return nodes.map((node) => domainFromNode(Domain, node, defaultIds.has(String(node.id))))
+  }
+
+  const requireDomain = async (identifier: string): Promise<DomainInfo> => {
+    const found = (await list()).find(
+      (domain) =>
+        domain.origin === identifier ||
+        domain.url === identifier ||
+        domain.id === identifier ||
+        (domain.id.startsWith('@') && domain.id.slice(1) === identifier),
+    )
+    if (found === undefined) throw new AdminDomainNotFoundError(identifier)
+    return found
+  }
+
+  return Object.freeze({
+    list,
+    require: requireDomain,
+    async publish(input: PublishDomainInput): Promise<PublishDomainResult> {
+      const existing = (await list()).find((domain) => domain.origin === input.origin)
+      const description = input.description ?? existing?.description
+      const registryChanged =
+        existing === undefined ||
+        existing.name !== input.name ||
+        existing.url !== input.url ||
+        existing.description !== description
+      let entry = existing
+      if (registryChanged) {
+        entry = domainFromSummary(
+          await binding.$.invoke(Fleet.$.method('publishDomain') as never, fleet, {
+            operationId: operationId('publish'),
+            origin: input.origin,
+            name: input.name,
+            discoveryUrl: input.url,
+            ...(description === undefined ? {} : { description }),
+          } as never),
+          existing?.installByDefault === true,
+        )
+      }
+      if (entry === undefined) throw new TypeError('Admin Domain publication returned no entry.')
+
+      const defaultChanged =
+        input.installByDefault !== undefined &&
+        (entry.installByDefault ?? false) !== input.installByDefault
+      if (defaultChanged) {
+        entry = domainFromSummary(
+          await binding.$.invoke(
+            Domain.$.method('configureDefault') as never,
+            Path.parse(entry.id),
+            {
+              operationId: operationId('configure-default'),
+              enabled: input.installByDefault,
+            } as never,
+          ),
+          input.installByDefault === true,
+        )
+      }
+      return Object.freeze({
+        entry,
+        changed: registryChanged || defaultChanged,
+        isNew: existing === undefined,
+      })
+    },
+  })
+}
+
+async function bindInstalledAdmin(session: ClientSession): Promise<DomainBinding> {
+  return bind(session, await session.installed(ADMIN_ORIGIN))
+}
+
+type DynamicDefinition = ReturnType<DomainBinding['$']['class']>
+
+function domainFromNode(
+  definition: DynamicDefinition,
+  node: Node,
+  installByDefault: boolean,
+): DomainInfo {
+  return Object.freeze({
+    id: Path.id(node.id).raw,
+    origin: requiredProperty(definition, node, 'origin'),
+    name: requiredProperty(definition, node, 'name'),
+    url: requiredProperty(definition, node, 'discoveryUrl'),
+    ...optionalProperty(definition, node, 'description'),
+    ...(installByDefault ? { installByDefault: true } : {}),
+    createdAt: requiredProperty(definition, node, 'createdAt'),
+    updatedAt: requiredProperty(definition, node, 'updatedAt'),
+  })
+}
+
+function domainFromSummary(input: unknown, installByDefault: boolean): DomainInfo {
+  const value = record(input, 'Admin Domain summary')
+  return Object.freeze({
+    id: requiredString(value.id, 'Admin Domain id'),
+    origin: requiredString(value.origin, 'Admin Domain origin'),
+    name: requiredString(value.name, 'Admin Domain name'),
+    url: requiredString(value.discoveryUrl, 'Admin Domain discovery URL'),
+    ...(value.description === undefined
+      ? {}
+      : { description: requiredString(value.description, 'Admin Domain description') }),
+    ...(installByDefault ? { installByDefault: true } : {}),
+    createdAt: requiredString(value.createdAt, 'Admin Domain creation time'),
+    updatedAt: requiredString(value.updatedAt, 'Admin Domain update time'),
+  })
+}
+
+function requiredProperty(definition: DynamicDefinition, node: Node, name: string): string {
+  return requiredString(node.props[definition.$.property(name).key], `Admin Domain.${name}`)
+}
+
+function optionalProperty(
+  definition: DynamicDefinition,
+  node: Node,
+  name: string,
+): Readonly<Record<string, string>> {
+  const value = node.props[definition.$.property(name).key]
+  return value === undefined ? {} : { [name]: requiredString(value, `Admin Domain.${name}`) }
+}
+
+function requiredString(input: unknown, label: string): string {
+  if (typeof input !== 'string' || input.length === 0) throw new TypeError(`${label} is invalid.`)
+  return input
+}
+
+function record(input: unknown, label: string): Readonly<Record<string, unknown>> {
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    throw new TypeError(`${label} is invalid.`)
+  }
+  return input as Readonly<Record<string, unknown>>
+}
+
+function defaultOperationId(kind: 'publish' | 'configure-default'): string {
+  return `cli.domain.${kind}:${globalThis.crypto.randomUUID()}`
+}

package/src/admin/catalog/index.ts

@@ -0,0 +1,13 @@
+export {
+  connectAdminCatalog,
+  type AdminCatalogApi,
+  type AdminCatalogContext,
+  type AdminCatalogDependencies,
+} from './client'
+export {
+  AdminDomainNotFoundError,
+  type DomainInfo,
+  type InstallDomainResult,
+  type PublishDomainInput,
+  type PublishDomainResult,
+} from './model'

package/src/admin/catalog/model.ts

@@ -0,0 +1,42 @@
+/** CLI-stable projection of one Admin Domain catalog record. */
+export interface DomainInfo {
+  readonly id: string
+  readonly origin: string
+  readonly name: string
+  readonly url?: string
+  readonly description?: string
+  readonly installByDefault?: boolean
+  readonly createdAt: string
+  readonly updatedAt: string
+}
+
+export interface PublishDomainInput {
+  readonly origin: string
+  readonly name: string
+  readonly url: string
+  readonly description?: string
+  readonly installByDefault?: boolean
+}
+
+export interface PublishDomainResult {
+  readonly entry: DomainInfo
+  readonly changed: boolean
+  readonly isNew: boolean
+}
+
+export interface InstallDomainResult {
+  readonly name: string
+  readonly origin: string
+  readonly instanceId: string
+  readonly url: string
+  readonly ok: boolean
+  readonly error?: string | null
+}
+
+export class AdminDomainNotFoundError extends Error {
+  readonly name = 'NotFoundError'
+
+  constructor(readonly identifier: string) {
+    super(`No visible Admin Domain matches ${JSON.stringify(identifier)}.`)
+  }
+}

package/src/admin/catalog/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "types": ["@types/node"]
+  },
+  "include": ["*.ts"],
+  "exclude": ["__tests__"]
+}

package/src/admin/graph/.spec/api.d.ts

@@ -0,0 +1,28 @@
+import type { GraphQueryOptions, NeighborsOptions, NodePage } from '@astrale-os/kernel-client/graph'
+import type { ClassPath } from '@astrale-os/sdk/graph/class'
+import type { Node } from '@astrale-os/sdk/graph/node'
+import type { PathLike } from '@astrale-os/sdk/graph/path'
+import type { QueryAST, QueryResult } from '@astrale-os/sdk/query'
+
+/** Smallest Kernel graph capability needed by bounded Admin graph reads. */
+export interface AdminGraphQueryApi {
+  query(ast: QueryAST, options?: GraphQueryOptions): Promise<QueryResult>
+}
+
+/** Caller-scoped graph reads shared by the Admin catalog and Instance journeys. */
+export interface AdminGraphApi extends AdminGraphQueryApi {
+  neighbors(source: PathLike, edge: ClassPath, options: NeighborsOptions): Promise<NodePage>
+}
+
+export interface ReadAllNodesOptions {
+  readonly label: string
+  readonly maximum: number
+  readonly maximumPages: number
+}
+
+/** Collect one bounded Node selection and reject projection, cursor, or identity anomalies. */
+export function readAllNodes(
+  graph: AdminGraphQueryApi,
+  ast: QueryAST,
+  options: ReadAllNodesOptions,
+): Promise<readonly Node[]>

package/src/admin/graph/.spec/architecture.md

@@ -0,0 +1,5 @@
+# Admin Graph inventory helper
+
+This internal helper consumes only public `GraphApi.query` pages. It requires a Node selection,
+enforces explicit Node and page bounds, rejects repeated cursors and Node identities, and returns a
+frozen inventory. It owns no Admin schema meaning and performs no mutation or invocation.

package/src/admin/graph/.spec/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#0891b2" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+  <circle cx="5" cy="12" r="2"/><circle cx="12" cy="6" r="2"/><circle cx="19" cy="12" r="2"/><circle cx="12" cy="18" r="2"/><path d="m7 11 3.5-3.5M13.5 7.5 17 11M17 13l-3.5 3.5M10.5 16.5 7 13"/>
+</svg>

package/src/admin/graph/.spec/layout.ts

@@ -0,0 +1,3 @@
+import { defineLayout } from '@astrale-os/spec/authoring'
+
+export default defineLayout({ entries: ['index.ts', 'nodes.ts'], exact: true })

package/src/admin/graph/index.ts

@@ -0,0 +1,6 @@
+export {
+  readAllNodes,
+  type AdminGraphApi,
+  type AdminGraphQueryApi,
+  type ReadAllNodesOptions,
+} from './nodes'

package/src/admin/graph/nodes.ts

@@ -0,0 +1,56 @@
+import type { GraphApi } from '@astrale-os/kernel-client/graph'
+import type { Node } from '@astrale-os/sdk/graph/node'
+import type { QueryAST } from '@astrale-os/sdk/query'
+
+export type AdminGraphQueryApi = Pick<GraphApi, 'query'>
+export type AdminGraphApi = Pick<GraphApi, 'query' | 'neighbors'>
+
+export interface ReadAllNodesOptions {
+  readonly label: string
+  readonly maximum: number
+  readonly maximumPages: number
+}
+
+/** Collect one explicitly bounded Node-value projection without hiding cursors. */
+export async function readAllNodes(
+  graph: AdminGraphQueryApi,
+  ast: QueryAST,
+  options: ReadAllNodesOptions,
+): Promise<readonly Node[]> {
+  const nodes: Node[] = []
+  const ids = new Set<string>()
+  const cursors = new Set<string>()
+  let cursor: string | undefined
+  let pages = 0
+  const pageSize = Math.min(options.maximum, 256)
+  do {
+    pages += 1
+    if (pages > options.maximumPages) {
+      throw new TypeError(`${options.label} exceeded its page bound.`)
+    }
+    const response = await graph.query(ast, {
+      page: { size: pageSize, ...(cursor === undefined ? {} : { after: cursor }) },
+    })
+    const result = response.result
+    if (result.kind !== 'nodes')
+      throw new TypeError(`${options.label} returned the wrong projection.`)
+    for (const projection of result.nodes) {
+      if (projection.kind !== 'value') {
+        throw new TypeError(`${options.label} omitted requested Node values.`)
+      }
+      const node = projection.value
+      if (ids.has(String(node.id))) throw new TypeError(`${options.label} repeated a Node.`)
+      ids.add(String(node.id))
+      nodes.push(node)
+    }
+    if (nodes.length > options.maximum) {
+      throw new TypeError(`${options.label} exceeded its Node bound.`)
+    }
+    cursor = response.page.next
+    if (cursor !== undefined && cursors.has(cursor)) {
+      throw new TypeError(`${options.label} repeated a cursor.`)
+    }
+    if (cursor !== undefined) cursors.add(cursor)
+  } while (cursor !== undefined)
+  return Object.freeze(nodes)
+}

package/src/admin/index.ts

@@ -0,0 +1,2 @@
+export * as catalog from './catalog'
+export * as instance from './instance'

package/src/admin/instance/.spec/api.d.ts

@@ -0,0 +1,66 @@
+import type { DomainBinding } from '@astrale-os/kernel-client/domain'
+import type { ClientSession } from '@astrale-os/kernel-client/session'
+
+import type { AdminGraphApi } from '../../graph/.spec/api.js'
+
+export type InstanceState = 'provisioning' | 'ready' | 'deleting' | 'failed' | 'deleted'
+
+export interface InstanceInfo {
+  readonly id: string
+  readonly slug: string
+  readonly url: string
+  readonly hostId?: string
+  readonly region?: string
+  readonly state?: InstanceState
+  readonly phase?: string
+  readonly error?: string | null
+  readonly createdAt?: string
+  readonly organizationId?: string
+}
+
+export interface OwnedInstanceInfo extends InstanceInfo {
+  readonly state: InstanceState
+}
+
+export interface DomainInstallReceipt {
+  readonly domain: string
+  readonly instance: string
+  readonly origin: string
+  readonly ok: boolean
+  readonly installedRevision?: string
+  readonly error?: string
+}
+
+export interface AdminInstanceContext {
+  readonly session: ClientSession
+  readonly graph: AdminGraphApi
+}
+
+export interface AdminInstanceApi {
+  list(): Promise<OwnedInstanceInfo[]>
+  create(slug: string, hostId?: string): Promise<InstanceInfo>
+  status(identifier: string): Promise<InstanceInfo>
+  delete(identifier: string): Promise<InstanceInfo>
+  installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>
+}
+
+export class AdminInstanceNotFoundError extends Error {
+  constructor(identifier: string)
+  readonly name: 'NotFoundError'
+  readonly identifier: string
+}
+
+export interface AdminInstanceDependencies {
+  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
+  readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string
+}
+
+export function connectAdminInstances(
+  context: AdminInstanceContext,
+  dependencies?: AdminInstanceDependencies,
+): Promise<AdminInstanceApi>
+export function findOwnedInstance(
+  instances: readonly OwnedInstanceInfo[],
+  identifier: string,
+): OwnedInstanceInfo | undefined
+export function formatInstanceLocation(info: InstanceInfo): string

package/src/admin/instance/.spec/architecture.md

@@ -0,0 +1,10 @@
+# CLI Admin Instance adapter
+
+The adapter discovers and binds the configured Admin Domain, proves its origin, and resolves the
+singleton Fleet receiver. Policy-visible `Instance` and `Host` Nodes come from bounded Graph queries;
+Host location is joined through `instance_runs_on_host`.
+
+Automatic creation invokes `Fleet.createInstance`; explicit `--host-id` resolves one visible,
+non-reserved Host and invokes `Host.createInstance`. Status, deletion, and Domain installation
+invoke the exact Instance receiver. The adapter creates internal operation IDs but preserves the
+existing CLI projection and selection-required experience.

package/src/admin/instance/.spec/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#2563eb" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="4" y="4" width="16" height="16" rx="3"/><path d="M8 9h8M8 13h8M8 17h5"/><circle cx="17" cy="17" r="1" fill="#2563eb"/>
+</svg>

package/src/admin/instance/.spec/layout.ts

@@ -0,0 +1,6 @@
+import { defineLayout } from '@astrale-os/spec/authoring'
+
+export default defineLayout({
+  entries: ['__tests__/', 'client.ts', 'index.ts', 'model.ts', 'tsconfig.json'],
+  exact: true,
+})