@astrale-os/cli 0.8.1-alpha.5 → 0.8.1-alpha.7

package/src/commands/view.ts

@@ -172,22 +172,34 @@ async function findOnPath(name: string): Promise<string | null> {
 
 /** Dev checkout: (re)build the node-runnable CLI bundle when missing or stale. */
 async function ensureDevDist(entry: string, dist: string): Promise<void> {
-  const bun = (
-    globalThis as {
-      Bun?: { build: (o: object) => Promise<{ success: boolean; logs: unknown[] }> }
-    }
-  ).Bun
-  if (!bun) return
-  const srcDir = join(dirname(entry), '..', 'src')
-  if (existsSync(dist) && !(await newerThan(srcDir, statSync(dist).mtimeMs))) return
-  // stderr: --json consumers parse stdout.
-  console.error('(dev) building dist/astrale.js for the session server…')
-  await bun.build({
-    entrypoints: [entry],
-    outdir: dirname(dist),
-    target: 'node',
-    format: 'esm',
-  })
+  if (!(await devDistIsStale(entry, dist))) return
+  const projectDir = join(dirname(entry), '..')
+  const buildScript = join(projectDir, 'scripts', 'build.ts')
+  const bun = await findOnPath('bun')
+  if (!bun || !existsSync(buildScript)) return
+
+  // Build output goes to stderr so --json stdout remains valid.
+  console.error('(dev) dist/astrale.js is stale — running the official CLI build…')
+  const built = await run(bun, [buildScript], { cwd: projectDir })
+  if (built.stdout) process.stderr.write(built.stdout)
+  if (built.stderr) process.stderr.write(built.stderr)
+  if (built.code !== 0) throw new Error(`Official CLI build failed with exit code ${built.code}.`)
+}
+
+export async function devDistIsStale(entry: string, dist: string): Promise<boolean> {
+  if (!existsSync(dist)) return true
+  const projectDir = join(dirname(entry), '..')
+  const builtAt = statSync(dist).mtimeMs
+  const directories = [join(projectDir, 'src'), join(projectDir, 'bin'), join(projectDir, 'vendor')]
+  const files = [
+    join(projectDir, 'scripts', 'build.ts'),
+    join(projectDir, 'package.json'),
+    join(projectDir, 'pnpm-lock.yaml'),
+  ]
+  for (const directory of directories) {
+    if (existsSync(directory) && (await newerThan(directory, builtAt))) return true
+  }
+  return files.some((file) => existsSync(file) && statSync(file).mtimeMs > builtAt)
 }
 
 async function newerThan(dir: string, mtimeMs: number): Promise<boolean> {
@@ -522,15 +534,17 @@ What it does:
   an audience-bound credential for shell mounts, and the kernel endpoint.
 
 Examples:
-  $ astrale view /crm/customers/ada                      # views on a node
-  $ astrale view /:crm.acme.dev:view.dashboard           # explicit ViewPath
+  $ astrale view @customer
+  $ astrale view /:crm.example.dev:view.dashboard
   $ astrale view /:agents.astrale.ai:view.agent --target @f00d1234 --as alice
-  $ astrale view /crm/customers/ada --snapshot           # open + show it
+  $ astrale view @customer --snapshot
+  $ astrale view --list
   $ astrale view --sessions ; astrale view --close --all
 `,
   action: async (spec: string | undefined, opts: ViewOpts) => {
     if (opts.close !== undefined) return closeCommand(opts)
     if (opts.sessions) return sessionsCommand(opts)
+    if (opts.list && !spec) return sessionsCommand(opts)
 
     rejectUnrepresentableOverrides(opts)
     if (!spec) return fatal(new Error('Nothing to open — pass a ViewPath or target node.'))

package/src/connection/.spec/architecture.md

@@ -39,3 +39,8 @@ The target, timeout, and optional CA file are resolved before constructing the s
 customizes only the Fetch capability passed to Client. `withClientSession` and
 `withAdminClientSession` are terminal lifecycle boundaries: success, failure, and cancellation all
 close both the Client Session and its direct source-Auth client.
+
+The command boundary maps typed Client transport phase and delivery evidence without inspecting a
+private cause message. It preserves every admitted Kernel reason in machine output; human repair
+details are rendered only after the connection owner admits bounded public Function issues or one
+exact Query reason variant.

package/src/connection/.spec/laws/connection.ts

@@ -179,3 +179,23 @@ export const CLI_CONNECTION_PUBLIC_SEMANTIC_REASON = defineLaw({
     },
   ],
 })
+
+export const CLI_CONNECTION_TYPED_ERROR_PRESENTATION = defineLaw({
+  id: 'CLI-CONNECTION-TYPED-ERROR-PRESENTATION',
+  statement:
+    'The command boundary maps typed Client transport phase and delivery evidence without parsing a private cause, preserves the admitted Kernel reason in machine output, and renders only bounded public Function issues or one exact Query repair variant for humans.',
+  tests: [
+    {
+      file: '__tests__/errors.test.ts',
+      id: 'TEST-CLI-CONNECTION-MAPS-TYPED-TRANSPORT',
+    },
+    {
+      file: '__tests__/errors.test.ts',
+      id: 'TEST-CLI-CONNECTION-PRESENTS-BOUNDED-REPAIRS',
+    },
+    {
+      file: '__tests__/reasons.test.ts',
+      id: 'TEST-CLI-CONNECTION-ADMITS-BOUNDED-REASONS',
+    },
+  ],
+})

package/src/connection/.spec/layout.ts

@@ -10,6 +10,7 @@ export default defineLayout({
     'errors.ts',
     'exchange.ts',
     'index.ts',
+    'reasons.ts',
     'self.ts',
     'session.ts',
     'target.ts',

package/src/connection/__tests__/auth.test.ts

@@ -3,7 +3,9 @@ import { describe, expect, test } from 'bun:test'
 import type { Identity } from '../../identity/index'
 import type { AstraleConfig } from '../../lib/config'
 
-import { resolveKeyIdentityAuthOptions } from '../auth'
+import { IdpAudienceMismatchError } from '../../lib/idp'
+import { IdpSessionNoRefreshTokenError } from '../../lib/idp-session'
+import { classifyNoRefreshTokenError, resolveKeyIdentityAuthOptions } from '../auth'
 
 const config: AstraleConfig = {
   issuer: 'https://unregistered.invalid',
@@ -100,3 +102,27 @@ describe('resolveKeyIdentityAuthOptions', () => {
     })
   })
 })
+
+describe('classifyNoRefreshTokenError', () => {
+  test('preserves expiry when the non-refreshable session already targets the required audience', () => {
+    const expired = new IdpSessionNoRefreshTokenError('alice')
+
+    expect(
+      classifyNoRefreshTokenError('https://kernel.example', 'https://kernel.example', expired),
+    ).toBe(expired)
+  })
+
+  test('reports a real audience mismatch when the source audience differs', () => {
+    const result = classifyNoRefreshTokenError(
+      'https://child.example',
+      'https://manager.example',
+      new IdpSessionNoRefreshTokenError('alice'),
+    )
+
+    expect(result).toBeInstanceOf(IdpAudienceMismatchError)
+    expect(result).toMatchObject({
+      requested: 'https://child.example',
+      actual: 'https://manager.example',
+    })
+  })
+})

package/src/connection/__tests__/ca-fetch.test.ts

@@ -29,7 +29,10 @@ describe('connection CA fetch', () => {
       hostname: '127.0.0.1',
       port: 0,
       tls: { cert: certificate, key },
-      fetch: () => new Response('trusted'),
+      fetch: (request) =>
+        new URL(request.url).pathname === '/cached'
+          ? new Response(null, { status: 304, headers: { etag: 'retained' } })
+          : new Response('trusted'),
     })
 
     const requests: Array<{ input: RequestInfo | URL; init?: RequestInit }> = []
@@ -45,6 +48,10 @@ describe('connection CA fetch', () => {
     expect(await httpsResponse.text()).toBe('trusted')
     expect(httpsResponse.url).toBe(httpsUrl)
     expect(httpsResponse.redirected).toBe(false)
+    const cachedResponse = await scoped(`https://127.0.0.1:${server.port}/cached`)
+    expect(cachedResponse.status).toBe(304)
+    expect(cachedResponse.body).toBeNull()
+    expect(cachedResponse.headers.get('etag')).toBe('retained')
     await expect(
       scoped('http://localhost:8080/invoke', init).then((value) => value.text()),
     ).resolves.toBe('fallback')

package/src/connection/__tests__/credential.test.ts

@@ -82,6 +82,16 @@ describe('connection credential', () => {
     expect(auth).toBeUndefined()
   })
 
+  test('rejects --as combined with --creds', () => {
+    expect(() =>
+      createCliCredential(
+        { url: `${SOURCE}/invoke`, kernelIssuer: SOURCE },
+        { as: 'alice', creds: 'token' },
+        config,
+      ),
+    ).toThrow('--as cannot be combined with --creds')
+  })
+
   /** @evidence TEST-CLI-CONNECTION-PROPAGATES-AUTH-CANCELLATION */
   test('passes the live Session operation signal to source credential resolution', async () => {
     const controller = new AbortController()

package/src/connection/__tests__/errors.test.ts

@@ -1,47 +1,42 @@
-import { ResponseError } from '@astrale-os/kernel-client'
+import { ResponseError, TransportError } from '@astrale-os/kernel-client'
 import { describe, expect, test } from 'bun:test'
 
-import { formatKernelError, stripMethodSuffix } from '../errors'
+import { formatKernelError, functionInputIssues, schemaUpgradeHint } from '../errors'
 
 const CONFLICT = 4001
+const VALIDATION = 1003
 
-describe('stripMethodSuffix', () => {
-  test('strips ::listChildren from path', () => {
-    expect(stripMethodSuffix('Path not found: "/nonexistent::listChildren"')).toBe(
-      'Path not found: "/nonexistent"',
-    )
-  })
-
-  test('strips ::get from path', () => {
-    expect(stripMethodSuffix('Path not found: "/some/path::get"')).toBe(
-      'Path not found: "/some/path"',
-    )
-  })
-
-  test('strips any method name', () => {
-    expect(stripMethodSuffix('"/kernel.astrale.ai/Root::describe"')).toBe(
-      '"/kernel.astrale.ai/Root"',
-    )
-  })
-
-  test('does not strip from non-path strings', () => {
-    expect(stripMethodSuffix('regular::text')).toBe('regular::text')
-  })
-
-  test('handles multiple paths in one message', () => {
-    expect(stripMethodSuffix('"/a/b::get" and "/c/d::list"')).toBe('"/a/b" and "/c/d"')
-  })
-
-  test('preserves messages without method suffixes', () => {
-    expect(stripMethodSuffix('No path found')).toBe('No path found')
-  })
+describe('formatKernelError', () => {
+  /** @evidence TEST-CLI-CONNECTION-MAPS-TYPED-TRANSPORT */
+  test('maps typed discovery transport evidence without inspecting its cause message', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    const error = new TransportError('Publication discovery request failed.', {
+      cause: Object.assign(new Error('connect ECONNREFUSED'), { code: 'ECONNREFUSED' }),
+      phase: 'connect',
+      delivery: 'unknown',
+    }) as TransportError & { url?: string }
+    error.url = 'https://localhost:8443/kernel/host'
+    try {
+      await formatKernelError(error, true)
+    } finally {
+      process.stderr.write = original
+    }
 
-  test('does not strip single colon (not a method dispatch)', () => {
-    expect(stripMethodSuffix('"/a/b:notMethod"')).toBe('"/a/b:notMethod"')
+    expect(JSON.parse(writes[0]!)).toMatchObject({
+      error: 'CONNECTION_ERROR',
+      message: 'Publication discovery request failed.',
+      url: 'https://localhost:8443/kernel/host',
+      phase: 'connect',
+      delivery: 'unknown',
+    })
+    expect(writes[0]).not.toContain('ECONNREFUSED')
   })
-})
 
-describe('formatKernelError', () => {
   /** @evidence TEST-CLI-CONNECTION-PRESERVES-PUBLIC-SEMANTIC-REASON */
   test('preserves a Kernel-admitted semantic reason in machine output', async () => {
     const writes: string[] = []
@@ -93,4 +88,403 @@ describe('formatKernelError', () => {
       },
     })
   })
+
+  test('explains deletion-only schema work without changing the Kernel reason', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      await formatKernelError(
+        new ResponseError(CONFLICT, 'Schema change requires migration.', {
+          code: 'DATA_MIGRATION_REQUIRED',
+          details: {
+            requirements: [
+              {
+                operation: 'remove-facts',
+                reason: 'destructive-change',
+                subject: {
+                  kind: 'definition',
+                  ref: { origin: 'x.test', kind: 'class', name: 'X' },
+                },
+                work: { observedFacts: 1 },
+              },
+            ],
+          },
+        }),
+        true,
+      )
+    } finally {
+      process.stderr.write = original
+    }
+
+    expect(JSON.parse(writes[0]!)).toEqual({
+      error: 'RESPONSE_ERROR',
+      code: CONFLICT,
+      message: 'Schema change requires migration.',
+      reason: {
+        code: 'DATA_MIGRATION_REQUIRED',
+        details: {
+          requirements: [
+            {
+              operation: 'remove-facts',
+              reason: 'destructive-change',
+              subject: {
+                kind: 'definition',
+                ref: { origin: 'x.test', kind: 'class', name: 'X' },
+              },
+              work: { observedFacts: 1 },
+            },
+          ],
+        },
+      },
+      hint: 'Delete this data explicitly, then retry. No data was deleted.',
+    })
+  })
+
+  test('prints an actionable message for deletion-only schema work', async () => {
+    const errors: string[] = []
+    const hints: string[] = []
+    const originalError = console.error
+    const originalLog = console.log
+    console.error = (...values: unknown[]) => errors.push(values.map(String).join(' '))
+    console.log = (...values: unknown[]) => hints.push(values.map(String).join(' '))
+    try {
+      await formatKernelError(
+        new ResponseError(CONFLICT, 'Schema change requires migration.', {
+          code: 'DATA_MIGRATION_REQUIRED',
+          details: {
+            requirements: [
+              {
+                operation: 'remove-facts',
+                reason: 'destructive-change',
+                subject: {
+                  kind: 'definition',
+                  ref: { origin: 'x.test', kind: 'class', name: 'X' },
+                },
+                work: { observedFacts: 1 },
+              },
+            ],
+          },
+        }),
+        false,
+      )
+    } finally {
+      console.error = originalError
+      console.log = originalLog
+    }
+
+    expect(errors.join('\n')).toContain('DATA_MIGRATION_REQUIRED')
+    expect(errors.join('\n')).toContain(
+      'Existing business data still uses schema definitions being removed.',
+    )
+    expect(hints.join('\n')).toContain(
+      'Delete this data explicitly, then retry. No data was deleted.',
+    )
+  })
+
+  test('maps SDK class names to stable CLI error codes', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      const pathError = new Error('Path must have an Id or Domain anchor.')
+      pathError.name = 'PathError'
+      await formatKernelError(pathError, true)
+    } finally {
+      process.stderr.write = original
+    }
+    expect(JSON.parse(writes[0]!)).toEqual({
+      error: 'PATH_INVALID',
+      message: 'Path must have an Id or Domain anchor.',
+    })
+  })
+
+  /** @evidence TEST-CLI-CONNECTION-PRESENTS-BOUNDED-REPAIRS */
+  test('renders callable and Query repair coordinates for humans', async () => {
+    const lines: string[] = []
+    const originalError = console.error
+    const originalLog = console.log
+    console.error = (...values: unknown[]) => lines.push(values.join(' '))
+    console.log = (...values: unknown[]) => lines.push(values.join(' '))
+    try {
+      await formatKernelError(
+        new ResponseError(VALIDATION, 'Function input is invalid.', {
+          code: 'FUNCTION_INPUT_INVALID',
+          details: {
+            issues: [
+              {
+                code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+                path: '/issuer',
+                message: 'Object is missing required property issuer.',
+              },
+              {
+                code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+                path: '/operationId',
+                message: 'Object is missing required property operationId.',
+              },
+              {
+                code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+                path: '/slug',
+                message: 'Object is missing required property slug.',
+              },
+            ],
+          },
+        }),
+        false,
+      )
+      await formatKernelError(
+        new ResponseError(VALIDATION, 'Query input is invalid.', {
+          code: 'QUERY_INPUT_INVALID',
+          details: {
+            phase: 'plan',
+            issue: 'QUERY_DEFINITION_NOT_EDGE',
+            path: '/steps/0/via/0',
+          },
+        }),
+        false,
+      )
+    } finally {
+      console.error = originalError
+      console.log = originalLog
+    }
+
+    const rendered = lines.join('\n')
+    expect(rendered).toContain('/issuer: Object is missing required property issuer.')
+    expect(rendered).toContain('/operationId: Object is missing required property operationId.')
+    expect(rendered).toContain('/slug: Object is missing required property slug.')
+    expect(rendered).toContain('/steps/0/via/0  QUERY_DEFINITION_NOT_EDGE')
+  })
+
+  test('explains immutable issuer replacements and preserves the Kernel reason', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      await formatKernelError(
+        new ResponseError(5001, 'Schema operation is not supported.', {
+          code: 'SCHEMA_UPGRADE_INCOMPATIBLE',
+          details: {
+            phase: 'upgrade',
+            origin: 'grc.example',
+            expected: 'https://old.example',
+            actual: 'https://new.example',
+          },
+        }),
+        true,
+      )
+    } finally {
+      process.stderr.write = original
+    }
+
+    expect(JSON.parse(writes[0]!)).toEqual({
+      error: 'RESPONSE_ERROR',
+      code: 5001,
+      message: 'Schema operation is not supported.',
+      reason: {
+        code: 'SCHEMA_UPGRADE_INCOMPATIBLE',
+        details: {
+          phase: 'upgrade',
+          origin: 'grc.example',
+          expected: 'https://old.example',
+          actual: 'https://new.example',
+        },
+      },
+      hint: schemaUpgradeHint({
+        origin: 'grc.example',
+        expected: 'https://old.example',
+        actual: 'https://new.example',
+      }),
+    })
+  })
+
+  test('explains a private Domain source without exposing transport diagnostics', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      await formatKernelError(
+        new ResponseError(1003, 'Function input is invalid.', {
+          code: 'SCHEMA_DOMAIN_ADDRESS_NOT_PUBLIC',
+          details: { phase: 'publication', requiredScope: 'public' },
+        }),
+        true,
+      )
+    } finally {
+      process.stderr.write = original
+    }
+
+    expect(JSON.parse(writes[0]!)).toEqual({
+      error: 'RESPONSE_ERROR',
+      code: 1003,
+      message: 'Expose the Domain through a public HTTPS URL or public tunnel, then retry.',
+      reason: {
+        code: 'SCHEMA_DOMAIN_ADDRESS_NOT_PUBLIC',
+        details: { phase: 'publication', requiredScope: 'public' },
+      },
+    })
+  })
+
+  test('prints the actionable private-source message in interactive output', async () => {
+    const errors: string[] = []
+    const hints: string[] = []
+    const originalError = console.error
+    const originalLog = console.log
+    console.error = (...values: unknown[]) => errors.push(values.map(String).join(' '))
+    console.log = (...values: unknown[]) => hints.push(values.map(String).join(' '))
+    try {
+      await formatKernelError(
+        new ResponseError(1003, 'Function input is invalid.', {
+          code: 'SCHEMA_DOMAIN_ADDRESS_NOT_PUBLIC',
+          details: { phase: 'publication', requiredScope: 'public' },
+        }),
+        false,
+      )
+    } finally {
+      console.error = originalError
+      console.log = originalLog
+    }
+
+    expect(errors.join('\n')).toContain('SCHEMA_DOMAIN_ADDRESS_NOT_PUBLIC')
+    expect(errors.join('\n')).toContain(
+      'Expose the Domain through a public HTTPS URL or public tunnel, then retry.',
+    )
+    expect(hints).toEqual([])
+  })
+
+  test('preserves structured Function input issues in machine output', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      await formatKernelError(
+        new ResponseError(1003, 'Function input is invalid.', {
+          code: 'FUNCTION_INPUT_INVALID',
+          details: {
+            issues: [
+              {
+                code: 'INVALID_FORMAT',
+                path: '/customer/email',
+                message: 'Must be a valid email address.',
+              },
+            ],
+          },
+        }),
+        true,
+      )
+    } finally {
+      process.stderr.write = original
+    }
+
+    expect(JSON.parse(writes[0]!)).toEqual({
+      error: 'RESPONSE_ERROR',
+      code: 1003,
+      message: 'Function input is invalid.',
+      reason: {
+        code: 'FUNCTION_INPUT_INVALID',
+        details: {
+          issues: [
+            {
+              code: 'INVALID_FORMAT',
+              path: '/customer/email',
+              message: 'Must be a valid email address.',
+            },
+          ],
+        },
+      },
+      hint: 'Use `astrale introspect <path>` to see the callable input.',
+    })
+  })
+
+  test('prints Kernel-provided Function input messages in interactive output', async () => {
+    const errors: string[] = []
+    const details: string[] = []
+    const originalError = console.error
+    const originalLog = console.log
+    console.error = (...values: unknown[]) => errors.push(values.map(String).join(' '))
+    console.log = (...values: unknown[]) => details.push(values.map(String).join(' '))
+    try {
+      await formatKernelError(
+        new ResponseError(1003, 'Function input is invalid.', {
+          code: 'FUNCTION_INPUT_INVALID',
+          details: {
+            issues: [
+              {
+                code: 'INVALID_FORMAT',
+                path: '/customer/email',
+                message: 'Must be a valid email address.',
+              },
+            ],
+          },
+        }),
+        false,
+      )
+    } finally {
+      console.error = originalError
+      console.log = originalLog
+    }
+
+    expect(errors.join('\n')).toContain('Function input is invalid.')
+    expect(details.join('\n')).toContain(
+      '/customer/email: Must be a valid email address. (INVALID_FORMAT)',
+    )
+    expect(details.join('\n')).not.toContain('astrale introspect')
+  })
+
+  test('keeps the introspection fallback for legacy Function input issues', async () => {
+    const writes: string[] = []
+    const original = process.stderr.write
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stderr.write
+    try {
+      await formatKernelError(
+        new ResponseError(1003, 'Function input is invalid.', {
+          code: 'FUNCTION_INPUT_INVALID',
+          details: { issues: [{ code: 'INVALID_FORMAT', path: '/customer/email' }] },
+        }),
+        true,
+      )
+    } finally {
+      process.stderr.write = original
+    }
+
+    expect(JSON.parse(writes[0]!)).toMatchObject({
+      reason: {
+        code: 'FUNCTION_INPUT_INVALID',
+        details: { issues: [{ code: 'INVALID_FORMAT', path: '/customer/email' }] },
+      },
+      hint: 'Use `astrale introspect <path>` to see the callable input.',
+    })
+  })
+
+  test('rejects malformed public Function issue messages', () => {
+    expect(
+      functionInputIssues({
+        code: 'FUNCTION_INPUT_INVALID',
+        details: {
+          issues: [
+            { code: 'INVALID_FORMAT', path: '/safe', message: 'Safe message.' },
+            { code: 'INVALID_FORMAT', path: 'not-a-pointer', message: 'Unsafe path.' },
+            { code: 'INVALID_FORMAT', path: '/unsafe', message: 'Unsafe\nmessage.' },
+          ],
+        },
+      }),
+    ).toEqual([{ code: 'INVALID_FORMAT', path: '/safe', message: 'Safe message.' }])
+  })
 })