@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.2

package/studio/server/cache.ts

@@ -7,13 +7,17 @@ import { createHash } from 'node:crypto'
 import { existsSync, readFileSync } from 'node:fs'
 import { join, relative } from 'node:path'
 
-import type { DomainAnatomy, StudioCore, StudioSchemaBundle } from '../shared/types'
+import type { DomainAnatomy, SchemaOverlay, StudioCore, StudioSchemaBundle } from '../shared/types'
 
+import { isSchemaRevision } from '../shared/types'
 import { invalidateClientPackage, resolveClientPackage } from './client-package'
 import { getDomain } from './domain'
 import { buildAnatomy } from './introspect/anatomy'
 import { buildBundle } from './introspect/bundle'
+import { isCanonicalDomainSchemaV1 } from './introspect/canonical-schema'
 import { buildCore } from './introspect/core'
+import { decodeIrInterfaceRecord, decodeSchemaIR } from './introspect/schema-ir-json'
+import { asBoolean, asFiniteNumber, asJsonRecord, asString, asStringArray } from './json'
 import { hashAnatomyFiles } from './state/baseline'
 import { readJson, writeJson } from './state/store'
 
@@ -22,7 +26,7 @@ const anatomies = new Map<string, Promise<DomainAnatomy>>()
 const cores = new Map<string, StudioCore>()
 
 const BUNDLE_CACHE_FILE = '.cache/schema-bundle.json'
-const BUNDLE_CACHE_VERSION = 3
+const BUNDLE_CACHE_VERSION = 4
 const LOCKFILES = ['bun.lock', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']
 const TOOL_INPUTS = [
   'cache.ts',
@@ -33,6 +37,11 @@ const TOOL_INPUTS = [
   'introspect/canonical-schema.ts',
   'introspect/overlay.ts',
   'introspect/overlay-tsmorph.ts',
+  'introspect/source-overlay/annotations.ts',
+  'introspect/source-overlay/handlers.ts',
+  'introspect/source-overlay/kernel-calls.ts',
+  'introspect/source-overlay/project.ts',
+  'introspect/source-overlay/spans.ts',
   'introspect/hash.ts',
   'state/baseline.ts',
   '../shared/types.ts',
@@ -44,6 +53,149 @@ interface BundleCacheEntry {
   bundle: StudioSchemaBundle
 }
 
+function isCrossDomainImport(value: unknown): boolean {
+  const record = asJsonRecord(value)
+  return (
+    typeof record?.name === 'string' &&
+    typeof record.origin === 'string' &&
+    (record.definition === 'class' || record.definition === 'interface')
+  )
+}
+
+function isHandlerLink(value: unknown): boolean {
+  const record = asJsonRecord(value)
+  return (
+    typeof record?.owner === 'string' &&
+    ['class', 'interface', 'function'].includes(String(record.ownerKind)) &&
+    typeof record.method === 'string' &&
+    typeof record.static === 'boolean' &&
+    typeof record.implemented === 'boolean'
+  )
+}
+
+function isSourceSpan(value: unknown): boolean {
+  const record = asJsonRecord(value)
+  return (
+    typeof record?.file === 'string' &&
+    asFiniteNumber(record.startLine) !== undefined &&
+    asFiniteNumber(record.endLine) !== undefined &&
+    (record.doc === undefined || typeof record.doc === 'string')
+  )
+}
+
+function isAnnotation(value: unknown): boolean {
+  const record = asJsonRecord(value)
+  return (
+    typeof record?.target === 'string' &&
+    (record.severity === 'warn' || record.severity === 'info') &&
+    (record.code === 'COMPILE_ERROR' || record.code === 'EDGE_PROP_TYPE_MISSING') &&
+    typeof record.message === 'string'
+  )
+}
+
+function decodeOverlay(value: unknown): SchemaOverlay | undefined {
+  const record = asJsonRecord(value)
+  const requires = asStringArray(record?.requires)
+  const crossDomainImports = record?.crossDomainImports
+  const mixins = record?.mixins
+  const handlerLinks = record?.handlerLinks
+  const sourceSpans = asJsonRecord(record?.sourceSpans)
+  const annotations = record?.annotations
+  if (
+    typeof record?.origin !== 'string' ||
+    !requires ||
+    !Array.isArray(crossDomainImports) ||
+    !crossDomainImports.every(isCrossDomainImport) ||
+    !Array.isArray(mixins) ||
+    !mixins.every(isCrossDomainImport) ||
+    !Array.isArray(handlerLinks) ||
+    !handlerLinks.every(isHandlerLink) ||
+    !sourceSpans ||
+    !Object.values(sourceSpans).every(isSourceSpan) ||
+    !Array.isArray(annotations) ||
+    !annotations.every(isAnnotation)
+  ) {
+    return undefined
+  }
+  return record as unknown as SchemaOverlay
+}
+
+function decodeBundle(value: unknown): StudioSchemaBundle | undefined {
+  const record = asJsonRecord(value)
+  if (!record) return undefined
+  const domainId = asString(record.domainId)
+  const renderFingerprint = asString(record.renderFingerprint)
+  const schemaMode = (
+    ['canonical-admitted', 'canonical-preview', 'legacy', 'unavailable'] as const
+  ).find((candidate) => candidate === record.schemaMode)
+  const extractedBy = record.extractedBy
+  const depsInstalled = asBoolean(record.depsInstalled)
+  const ir = record.ir === null ? null : decodeSchemaIR(record.ir)
+  const overlay = decodeOverlay(record.overlay)
+  const extractedAt = asString(record.extractedAt)
+  if (
+    !domainId ||
+    renderFingerprint === undefined ||
+    !schemaMode ||
+    (extractedBy !== 'runtime-bun' && extractedBy !== 'static-tsmorph-fallback') ||
+    depsInstalled === undefined ||
+    ir === undefined ||
+    !overlay ||
+    !extractedAt
+  ) {
+    return undefined
+  }
+  const schemaRevision = record.schemaRevision
+  if (schemaRevision !== undefined && !isSchemaRevision(schemaRevision)) return undefined
+  if (
+    schemaMode === 'canonical-admitted' &&
+    (!isSchemaRevision(schemaRevision) || !isCanonicalDomainSchemaV1(record.schemaRoot))
+  ) {
+    return undefined
+  }
+  const importedInterfaces =
+    record.importedInterfaces === undefined
+      ? undefined
+      : decodeIrInterfaceRecord(record.importedInterfaces)
+  if (record.importedInterfaces !== undefined && importedInterfaces === undefined) return undefined
+  const errorRecord = record.error === null ? null : asJsonRecord(record.error)
+  const errorMessage = asString(errorRecord?.message)
+  if (record.error !== undefined && record.error !== null && errorMessage === undefined) {
+    return undefined
+  }
+  return {
+    domainId,
+    renderFingerprint,
+    schemaMode,
+    ...(schemaRevision === undefined ? {} : { schemaRevision }),
+    extractedBy,
+    depsInstalled,
+    ir,
+    ...(record.schemaRoot === undefined ? {} : { schemaRoot: record.schemaRoot }),
+    overlay,
+    ...(importedInterfaces === undefined ? {} : { importedInterfaces }),
+    ...(record.error === undefined
+      ? {}
+      : record.error === null
+        ? { error: null }
+        : {
+            error: {
+              message: errorMessage!,
+              ...(typeof errorRecord!.file === 'string' ? { file: errorRecord!.file } : {}),
+            },
+          }),
+    extractedAt,
+  }
+}
+
+export function decodeBundleCacheEntry(value: unknown): BundleCacheEntry | undefined {
+  const record = asJsonRecord(value)
+  const version = asFiniteNumber(record?.version)
+  const key = asString(record?.key)
+  const bundle = decodeBundle(record?.bundle)
+  return version !== undefined && key !== undefined && bundle ? { version, key, bundle } : undefined
+}
+
 function hashFileIfPresent(hash: ReturnType<typeof createHash>, label: string, file: string): void {
   try {
     if (!existsSync(file)) return
@@ -77,7 +229,7 @@ function bundleCacheKey(root: string, schemaDirName: string): string {
 }
 
 function readCachedBundle(root: string, key: string): StudioSchemaBundle | null {
-  const entry = readJson<BundleCacheEntry | null>(root, BUNDLE_CACHE_FILE, null)
+  const entry = readJson(root, BUNDLE_CACHE_FILE, decodeBundleCacheEntry, null)
   if (!entry || entry.version !== BUNDLE_CACHE_VERSION || entry.key !== key || !entry.bundle)
     return null
   return entry.bundle
@@ -119,12 +271,14 @@ export async function getAnatomy(id: string, rebuild = false): Promise<DomainAna
   const h = getDomain(id)
   if (!h) return null
   if (!rebuild && anatomies.has(id)) return anatomies.get(id)!
-  const anatomy = resolveClientPackage(h.root, rebuild).then((client) =>
-    buildAnatomy({
-      root: h.root,
-      schemaDirName: h.schemaDirName,
-      clientDir: client.status === 'available' ? client.sourceDir : undefined,
-    }),
+  const anatomy = Promise.all([resolveClientPackage(h.root, rebuild), getBundle(id, rebuild)]).then(
+    ([client, bundle]) =>
+      buildAnatomy({
+        root: h.root,
+        schemaDirName: h.schemaDirName,
+        clientDir: client.status === 'available' ? client.sourceDir : undefined,
+        canonicalViews: bundle?.ir?.format === 'astrale.dsl' ? (bundle.ir.views ?? {}) : undefined,
+      }),
   )
   anatomies.set(id, anatomy)
   return anatomy

package/studio/server/cli-consumers.test.ts

@@ -0,0 +1,494 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { StudioSchemaBundle, ViewInfo } from '../shared/types'
+
+import { STUDIO_CLI_DESCRIPTOR_ENV } from './cli'
+import { activeInstanceName, listInstances, setActiveInstance } from './instances/active'
+import { readRememberedTarget } from './views/selection-repository'
+import { launchViewSession } from './views/session'
+import { listViewTargets } from './views/target'
+import { applyUpdates, getUpdates } from './workspace/updates'
+
+interface FakeResponse {
+  stdout?: unknown
+  stderr?: unknown
+  exitCode?: number
+}
+
+interface FakeCall {
+  args: string[]
+  cwd: string
+}
+
+const priorDescriptor = process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+const roots: string[] = []
+
+afterEach(() => {
+  if (priorDescriptor === undefined) delete process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+  else process.env[STUDIO_CLI_DESCRIPTOR_ENV] = priorDescriptor
+  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function exactArgs(args: string[]): string {
+  return JSON.stringify(args)
+}
+
+function installFakeCli(responses: Array<{ args: string[]; responses: FakeResponse[] }>): {
+  root: string
+  calls: () => FakeCall[]
+} {
+  const root = mkdtempSync(join(tmpdir(), 'studio-cli-consumer-'))
+  roots.push(root)
+  const scenarioFile = join(root, 'scenario.json')
+  const callsFile = join(root, 'calls.ndjson')
+  const entry = join(root, 'fake-cli.ts')
+  const scenario = Object.fromEntries(
+    responses.map((rule) => [exactArgs(rule.args), rule.responses]),
+  )
+  writeFileSync(scenarioFile, JSON.stringify(scenario))
+  writeFileSync(
+    entry,
+    `import { appendFileSync, existsSync, readFileSync } from 'node:fs'
+
+const scenarioFile = ${JSON.stringify(scenarioFile)}
+const callsFile = ${JSON.stringify(callsFile)}
+const args = process.argv.slice(2)
+const prior = existsSync(callsFile)
+  ? readFileSync(callsFile, 'utf8').split('\\n').filter(Boolean).map((line) => JSON.parse(line))
+  : []
+const matchingCalls = prior.filter((call) => JSON.stringify(call.args) === JSON.stringify(args)).length
+appendFileSync(callsFile, JSON.stringify({ args, cwd: process.cwd() }) + '\\n')
+const scenario = JSON.parse(readFileSync(scenarioFile, 'utf8'))
+const responses = scenario[JSON.stringify(args)]
+const response = Array.isArray(responses) ? responses[matchingCalls] : undefined
+if (!response) {
+  process.stderr.write(JSON.stringify({ message: 'Unexpected fake CLI call', args }))
+  process.exit(91)
+}
+const render = (value) => typeof value === 'string' ? value : JSON.stringify(value)
+if (response.stdout !== undefined) process.stdout.write(render(response.stdout))
+if (response.stderr !== undefined) process.stderr.write(render(response.stderr))
+process.exit(response.exitCode ?? 0)
+`,
+  )
+  process.env[STUDIO_CLI_DESCRIPTOR_ENV] = JSON.stringify({
+    version: 1,
+    executable: process.execPath,
+    args: [realpathSync(entry)],
+  })
+  return {
+    root,
+    calls: () =>
+      existsSync(callsFile)
+        ? readFileSync(callsFile, 'utf8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line) as FakeCall)
+        : [],
+  }
+}
+
+const activeArgs = ['instance', 'active', '--json']
+const bookmarkedArgs = ['instance', 'list', '--bookmarked', '--json']
+const managedArgs = ['instance', 'list', '--admin-only', '--json']
+
+describe('instance CLI orchestration', () => {
+  test('reads active/list from the exact CLI and merges bookmarks with managed instances', async () => {
+    const fake = installFakeCli([
+      { args: activeArgs, responses: [{ stdout: { name: 'local' } }] },
+      {
+        args: bookmarkedArgs,
+        responses: [
+          {
+            stdout: {
+              active: 'staging',
+              bookmarks: [
+                { name: 'local', url: 'http://127.0.0.1:7200' },
+                { name: 'staging', url: 'https://staging.example', active: true },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        args: managedArgs,
+        responses: [
+          {
+            stdout: {
+              instances: [
+                { slug: 'staging', url: 'https://duplicate.example' },
+                { slug: 'production', url: 'https://production.example' },
+              ],
+            },
+          },
+        ],
+      },
+    ])
+
+    expect(await activeInstanceName()).toBe('local')
+    expect(await listInstances()).toEqual({
+      active: 'staging',
+      instances: [
+        {
+          name: 'local',
+          url: 'http://127.0.0.1:7200',
+          active: false,
+          kind: 'bookmark',
+        },
+        {
+          name: 'staging',
+          url: 'https://staging.example',
+          active: true,
+          kind: 'bookmark',
+        },
+        {
+          name: 'production',
+          url: 'https://production.example',
+          active: false,
+          kind: 'managed',
+        },
+      ],
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, bookmarkedArgs, managedArgs])
+  })
+
+  test('uses the exact non-interactive instance switch flags and re-reads CLI-owned state', async () => {
+    const useArgs = ['instance', 'use', 'staging', '--adopt-default', '--skip-jwks-check']
+    const fake = installFakeCli([
+      { args: useArgs, responses: [{ stdout: 'Now using staging.\n' }] },
+      { args: activeArgs, responses: [{ stdout: { name: 'staging' } }] },
+    ])
+
+    expect(await setActiveInstance('staging')).toEqual({
+      ok: true,
+      active: 'staging',
+      output: 'Now using staging.',
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([useArgs, activeArgs])
+  })
+
+  test('does not invent active state from malformed or failed CLI output', async () => {
+    const fake = installFakeCli([
+      {
+        args: activeArgs,
+        responses: [
+          { stdout: 'not-json' },
+          {
+            stdout: { name: 'must-not-be-used' },
+            stderr: 'Instance store is unavailable.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+
+    expect(await activeInstanceName()).toBeNull()
+    expect(await activeInstanceName()).toBeNull()
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, activeArgs])
+  })
+})
+
+describe('workspace update CLI orchestration', () => {
+  test('accepts stale exit 10 and applies updates in the domain root', async () => {
+    const checkArgs = ['update', '--check', '--json']
+    const applyArgs = ['update', '--yes']
+    const fake = installFakeCli([
+      {
+        args: checkArgs,
+        responses: [
+          {
+            stdout: {
+              stale: true,
+              cli: {
+                stale: true,
+                managed: true,
+                current: '0.7.0',
+                latest: '0.8.0',
+                channel: 'latest',
+              },
+              sdk: {
+                stale: true,
+                inProject: true,
+                outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+              },
+            },
+            exitCode: 10,
+          },
+        ],
+      },
+      {
+        args: applyArgs,
+        responses: [{ stdout: 'CLI updated.\n', stderr: 'SDK updated.\n' }],
+      },
+    ])
+    const domainRoot = realpathSync(fake.root)
+
+    expect(await getUpdates(domainRoot)).toEqual({
+      stale: true,
+      cli: {
+        stale: true,
+        managed: true,
+        current: '0.7.0',
+        latest: '0.8.0',
+        channel: 'latest',
+      },
+      sdk: {
+        stale: true,
+        inProject: true,
+        outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+      },
+    })
+    expect(await applyUpdates(domainRoot)).toEqual({
+      ok: true,
+      output: 'CLI updated.\nSDK updated.',
+    })
+    expect(fake.calls()).toEqual([
+      { args: checkArgs, cwd: domainRoot },
+      { args: applyArgs, cwd: domainRoot },
+    ])
+  })
+
+  test('hides the badge when check output is malformed or fails', async () => {
+    const checkArgs = ['update', '--check', '--json']
+    const fake = installFakeCli([
+      {
+        args: checkArgs,
+        responses: [
+          { stdout: { stale: true, cli: {}, sdk: {} }, exitCode: 10 },
+          {
+            stdout: {
+              stale: true,
+              cli: { stale: true, managed: true },
+              sdk: {
+                stale: true,
+                inProject: true,
+                outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+              },
+            },
+            stderr: 'Registry offline.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+    const expected = {
+      stale: false,
+      cli: { stale: false, managed: true },
+      sdk: { stale: false, inProject: false, outdated: [] },
+    }
+
+    expect(await getUpdates(fake.root)).toEqual(expected)
+    expect(await getUpdates(fake.root)).toEqual(expected)
+    const domainRoot = realpathSync(fake.root)
+    expect(fake.calls()).toEqual([
+      { args: checkArgs, cwd: domainRoot },
+      { args: checkArgs, cwd: domainRoot },
+    ])
+  })
+})
+
+const view = {
+  slug: 'issue-detail',
+  kind: 'unknown',
+  viewFor: 'Issue',
+} satisfies ViewInfo
+
+const bundle = {
+  ir: {
+    views: {
+      'issue-detail': {
+        name: 'issue-detail',
+        auth: 'required',
+        target: {
+          kind: 'definition',
+          definitions: [{ origin: 'issues.example.dev', kind: 'class', name: 'Issue' }],
+        },
+      },
+    },
+  },
+} as unknown as StudioSchemaBundle
+
+const queryArgs = [
+  'query',
+  '--definition',
+  '/:issues.example.dev:class.Issue',
+  '--limit',
+  '201',
+  '--json',
+  '-i',
+  'staging',
+]
+
+const targetQuery = {
+  graph: {
+    nodes: [
+      {
+        id: 'issue-1',
+        props: {
+          'kernel.astrale.ai:interface.Named.property.name': 'First issue',
+        },
+      },
+    ],
+  },
+}
+
+describe('View CLI orchestration', () => {
+  test('queries exact target coordinates and preserves malformed/nonzero failures', async () => {
+    const fake = installFakeCli([
+      {
+        args: queryArgs,
+        responses: [
+          { stdout: targetQuery },
+          { stdout: { graph: { nodes: 'invalid' } } },
+          { stderr: { message: 'Instance is offline.' }, exitCode: 7 },
+        ],
+      },
+    ])
+
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toEqual({
+      status: 'available',
+      items: [
+        {
+          id: 'issue-1',
+          ref: '@issue-1',
+          className: 'Issue',
+          classOrigin: 'issues.example.dev',
+          label: 'First issue',
+        },
+      ],
+      selected: null,
+      stale: null,
+      truncated: false,
+    })
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toMatchObject({ status: 'unavailable', items: [] })
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toMatchObject({ status: 'unavailable', reason: 'Instance is offline.' })
+    expect(fake.calls().map((call) => call.args)).toEqual([queryArgs, queryArgs, queryArgs])
+  })
+
+  test('launches against the selected target, trusts route.href, and remembers the target', async () => {
+    const launchArgs = [
+      'view',
+      '/:issues.example.dev:view.issue-detail',
+      '--target',
+      '@issue-1',
+      '--no-open',
+      '--json',
+      '-i',
+      'staging',
+    ]
+    const fake = installFakeCli([
+      { args: activeArgs, responses: [{ stdout: { name: 'staging' } }] },
+      { args: queryArgs, responses: [{ stdout: targetQuery }] },
+      {
+        args: launchArgs,
+        responses: [
+          {
+            stdout: {
+              session: {
+                id: 'v-a1b2',
+                pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+                view: { route: { href: 'https://shell.example.dev/views/issue-1' } },
+              },
+            },
+          },
+        ],
+      },
+    ])
+
+    expect(
+      await launchViewSession(
+        fake.root,
+        'issues.example.dev',
+        view,
+        bundle,
+        { targetId: 'issue-1' },
+        2000,
+      ),
+    ).toEqual({
+      status: 'ready',
+      sessionId: 'v-a1b2',
+      pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+      viewUrl: 'https://shell.example.dev/views/issue-1',
+      target: {
+        id: 'issue-1',
+        ref: '@issue-1',
+        className: 'Issue',
+        classOrigin: 'issues.example.dev',
+        label: 'First issue',
+      },
+    })
+    expect(readRememberedTarget(fake.root, 'staging', 'issue-detail')).toEqual({
+      id: 'issue-1',
+      className: 'Issue',
+      classOrigin: 'issues.example.dev',
+      label: 'First issue',
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, queryArgs, launchArgs])
+  })
+
+  test('does not expose a session when the CLI payload is malformed or exits nonzero', async () => {
+    const standalone = { slug: 'dashboard', kind: 'unknown' } satisfies ViewInfo
+    const launchArgs = [
+      'view',
+      '/:issues.example.dev:view.dashboard',
+      '--no-open',
+      '--json',
+      '-i',
+      'staging',
+    ]
+    const fake = installFakeCli([
+      {
+        args: activeArgs,
+        responses: [{ stdout: { name: 'staging' } }, { stdout: { name: 'staging' } }],
+      },
+      {
+        args: launchArgs,
+        responses: [
+          { stdout: { session: { id: 'v-no-route', pageUrl: 'http://127.0.0.1/' } } },
+          {
+            stdout: {
+              session: {
+                id: 'v-must-not-open',
+                pageUrl: 'http://127.0.0.1/forbidden',
+                view: { route: { href: 'https://shell.example.dev/forbidden' } },
+              },
+            },
+            stderr: 'Permission denied.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+
+    const malformed = await launchViewSession(
+      fake.root,
+      'issues.example.dev',
+      standalone,
+      null,
+      {},
+      2000,
+    )
+    expect(malformed.status).toBe('unavailable')
+    if (malformed.status !== 'unavailable')
+      throw new Error('expected the malformed session to fail')
+    expect(malformed.reason).toContain('v-no-route')
+    expect(
+      await launchViewSession(fake.root, 'issues.example.dev', standalone, null, {}, 2000),
+    ).toEqual({ status: 'unavailable', reason: 'Permission denied.' })
+    expect(fake.calls().map((call) => call.args)).toEqual([
+      activeArgs,
+      launchArgs,
+      activeArgs,
+      launchArgs,
+    ])
+  })
+})