@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/__tests__/fixtures/publication.ts

@@ -1,20 +0,0 @@
-import type { schema } from '@astrale-os/sdk/schema'
-
-import { defineApplication } from '@astrale-os/sdk/application'
-import { compile } from '@astrale-os/sdk/deployment/build'
-import { addressing, assemble } from '@astrale-os/sdk/deployment/release'
-import { defineRuntime } from '@astrale-os/sdk/runtime'
-
-/** Build a canonical empty-runtime Release for cross-boundary CLI tests. */
-export function releaseFor<const Schema extends schema.DomainSchema>(
-  source: Schema,
-  issuer: string,
-) {
-  const runtime = defineRuntime<Schema>()({
-    integrations: {},
-    initialize: () => ({ providers: {} }),
-    actions: [],
-    workflows: [],
-  })
-  return assemble(compile(defineApplication({ schema: source, runtime })), addressing(issuer))
-}

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

@@ -1,3 +0,0 @@
-/** CLI-private V2 Admin adapters; no package export or duplicate control-plane semantics. */
-export * as catalog from '../catalog/.spec/api.js'
-export * as instance from '../instance/.spec/api.js'

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

@@ -1,22 +0,0 @@
-# CLI Admin adapters
-
-This private aggregate translates the frozen CLI command journey into the stable public
-`admin.astrale.ai` contract. Routine commands use canonical Admin Class, Property, Core receiver,
-and Method paths through Kernel Client. They do not download, inspect, bind, or rebuild the Admin
-schema. Strict local decoders admit every untrusted Admin result. The adapter does not import Admin
-implementation code, call Host directly, or persist remote graph truth.
-
-`instance` owns create/list/status/delete/install projection and explicitly excludes the reserved
-Admin Host from consumer placement. `catalog` owns Domain inventory, publication, and default-set
-configuration. `graph` is their bounded cursor helper and is not re-exported by the aggregate.
-
-Commander grammar, help text, output shapes, bookmark behavior, and current interactive host
-selection remain owned by the existing command surface; these adapters change only its remote
-semantic owner.
-
-## Performance contract
-
-`instance list` performs one Admin method call after connection setup and no schema-discovery call.
-Against the production beta Admin endpoint, the complete command must finish in less than 1 second
-with a warm route/cache and less than 2 seconds from a cold CLI process. Unit tests prove the
-single-call/no-reflection shape; retained live evidence proves the wall-clock bounds.

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

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#7c3aed" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <path d="M12 3 4.5 7v10L12 21l7.5-4V7z"/><path d="M8 10h8M8 14h5"/><circle cx="17" cy="16" r="2.5"/>
-</svg>

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

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

package/src/admin/__tests__/fixture.ts

@@ -1,25 +0,0 @@
-import type { Call } from '@astrale-os/sdk/client'
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-
-import { mock } from 'bun:test'
-
-export function adminSession(implementation?: (target: string, input: unknown) => unknown): {
-  readonly call: ReturnType<typeof mock>
-  readonly reflection: ReturnType<typeof mock>
-  readonly session: ClientSession
-} {
-  const call = mock(async (request: Call) =>
-    implementation?.(String(request.target), request.input),
-  )
-  const reflection = mock(() => {
-    throw new Error('Routine Admin commands must not perform schema discovery or reflection.')
-  })
-  const session = {
-    call,
-    installation: reflection,
-    snapshot: reflection,
-    bind: reflection,
-    invoke: reflection,
-  } as unknown as ClientSession
-  return { call, reflection, session }
-}

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

@@ -1,63 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-
-import type { AdminGraphApi } from '../../graph/.spec/api.js'
-
-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 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 class AdminDomainNotFoundError extends Error {
-  constructor(identifier: string)
-  readonly name: 'NotFoundError'
-  readonly identifier: string
-}
-
-export interface AdminCatalogDependencies {
-  readonly operationId?: (kind: 'publish' | 'configure-default') => string
-}
-
-export function connectAdminCatalog(
-  context: AdminCatalogContext,
-  dependencies?: AdminCatalogDependencies,
-): Promise<AdminCatalogApi>

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

@@ -1,7 +0,0 @@
-# CLI Admin catalog adapter
-
-The adapter reads policy-visible `Domain` Nodes through bounded Graph pages using stable Class and
-Property keys, and derives default membership from the stable Fleet relation. It performs no schema
-discovery or reflection. Publication invokes `Fleet.publishDomain`; a requested default change is a
-separate explicit `Domain.configureDefault` call. Unchanged publication input is a no-op, and an
-omitted description preserves the current value.

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

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="#059669" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
-  <path d="M5 4h14v16H5zM8 8h8M8 12h8M8 16h5"/><circle cx="17" cy="16" r="2"/>
-</svg>

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

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

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

@@ -1,245 +0,0 @@
-import type { Node } from '@astrale-os/sdk/graph/node'
-import type { QueryAST } from '@astrale-os/sdk/query'
-
-import { NodeId } from '@astrale-os/sdk/graph/node'
-import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
-import { PropertyKey } from '@astrale-os/sdk/schema'
-import { describe, expect, mock, test } from 'bun:test'
-
-import type { AdminGraphApi } from '../../graph'
-
-import { adminSession } from '../../__tests__/fixture'
-import { connectAdminCatalog } from '../client'
-
-const domainProperties = Object.freeze({
-  origin: PropertyKey('admin.astrale.ai:class.Domain.property.origin'),
-  name: PropertyKey('kernel.astrale.ai:class.Named.property.name'),
-  discoveryUrl: PropertyKey('admin.astrale.ai:class.Domain.property.discoveryUrl'),
-  description: PropertyKey('kernel.astrale.ai:class.Descriptable.property.description'),
-  createdAt: PropertyKey('kernel.astrale.ai:class.Timestamped.property.createdAt'),
-  updatedAt: PropertyKey('kernel.astrale.ai:class.Timestamped.property.updatedAt'),
-})
-
-function domainNode(id: string, origin: string): Node {
-  return {
-    id: NodeId(id),
-    class: 'admin.astrale.ai:Domain' as Node['class'],
-    props: normalizeProperties({
-      [domainProperties.origin]: origin,
-      [domainProperties.name]: origin.split('.')[0]!,
-      [domainProperties.discoveryUrl]: `https://${origin}`,
-      [domainProperties.description]: `${origin} description`,
-      [domainProperties.createdAt]: '2026-08-12T00:00:00.000Z',
-      [domainProperties.updatedAt]: '2026-08-12T00:00:00.000Z',
-    }),
-  }
-}
-
-function fixture(input: {
-  domains?: readonly Node[]
-  defaults?: readonly Node[]
-  invoke?: (target: string, value: unknown) => unknown
-}) {
-  const calls: Array<{
-    target: string
-    value: unknown
-  }> = []
-  const remote = adminSession((target, value) => {
-    calls.push({ target, value })
-    return input.invoke?.(target, value)
-  })
-  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 (
-      _source: Parameters<AdminGraphApi['neighbors']>[0],
-      _via: Parameters<AdminGraphApi['neighbors']>[1],
-      _options: Parameters<AdminGraphApi['neighbors']>[2],
-    ) => ({
-      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 {
-    call: remote.call,
-    reflection: remote.reflection,
-    query,
-    neighbors,
-    calls,
-    connect: () =>
-      connectAdminCatalog(
-        { session: remote.session, graph },
-        {
-          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 contract = fixture({ domains: [crm, notes], defaults: [crm] })
-    const api = await contract.connect()
-
-    await expect(api.list()).resolves.toEqual([
-      {
-        id: '@crm-domain',
-        origin: 'crm.acme.dev',
-        name: 'crm',
-        url: 'https://crm.acme.dev',
-        description: 'crm.acme.dev description',
-        installByDefault: true,
-        createdAt: '2026-08-12T00:00:00.000Z',
-        updatedAt: '2026-08-12T00:00:00.000Z',
-      },
-      {
-        id: '@notes-domain',
-        origin: 'notes.acme.dev',
-        name: 'notes',
-        url: 'https://notes.acme.dev',
-        description: 'notes.acme.dev description',
-        createdAt: '2026-08-12T00:00:00.000Z',
-        updatedAt: '2026-08-12T00:00:00.000Z',
-      },
-    ])
-    expect(contract.query).toHaveBeenCalledWith(
-      {
-        format: 'astrale.graph.query',
-        version: 'v6',
-        source: {
-          kind: 'node',
-          terms: [
-            {
-              kind: 'class',
-              class: { origin: 'admin.astrale.ai', kind: 'class', name: 'Domain' },
-            },
-          ],
-          binding: 'n0',
-        },
-        steps: [],
-        select: { kind: 'nodes', binding: 'n0', projection: { kind: 'value' } },
-      },
-      { page: { size: 256 } },
-    )
-    const [source, edge, options] = contract.neighbors.mock.calls[0]!
-    expect(String(source)).toBe('/:admin.astrale.ai:core.fleet')
-    expect(edge).toEqual({
-      origin: 'admin.astrale.ai',
-      kind: 'class',
-      name: 'fleet_installs_domain_by_default',
-    })
-    expect(options).toEqual({ direction: 'outgoing', page: { size: 256 } })
-  })
-
-  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.calls).toEqual([
-      {
-        target: '/:admin.astrale.ai:core.fleet::publishDomain',
-        value: {
-          operationId: 'cli.domain.publish:test',
-          origin: 'crm.acme.dev',
-          name: 'crm',
-          discoveryUrl: 'https://crm.acme.dev',
-        },
-      },
-      {
-        target: '@crm-domain::configureDefault',
-        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.call).not.toHaveBeenCalled()
-    expect(contract.reflection).not.toHaveBeenCalled()
-  })
-
-  test('connects without schema discovery or graph I/O', async () => {
-    const contract = fixture({})
-
-    await contract.connect()
-
-    expect(contract.call).not.toHaveBeenCalled()
-    expect(contract.reflection).not.toHaveBeenCalled()
-    expect(contract.query).not.toHaveBeenCalled()
-    expect(contract.neighbors).not.toHaveBeenCalled()
-  })
-
-  test('rejects malformed graph records and publication summaries', async () => {
-    const invalidNode = {
-      id: NodeId('invalid-domain'),
-      class: 'admin.astrale.ai:Domain' as Node['class'],
-      props: normalizeProperties({
-        [domainProperties.origin]: 'invalid.example.dev',
-        [domainProperties.name]: 'invalid',
-        [domainProperties.discoveryUrl]: 'https://invalid.example.dev',
-        [domainProperties.createdAt]: '2026-08-12T00:00:00.000Z',
-      }),
-    }
-    await expect((await fixture({ domains: [invalidNode] }).connect()).list()).rejects.toThrow(
-      'Admin Domain.updatedAt is invalid.',
-    )
-
-    const malformed = fixture({ invoke: () => ({ id: '@domain-only' }) })
-    await expect(
-      (await malformed.connect()).publish({
-        origin: 'crm.acme.dev',
-        name: 'crm',
-        url: 'https://crm.acme.dev',
-      }),
-    ).rejects.toThrow('Admin Domain origin is invalid.')
-
-    const malformedPath = fixture({ invoke: () => ({ ...summary('crm.acme.dev'), id: 'bad' }) })
-    await expect(
-      (await malformedPath.connect()).publish({
-        origin: 'crm.acme.dev',
-        name: 'crm',
-        url: 'https://crm.acme.dev',
-      }),
-    ).rejects.toThrow('Admin Domain id is invalid.')
-  })
-})

package/src/admin/catalog/client.ts

@@ -1,195 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session'
-import type { Node } from '@astrale-os/sdk/graph/node'
-
-import { Path } from '@astrale-os/sdk/graph/path'
-import { Query } from '@astrale-os/sdk/query'
-
-import { AdminContract, callAdminMethod } from '../contract'
-import { readAllNodes, type AdminGraphApi } from '../graph'
-import {
-  AdminDomainNotFoundError,
-  type DomainInfo,
-  type PublishDomainInput,
-  type PublishDomainResult,
-} from './model'
-
-const PAGE_SIZE = 256
-const MAXIMUM_DOMAINS = 10_000
-const MAXIMUM_PAGES = Math.ceil(MAXIMUM_DOMAINS / PAGE_SIZE) + 1
-
-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 operationId?: (kind: 'publish' | 'configure-default') => string
-}
-
-/** Connect the Domain catalog journey without schema discovery or reflection. */
-export async function connectAdminCatalog(
-  context: AdminCatalogContext,
-  dependencies: AdminCatalogDependencies = {},
-): Promise<AdminCatalogApi> {
-  const operationId = dependencies.operationId ?? defaultOperationId
-
-  const list = async (): Promise<DomainInfo[]> => {
-    const [nodes, defaultsPage] = await Promise.all([
-      readAllNodes(
-        context.graph,
-        Query.from({ nodes: [AdminContract.classes.Domain] }).select({
-          kind: 'nodes',
-          projection: { kind: 'value' },
-        }),
-        {
-          label: 'Admin Domain catalog',
-          maximum: MAXIMUM_DOMAINS,
-          maximumPages: MAXIMUM_PAGES,
-        },
-      ),
-      context.graph.neighbors(
-        AdminContract.fleet,
-        AdminContract.edges.fleetInstallsDomainByDefault,
-        {
-          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(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 callAdminMethod(context.session, AdminContract.fleet, 'publishDomain', {
-            operationId: operationId('publish'),
-            origin: input.origin,
-            name: input.name,
-            discoveryUrl: input.url,
-            ...(description === undefined ? {} : { description }),
-          }),
-          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 callAdminMethod(context.session, Path.parse(entry.id), 'configureDefault', {
-            operationId: operationId('configure-default'),
-            enabled: input.installByDefault,
-          }),
-          input.installByDefault === true,
-        )
-      }
-      return Object.freeze({
-        entry,
-        changed: registryChanged || defaultChanged,
-        isNew: existing === undefined,
-      })
-    },
-  })
-}
-
-function domainFromNode(node: Node, installByDefault: boolean): DomainInfo {
-  return Object.freeze({
-    id: Path.id(node.id).raw,
-    origin: requiredProperty(node, 'origin'),
-    name: requiredProperty(node, 'name'),
-    url: requiredProperty(node, 'discoveryUrl'),
-    ...optionalProperty(node, 'description'),
-    ...(installByDefault ? { installByDefault: true } : {}),
-    createdAt: requiredProperty(node, 'createdAt'),
-    updatedAt: requiredProperty(node, 'updatedAt'),
-  })
-}
-
-function domainFromSummary(input: unknown, installByDefault: boolean): DomainInfo {
-  const value = record(input, 'Admin Domain summary')
-  return Object.freeze({
-    id: requiredNodePath(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(node: Node, name: keyof typeof AdminContract.properties.domain): string {
-  return requiredString(node.props[AdminContract.properties.domain[name]], `Admin Domain.${name}`)
-}
-
-function optionalProperty(
-  node: Node,
-  name: keyof typeof AdminContract.properties.domain,
-): Readonly<Record<string, string>> {
-  const value = node.props[AdminContract.properties.domain[name]]
-  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 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 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

@@ -1,13 +0,0 @@
-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

@@ -1,41 +0,0 @@
-/** 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 AstraleError {
-  constructor(readonly identifier: string) {
-    super('DOMAIN_NOT_FOUND', `No visible Admin Domain matches ${JSON.stringify(identifier)}.`)
-  }
-}
-import { AstraleError } from '../../errors'

package/src/admin/catalog/tsconfig.json

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