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

package/studio/server/json.ts

@@ -0,0 +1,46 @@
+/** Pure structural helpers for JSON trust boundaries. */
+
+export type JsonRecord = Record<string, unknown>
+export type JsonDecoder<T> = (value: unknown) => T | undefined
+
+export function asJsonRecord(value: unknown): JsonRecord | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : undefined
+}
+
+export function asJsonArray(value: unknown): unknown[] | undefined {
+  return Array.isArray(value) ? value : undefined
+}
+
+export function asString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+export function asBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined
+}
+
+export function asFiniteNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+export function asStringArray(value: unknown): string[] | undefined {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string') ? value : undefined
+}
+
+export function asStringRecord(value: unknown): Record<string, string> | undefined {
+  const record = asJsonRecord(value)
+  if (!record || Object.values(record).some((item) => typeof item !== 'string')) return undefined
+  return record as Record<string, string>
+}
+
+/** Parse JSON as untrusted data. `undefined` means syntax failure. */
+export function parseJson(text: string): unknown | undefined {
+  try {
+    const value: unknown = JSON.parse(text)
+    return value
+  } catch {
+    return undefined
+  }
+}

package/studio/server/lifecycle.ts

@@ -26,7 +26,11 @@ export async function bootDomain(handle: DomainHandle): Promise<BootedDomain> {
   if (!loadBaseline(handle.root))
     captureBaseline(
       handle.root,
-      bundle?.ir ?? null,
+      {
+        ir: bundle?.ir ?? null,
+        root: bundle?.schemaMode === 'canonical-admitted' ? (bundle.schemaRoot ?? null) : null,
+        revision: bundle?.schemaRevision ?? null,
+      },
       hashAnatomyFiles(handle.root, handle.schemaDirName),
     )
   const stop = watchDomain(handle)

package/studio/server/sse.test.ts

@@ -0,0 +1,26 @@
+import { expect, test } from 'bun:test'
+
+import { broadcast, sseResponse } from './sse'
+
+test('SSE response preserves headers and emits the initial workspace frame', async () => {
+  const response = sseResponse(['issues', 'shell'])
+  expect(response.status).toBe(200)
+  expect(response.headers.get('content-type')).toBe('text/event-stream')
+  expect(response.headers.get('cache-control')).toBe('no-cache, no-transform')
+  expect(response.headers.get('connection')).toBe('keep-alive')
+
+  const reader = response.body!.getReader()
+  const first = await reader.read()
+  expect(new TextDecoder().decode(first.value)).toBe(
+    'data: {"type":"hello","domains":["issues","shell"]}\n\n',
+  )
+
+  expect(broadcast({ type: 'workspace', domains: ['issues', 'billing'] })).toBe(1)
+  const update = await reader.read()
+  expect(new TextDecoder().decode(update.value)).toBe(
+    'data: {"type":"workspace","domains":["issues","billing"]}\n\n',
+  )
+
+  await reader.cancel()
+  expect(broadcast({ type: 'workspace', domains: [] })).toBe(0)
+})

package/studio/server/sse.ts

@@ -41,7 +41,9 @@ export function sseResponse(domains: string[]): Response {
   })
 }
 
-export function broadcast(event: StudioEvent): void {
+/** Broadcast an event and report how many clients were registered at dispatch start. */
+export function broadcast(event: StudioEvent): number {
+  const recipients = clients.size
   const payload = encoder.encode(frame(event))
   for (const [id, c] of clients) {
     try {
@@ -50,6 +52,7 @@ export function broadcast(event: StudioEvent): void {
       clients.delete(id)
     }
   }
+  return recipients
 }
 
 function frame(event: StudioEvent): string {

package/studio/server/state/baseline.test.ts

@@ -3,7 +3,17 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { hashAnatomyFiles } from './baseline'
+import type { SchemaIR } from '../../shared/types'
+
+import { STUDIO_SCHEMA_PROJECTION_VERSION } from '../../shared/types'
+import {
+  BASELINE_FORMAT_VERSION,
+  captureBaseline,
+  computeChanges,
+  hashAnatomyFiles,
+  loadBaseline,
+} from './baseline'
+import { writeJson, writeState } from './store'
 
 const roots: string[] = []
 
@@ -49,3 +59,204 @@ test('hashes current implementation and semantic layer files alongside legacy an
     'views/risk/index.ts',
   ])
 })
+
+const schema = (domain: string): SchemaIR => ({
+  format: 'astrale.dsl',
+  version: 'v1',
+  domain,
+  types: {},
+  interfaces: {},
+  classes: {},
+  imports: {},
+  functions: {},
+})
+
+const canonicalRoot = {
+  format: 'astrale.dsl',
+  version: 'v1',
+  origin: 'notes.example.dev',
+} as const
+
+test('persists a versioned canonical baseline with revision and raw root', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-versioned-baseline-'))
+  roots.push(root)
+  const revision = `sha256:${'b'.repeat(64)}` as const
+
+  captureBaseline(
+    root,
+    { ir: schema('notes.example.dev'), root: canonicalRoot, revision },
+    { source: 'hash' },
+  )
+
+  expect(loadBaseline(root)).toMatchObject({
+    formatVersion: BASELINE_FORMAT_VERSION,
+    revision,
+    root: canonicalRoot,
+    files: { source: 'hash' },
+  })
+})
+
+test('invalidates an unversioned baseline instead of diffing it through a new projection', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-legacy-baseline-'))
+  roots.push(root)
+  writeJson(root, '.cache/baseline/meta.json', { capturedAt: '2026-01-01T00:00:00.000Z' })
+  writeJson(root, '.cache/baseline/ir.json', schema('notes.example.dev'))
+  writeJson(root, '.cache/baseline/files.json', {})
+
+  expect(loadBaseline(root)).toBeNull()
+})
+
+const corruptBaselineCases = [
+  {
+    name: 'missing meta',
+    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/meta.json')),
+  },
+  {
+    name: 'syntactically invalid meta',
+    mutate: (root: string) => writeState(root, '.cache/baseline/meta.json', '{'),
+  },
+  {
+    name: 'structurally invalid meta',
+    mutate: (root: string) =>
+      writeJson(root, '.cache/baseline/meta.json', {
+        formatVersion: BASELINE_FORMAT_VERSION,
+        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
+      }),
+  },
+  {
+    name: 'future baseline format',
+    mutate: (root: string) =>
+      writeJson(root, '.cache/baseline/meta.json', {
+        formatVersion: BASELINE_FORMAT_VERSION + 1,
+        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
+        revision: `sha256:${'d'.repeat(64)}`,
+      }),
+  },
+  {
+    name: 'future projection format',
+    mutate: (root: string) =>
+      writeJson(root, '.cache/baseline/meta.json', {
+        formatVersion: BASELINE_FORMAT_VERSION,
+        projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION + 1,
+        revision: `sha256:${'d'.repeat(64)}`,
+      }),
+  },
+  {
+    name: 'missing IR',
+    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/ir.json')),
+  },
+  {
+    name: 'syntactically invalid IR',
+    mutate: (root: string) => writeState(root, '.cache/baseline/ir.json', '{'),
+  },
+  {
+    name: 'structurally invalid IR',
+    mutate: (root: string) =>
+      writeJson(root, '.cache/baseline/ir.json', {
+        ...schema('notes.example.dev'),
+        classes: { Broken: null },
+      }),
+  },
+  {
+    name: 'missing canonical root',
+    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/schema-root.json')),
+  },
+  {
+    name: 'syntactically invalid canonical root',
+    mutate: (root: string) => writeState(root, '.cache/baseline/schema-root.json', '{'),
+  },
+  {
+    name: 'structurally invalid canonical root',
+    mutate: (root: string) =>
+      writeJson(root, '.cache/baseline/schema-root.json', { canonical: true }),
+  },
+  {
+    name: 'missing file hashes',
+    mutate: (root: string) => rmSync(join(root, '.domain-studio/.cache/baseline/files.json')),
+  },
+  {
+    name: 'syntactically invalid file hashes',
+    mutate: (root: string) => writeState(root, '.cache/baseline/files.json', '{'),
+  },
+  {
+    name: 'structurally invalid file hashes',
+    mutate: (root: string) => writeJson(root, '.cache/baseline/files.json', { source: 42 }),
+  },
+] as const
+
+for (const scenario of corruptBaselineCases) {
+  test(`invalidates a baseline with ${scenario.name}`, () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-corrupt-baseline-'))
+    roots.push(root)
+    const revision = `sha256:${'d'.repeat(64)}` as const
+    captureBaseline(root, { ir: schema('notes.example.dev'), root: canonicalRoot, revision }, {})
+
+    scenario.mutate(root)
+
+    expect(loadBaseline(root)).toBeNull()
+  })
+}
+
+test('keeps a valid current-format legacy baseline without a canonical root or revision', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-legacy-v2-baseline-'))
+  roots.push(root)
+  const legacyIr = { ...schema('notes.example.dev'), version: 'legacy' }
+
+  captureBaseline(root, { ir: legacyIr, root: null, revision: null }, { source: 'hash' })
+
+  expect(loadBaseline(root)).toMatchObject({
+    formatVersion: BASELINE_FORMAT_VERSION,
+    ir: legacyIr,
+    root: null,
+    revision: null,
+    files: { source: 'hash' },
+  })
+})
+
+test('uses equal admitted revisions to suppress projection-only schema churn', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-revision-baseline-'))
+  roots.push(root)
+  const revision = `sha256:${'c'.repeat(64)}` as const
+  captureBaseline(
+    root,
+    {
+      ir: schema('old-projection.example.dev'),
+      root: { ...canonicalRoot, origin: 'old-projection.example.dev' },
+      revision,
+    },
+    {},
+  )
+
+  const changes = computeChanges(
+    root,
+    schema('new-projection.example.dev'),
+    {},
+    {
+      currentRevision: revision,
+      git: { hasGit: false },
+    },
+  )
+  expect(changes.schemaChanges).toEqual([])
+  expect(changes.structuralStatus).toBe('none')
+  expect(changes.baselineRevision).toBe(revision)
+  expect(changes.currentRevision).toBe(revision)
+})
+
+test('uses caller-provided Git enrichment without importing workspace effects', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-enriched-baseline-'))
+  roots.push(root)
+  captureBaseline(root, { ir: schema('notes.example.dev'), root: null, revision: null }, {})
+
+  const changes = computeChanges(
+    root,
+    schema('notes.example.dev'),
+    {},
+    {
+      git: { hasGit: true, diffText: 'diff --git a/schema/index.ts b/schema/index.ts' },
+    },
+  )
+
+  expect(changes.source).toBe('git')
+  expect(changes.hasGit).toBe(true)
+  expect(changes.schemaDiffText).toBe('diff --git a/schema/index.ts b/schema/index.ts')
+})

package/studio/server/state/baseline.ts

@@ -1,26 +1,38 @@
 /**
  * baseline.ts — the PRIMARY change tracker. On first launch we capture a
- * snapshot (the schema IR + a content hash of the "anatomy + schema fileset")
+ * versioned snapshot (canonical revision/root, render IR, and a content hash of
+ * the "anatomy + schema fileset")
  * under `.domain-studio/.cache/baseline/`. Subsequent runs diff the live state
  * against that baseline to compute a ChangeSet. Git (git.ts) only enriches when
  * a real repo is present; the fixtures are not repos, so baseline stands alone.
  *
  * Layout under `.cache/baseline/`:
- *   ir.json     — the captured SchemaIR (or null)
- *   files.json  — { [relpathFromRoot]: sha256 }
- *   meta.json   — { capturedAt }
+ *   ir.json           — the captured render SchemaIR (or null)
+ *   schema-root.json  — the admitted portable V1 root (or null)
+ *   files.json        — { [relpathFromRoot]: sha256 }
+ *   meta.json         — format/projection versions, revision, capturedAt
  */
 import { createHash } from 'node:crypto'
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join, relative, resolve } from 'node:path'
 
-import type { ChangeSet, FileChange, SchemaChange, SchemaIR } from '../../shared/types'
+import type {
+  ChangeSet,
+  FileChange,
+  SchemaChange,
+  SchemaIR,
+  SchemaRevision,
+} from '../../shared/types'
 
-import { classify, diffSchemas } from '../introspect/diff'
-import { detectGit, gitDiff } from './git'
-import { readJson, writeJson } from './store'
+import { isSchemaRevision, STUDIO_SCHEMA_PROJECTION_VERSION } from '../../shared/types'
+import { isCanonicalDomainSchemaV1 } from '../introspect/canonical-schema'
+import { diffSchemas, structuralStatusOf } from '../introspect/diff'
+import { decodeSchemaIR } from '../introspect/schema-ir-json'
+import { asFiniteNumber, asJsonRecord, asStringRecord, parseJson } from '../json'
+import { readState, writeJson } from './store'
 
 const BASE = '.cache/baseline'
+export const BASELINE_FORMAT_VERSION = 2
 
 /** Directories to never descend into when hashing the fileset. */
 const SKIP_DIRS = new Set(['node_modules', '.dist', 'dist', '.domain-studio', '.git'])
@@ -140,30 +152,128 @@ export function hashAnatomyFiles(root: string, schemaDirName: string): Record<st
 }
 
 export interface Baseline {
+  formatVersion: typeof BASELINE_FORMAT_VERSION
+  projectionVersion: number
   ir: SchemaIR | null
+  /** Admitted canonical root only; null for legacy/preview snapshots. */
+  root: unknown | null
+  revision: SchemaRevision | null
   files: Record<string, string>
   capturedAt?: string
 }
 
+export interface BaselineSchemaSnapshot {
+  ir: SchemaIR | null
+  /** Admitted canonical root only; preview roots must be passed as null. */
+  root: unknown | null
+  revision: SchemaRevision | null
+}
+
+interface BaselineMeta {
+  formatVersion: number
+  projectionVersion: number
+  revision: SchemaRevision | null
+  capturedAt?: string
+}
+
+function decodeBaselineMeta(value: unknown): BaselineMeta | undefined {
+  const record = asJsonRecord(value)
+  if (!record) return undefined
+  const formatVersion = asFiniteNumber(record.formatVersion)
+  const projectionVersion = asFiniteNumber(record.projectionVersion)
+  const revision =
+    record.revision === null
+      ? null
+      : isSchemaRevision(record.revision)
+        ? record.revision
+        : undefined
+  const capturedAt = record.capturedAt
+  if (
+    formatVersion === undefined ||
+    projectionVersion === undefined ||
+    revision === undefined ||
+    (capturedAt !== undefined && typeof capturedAt !== 'string')
+  ) {
+    return undefined
+  }
+  return {
+    formatVersion,
+    projectionVersion,
+    revision,
+    ...(capturedAt === undefined ? {} : { capturedAt }),
+  }
+}
+
+function decodeNullableSchemaIR(value: unknown): SchemaIR | null | undefined {
+  return value === null ? null : decodeSchemaIR(value)
+}
+
+function decodeNullableSchemaRoot(value: unknown): unknown | null | undefined {
+  return value === null ? null : isCanonicalDomainSchemaV1(value) ? value : undefined
+}
+
+function readBaselineJson<T>(
+  root: string,
+  subpath: string,
+  decode: (value: unknown) => T | undefined,
+): T | undefined {
+  const raw = readState(root, subpath)
+  if (raw === null) return undefined
+  const parsed = parseJson(raw)
+  return parsed === undefined ? undefined : decode(parsed)
+}
+
 /** Persist a baseline snapshot under `.cache/baseline/`. All writes go through the store. */
 export function captureBaseline(
   root: string,
-  ir: SchemaIR | null,
+  snapshot: BaselineSchemaSnapshot,
   fileHashes: Record<string, string>,
 ): void {
-  writeJson(root, `${BASE}/ir.json`, ir)
+  writeJson(root, `${BASE}/ir.json`, snapshot.ir)
+  writeJson(root, `${BASE}/schema-root.json`, snapshot.root)
   writeJson(root, `${BASE}/files.json`, fileHashes)
-  writeJson(root, `${BASE}/meta.json`, { capturedAt: new Date().toISOString() })
+  writeJson(root, `${BASE}/meta.json`, {
+    formatVersion: BASELINE_FORMAT_VERSION,
+    projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
+    revision: snapshot.revision,
+    capturedAt: new Date().toISOString(),
+  } satisfies BaselineMeta)
 }
 
-/** Load a previously-captured baseline, or null if none exists. Never throws. */
+/**
+ * Load a current baseline. Older/unrecognised formats and render-projection
+ * versions are explicitly invalidated so adapter changes cannot masquerade as
+ * authored schema changes. The lifecycle will seed a replacement snapshot.
+ */
 export function loadBaseline(root: string): Baseline | null {
-  const irPath = join(resolve(root), '.domain-studio', BASE, 'meta.json')
-  if (!existsSync(irPath)) return null
-  const ir = readJson<SchemaIR | null>(root, `${BASE}/ir.json`, null)
-  const files = readJson<Record<string, string>>(root, `${BASE}/files.json`, {})
-  const meta = readJson<{ capturedAt?: string }>(root, `${BASE}/meta.json`, {})
-  return { ir, files, capturedAt: meta.capturedAt }
+  const meta = readBaselineJson(root, `${BASE}/meta.json`, decodeBaselineMeta)
+  if (
+    !meta ||
+    meta.formatVersion !== BASELINE_FORMAT_VERSION ||
+    meta.projectionVersion !== STUDIO_SCHEMA_PROJECTION_VERSION ||
+    !isSchemaRevisionOrNull(meta.revision)
+  ) {
+    return null
+  }
+  const ir = readBaselineJson(root, `${BASE}/ir.json`, decodeNullableSchemaIR)
+  const schemaRoot = readBaselineJson(root, `${BASE}/schema-root.json`, decodeNullableSchemaRoot)
+  const files = readBaselineJson(root, `${BASE}/files.json`, asStringRecord)
+  if (ir === undefined || schemaRoot === undefined || files === undefined) return null
+  if (meta.revision !== null && (schemaRoot === null || ir === null)) return null
+  if (meta.revision === null && schemaRoot !== null) return null
+  return {
+    formatVersion: BASELINE_FORMAT_VERSION,
+    projectionVersion: STUDIO_SCHEMA_PROJECTION_VERSION,
+    ir,
+    root: schemaRoot,
+    revision: meta.revision ?? null,
+    files,
+    capturedAt: meta.capturedAt,
+  }
+}
+
+function isSchemaRevisionOrNull(value: unknown): value is SchemaRevision | null {
+  return value === null || isSchemaRevision(value)
 }
 
 /** Compare two file-hash maps into added/modified/removed FileChange[]. */
@@ -185,9 +295,8 @@ function summarizeSchemaChanges(changes: SchemaChange[]): string {
   if (changes.length === 0) return 'No schema changes.'
   return changes
     .map((c) => {
-      const flag = c.breaking ? 'breaking' : 'additive'
       const detail = c.detail ? `: ${c.detail}` : ''
-      return `${c.kind} ${c.target}${detail} (${flag})`
+      return `${c.kind} ${c.target}${detail}`
     })
     .join('\n')
 }
@@ -202,9 +311,12 @@ export function computeChanges(
   root: string,
   currentIr: SchemaIR | null,
   currentFiles: Record<string, string>,
-  opts: { schemaDirName: string },
+  opts: {
+    currentRevision?: SchemaRevision | null
+    git: { hasGit: boolean; diffText?: string }
+  },
 ): ChangeSet {
-  const { hasGit } = detectGit(root)
+  const { hasGit } = opts.git
   const source: ChangeSet['source'] = hasGit ? 'git' : 'baseline'
   const baseline = loadBaseline(root)
 
@@ -215,17 +327,19 @@ export function computeChanges(
       hasBaseline: false,
       schemaChanges: [],
       fileChanges: [],
-      classification: 'none',
+      structuralStatus: 'none',
+      ...(opts.currentRevision ? { currentRevision: opts.currentRevision } : {}),
     }
   }
 
-  const schemaChanges = diffSchemas(baseline.ir ?? null, currentIr)
-  const classification = classify(schemaChanges)
+  const schemaChanges =
+    baseline.revision && opts.currentRevision === baseline.revision
+      ? []
+      : diffSchemas(baseline.ir ?? null, currentIr)
+  const structuralStatus = structuralStatusOf(schemaChanges)
   const fileChanges = diffFiles(baseline.files ?? {}, currentFiles)
 
-  const schemaDiffText = hasGit
-    ? (gitDiff(root, opts.schemaDirName) ?? undefined)
-    : summarizeSchemaChanges(schemaChanges)
+  const schemaDiffText = hasGit ? opts.git.diffText : summarizeSchemaChanges(schemaChanges)
 
   return {
     source,
@@ -234,7 +348,9 @@ export function computeChanges(
     schemaChanges,
     fileChanges,
     schemaDiffText,
-    classification,
+    structuralStatus,
+    ...(baseline.revision ? { baselineRevision: baseline.revision } : {}),
+    ...(opts.currentRevision ? { currentRevision: opts.currentRevision } : {}),
     baselineCapturedAt: baseline.capturedAt,
   }
 }

package/studio/server/state/comments.test.ts

@@ -3,7 +3,8 @@ import { mkdtempSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { readComments, upsertComment } from './comments'
+import { mergeReply, readComments, upsertComment } from './comments'
+import { writeJson } from './store'
 
 const roots: string[] = []
 
@@ -27,3 +28,67 @@ test('missing comment stores do not share entries across domains', () => {
   ])
   expect(readComments(rootB).comments).toEqual([])
 })
+
+test('normalizes malformed nested comment data and ignores future fields', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-comments-corrupt-'))
+  roots.push(root)
+  writeJson(root, 'comments.json', {
+    schemaVersion: 'render-fingerprint',
+    futureStoreField: { version: 2 },
+    comments: [
+      {
+        id: 'kept',
+        anchors: ['Thing'],
+        anchorRefs: [
+          { ref: 'class.Thing', kind: 'schema', futureAnchorField: true },
+          { ref: 42, kind: 'schema' },
+        ],
+        status: 'open',
+        thread: [
+          {
+            id: 'entry',
+            role: 'author',
+            type: 'text',
+            text: 'A valid question',
+            futureEntryField: true,
+          },
+          { id: 'broken', role: 'nobody', type: 'text', text: 'ignored' },
+        ],
+        createdAt: '2026-08-20T00:00:00.000Z',
+        futureCommentField: true,
+      },
+      { id: 42, thread: [] },
+    ],
+  })
+
+  expect(readComments(root)).toEqual({
+    schemaVersion: 'render-fingerprint',
+    comments: [
+      {
+        id: 'kept',
+        anchors: ['Thing'],
+        anchorRefs: [{ ref: 'class.Thing', kind: 'schema' }],
+        status: 'open',
+        thread: [
+          {
+            id: 'entry',
+            role: 'author',
+            type: 'text',
+            text: 'A valid question',
+          },
+        ],
+        createdAt: '2026-08-20T00:00:00.000Z',
+        kind: 'question',
+      },
+    ],
+  })
+})
+
+test('rejects a syntactically valid machine-state block with the wrong root shape', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-comments-paste-'))
+  roots.push(root)
+
+  expect(() => mergeReply(root, 'render-fingerprint', '```json\n[]\n```')).toThrow(
+    'invalid machine-state json block',
+  )
+})