@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.30

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

@@ -1,135 +1,46 @@
-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 { AdminBinding } from '../../binding'
-import type { AdminGraphApi } from '../../graph'
+import { describe, expect, test } from 'bun:test'
 
+import { adminSession } from '../../__tests__/fixture'
 import { connectAdminInstances } from '../client'
 
-const methods: Array<{ owner: string; name: string }> = []
-
-function definition(name: string) {
-  return {
-    name,
-    $: {
-      method(method: string) {
-        const value = { owner: name, name: method }
-        methods.push(value)
-        return value
-      },
-      property(property: string) {
-        return { key: property }
-      },
-    },
-  }
-}
-
-function node(id: string, props: Record<string, unknown>): Node {
-  return {
-    id: NodeId(id),
-    class: ClassPath.from('admin.astrale.ai', 'Instance'),
-    props: props as never,
-  }
-}
-
-function graphResult(nodes: readonly Node[], cursor?: string) {
-  return {
-    result: {
-      kind: 'nodes' as const,
-      nodes: nodes.map((value) => ({ kind: 'value' as const, value })),
-    },
-    page: cursor === undefined ? {} : { next: cursor },
-  }
-}
-
-function sourceName(ast: QueryAST): string | undefined {
-  const term = ast.source.terms[0]
-  return term?.kind === 'definition' ? term.definition.name : undefined
-}
-
-function fixture(input: {
-  instances?: readonly Node[]
-  hosts?: readonly Node[]
-  reserved?: Node | null
-  invoke?: (method: { owner: string; name: string }, receiver: unknown, input: unknown) => unknown
-}) {
-  methods.length = 0
-  const Instance = definition('Instance')
-  const Host = definition('Host')
-  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 === 'Instance') return Instance
-        if (name === 'Host') return Host
-        if (name === 'Fleet') return Fleet
-        throw new Error(`Unexpected class ${name}`)
-      },
-      core: { nodes: { fleet: { path: Path.id(NodeId('fleet')) } } },
-      invoke,
-    },
-  } as unknown as AdminBinding
-  const query = mock(async (ast: QueryAST) => {
-    const name = sourceName(ast)
-    if (name === 'Instance') return graphResult(input.instances ?? [])
-    if (name === 'Host') return graphResult(input.hosts ?? [])
-    throw new Error(`Unexpected graph query ${String(name)}`)
-  })
-  const neighbors = mock(async (source: unknown, edge: { name?: string }) => {
-    if (String(source) === '@fleet') return page(input.reserved ?? null)
-    if (edge.name === 'instance_runs_on_host') return page(input.hosts?.[0] ?? null)
-    throw new Error(`Unexpected neighbor query ${String(source)} ${String(edge)}`)
+function fixture(input: { invoke?: (target: string, input: unknown) => unknown }) {
+  const calls: Array<{
+    target: string
+    value: unknown
+  }> = []
+  const remote = adminSession((target, value) => {
+    calls.push({ target, value })
+    return input.invoke?.(target, value)
   })
-  const graph = { query, neighbors } as unknown as AdminGraphApi
   return {
-    binding,
-    graph,
-    invoke,
+    call: remote.call,
+    reflection: remote.reflection,
+    calls,
     connect: () =>
       connectAdminInstances(
-        { session: {} as never, graph },
+        { session: remote.session },
         {
-          bind: async () => binding,
           operationId: (kind) => `cli.instance.${kind}:test`,
         },
       ),
   }
 }
 
-function page(item: Node | null) {
-  return {
-    nodes: item === null ? [] : [item],
-    first: item,
-    graph: { nodes: item === null ? [] : [item], edges: [] },
-    cursor: null,
-  }
-}
-
 describe('V2 Admin Instance adapter', () => {
   test('lists caller-visible Instances through the Admin-owned Fleet operation', async () => {
     const contract = fixture({
-      invoke: (method) =>
-        method.name === 'listInstances'
+      invoke: (target) =>
+        target.endsWith('::listInstances')
           ? [
               {
                 id: '@instance-node',
                 slug: 'demo',
                 url: 'https://demo.eu.astrale.ai',
+                hostId: '@host-node',
+                region: 'fr-par',
                 state: 'ready',
                 createdAt: '2026-08-12T00:00:00.000Z',
                 updatedAt: '2026-08-12T00:00:00.000Z',
-                hostId: '@host-node',
-                region: 'fr-par',
               },
             ]
           : undefined,
@@ -140,17 +51,20 @@ describe('V2 Admin Instance adapter', () => {
         id: '@instance-node',
         slug: 'demo',
         url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-        createdAt: '2026-08-12T00:00:00.000Z',
         hostId: '@host-node',
         region: 'fr-par',
+        state: 'ready',
+        createdAt: '2026-08-12T00:00:00.000Z',
+        updatedAt: '2026-08-12T00:00:00.000Z',
       },
     ])
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      Path.id(NodeId('fleet')),
-      {},
-    )
+    expect(contract.calls).toEqual([
+      {
+        target: '/:admin.astrale.ai:core.fleet::listInstances',
+        value: {},
+      },
+    ])
+    expect(contract.reflection).not.toHaveBeenCalled()
   })
 
   test('delegates default placement to Fleet without reading Host inventory', async () => {
@@ -162,10 +76,7 @@ describe('V2 Admin Instance adapter', () => {
       createdAt: '2026-08-12T00:00:00.000Z',
       updatedAt: '2026-08-12T00:00:00.000Z',
     }
-    const contract = fixture({
-      hosts: [node('host-node', { id: 'host-paris', state: 'ready' })],
-      invoke: () => created,
-    })
+    const contract = fixture({ invoke: () => created })
 
     await expect((await contract.connect()).create('demo')).resolves.toMatchObject({
       id: created.id,
@@ -174,49 +85,18 @@ describe('V2 Admin Instance adapter', () => {
       state: created.state,
       createdAt: created.createdAt,
     })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Fleet', name: 'createInstance' }),
-      Path.id(NodeId('fleet')),
-      { operationId: 'cli.instance.create:test', slug: 'demo' },
-    )
-    expect(contract.graph.query).not.toHaveBeenCalled()
-    expect(contract.graph.neighbors).not.toHaveBeenCalled()
-  })
-
-  test('resolves --host-id to an exact Host receiver and rejects the reserved Admin Host', async () => {
-    const reserved = node('admin-host', { id: 'admin', state: 'ready' })
-    const consumer = node('consumer-host', { id: 'consumer-paris', state: 'ready' })
-    const contract = fixture({
-      hosts: [reserved, consumer],
-      reserved,
-      invoke: () => ({
-        id: '@instance-node',
-        slug: 'demo',
-        url: 'https://demo.eu.astrale.ai',
-        state: 'ready',
-      }),
-    })
-    const api = await contract.connect()
-
-    await expect(api.create('demo', 'admin')).rejects.toMatchObject({ name: 'NotFoundError' })
-    await expect(api.create('demo', 'consumer-paris')).resolves.toMatchObject({ slug: 'demo' })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Host', name: 'createInstance' }),
-      Path.id(NodeId('consumer-host')),
-      { operationId: 'cli.instance.create:test', slug: 'demo' },
-    )
+    expect(contract.calls).toEqual([
+      {
+        target: '/:admin.astrale.ai:core.fleet::createInstance',
+        value: { operationId: 'cli.instance.create:test', slug: 'demo' },
+      },
+    ])
   })
 
   test('refreshes and deletes through the resolved Instance receiver', async () => {
-    const instance = node('instance-node', {
-      slug: 'demo',
-      url: 'https://demo.eu.astrale.ai',
-      state: 'ready',
-    })
     const contract = fixture({
-      instances: [instance],
-      invoke: (method) =>
-        method.name === 'listInstances'
+      invoke: (target) =>
+        target.endsWith('::listInstances')
           ? [
               {
                 id: '@instance-node',
@@ -231,31 +111,34 @@ describe('V2 Admin Instance adapter', () => {
               id: '@instance-node',
               slug: 'demo',
               url: 'https://demo.eu.astrale.ai',
-              state: method.name === 'delete' ? 'deleted' : 'ready',
+              state: target.endsWith('::delete') ? 'deleted' : 'ready',
+              createdAt: '2026-08-12T00:00:00.000Z',
+              updatedAt: '2026-08-12T00:00:00.000Z',
             },
     })
     const api = await contract.connect()
 
     await expect(api.status('demo')).resolves.toMatchObject({ state: 'ready' })
     await expect(api.delete('@instance-node')).resolves.toMatchObject({ state: 'deleted' })
-    expect(contract.invoke.mock.calls.map(([method]) => method)).toEqual([
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      expect.objectContaining({ owner: 'Instance', name: 'status' }),
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      expect.objectContaining({ owner: 'Instance', name: 'delete' }),
+    expect(contract.calls).toEqual([
+      { target: '/:admin.astrale.ai:core.fleet::listInstances', value: {} },
+      {
+        target: '@instance-node::status',
+        value: { operationId: 'cli.instance.status:test' },
+      },
+      { target: '/:admin.astrale.ai:core.fleet::listInstances', value: {} },
+      {
+        target: '@instance-node::delete',
+        value: { operationId: 'cli.instance.delete:test' },
+      },
     ])
+    expect(contract.reflection).not.toHaveBeenCalled()
   })
 
   test('installs a resolved catalog Domain through Instance.installDomain', async () => {
-    const instance = node('instance-node', {
-      slug: 'demo',
-      url: 'https://demo.eu.astrale.ai',
-      state: 'ready',
-    })
     const contract = fixture({
-      instances: [instance],
-      invoke: (method) =>
-        method.name === 'listInstances'
+      invoke: (target) =>
+        target.endsWith('::listInstances')
           ? [
               {
                 id: '@instance-node',
@@ -282,10 +165,109 @@ describe('V2 Admin Instance adapter', () => {
       origin: 'crm.acme.dev',
       ok: true,
     })
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Instance', name: 'installDomain' }),
-      Path.id(NodeId('instance-node')),
-      { operationId: 'cli.instance.install-domain:test', domain: '@crm-domain' },
+    expect(contract.calls.at(-1)).toEqual({
+      target: '@instance-node::installDomain',
+      value: { operationId: 'cli.instance.install-domain:test', domain: '@crm-domain' },
+    })
+    expect(contract.reflection).not.toHaveBeenCalled()
+  })
+
+  test('connects without network I/O and list performs exactly one call', async () => {
+    const contract = fixture({ invoke: () => [] })
+
+    const api = await contract.connect()
+    expect(contract.call).not.toHaveBeenCalled()
+    expect(contract.reflection).not.toHaveBeenCalled()
+
+    await expect(api.list()).resolves.toEqual([])
+    expect(contract.call).toHaveBeenCalledTimes(1)
+    expect(contract.reflection).not.toHaveBeenCalled()
+  })
+
+  test('rejects malformed inventory, lifecycle, Method, and install outputs', async () => {
+    await expect((await fixture({ invoke: () => ({}) }).connect()).list()).rejects.toThrow(
+      'Admin Instance inventory is invalid.',
+    )
+    await expect(
+      (
+        await fixture({
+          invoke: () => [{ id: '@instance-node', slug: 'demo', state: 'mystery' }],
+        }).connect()
+      ).list(),
+    ).rejects.toThrow('Admin Instance state is invalid.')
+    await expect(
+      (
+        await fixture({
+          invoke: () => [{ id: 'not-a-path', slug: 'demo', state: 'ready' }],
+        }).connect()
+      ).list(),
+    ).rejects.toThrow('Admin Instance id is invalid.')
+    await expect(
+      (
+        await fixture({
+          invoke: () => [
+            { id: '@instance-node', slug: 'demo', hostId: 'not-a-path', state: 'ready' },
+          ],
+        }).connect()
+      ).list(),
+    ).rejects.toThrow('Admin Host id is invalid.')
+
+    const malformedStatus = fixture({
+      invoke: (target) =>
+        target.endsWith('::listInstances')
+          ? [
+              {
+                id: '@instance-node',
+                slug: 'demo',
+                state: 'ready',
+                createdAt: '2026-08-12T00:00:00.000Z',
+                updatedAt: '2026-08-12T00:00:00.000Z',
+              },
+            ]
+          : {
+              id: '@instance-node',
+              slug: 'demo',
+              state: 'ready',
+              failure: {},
+              createdAt: '2026-08-12T00:00:00.000Z',
+              updatedAt: '2026-08-12T00:00:00.000Z',
+            },
+    })
+    await expect((await malformedStatus.connect()).status('demo')).rejects.toThrow(
+      'Admin failure message is invalid.',
     )
+
+    const malformedInstall = fixture({
+      invoke: (target) =>
+        target.endsWith('::listInstances')
+          ? [
+              {
+                id: '@instance-node',
+                slug: 'demo',
+                state: 'ready',
+                createdAt: '2026-08-12T00:00:00.000Z',
+                updatedAt: '2026-08-12T00:00:00.000Z',
+              },
+            ]
+          : {
+              domain: '@crm-domain',
+              instance: '@instance-node',
+              origin: 'crm.acme.dev',
+              ok: 'yes',
+            },
+    })
+    await expect(
+      (await malformedInstall.connect()).installDomain('demo', '@crm-domain'),
+    ).rejects.toThrow('Admin Domain install outcome is invalid.')
+
+    const malformedInstallPath = fixture({
+      invoke: (target) =>
+        target.endsWith('::listInstances')
+          ? [{ id: '@instance-node', slug: 'demo', state: 'ready' }]
+          : { domain: 'not-a-path', instance: '@instance-node', origin: 'crm.acme.dev', ok: true },
+    })
+    await expect(
+      (await malformedInstallPath.connect()).installDomain('demo', '@crm-domain'),
+    ).rejects.toThrow('Admin Domain reference is invalid.')
   })
 })

package/src/admin/instance/client.ts

@@ -1,13 +1,9 @@
-import type { ClientSession } from '@astrale-os/kernel-client/session'
-import type { Node } from '@astrale-os/sdk/graph/node'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 
 import { Path } from '@astrale-os/sdk/graph/path'
-import { Query } from '@astrale-os/sdk/query'
 
-import { bindAdmin, type AdminBinding } from '../binding'
-import { readAllNodes, type AdminGraphApi } from '../graph'
+import { AdminContract, callAdminMethod } from '../contract'
 import {
-  AdminHostNotFoundError,
   AdminInstanceNotFoundError,
   findOwnedInstance,
   type DomainInstallReceipt,
@@ -16,62 +12,38 @@ import {
   type OwnedInstanceInfo,
 } from './model'
 
-const ADMIN_ORIGIN = 'admin.astrale.ai'
-const PAGE_SIZE = 256
-const MAXIMUM_INSTANCES = 10_000
-const MAXIMUM_PAGES = Math.ceil(MAXIMUM_INSTANCES / PAGE_SIZE) + 1
-
-const HostRef = Object.freeze({ origin: ADMIN_ORIGIN, kind: 'class' as const, name: 'Host' })
-const fleetReservesAdminHost = Object.freeze({
-  origin: ADMIN_ORIGIN,
-  kind: 'class' as const,
-  name: 'fleet_reserves_admin_host',
-})
-
 export interface AdminInstanceContext {
   readonly session: ClientSession
-  readonly graph: AdminGraphApi
 }
 
 export interface AdminInstanceApi {
   list(): Promise<OwnedInstanceInfo[]>
-  create(slug: string, hostId?: string): Promise<InstanceInfo>
+  create(slug: string): Promise<InstanceInfo>
   status(identifier: string): Promise<InstanceInfo>
   delete(identifier: string): Promise<InstanceInfo>
   installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>
 }
 
 export interface AdminInstanceDependencies {
-  readonly bind?: (session: ClientSession) => Promise<AdminBinding>
   readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string
 }
 
 /**
- * Bind one discovered Admin root revision and expose only the public Instance
- * product journey. No Host lifecycle method is present on this capability.
+ * Connect the public Instance journey through stable Admin call paths. Routine
+ * operations perform no schema discovery. No Host lifecycle method is present.
  */
 export async function connectAdminInstances(
   context: AdminInstanceContext,
   dependencies: AdminInstanceDependencies = {},
 ): Promise<AdminInstanceApi> {
-  const binding = await (dependencies.bind ?? bindAdmin)(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 Instance = binding.$.class('Instance')
-  const Host = binding.$.class('Host')
-  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<OwnedInstanceInfo[]> => {
-    const result: unknown = await binding.$.invoke(
-      Fleet.$.method('listInstances') as never,
-      fleet,
-      {} as never,
+    const result: unknown = await callAdminMethod(
+      context.session,
+      AdminContract.fleet,
+      'listInstances',
+      {},
     )
     if (!Array.isArray(result)) throw new TypeError('Admin Instance inventory is invalid.')
     return result.map((value) => instanceFromSummary(value) as OwnedInstanceInfo)
@@ -88,121 +60,55 @@ export async function connectAdminInstances(
     identifier: string,
   ): Promise<InstanceInfo> => {
     const instance = await requireInstance(identifier)
-    const output = await binding.$.invoke(
-      Instance.$.method(method) as never,
-      Path.parse(instance.id),
-      { operationId: operationId(method) } as never,
-    )
+    const output = await callAdminMethod(context.session, Path.parse(instance.id), method, {
+      operationId: operationId(method),
+    })
     return instanceFromSummary(output)
   }
 
   return Object.freeze({
     list,
-    async create(slug: string, hostId?: string) {
+    async create(slug: string) {
       const input = Object.freeze({
         operationId: operationId('create'),
         slug,
       })
-      if (hostId !== undefined) {
-        const selected = await hostInventory(context.graph, binding, Host, fleet)
-        const host = selected.hosts.find(
-          (item) => item.id === hostId && item.state === 'ready' && item.path !== selected.reserved,
-        )
-        if (host === undefined) throw new AdminHostNotFoundError(hostId)
-        return instanceFromSummary(
-          await binding.$.invoke(
-            Host.$.method('createInstance') as never,
-            Path.parse(host.path),
-            input as never,
-          ),
-        )
-      }
-
-      // Default placement belongs to Admin. Avoid a redundant Host graph read:
-      // it requires broader graph authority than this Fleet operation and can
-      // deny an otherwise authorized caller before the server selects a Host.
       return instanceFromSummary(
-        await binding.$.invoke(Fleet.$.method('createInstance') as never, fleet, input as never),
+        await callAdminMethod(context.session, AdminContract.fleet, 'createInstance', input),
       )
     },
     status: (identifier: string) => invokeInstance('status', identifier),
     delete: (identifier: string) => invokeInstance('delete', identifier),
     async installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt> {
       const instance = await requireInstance(identifier)
-      const output = await binding.$.invoke(
-        Instance.$.method('installDomain') as never,
+      const output = await callAdminMethod(
+        context.session,
         Path.parse(instance.id),
+        'installDomain',
         {
           operationId: operationId('install-domain'),
           domain: Path.parse(domain).raw,
-        } as never,
+        },
       )
       return domainInstallReceipt(output)
     },
   })
 }
 
-interface HostInventoryItem {
-  readonly id: string
-  readonly nodeId: string
-  readonly path: string
-  readonly state: string
-}
-
-async function hostInventory(
-  graph: AdminGraphApi,
-  binding: AdminBinding,
-  Host: ReturnType<AdminBinding['$']['class']>,
-  fleet: Path,
-): Promise<{ readonly hosts: readonly HostInventoryItem[]; readonly reserved?: string }> {
-  const [nodes, reservedPage] = await Promise.all([
-    readAllNodes(
-      graph,
-      Query.from({ kind: 'node', definitions: [HostRef] }).select({
-        kind: 'nodes',
-        projection: { kind: 'value' },
-      }),
-      {
-        label: 'Admin Host inventory',
-        maximum: MAXIMUM_INSTANCES,
-        maximumPages: MAXIMUM_PAGES,
-      },
-    ),
-    graph.neighbors(fleet, fleetReservesAdminHost, {
-      direction: 'outgoing',
-      page: { size: 1 },
-    }),
-  ])
-  const reserved = reservedPage.first === null ? undefined : Path.id(reservedPage.first.id).raw
-  return Object.freeze({
-    hosts: Object.freeze(
-      nodes.map((node) =>
-        Object.freeze({
-          id: requiredStringProperty(Host, node, 'id'),
-          nodeId: String(node.id),
-          path: Path.id(node.id).raw,
-          state: requiredStringProperty(Host, node, 'state'),
-        }),
-      ),
-    ),
-    ...(reserved === undefined ? {} : { reserved }),
-  })
-}
-
-type DynamicDefinition = ReturnType<AdminBinding['$']['class']>
-
 function instanceFromSummary(input: unknown): InstanceInfo {
   const value = record(input, 'Admin Instance summary')
   const failure = value.failure === undefined ? undefined : record(value.failure, 'Admin failure')
   return Object.freeze({
-    id: requiredString(value.id, 'Admin Instance id'),
+    id: requiredNodePath(value.id, 'Admin Instance id'),
     slug: requiredString(value.slug, 'Admin Instance slug'),
     url: optionalStringValue(value.url) ?? '',
-    state: instanceState(value.state),
     ...(value.hostId === undefined
       ? {}
-      : { hostId: requiredString(value.hostId, 'Admin Host id') }),
-    ...(value.region === undefined ? {} : { region: requiredString(value.region, 'Admin region') }),
+      : { hostId: requiredNodePath(value.hostId, 'Admin Host id') }),
+    ...(value.region === undefined
+      ? {}
+      : { region: requiredString(value.region, 'Admin Host region') }),
+    state: instanceState(value.state),
     ...(value.phase === undefined
       ? {}
       : { phase: requiredString(value.phase, 'Admin Instance phase') }),
@@ -212,6 +118,9 @@ function instanceFromSummary(input: unknown): InstanceInfo {
     ...(value.createdAt === undefined
       ? {}
       : { createdAt: requiredString(value.createdAt, 'Admin Instance creation time') }),
+    ...(value.updatedAt === undefined
+      ? {}
+      : { updatedAt: requiredString(value.updatedAt, 'Admin Instance update time') }),
     ...(value.organizationId === undefined
       ? {}
       : { organizationId: requiredString(value.organizationId, 'Admin organization id') }),
@@ -223,8 +132,8 @@ function domainInstallReceipt(input: unknown): DomainInstallReceipt {
   const failure = value.failure === undefined ? undefined : record(value.failure, 'Admin failure')
   if (typeof value.ok !== 'boolean') throw new TypeError('Admin Domain install outcome is invalid.')
   return Object.freeze({
-    domain: requiredString(value.domain, 'Admin Domain reference'),
-    instance: requiredString(value.instance, 'Admin Instance reference'),
+    domain: requiredNodePath(value.domain, 'Admin Domain reference'),
+    instance: requiredNodePath(value.instance, 'Admin Instance reference'),
     origin: requiredString(value.origin, 'Installed Domain origin'),
     ok: value.ok,
     ...(value.installedRevision === undefined
@@ -238,13 +147,6 @@ function domainInstallReceipt(input: unknown): DomainInstallReceipt {
   })
 }
 
-function requiredStringProperty(definition: DynamicDefinition, node: Node, name: string): string {
-  return requiredString(
-    node.props[definition.$.property(name).key],
-    `Admin ${definition.name}.${name}`,
-  )
-}
-
 function instanceState(input: unknown): InstanceState {
   if (
     input === 'provisioning' ||
@@ -263,6 +165,15 @@ function requiredString(input: unknown, label: string): string {
   return input
 }
 
+function requiredNodePath(input: unknown, label: string): string {
+  const value = requiredString(input, label)
+  try {
+    return Path.parse(value).raw
+  } catch {
+    throw new TypeError(`${label} is invalid.`)
+  }
+}
+
 function optionalStringValue(input: unknown): string | undefined {
   if (input === undefined) return undefined
   return requiredString(input, 'Admin string value')