@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

package/src/lib/__tests__/meta.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { checkIssuerReachability } from '../meta'
-
-const ISSUER = 'https://host.example/kernel/child'
-const INVOCATION = `${ISSUER}/invoke`
-
-describe('issuer reachability', () => {
-  /** @evidence TEST-CLI-CONNECTION-PROBES-PINNED-ISSUER */
-  test('probes OIDC discovery at the separately pinned issuer, not the invocation endpoint', async () => {
-    const requests: string[] = []
-    const fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = String(input)
-      requests.push(url)
-      if (url === `${ISSUER}/.well-known/openid-configuration`) {
-        return Response.json({
-          issuer: ISSUER,
-          jwks_uri: `${ISSUER}/.well-known/jwks.json`,
-        })
-      }
-      if (url === `${ISSUER}/.well-known/jwks.json`) {
-        return Response.json({ keys: [{ kid: 'bootstrap' }] })
-      }
-      return new Response(null, { status: 404 })
-    }
-
-    await expect(checkIssuerReachability(INVOCATION, ISSUER, fetch)).resolves.toEqual({
-      issuer: ISSUER,
-      keys: [{ kid: 'bootstrap' }],
-    })
-    expect(requests).toEqual([
-      `${ISSUER}/.well-known/openid-configuration`,
-      `${ISSUER}/.well-known/jwks.json`,
-    ])
-  })
-
-  /** @evidence TEST-CLI-CONNECTION-REJECTS-DISCOVERY-ISSUER-MISMATCH */
-  test('rejects discovery that contradicts the separately pinned issuer', async () => {
-    const conflictingIssuer = 'https://attacker.example/kernel/child'
-    const fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = String(input)
-      if (url.endsWith('/.well-known/openid-configuration')) {
-        return Response.json({
-          issuer: conflictingIssuer,
-          jwks_uri: `${conflictingIssuer}/.well-known/jwks.json`,
-        })
-      }
-      return Response.json({ keys: [{ kid: 'attacker' }] })
-    }
-
-    await expect(checkIssuerReachability(INVOCATION, ISSUER, fetch)).rejects.toMatchObject({
-      code: 'ISSUER_UNREACHABLE',
-    })
-  })
-})

package/src/lib/__tests__/output.test.ts

@@ -1,162 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
-
-import { denoise, isMachine, output, present, presentList } from '../output'
-
-function captureStdout(): { writes: string[]; restore: () => void } {
-  const writes: string[] = []
-  const original = process.stdout.write.bind(process.stdout)
-  process.stdout.write = mock((chunk: string | Uint8Array) => {
-    writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
-    return true
-  }) as typeof process.stdout.write
-  return { writes, restore: () => (process.stdout.write = original) }
-}
-
-describe('output — void/undefined normalization', () => {
-  let writes: string[] = []
-  let originalWrite: typeof process.stdout.write
-
-  beforeEach(() => {
-    writes = []
-    originalWrite = process.stdout.write.bind(process.stdout)
-    process.stdout.write = mock((chunk: string | Uint8Array) => {
-      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
-      return true
-    }) as typeof process.stdout.write
-  })
-
-  afterEach(() => {
-    process.stdout.write = originalWrite
-  })
-
-  test('--raw output for void syscall is "null", not bare "undefined"', () => {
-    // Regression: JSON.stringify(undefined) returns undefined (not "undefined"),
-    // so concatenating with '\n' coerced to the literal string 'undefined\n'.
-    // Any wrapper doing JSON.parse(stdout) would blow up.
-    output(undefined, { raw: true })
-    expect(writes.join('')).toBe('null\n')
-  })
-
-  test('--json output for void syscall is "null"', () => {
-    output(undefined, { json: true })
-    expect(writes.join('')).toBe('null\n')
-  })
-
-  test('explicit format=json on non-TTY yields "null" for void', () => {
-    output(undefined, { format: 'json' })
-    const out = writes.join('')
-    // On TTY the value gets ANSI-colored; either way the parseable token is `null`.
-    expect(out).toContain('null')
-    expect(out).not.toContain('undefined')
-  })
-
-  test('--raw output for actual data is unchanged', () => {
-    output({ a: 1 }, { raw: true })
-    expect(writes.join('')).toBe('{\n  "a": 1\n}\n')
-  })
-})
-
-describe('isMachine', () => {
-  test('returns true for --raw', () => {
-    expect(isMachine({ raw: true })).toBe(true)
-  })
-
-  test('returns true for --json', () => {
-    expect(isMachine({ json: true })).toBe(true)
-  })
-
-  test('returns true when both are set', () => {
-    expect(isMachine({ raw: true, json: true })).toBe(true)
-  })
-
-  test('returns false for empty opts when TTY', () => {
-    // This test depends on the test runner's TTY state.
-    // In a non-TTY environment (CI), isMachine({}) returns true.
-    const result = isMachine({})
-    expect(typeof result).toBe('boolean')
-  })
-
-  test('handles undefined opts', () => {
-    const result = isMachine()
-    expect(typeof result).toBe('boolean')
-  })
-})
-
-describe('present — scalar', () => {
-  let cap: ReturnType<typeof captureStdout>
-  beforeEach(() => (cap = captureStdout()))
-  afterEach(() => cap.restore())
-
-  test('--raw prints a bare string (no quotes) for shell capture', () => {
-    present('alice', { raw: true })
-    expect(cap.writes.join('')).toBe('alice\n')
-  })
-
-  test('--json prints a quoted JSON string', () => {
-    present('alice', { json: true })
-    expect(cap.writes.join('')).toBe('"alice"\n')
-  })
-
-  test('objects fall back to JSON under --raw (nothing rawer to give)', () => {
-    present({ a: 1 }, { raw: true })
-    expect(cap.writes.join('')).toBe('{\n  "a": 1\n}\n')
-  })
-})
-
-describe('denoise', () => {
-  test('strips schema / icon / code at any depth, keeps the rest', () => {
-    const out = denoise({
-      id: 'x',
-      icon: '<svg/>',
-      props: { schema: 'huge', name: 'n', code: 'c' },
-    })
-    expect(out).toEqual({ id: 'x', props: { name: 'n' } })
-  })
-
-  test('strips qualified property keys whose leaf is schema', () => {
-    const out = denoise({
-      props: {
-        'kernel.astrale.ai:class.Domain.property.schema': { huge: true },
-        'kernel.astrale.ai:class.Domain.property.origin': 'kernel.astrale.ai',
-      },
-    })
-    expect(out).toEqual({
-      props: { 'kernel.astrale.ai:class.Domain.property.origin': 'kernel.astrale.ai' },
-    })
-  })
-})
-
-describe('presentList', () => {
-  let cap: ReturnType<typeof captureStdout>
-  beforeEach(() => (cap = captureStdout()))
-  afterEach(() => cap.restore())
-
-  const project = (items: Array<{ name: string; path?: string; props?: unknown }>) => ({
-    columns: [{ key: 'name', header: 'NAME' }],
-    rows: items.map((i) => ({ name: i.name })),
-    paths: items.map((i) => i.path ?? ''),
-  })
-
-  test('--count prints only the number', () => {
-    presentList([{ name: 'a' }, { name: 'b' }], { count: true }, project)
-    expect(cap.writes.join('')).toBe('2\n')
-  })
-
-  test('-q prints one path per line', () => {
-    presentList(
-      [
-        { name: 'a', path: '/a' },
-        { name: 'b', path: '/b' },
-      ],
-      { quiet: true },
-      project,
-    )
-    expect(cap.writes.join('')).toBe('/a\n/b\n')
-  })
-
-  test('machine output is the denoised raw items, not the projected rows', () => {
-    presentList([{ name: 'a', props: { schema: 'big', keep: 1 } }], { json: true }, project)
-    const out = JSON.parse(cap.writes.join(''))
-    expect(out).toEqual([{ name: 'a', props: { keep: 1 } }])
-  })
-})

package/src/lib/__tests__/panel.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import chalk from 'chalk'
-
-import { panel, renderInstanceHero } from '../panel'
-
-// Built from a char code so the regex source carries no literal control char.
-const ANSI_RE = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g')
-const stripAnsi = (s: string): string => s.replace(ANSI_RE, '')
-
-describe('panel — rounded box framing', () => {
-  test('every visible line is the same width (ANSI excluded)', () => {
-    const lines = stripAnsi(panel(['short', 'a much longer line here'])).split('\n')
-    const widths = new Set(lines.map((l) => l.length))
-    expect(widths.size).toBe(1)
-  })
-
-  test('draws rounded corners top and bottom', () => {
-    const lines = stripAnsi(panel(['x'])).split('\n')
-    expect(lines[0]).toContain('╭')
-    expect(lines[0]).toContain('╮')
-    expect(lines[lines.length - 1]).toContain('╰')
-    expect(lines[lines.length - 1]).toContain('╯')
-  })
-
-  test('colored content does not break alignment', () => {
-    // A bold/underlined cell carries ANSI; visible width must still align.
-    const out = panel(['plain', chalk.bold.cyan.underline('https://my-app.eu.astrale.ai')])
-    const lines = stripAnsi(out).split('\n')
-    expect(new Set(lines.map((l) => l.length)).size).toBe(1)
-  })
-})
-
-describe('renderInstanceHero', () => {
-  test('puts the URL front and center', () => {
-    const out = stripAnsi(renderInstanceHero('my-app', 'https://my-app.eu.astrale.ai'))
-    expect(out).toContain('Your instance is live')
-    expect(out).toContain('https://my-app.eu.astrale.ai')
-    expect(out).toContain('my-app')
-  })
-})

package/src/lib/__tests__/port.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import net from 'node:net'
-
-import { findFreePort, portFree } from '../port'
-
-function listen(port: number): Promise<net.Server> {
-  return new Promise((resolve, reject) => {
-    const s = net.createServer()
-    s.once('error', reject)
-    s.listen({ port, host: '127.0.0.1', exclusive: true }, () => resolve(s))
-  })
-}
-const close = (s: net.Server) => new Promise<void>((r) => s.close(() => r()))
-
-describe('port', () => {
-  it('portFree: true for an unbound port, false once it is bound', async () => {
-    const p = await findFreePort(48000, 200)
-    expect(p).not.toBeNull()
-    expect(await portFree(p as number)).toBe(true)
-    const srv = await listen(p as number)
-    try {
-      expect(await portFree(p as number)).toBe(false)
-    } finally {
-      await close(srv)
-    }
-  })
-
-  it('findFreePort: skips a busy port and returns a later free one', async () => {
-    const base = await findFreePort(48000, 200)
-    expect(base).not.toBeNull()
-    const srv = await listen(base as number)
-    try {
-      const next = await findFreePort(base as number, 10)
-      expect(next).not.toBeNull()
-      expect(next as number).toBeGreaterThan(base as number)
-    } finally {
-      await close(srv)
-    }
-  })
-
-  it('findFreePort: returns null when the band is empty (span 0)', async () => {
-    expect(await findFreePort(48000, 0)).toBeNull()
-  })
-})

package/src/lib/__tests__/prompt.test.ts

@@ -1,25 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-
-import { promptText } from '../prompt'
-
-// The no-TTY branch IS the LLM / CI / piped case. promptText must resolve to a
-// default (never await a stdin read) there, so `astrale domain publish` fails
-// fast on its required-flag error instead of hanging. Force isTTY=false so this
-// holds even when the suite is run from an interactive terminal.
-describe('promptText — non-TTY never blocks on input', () => {
-  const original = process.stdin.isTTY
-  beforeAll(() => {
-    ;(process.stdin as { isTTY?: boolean }).isTTY = false
-  })
-  afterAll(() => {
-    ;(process.stdin as { isTTY?: boolean }).isTTY = original
-  })
-
-  test('returns the provided default', async () => {
-    expect(await promptText('Domain origin', { default: 'crm.acme.dev' })).toBe('crm.acme.dev')
-  })
-
-  test('returns undefined with no default (caller then hits its required-flag error)', async () => {
-    expect(await promptText('Published worker URL')).toBeUndefined()
-  })
-})

package/src/lib/__tests__/sdk-deps.test.ts

@@ -1,68 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { foreignPackageManager, inDomainProject, parseSdkOutdated } from '../sdk-deps'
-
-describe('parseSdkOutdated', () => {
-  test('keeps only deps with a strictly newer latest; uses wanted when current is absent', () => {
-    const json = JSON.stringify({
-      '@astrale-os/sdk': { current: '0.1.5', wanted: '0.1.5', latest: '0.1.9' }, // behind
-      '@astrale-os/sdk/schema': { current: '0.1.2', wanted: '0.1.2', latest: '0.1.2' }, // current
-      '@astrale-os/shell': { wanted: '0.1.0', latest: '0.1.1' }, // no `current` (not installed)
-    })
-    expect(parseSdkOutdated(json)).toEqual([
-      { pkg: '@astrale-os/sdk', current: '0.1.5', latest: '0.1.9' },
-      { pkg: '@astrale-os/shell', current: '0.1.0', latest: '0.1.1' },
-    ])
-  })
-
-  test('empty / non-JSON / no-latest input yields no upgrades (never throws)', () => {
-    expect(parseSdkOutdated('')).toEqual([])
-    expect(parseSdkOutdated('{}')).toEqual([])
-    expect(parseSdkOutdated('not json')).toEqual([])
-    expect(parseSdkOutdated(JSON.stringify({ '@astrale-os/sdk': { current: '0.1.9' } }))).toEqual(
-      [],
-    )
-  })
-})
-
-describe('inDomainProject', () => {
-  let tmp: string
-  afterEach(async () => {
-    if (tmp) await rm(tmp, { recursive: true, force: true })
-  })
-
-  test('true only where astrale.config.ts exists', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-'))
-    expect(inDomainProject(tmp)).toBe(false)
-    await writeFile(join(tmp, 'astrale.config.ts'), 'export default {}\n')
-    expect(inDomainProject(tmp)).toBe(true)
-  })
-})
-
-describe('foreignPackageManager', () => {
-  let tmp: string
-  afterEach(async () => {
-    if (tmp) await rm(tmp, { recursive: true, force: true })
-  })
-
-  test('pnpm-lock / no lockfile → null (we own it); other lockfiles → that PM', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-pm-'))
-    expect(foreignPackageManager(tmp)).toBeNull() // fresh → pnpm-first default
-
-    await writeFile(join(tmp, 'package-lock.json'), '{}')
-    expect(foreignPackageManager(tmp)).toBe('npm')
-
-    // pnpm-lock wins even alongside another lockfile (it's a pnpm project).
-    await writeFile(join(tmp, 'pnpm-lock.yaml'), "lockfileVersion: '9.0'\n")
-    expect(foreignPackageManager(tmp)).toBeNull()
-  })
-
-  test('yarn.lock → yarn', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-yarn-'))
-    await writeFile(join(tmp, 'yarn.lock'), '')
-    expect(foreignPackageManager(tmp)).toBe('yarn')
-  })
-})

package/src/lib/__tests__/self.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { containsSelfRef, expandSelfReferences } from '../self'
-
-describe('containsSelfRef / expandSelfReferences', () => {
-  const ID = 'node-abc-123'
-
-  test.each([
-    ['@self', `@${ID}`],
-    ['@self::deployFunction', `@${ID}::deployFunction`],
-    ['@self/functions', `@${ID}/functions`],
-    ['@self/functions/foo', `@${ID}/functions/foo`],
-    ['node=@self', `node=@${ID}`],
-    ['target=@self::method', `target=@${ID}::method`],
-    ['target=@self/sub', `target=@${ID}/sub`],
-    ['x=@self::m  y=@self', `x=@${ID}::m  y=@${ID}`],
-  ])('expands %p -> %p', (input, expected) => {
-    expect(containsSelfRef(input)).toBe(true)
-    expect(expandSelfReferences(input, ID)).toBe(expected)
-  })
-
-  test.each([
-    ['@self', 'x$&y', '@x$&y'],
-    ['@self', 'x$$y', '@x$$y'],
-    ['@self', 'x$1y', '@x$1y'],
-    ['@self', 'x$`y', '@x$`y'],
-    ['@self::m', 'x$&y', '@x$&y::m'],
-  ])('treats replacement metacharacters literally: %p x %p -> %p', (input, id, expected) => {
-    expect(expandSelfReferences(input, id)).toBe(expected)
-  })
-
-  test.each([
-    'prefix@self',
-    '@selfsuffix',
-    '@self.example',
-    '@self,@other',
-    'node=before@self',
-    '{"ref":"@self"}',
-    'no-self-here',
-  ])('does not expand %p', (input) => {
-    expect(containsSelfRef(input)).toBe(false)
-    expect(expandSelfReferences(input, ID)).toBe(input)
-  })
-
-  test('is stateless across calls', () => {
-    expect(containsSelfRef('@self')).toBe(true)
-    expect(containsSelfRef('@self')).toBe(true)
-    expect(containsSelfRef('@self')).toBe(true)
-  })
-})

package/src/lib/__tests__/studio-server-deps.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { readFileSync, readdirSync, statSync } from 'node:fs'
-import { join, relative } from 'node:path'
-import { Project } from 'ts-morph'
-
-/**
- * The Domain Studio SERVER ships as raw source inside the published CLI package
- * (package.json `files`: studio/server, studio/shared) and runs UNBUNDLED under
- * Bun — unlike the CLI itself, which is bundled into dist/astrale.js with all its
- * deps inlined. So at `astrale studio` runtime, the server can only resolve the
- * third-party packages that the CLI declares in its own `dependencies` (the
- * studio's package.json deps are NOT installed for an `npm i -g @astrale-os/cli`
- * consumer — they're client/build-only, inlined into studio/client/dist).
- *
- * This test enforces that invariant. If it fails, either add the package to the
- * CLI's `dependencies` or drop the import — do NOT add it to studio/package.json
- * (that won't ship to npm consumers).
- */
-
-const CLI_ROOT = new URL('../../../', import.meta.url).pathname
-
-interface PackageManifest {
-  dependencies?: Record<string, string>
-  scripts?: Record<string, string>
-}
-
-const cliPackage = JSON.parse(
-  readFileSync(join(CLI_ROOT, 'package.json'), 'utf8'),
-) as PackageManifest
-const studioPackage = JSON.parse(
-  readFileSync(join(CLI_ROOT, 'studio/package.json'), 'utf8'),
-) as PackageManifest
-
-/** Base package of a bare specifier: `@scope/pkg/sub` → `@scope/pkg`, `pkg/sub` → `pkg`. */
-function basePackage(spec: string): string {
-  const parts = spec.split('/')
-  return spec.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]!
-}
-
-function isBuiltin(spec: string): boolean {
-  return spec.startsWith('node:') || spec === 'bun' || spec.startsWith('bun:')
-}
-
-function runtimeFiles(directory: string): string[] {
-  return readdirSync(directory).flatMap((entry) => {
-    const path = join(directory, entry)
-    if (statSync(path).isDirectory()) return runtimeFiles(path)
-    return /\.(?:ts|tsx)$/.test(path) && !/\.test\.(?:ts|tsx)$/.test(path) ? [path] : []
-  })
-}
-
-const studioPath = (path: string) => relative(CLI_ROOT, path).replaceAll('\\', '/')
-
-describe('studio server runtime deps', () => {
-  const deps = new Set(Object.keys(cliPackage.dependencies ?? {}))
-
-  const project = new Project({ skipAddingFilesFromTsConfig: true })
-  project.addSourceFilesAtPaths([
-    join(CLI_ROOT, 'studio/server/**/*.ts'),
-    join(CLI_ROOT, 'studio/server/**/*.tsx'),
-    join(CLI_ROOT, 'studio/shared/**/*.ts'),
-    join(CLI_ROOT, 'studio/shared/**/*.tsx'),
-  ])
-  const runtimeSourceFiles = project
-    .getSourceFiles()
-    .filter((sourceFile) => !/\.test\.(?:ts|tsx)$/.test(sourceFile.getBaseName()))
-
-  // getImportStringLiterals covers static imports, re-exports, and dynamic import().
-  const offenders: Record<string, string[]> = {}
-  for (const sf of runtimeSourceFiles) {
-    const specs = sf.getImportStringLiterals().map((l) => l.getLiteralValue())
-    for (const spec of specs) {
-      if (spec.startsWith('.') || spec.startsWith('/') || isBuiltin(spec)) continue
-      const pkg = basePackage(spec)
-      if (!deps.has(pkg)) (offenders[pkg] ??= []).push(sf.getFilePath().replace(CLI_ROOT, ''))
-    }
-  }
-
-  test('only import Node/Bun builtins or packages in the CLI dependencies', () => {
-    expect(
-      offenders,
-      `studio server imports packages NOT in the CLI's package.json dependencies — ` +
-        `they won't be installed for an \`npm i -g @astrale-os/cli\` consumer:\n` +
-        JSON.stringify(offenders, null, 2),
-    ).toEqual({})
-  })
-
-  test('parses every shipped Studio server and shared runtime source', () => {
-    const expected = [
-      ...runtimeFiles(join(CLI_ROOT, 'studio/server')),
-      ...runtimeFiles(join(CLI_ROOT, 'studio/shared')),
-    ]
-      .map(studioPath)
-      .sort()
-    const parsed = runtimeSourceFiles
-      .map((sourceFile) => studioPath(sourceFile.getFilePath()))
-      .sort()
-
-    expect(parsed).toEqual(expected)
-  })
-})
-
-describe('studio test gate', () => {
-  test('the root and Studio suites include all client, server, and shared tests', () => {
-    expect(cliPackage.scripts?.test).toBe(
-      'node scripts/qualification/source-boundary.mjs --target && bun test src studio/client/src studio/server studio/shared && node --test scripts/*.test.mjs',
-    )
-    expect(cliPackage.scripts?.['test:studio']).toBe('pnpm --dir studio test')
-    expect(studioPackage.scripts?.test).toBe('bun test client/src server shared')
-  })
-})

package/src/lib/__tests__/table.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { renderTable } from '../table'
-
-const ESC = String.fromCharCode(27)
-const strip = (s: string): string => s.replace(new RegExp(`${ESC}\\[[0-9;]*m`, 'g'), '')
-
-const COLS = [
-  { key: 'name', header: 'NAME' },
-  { key: 'kind', header: 'KIND' },
-]
-
-describe('renderTable', () => {
-  test('aligns the KIND column across rows of different name widths', () => {
-    const out = strip(
-      renderTable(
-        [
-          { name: 'example.astrale.ai', kind: 'Domain' },
-          { name: 'workspace', kind: 'Folder' },
-        ],
-        { columns: COLS },
-      ),
-    )
-    const [a, b] = out.split('\n')
-    expect(a.indexOf('Domain')).toBe(b.indexOf('Folder'))
-  })
-
-  test('empty rows render as (empty)', () => {
-    expect(strip(renderTable([], { columns: COLS }))).toContain('(empty)')
-  })
-
-  test('drops a column that is empty across every row (with header)', () => {
-    const out = strip(renderTable([{ name: 'a', kind: '' }], { columns: COLS, showHeader: true }))
-    expect(out).toContain('NAME')
-    expect(out).not.toContain('KIND')
-  })
-
-  test('computes width on visible length, ignoring ANSI in cells', () => {
-    const colored = `${ESC}[32mok${ESC}[39m`
-    const out = strip(
-      renderTable(
-        [
-          { name: colored, kind: 'x' },
-          { name: 'wider-name', kind: 'y' },
-        ],
-        { columns: COLS },
-      ),
-    )
-    const [a, b] = out.split('\n')
-    // KIND aligns despite the ANSI codes that were in row 0's name cell.
-    expect(a.indexOf('x')).toBe(b.indexOf('y'))
-  })
-})