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

package/studio/server/agent/harness/mock/domain-edit.ts

@@ -1,41 +0,0 @@
-import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-function identifier(text: string, fallback: string): string {
-  const words = text
-    .toLowerCase()
-    .replace(/[^a-z0-9 ]+/g, ' ')
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean)
-    .slice(0, 3)
-  if (words.length === 0) return fallback
-  return words
-    .map((word, index) => (index === 0 ? word : word[0].toUpperCase() + word.slice(1)))
-    .join('')
-}
-
-/** Apply the deterministic schema edit used by the local mock harness. */
-export function applyMockDomainEdit(
-  root: string,
-  instruction: string,
-): { file: string; prop: string } | null {
-  const schemaDir = join(root, 'schema')
-  if (!existsSync(schemaDir)) return null
-  const files = readdirSync(schemaDir).filter((file) => file.endsWith('.ts') && file !== 'index.ts')
-  const propName = identifier(instruction, 'agentNote')
-  for (const file of files) {
-    const absolute = join(schemaDir, file)
-    const source = readFileSync(absolute, 'utf8')
-    const props = source.indexOf('props: {')
-    if (props < 0) continue
-    let prop = propName
-    let suffix = 2
-    while (new RegExp(`\\b${prop}\\b\\s*:`).test(source)) prop = `${propName}${suffix++}`
-    const insertAt = props + 'props: {'.length
-    const line = `\n    /** Added by the agent in response to a studio comment. */\n    ${prop}: z.string().optional(),`
-    writeFileSync(absolute, source.slice(0, insertAt) + line + source.slice(insertAt))
-    return { file: `schema/${file}`, prop }
-  }
-  return null
-}

package/studio/server/agent/harness/process.test.ts

@@ -1,46 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { captureCommand } from './process'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function hangingCommand(root: string): string {
-  const file = join(root, 'hang')
-  writeFileSync(file, '#!/usr/bin/env bun\nsetInterval(() => {}, 1000)\n')
-  chmodSync(file, 0o755)
-  return file
-}
-
-test('bounds hanging probes with a timeout', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-process-timeout-'))
-  roots.push(root)
-  const result = await captureCommand(hangingCommand(root), [], root, { timeoutMs: 30 })
-  expect(result).toMatchObject({
-    code: -1,
-    timedOut: true,
-    stderr: 'command timed out after 30ms',
-  })
-})
-
-test('lets setup cancellation abort an in-flight probe', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-process-abort-'))
-  roots.push(root)
-  const controller = new AbortController()
-  const pending = captureCommand(hangingCommand(root), [], root, {
-    signal: controller.signal,
-    timeoutMs: 5_000,
-  })
-  controller.abort()
-  expect(await pending).toMatchObject({
-    code: -1,
-    aborted: true,
-    stderr: 'canceled',
-  })
-})

package/studio/server/agent/harness/process.ts

@@ -1,104 +0,0 @@
-import { spawn } from 'node:child_process'
-
-export interface CapturedCommand {
-  code: number
-  stdout: string
-  stderr: string
-  aborted?: boolean
-  timedOut?: boolean
-}
-
-export interface CaptureOptions {
-  env?: Record<string, string>
-  signal?: AbortSignal
-  timeoutMs?: number
-}
-
-/** Merge overrides into the spawned harness only. */
-export function childEnvironment(extra?: Record<string, string>): NodeJS.ProcessEnv | undefined {
-  return extra && Object.keys(extra).length ? { ...process.env, ...extra } : undefined
-}
-
-/** Capture a short-lived harness command such as version or loadout discovery. */
-export function captureCommand(
-  bin: string,
-  args: string[],
-  cwd: string,
-  options: CaptureOptions = {},
-): Promise<CapturedCommand> {
-  return new Promise((resolve) => {
-    let stdout = ''
-    let stderr = ''
-    let settled = false
-    let timer: ReturnType<typeof setTimeout> | undefined
-    let onAbort = () => {}
-    const finish = (result: CapturedCommand) => {
-      if (settled) return
-      settled = true
-      if (timer) clearTimeout(timer)
-      options.signal?.removeEventListener('abort', onAbort)
-      resolve(result)
-    }
-    if (options.signal?.aborted) {
-      finish({ code: -1, stdout, stderr: 'canceled', aborted: true })
-      return
-    }
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawn(bin, args, {
-        cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: childEnvironment(options.env),
-        detached: process.platform !== 'win32',
-      })
-    } catch (error) {
-      finish({ code: -1, stdout, stderr: String(error) })
-      return
-    }
-    onAbort = () => {
-      terminateProcessTree(child, 'SIGKILL')
-      finish({ code: -1, stdout, stderr: 'canceled', aborted: true })
-    }
-    options.signal?.addEventListener('abort', onAbort, { once: true })
-    const timeoutMs = options.timeoutMs ?? 15_000
-    if (timeoutMs > 0) {
-      timer = setTimeout(() => {
-        terminateProcessTree(child, 'SIGKILL')
-        finish({
-          code: -1,
-          stdout,
-          stderr: `command timed out after ${timeoutMs}ms`,
-          timedOut: true,
-        })
-      }, timeoutMs)
-      timer.unref?.()
-    }
-    child.stdout?.setEncoding('utf8')
-    child.stderr?.setEncoding('utf8')
-    child.stdout?.on('data', (chunk: string) => {
-      stdout += chunk
-    })
-    child.stderr?.on('data', (chunk: string) => {
-      stderr += chunk
-    })
-    child.on('error', (error) => finish({ code: -1, stdout, stderr: error.message }))
-    child.on('close', (code) => finish({ code: code ?? -1, stdout, stderr }))
-  })
-}
-
-/** Terminate the whole harness process group so child commands cannot leak. */
-export function terminateProcessTree(
-  child: ReturnType<typeof spawn>,
-  signal: NodeJS.Signals = 'SIGTERM',
-): void {
-  try {
-    if (process.platform !== 'win32' && child.pid) process.kill(-child.pid, signal)
-    else child.kill(signal)
-  } catch {
-    try {
-      child.kill(signal)
-    } catch {
-      /* already gone */
-    }
-  }
-}

package/studio/server/agent/harness/registry.ts

@@ -1,37 +0,0 @@
-import type { AgentHarness } from './adapter'
-
-/**
- * Register the concrete local harness adapters and reuse their process-level
- * caches across domains.
- */
-import { ClaudeCodeHarness } from './claude/adapter'
-import { CodexHarness } from './codex/adapter'
-import { MockHarness } from './mock/adapter'
-
-const harnesses: Record<string, () => AgentHarness> = {
-  claude: () => new ClaudeCodeHarness(),
-  codex: () => new CodexHarness(),
-  mock: () => new MockHarness(),
-}
-
-const instances = new Map<string, AgentHarness>()
-
-export function hasHarness(id: string): boolean {
-  return !!harnesses[id]
-}
-
-export function getHarnessById(id: string): AgentHarness {
-  let harness = instances.get(id)
-  if (!harness) {
-    harness = (harnesses[id] ?? harnesses.claude)()
-    instances.set(id, harness)
-  }
-  return harness
-}
-
-/** All registered harnesses (id + label) — for the (currently locked) UI selector. */
-export function listHarnesses(selected?: string): { id: string; label: string }[] {
-  return Object.entries(harnesses)
-    .filter(([id]) => id !== 'mock' || id === selected)
-    .map(([id, make]) => ({ id, label: make().label }))
-}

package/studio/server/agent/harness/selection.test.ts

@@ -1,75 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { updateSettings } from '../../state/settings'
-import {
-  getHarness,
-  getHarnessSelection,
-  resolveHarnessConfiguration,
-  setHarnessSelection,
-} from './selection'
-
-const roots: string[] = []
-const previous = process.env.DOMAIN_STUDIO_HARNESS
-
-afterEach(() => {
-  if (previous === undefined) delete process.env.DOMAIN_STUDIO_HARNESS
-  else process.env.DOMAIN_STUDIO_HARNESS = previous
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('persists a per-domain Codex selection', () => {
-  delete process.env.DOMAIN_STUDIO_HARNESS
-  const rootA = mkdtempSync(join(tmpdir(), 'studio-harness-a-'))
-  const rootB = mkdtempSync(join(tmpdir(), 'studio-harness-b-'))
-  roots.push(rootA, rootB)
-  expect(getHarnessSelection(rootA)).toMatchObject({ id: 'claude', source: 'default' })
-  expect(getHarnessSelection(rootB)).toMatchObject({ id: 'claude', source: 'default' })
-
-  setHarnessSelection(rootA, 'codex')
-  expect(getHarnessSelection(rootA)).toEqual({
-    id: 'codex',
-    locked: false,
-    source: 'domain',
-  })
-  expect(getHarness(rootA).id).toBe('codex')
-  expect(getHarnessSelection(rootB)).toEqual({
-    id: 'claude',
-    locked: false,
-    source: 'default',
-  })
-  expect(getHarness(rootB).id).toBe('claude')
-})
-
-test('environment selection locks the GUI override', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-'))
-  roots.push(root)
-  process.env.DOMAIN_STUDIO_HARNESS = 'codex'
-  expect(getHarnessSelection(root)).toEqual({
-    id: 'codex',
-    locked: true,
-    source: 'environment',
-  })
-  expect(() => setHarnessSelection(root, 'claude')).toThrow('locked to codex')
-})
-
-test('resolves persisted Claude max and Ultracode effort modes', async () => {
-  delete process.env.DOMAIN_STUDIO_HARNESS
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-effort-'))
-  roots.push(root)
-  updateSettings(root, { agentEffort: 'max' })
-
-  const resolved = await resolveHarnessConfiguration(root)
-  expect(resolved.ok).toBe(true)
-  if (!resolved.ok) return
-  expect(resolved.configuration.harness.id).toBe('claude')
-  expect(resolved.configuration.effort).toBe('max')
-
-  updateSettings(root, { agentEffort: 'ultracode' })
-  const ultracode = await resolveHarnessConfiguration(root)
-  expect(ultracode.ok).toBe(true)
-  if (!ultracode.ok) return
-  expect(ultracode.configuration.effort).toBe('ultracode')
-})

package/studio/server/agent/harness/selection.ts

@@ -1,85 +0,0 @@
-import type { AgentEffort, StudioSettings } from '../../../shared/types'
-import type { AgentHarness } from './adapter'
-
-import { effectiveAgentEffort } from '../../../shared/agent-effort'
-import { asJsonRecord, asString } from '../../json'
-import { readSettings } from '../../state/settings'
-import { readJson, writeJson } from '../../state/store'
-import { resolveHarnessEnv } from './gateway/config'
-import { getHarnessById, hasHarness } from './registry'
-
-const SELECTION_FILE = '.cache/agent/harness.json'
-
-export interface HarnessSelection {
-  id: string
-  locked: boolean
-  source: 'environment' | 'domain' | 'default'
-}
-
-export interface HarnessConfiguration {
-  harness: AgentHarness
-  settings: StudioSettings
-  model?: string
-  effort?: AgentEffort
-  env: Record<string, string>
-}
-
-export type HarnessConfigurationResult =
-  | { ok: true; configuration: HarnessConfiguration }
-  | { ok: false; error: string }
-
-function decodeStoredSelection(value: unknown): { id?: string } | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  const id = asString(record.id)
-  return id === undefined ? {} : { id }
-}
-
-export function getHarnessSelection(root: string): HarnessSelection {
-  const environment = process.env.DOMAIN_STUDIO_HARNESS?.trim().toLowerCase()
-  if (environment && hasHarness(environment))
-    return { id: environment, locked: true, source: 'environment' }
-  const stored = readJson(root, SELECTION_FILE, decodeStoredSelection, {})
-  const id = stored.id?.toLowerCase()
-  if (id && hasHarness(id)) return { id, locked: false, source: 'domain' }
-  return { id: 'claude', locked: false, source: 'default' }
-}
-
-export function setHarnessSelection(root: string, id: string): HarnessSelection {
-  const normalized = id.trim().toLowerCase()
-  if (!hasHarness(normalized) || normalized === 'mock') throw new Error(`unknown harness: ${id}`)
-  const current = getHarnessSelection(root)
-  if (current.locked)
-    throw new Error(`the harness is locked to ${current.id} by DOMAIN_STUDIO_HARNESS / --harness`)
-  writeJson(root, SELECTION_FILE, { id: normalized })
-  return { id: normalized, locked: false, source: 'domain' }
-}
-
-export function getHarness(root: string): AgentHarness {
-  return getHarnessById(getHarnessSelection(root).id)
-}
-
-/** Resolve the selected adapter and every per-domain option used to invoke it. */
-export async function resolveHarnessConfiguration(
-  root: string,
-  harness = getHarness(root),
-): Promise<HarnessConfigurationResult> {
-  const settings = readSettings(root)
-  const model = settings.agentModels[harness.id]?.trim() || undefined
-  const effort = effectiveAgentEffort(harness.capabilities.effortLevels, settings.agentEffort)
-  const environment =
-    harness.capabilities.gateway === 'anthropic'
-      ? await resolveHarnessEnv(root)
-      : { ok: true as const, env: {} }
-  if (!environment.ok) return { ok: false, error: environment.error }
-  return {
-    ok: true,
-    configuration: {
-      harness,
-      settings,
-      model,
-      effort,
-      env: environment.env,
-    },
-  }
-}

package/studio/server/agent/harness/skills.test.ts

@@ -1,95 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { scanClaudeSkills } from './claude/skills'
-import { scanCodexSkills } from './codex/skills'
-import { readSkillContent } from './skills'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function skill(dir: string, command: string, frontmatter: string): string {
-  const target = join(dir, command)
-  mkdirSync(target, { recursive: true })
-  const path = join(target, 'SKILL.md')
-  writeFileSync(path, `---\n${frontmatter}\n---\n\nInstructions for ${command}.\n`)
-  return path
-}
-
-test('Codex skill discovery prefers the nearest project skill and preserves disabled plugins', () => {
-  const parent = mkdtempSync(join(tmpdir(), 'studio-skills-'))
-  roots.push(parent)
-  const root = join(parent, 'domain')
-  mkdirSync(root)
-  const parentSkill = skill(
-    join(parent, '.agents', 'skills'),
-    'project-check',
-    'name: Parent\ndescription: parent',
-  )
-  const nearestSkill = skill(
-    join(root, '.agents', 'skills'),
-    'project-check',
-    `name: Nearest
-description: >
-  First line of a folded description.
-  Second line stays visible.`,
-  )
-  const pluginRoot = join(parent, 'plugin')
-  const pluginSkill = skill(
-    join(pluginRoot, 'skills'),
-    'review',
-    'name: Review\ndescription: Disabled review tool',
-  )
-
-  const found = scanCodexSkills(root, [{ name: 'demo', path: pluginRoot, enabled: false }])
-  const project = found.find((item) => item.command === 'project-check')!
-  const plugin = found.find((item) => item.command === 'demo:review')!
-
-  expect(project).toMatchObject({
-    name: 'Nearest',
-    description: 'First line of a folded description. Second line stays visible.',
-    source: 'project',
-    loaded: true,
-    path: nearestSkill,
-  })
-  expect(plugin).toMatchObject({
-    name: 'Review',
-    source: 'plugin',
-    plugin: 'demo',
-    loaded: false,
-    path: pluginSkill,
-  })
-  expect(readSkillContent(found, 'demo:review')).toEqual({
-    command: 'demo:review',
-    content: `---\nname: Review\ndescription: Disabled review tool\n---\n\nInstructions for review.\n`,
-    path: pluginSkill,
-  })
-})
-
-test('Claude skill discovery owns Claude project precedence without leaking Codex policy', () => {
-  const parent = mkdtempSync(join(tmpdir(), 'studio-claude-skills-'))
-  roots.push(parent)
-  const root = join(parent, 'domain')
-  mkdirSync(root)
-  skill(join(root, '.agents', 'skills'), 'review', 'name: Shared\ndescription: shared fallback')
-  const claudeSkill = skill(
-    join(root, '.claude', 'skills'),
-    'review',
-    'name: Claude Review\ndescription: Claude-native project skill',
-  )
-
-  const reviews = scanClaudeSkills(root).filter((item) => item.command === 'review')
-  expect(reviews).toEqual([
-    expect.objectContaining({
-      name: 'Claude Review',
-      source: 'project',
-      loaded: true,
-      path: claudeSkill,
-    }),
-  ])
-})

package/studio/server/agent/harness/skills.ts

@@ -1,100 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { parse as parseYaml } from 'yaml'
-
-import type { LoadoutSkill } from '../../../shared/types'
-
-function readSkillMeta(skillMd: string): { name?: string; description?: string } {
-  let text: string
-  try {
-    text = readFileSync(skillMd, 'utf8')
-  } catch {
-    return {}
-  }
-  if (!text.startsWith('---')) return {}
-  const end = text.indexOf('\n---', 3)
-  const fm = end >= 0 ? text.slice(3, end) : text.slice(3)
-  try {
-    const meta = parseYaml(fm) as { name?: unknown; description?: unknown } | null
-    return {
-      name: typeof meta?.name === 'string' ? meta.name : undefined,
-      description: typeof meta?.description === 'string' ? meta.description.trim() : undefined,
-    }
-  } catch {
-    return {}
-  }
-}
-
-export function scanSkillDir(
-  dir: string,
-  source: LoadoutSkill['source'],
-  plugin: string | undefined,
-  commandPrefix: string,
-  loaded: boolean,
-  out: LoadoutSkill[],
-  seen: Set<string>,
-): void {
-  if (!existsSync(dir)) return
-  let entries: string[]
-  try {
-    entries = readdirSync(dir)
-  } catch {
-    return
-  }
-  for (const entry of entries) {
-    const skillMd = join(dir, entry, 'SKILL.md')
-    if (!existsSync(skillMd)) continue
-    const command = commandPrefix + entry
-    if (seen.has(command)) continue
-    seen.add(command)
-    const meta = readSkillMeta(skillMd)
-    out.push({
-      command,
-      name: meta.name || entry,
-      description: meta.description,
-      source,
-      plugin,
-      loaded,
-      path: skillMd,
-    })
-  }
-}
-
-export function scanAncestors(
-  root: string,
-  dirs: string[],
-  out: LoadoutSkill[],
-  seen: Set<string>,
-): void {
-  const home = homedir()
-  let current = root
-  for (let i = 0; i < 12 && current !== home; i++) {
-    for (const dir of dirs)
-      scanSkillDir(join(current, dir), 'project', undefined, '', true, out, seen)
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-}
-
-export function readSkillContent(
-  skills: LoadoutSkill[],
-  command: string,
-): { command: string; content: string; path: string } | null {
-  const skill = skills.find((candidate) => candidate.command === command)
-  if (!skill?.path) return null
-  try {
-    return { command, content: readFileSync(skill.path, 'utf8'), path: skill.path }
-  } catch {
-    return null
-  }
-}
-
-export function reconcileLoadedSkills(
-  installed: LoadoutSkill[],
-  loadedCommands: string[],
-): LoadoutSkill[] {
-  const loaded = new Set(loadedCommands)
-  return installed.map((skill) => ({ ...skill, loaded: loaded.has(skill.command) }))
-}

package/studio/server/agent/layout.test.ts

@@ -1,95 +0,0 @@
-import { expect, test } from 'bun:test'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { dirname, join, relative, resolve } from 'node:path'
-
-const ROOT = resolve(import.meta.dir)
-
-function sourceFiles(dir = ROOT): string[] {
-  return readdirSync(dir)
-    .flatMap((entry) => {
-      const path = join(dir, entry)
-      if (statSync(path).isDirectory()) return sourceFiles(path)
-      return path.endsWith('.ts') && !path.endsWith('.test.ts') ? [path] : []
-    })
-    .sort()
-}
-
-function imports(file: string): string[] {
-  const source = readFileSync(file, 'utf8')
-  const found: string[] = []
-  const pattern = /(?:from\s+|import\s*\()\s*['"]([^'"]+)['"]/g
-  for (const match of source.matchAll(pattern)) {
-    const specifier = match[1]
-    if (!specifier.startsWith('.')) continue
-    const target = resolve(dirname(file), specifier)
-    const candidate = target.endsWith('.ts') ? target : `${target}.ts`
-    if (candidate.startsWith(ROOT)) found.push(candidate)
-  }
-  return found
-}
-
-function agentPath(file: string): string {
-  return relative(ROOT, file).replaceAll('\\', '/')
-}
-
-test('agent concepts form an acyclic dependency graph', () => {
-  const graph = new Map(sourceFiles().map((file) => [file, imports(file)]))
-  const visiting = new Set<string>()
-  const visited = new Set<string>()
-  const stack: string[] = []
-  const cycles: string[][] = []
-
-  const visit = (file: string) => {
-    if (visiting.has(file)) {
-      const start = stack.indexOf(file)
-      cycles.push([...stack.slice(start), file].map(agentPath))
-      return
-    }
-    if (visited.has(file)) return
-    visiting.add(file)
-    stack.push(file)
-    for (const dependency of graph.get(file) ?? []) if (graph.has(dependency)) visit(dependency)
-    stack.pop()
-    visiting.delete(file)
-    visited.add(file)
-  }
-
-  for (const file of graph.keys()) visit(file)
-  expect(cycles).toEqual([])
-})
-
-test('leaf concepts do not depend on orchestration or HTTP ownership', () => {
-  const violations: string[] = []
-  for (const file of sourceFiles()) {
-    const source = agentPath(file)
-    for (const dependency of imports(file).map(agentPath)) {
-      if (
-        source.startsWith('harness/') &&
-        (dependency.startsWith('run/') ||
-          dependency.startsWith('bridge/') ||
-          dependency.startsWith('prompts/') ||
-          dependency === 'routes.ts')
-      )
-        violations.push(`${source} -> ${dependency}`)
-      if (
-        source.startsWith('prompts/') &&
-        (dependency.startsWith('run/') ||
-          dependency.startsWith('bridge/') ||
-          dependency.startsWith('harness/') ||
-          dependency === 'routes.ts')
-      )
-        violations.push(`${source} -> ${dependency}`)
-      if (
-        source.startsWith('bridge/') &&
-        (dependency.startsWith('run/') ||
-          dependency.startsWith('prompts/') ||
-          dependency.startsWith('harness/claude/') ||
-          dependency.startsWith('harness/codex/') ||
-          dependency.startsWith('harness/mock/') ||
-          dependency === 'routes.ts')
-      )
-        violations.push(`${source} -> ${dependency}`)
-    }
-  }
-  expect(violations).toEqual([])
-})

package/studio/server/agent/notify.ts

@@ -1,12 +0,0 @@
-import type { StudioEvent } from '../../shared/types'
-
-export type Notify = (event: StudioEvent) => void
-
-/** Keep optional UI delivery failures from corrupting committed agent state. */
-export function emitStudioEvent(notify: Notify, event: StudioEvent): void {
-  try {
-    notify(event)
-  } catch {
-    /* the persisted state remains authoritative; clients can refetch */
-  }
-}