@astrale-os/cli 1.0.0-beta.5 → 1.0.0-beta.7

package/src/admin/graph/nodes.ts

@@ -1,4 +1,4 @@
-import type { GraphApi } from '@astrale-os/kernel-client/graph'
+import type { GraphApi } from '@astrale-os/sdk/client'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { QueryAST } from '@astrale-os/sdk/query'
 

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

@@ -1,4 +1,4 @@
-import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 import type { DomainBinding } from '@astrale-os/shell'
 
 import type { AdminGraphApi } from '../../graph/.spec/api.js'

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

@@ -1,39 +1,28 @@
 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 { AdminTestDomain, adminBinding, adminSession } from '../../__tests__/fixture'
 import { connectAdminInstances } from '../client'
 
-const methods: Array<{ owner: string; name: string }> = []
-
-function definition(name: string) {
+function hostNode(id: string, props: { readonly id: string; readonly state: string }): Node {
   return {
-    name,
-    $: {
-      method(method: string) {
-        const value = { owner: name, name: method }
-        methods.push(value)
-        return value
-      },
-      property(property: string) {
-        return { key: property }
-      },
-    },
+    id: NodeId(id),
+    class: AdminTestDomain.classes.Host.key,
+    props: AdminTestDomain.classes.Host.properties.from(props),
   }
 }
 
-function node(id: string, props: Record<string, unknown>): Node {
+function instanceNode(id: string): Node {
   return {
     id: NodeId(id),
-    class: ClassPath.from('admin.astrale.ai', 'Instance'),
-    props: props as never,
+    class: AdminTestDomain.classes.Instance.key,
+    props: AdminTestDomain.classes.Instance.properties.from({}),
   }
 }
 
@@ -49,7 +38,7 @@ function graphResult(nodes: readonly Node[], cursor?: string) {
 
 function sourceName(ast: QueryAST): string | undefined {
   const term = ast.source.terms[0]
-  return term?.kind === 'definition' ? term.definition.name : undefined
+  return term?.kind === 'class' ? term.class.name : undefined
 }
 
 function fixture(input: {
@@ -58,27 +47,16 @@ function fixture(input: {
   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 calls: Array<{
+    method: { owner: string; name: string }
+    receiver: string
+    value: unknown
+  }> = []
+  const remote = adminSession((method, receiver, value) => {
+    calls.push({ method, receiver: String(receiver), value })
+    return input.invoke?.(method, receiver, value)
+  })
+  const binding = adminBinding()
   const query = mock(async (ast: QueryAST) => {
     const name = sourceName(ast)
     if (name === 'Instance') return graphResult(input.instances ?? [])
@@ -86,7 +64,7 @@ function fixture(input: {
     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 (String(source) === '/:admin.astrale.ai:core.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)}`)
   })
@@ -94,10 +72,11 @@ function fixture(input: {
   return {
     binding,
     graph,
-    invoke,
+    invoke: remote.invoke,
+    calls,
     connect: () =>
       connectAdminInstances(
-        { session: {} as never, graph },
+        { session: remote.session, graph },
         {
           bind: async () => binding,
           operationId: (kind) => `cli.instance.${kind}:test`,
@@ -146,11 +125,13 @@ describe('V2 Admin Instance adapter', () => {
         region: 'fr-par',
       },
     ])
-    expect(contract.invoke).toHaveBeenCalledWith(
-      expect.objectContaining({ owner: 'Fleet', name: 'listInstances' }),
-      Path.id(NodeId('fleet')),
-      {},
-    )
+    expect(contract.calls).toEqual([
+      {
+        method: { owner: 'Fleet', name: 'listInstances' },
+        receiver: '/:admin.astrale.ai:core.fleet::listInstances',
+        value: {},
+      },
+    ])
   })
 
   test('delegates default placement to Fleet without reading Host inventory', async () => {
@@ -163,7 +144,7 @@ describe('V2 Admin Instance adapter', () => {
       updatedAt: '2026-08-12T00:00:00.000Z',
     }
     const contract = fixture({
-      hosts: [node('host-node', { id: 'host-paris', state: 'ready' })],
+      hosts: [hostNode('host-node', { id: 'host-paris', state: 'ready' })],
       invoke: () => created,
     })
 
@@ -174,18 +155,20 @@ 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.calls).toEqual([
+      {
+        method: { owner: 'Fleet', name: 'createInstance' },
+        receiver: '/:admin.astrale.ai:core.fleet::createInstance',
+        value: { 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 reserved = hostNode('admin-host', { id: 'admin', state: 'ready' })
+    const consumer = hostNode('consumer-host', { id: 'consumer-paris', state: 'ready' })
     const contract = fixture({
       hosts: [reserved, consumer],
       reserved,
@@ -198,21 +181,17 @@ describe('V2 Admin Instance adapter', () => {
     })
     const api = await contract.connect()
 
-    await expect(api.create('demo', 'admin')).rejects.toMatchObject({ name: 'NotFoundError' })
+    await expect(api.create('demo', 'admin')).rejects.toMatchObject({ code: 'HOST_NOT_FOUND' })
     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.at(-1)).toEqual({
+      method: { owner: 'Host', name: 'createInstance' },
+      receiver: '@consumer-host::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 instance = instanceNode('instance-node')
     const contract = fixture({
       instances: [instance],
       invoke: (method) =>
@@ -238,20 +217,16 @@ describe('V2 Admin Instance adapter', () => {
 
     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.map(({ method }) => method)).toEqual([
+      { owner: 'Fleet', name: 'listInstances' },
+      { owner: 'Instance', name: 'status' },
+      { owner: 'Fleet', name: 'listInstances' },
+      { owner: 'Instance', name: 'delete' },
     ])
   })
 
   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 instance = instanceNode('instance-node')
     const contract = fixture({
       instances: [instance],
       invoke: (method) =>
@@ -282,10 +257,10 @@ 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({
+      method: { owner: 'Instance', name: 'installDomain' },
+      receiver: '@instance-node::installDomain',
+      value: { operationId: 'cli.instance.install-domain:test', domain: '@crm-domain' },
+    })
   })
 })

package/src/admin/instance/client.ts

@@ -1,10 +1,19 @@
-import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 import type { Node } from '@astrale-os/sdk/graph/node'
+import type { ResolvedClass } from '@astrale-os/sdk/schema'
 
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
 
-import { bindAdmin, type AdminBinding } from '../binding'
+import {
+  bindAdmin,
+  invokeAdminMethod,
+  requireAdminBinding,
+  requireAdminClass,
+  requireAdminCore,
+  requireAdminProperty,
+  type AdminBinding,
+} from '../binding'
 import { readAllNodes, type AdminGraphApi } from '../graph'
 import {
   AdminHostNotFoundError,
@@ -16,18 +25,10 @@ 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
@@ -54,24 +55,24 @@ 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 binding = requireAdminBinding(await (dependencies.bind ?? bindAdmin)(context.session))
 
-  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 Instance = requireAdminClass(binding, 'Instance', 'node')
+  const Host = requireAdminClass(binding, 'Host', 'node')
+  const Fleet = requireAdminClass(binding, 'Fleet', 'node')
+  const fleetReservesAdminHost = requireAdminClass(binding, 'fleet_reserves_admin_host', 'edge')
+  const fleet = requireAdminCore(binding, 'fleet')
 
   const operationId = dependencies.operationId ?? defaultOperationId
 
   const list = async (): Promise<OwnedInstanceInfo[]> => {
-    const result: unknown = await binding.$.invoke(
-      Fleet.$.method('listInstances') as never,
+    const result: unknown = await invokeAdminMethod(
+      context.session,
+      binding,
+      Fleet,
+      'listInstances',
       fleet,
-      {} as never,
+      {},
     )
     if (!Array.isArray(result)) throw new TypeError('Admin Instance inventory is invalid.')
     return result.map((value) => instanceFromSummary(value) as OwnedInstanceInfo)
@@ -88,10 +89,13 @@ export async function connectAdminInstances(
     identifier: string,
   ): Promise<InstanceInfo> => {
     const instance = await requireInstance(identifier)
-    const output = await binding.$.invoke(
-      Instance.$.method(method) as never,
+    const output = await invokeAdminMethod(
+      context.session,
+      binding,
+      Instance,
+      method,
       Path.parse(instance.id),
-      { operationId: operationId(method) } as never,
+      { operationId: operationId(method) },
     )
     return instanceFromSummary(output)
   }
@@ -104,16 +108,19 @@ export async function connectAdminInstances(
         slug,
       })
       if (hostId !== undefined) {
-        const selected = await hostInventory(context.graph, binding, Host, fleet)
+        const selected = await hostInventory(context.graph, Host, fleetReservesAdminHost, 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,
+          await invokeAdminMethod(
+            context.session,
+            binding,
+            Host,
+            'createInstance',
             Path.parse(host.path),
-            input as never,
+            input,
           ),
         )
       }
@@ -122,20 +129,23 @@ export async function connectAdminInstances(
       // 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 invokeAdminMethod(context.session, binding, Fleet, 'createInstance', fleet, 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 invokeAdminMethod(
+        context.session,
+        binding,
+        Instance,
+        'installDomain',
         Path.parse(instance.id),
         {
           operationId: operationId('install-domain'),
           domain: Path.parse(domain).raw,
-        } as never,
+        },
       )
       return domainInstallReceipt(output)
     },
@@ -151,14 +161,14 @@ interface HostInventoryItem {
 
 async function hostInventory(
   graph: AdminGraphApi,
-  binding: AdminBinding,
-  Host: ReturnType<AdminBinding['$']['class']>,
+  Host: ResolvedClass<'node'>,
+  fleetReservesAdminHost: ResolvedClass<'edge'>,
   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({
+      Query.from({ nodes: [Host] }).select({
         kind: 'nodes',
         projection: { kind: 'value' },
       }),
@@ -189,7 +199,7 @@ async function hostInventory(
   })
 }
 
-type DynamicDefinition = ReturnType<AdminBinding['$']['class']>
+type DynamicDefinition = ResolvedClass<'node'>
 
 function instanceFromSummary(input: unknown): InstanceInfo {
   const value = record(input, 'Admin Instance summary')
@@ -240,8 +250,8 @@ 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}`,
+    node.props[requireAdminProperty(definition, name).key],
+    `Admin ${definition.ref.name}.${name}`,
   )
 }
 

package/src/admin/instance/model.ts

@@ -28,19 +28,19 @@ export interface DomainInstallReceipt {
   readonly error?: string
 }
 
-export class AdminInstanceNotFoundError extends Error {
-  readonly name = 'NotFoundError'
-
+export class AdminInstanceNotFoundError extends AstraleError {
   constructor(readonly identifier: string) {
-    super(`No owned Admin Instance matches ${JSON.stringify(identifier)}.`)
+    super(
+      'INSTANCE_NOT_FOUND',
+      `No owned Admin Instance matches ${JSON.stringify(identifier)}.`,
+      'Run `astrale instance list` to see your instances.',
+    )
   }
 }
 
-export class AdminHostNotFoundError extends Error {
-  readonly name = 'NotFoundError'
-
+export class AdminHostNotFoundError extends AstraleError {
   constructor(readonly identifier: string) {
-    super(`No caller-usable Admin Host matches ${JSON.stringify(identifier)}.`)
+    super('HOST_NOT_FOUND', `No caller-usable Admin Host matches ${JSON.stringify(identifier)}.`)
   }
 }
 
@@ -63,3 +63,4 @@ export function formatInstanceLocation(info: InstanceInfo): string {
     .filter(Boolean)
     .join(' · ')
 }
+import { AstraleError } from '../../errors'

package/src/commands/__tests__/call-describe.test.ts

@@ -1,34 +1,47 @@
 import { Path } from '@astrale-os/sdk/graph/path'
+import { bundle, defineSchema, func, method, nodeClass } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import { describeCallableFromSchema } from '../call-describe'
+import { describeCallableFromBundle } from '../call-describe'
 
-const schema = {
-  classes: {
-    Manager: {
-      methods: {
-        createInstance: {
-          auth: 'authorized',
-          description: 'Create one child Instance.',
-          input: { type: 'object', required: ['operationId', 'slug'] },
-          output: { mode: 'value' },
-        },
-      },
-    },
+const createInstance = method({
+  auth: 'authenticated',
+  description: 'Create one child Instance.',
+  input: {
+    type: 'object',
+    properties: { operationId: { type: 'string' }, slug: { type: 'string' } },
+    required: ['operationId', 'slug'],
+    additionalProperties: false,
   },
-  functions: {
-    journal: {
-      description: 'Read the authorized Kernel journal.',
-      input: { type: 'object' },
-    },
+  output: { type: 'object', additionalProperties: true },
+  static: true,
+})
+const inspectInstance = method({
+  auth: 'authenticated',
+  description: 'Inspect one child Instance.',
+  input: { type: 'object', properties: {}, additionalProperties: false },
+  output: { type: 'object', additionalProperties: true },
+})
+const journal = func({
+  auth: 'authenticated',
+  description: 'Read the authorized Kernel journal.',
+  input: { type: 'object', properties: {}, additionalProperties: false },
+  output: { type: 'object', additionalProperties: true },
+})
+const source = defineSchema('host.astrale.ai', {
+  classes: {
+    Manager: nodeClass({ methods: { createInstance } }),
+    Instance: nodeClass({ methods: { inspectInstance } }),
   },
-}
+  functions: { journal },
+})
+const installed = bundle.create(source)
 
-describe('describeCallableFromSchema', () => {
-  test('reads a static Class method from the Domain schema', () => {
-    const described = describeCallableFromSchema(
+describe('describeCallableFromBundle', () => {
+  test('reads a static Class method from the resolved Domain', () => {
+    const described = describeCallableFromBundle(
       Path.parse('/:host.astrale.ai:class.Manager:createInstance'),
-      schema,
+      installed,
     )
     expect(described).toMatchObject({
       origin: 'host.astrale.ai',
@@ -36,30 +49,30 @@ describe('describeCallableFromSchema', () => {
       method: 'createInstance',
       dispatch: 'static',
       description: 'Create one child Instance.',
-      auth: 'authorized',
+      auth: 'authenticated',
     })
     expect(described?.input).toMatchObject({ required: ['operationId', 'slug'] })
   })
 
-  test('finds an instance method when the receiver Path is not a Class projection', () => {
+  test('finds one instance method when the receiver Path is not a Class projection', () => {
     expect(
-      describeCallableFromSchema(
-        Path.parse('/:host.astrale.ai:core.manager::createInstance'),
-        schema,
+      describeCallableFromBundle(
+        Path.parse('/:host.astrale.ai:core.manager::inspectInstance'),
+        installed,
       ),
     ).toMatchObject({
       origin: 'host.astrale.ai',
-      class: 'Manager',
-      method: 'createInstance',
+      class: 'Instance',
+      method: 'inspectInstance',
       dispatch: 'instance',
     })
   })
 
-  test('reads a standalone Function from the Domain schema', () => {
+  test('reads a standalone Function from the resolved Domain', () => {
     expect(
-      describeCallableFromSchema(Path.parse('/:kernel.astrale.ai:function.journal'), schema),
+      describeCallableFromBundle(Path.parse('/:host.astrale.ai:function.journal'), installed),
     ).toMatchObject({
-      origin: 'kernel.astrale.ai',
+      origin: 'host.astrale.ai',
       function: 'journal',
       description: 'Read the authorized Kernel journal.',
     })

package/src/commands/__tests__/domain-install-operation.test.ts

@@ -1,9 +1,7 @@
-import { defineDomain } from '@astrale-os/sdk'
-import { issuer } from '@astrale-os/sdk/auth'
-import { createDeployment } from '@astrale-os/sdk/deployment'
-import { defineSchema } from '@astrale-os/sdk/schema/v1'
+import { defineSchema } from '@astrale-os/sdk/schema'
 import { afterEach, describe, expect, mock, test } from 'bun:test'
 
+import { releaseFor } from '../../__tests__/fixtures/publication'
 import { installDirect } from '../domain/install'
 
 const GENERATED = '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8'
@@ -12,16 +10,7 @@ const RETRY = '139137b5-af47-47ce-92b2-b64a2b0c63d7'
 const originalFetch = globalThis.fetch
 
 const schema = defineSchema('crm.test', {})
-const definition = defineDomain({
-  schema,
-  handlers: { functions: {}, classes: {}, interfaces: {} },
-})
-const deployed = createDeployment({
-  definition,
-  issuer: issuer.accept('https://crm.test'),
-  bundleHref: 'https://crm.test/domain.bundle.json',
-  bindings: { callables: [] },
-}).publication
+const deployed = releaseFor(schema, 'https://crm.test').publication
 
 function publicationResponse(): Response {
   return Response.json(deployed)

package/src/commands/__tests__/domain-install-owned.test.ts

@@ -1,4 +1,4 @@
-import { ResponseError } from '@astrale-os/kernel-client'
+import { ResponseError } from '@astrale-os/sdk/client'
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
 
 import type { OwnedInstanceInfo } from '../../lib/admin-instance'