@fugood/bricks-ctor 2.25.0-beta.5 → 2.25.0-beta.51

package/tools/mcp-tools/__tests__/entry-editing.test.js

@@ -0,0 +1,866 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+jest.mock('oxfmt', () => ({
+  format: async (_file, source) => ({ code: source, errors: [] }),
+}))
+
+import { register, __test__ } from '../entry-editing'
+
+const writeFixtureProject = async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), 'bricks-entry-editing-'))
+  const subspaceDir = path.join(projectDir, 'subspaces/subspace-0')
+  await mkdir(subspaceDir, { recursive: true })
+  await writeFile(
+    path.join(subspaceDir, 'data.ts'),
+    `import type { Data } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+
+export const dMessage: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'message',
+  title: 'Message',
+  type: 'string',
+  schema: {},
+  events: {},
+  value: 'Hello',
+}
+
+export const dCount: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'count',
+  title: 'Count',
+  type: 'number',
+  schema: {},
+  events: {},
+  value: 0,
+}
+`,
+  )
+  await writeFile(
+    path.join(subspaceDir, 'bricks.ts'),
+    `import type { BrickText } from 'bricks-ctor'
+import { linkData, makeId } from 'bricks-ctor'
+import * as data from './data'
+
+export const bWelcome: BrickText = {
+  __typename: 'Brick',
+  id: makeId('brick'),
+  alias: 'welcome',
+  templateKey: 'BRICK_TEXT',
+  title: 'Welcome',
+  property: {
+    text: 'Hello',
+    source: linkData(() => data.dMessage),
+  },
+  events: {},
+  outlets: {
+    response: () => data.dMessage,
+  },
+  animation: {},
+  switches: [
+    {
+      id: makeId('switch'),
+      title: 'When message matches',
+      conds: [
+        {
+          method: '==',
+          cond: {
+            __typename: 'SwitchCondData',
+            data: () => data.dMessage,
+            value: 'Hello',
+          },
+        },
+      ],
+      property: {},
+      events: {},
+      outlets: {},
+      animation: {},
+    },
+  ],
+}
+
+export const bButton: BrickText = {
+  __typename: 'Brick',
+  id: makeId('brick'),
+  alias: 'button',
+  templateKey: 'BRICK_TEXT',
+  title: 'Button',
+  property: {},
+  events: {},
+  outlets: {},
+  animation: {},
+  switches: [],
+}
+`,
+  )
+  await writeFile(
+    path.join(subspaceDir, 'canvases.ts'),
+    `import type { Canvas } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+
+export const cMain: Canvas = {
+  __typename: 'Canvas',
+  id: makeId('canvas'),
+  alias: 'main',
+  title: 'Main',
+  property: {},
+  events: {},
+  switches: [],
+  items: [],
+}
+`,
+  )
+  await writeFile(
+    path.join(subspaceDir, 'generators.ts'),
+    `import type { GeneratorHTTP } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+
+export const gApi: GeneratorHTTP = {
+  __typename: 'Generator',
+  id: makeId('generator'),
+  alias: 'api',
+  templateKey: 'GENERATOR_HTTP',
+  title: 'API',
+  property: {},
+  events: {},
+  outlets: {},
+  switches: [],
+}
+`,
+  )
+  await writeFile(
+    path.join(subspaceDir, 'animations.ts'),
+    `import type { Animation } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+
+export const aFade: Animation = {
+  __typename: 'Animation',
+  id: makeId('animation'),
+  alias: 'fade',
+  title: 'Fade',
+  runType: 'once',
+  property: 'opacity',
+  config: {
+    __type: 'AnimationTimingConfig',
+    toValue: 1,
+    duration: 300,
+    easing: '',
+    delay: 0,
+    isInteraction: true,
+  },
+}
+`,
+  )
+  return projectDir
+}
+
+const readProjectFile = (projectDir, relPath) => readFile(path.join(projectDir, relPath), 'utf8')
+
+const readAudit = async (projectDir) =>
+  (await readFile(path.join(projectDir, '.bricks/edits.jsonl'), 'utf8'))
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line))
+
+describe('ctor MCP entry-editing tools', () => {
+  let projectDir
+
+  afterEach(async () => {
+    if (projectDir) await rm(projectDir, { recursive: true, force: true })
+    projectDir = null
+  })
+
+  test('registers the six entry-editing MCP tools', () => {
+    const calls = []
+    register(
+      {
+        tool(...args) {
+          calls.push(args)
+        },
+      },
+      '/tmp/project',
+    )
+
+    expect(calls.map(([name]) => name)).toEqual([
+      'edit_entry',
+      'edit_events',
+      'edit_canvas_items',
+      'edit_switches',
+      'new_entry',
+      'remove_entry',
+    ])
+    expect(
+      calls.every(([, description]) => typeof description === 'string' && description.length > 20),
+    ).toBe(true)
+    const editEntrySchema = calls[0][2]
+    expect(editEntrySchema.file.description).toContain('Project-relative')
+    expect(editEntrySchema.set.description).toContain('dotted paths')
+    expect(editEntrySchema.set.description).toContain('{ link')
+  })
+
+  test('edit_entry updates nested facets and resolves link/ref values', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bWelcome',
+      set: {
+        title: 'Updated Welcome',
+        'property.text': 'Hi',
+        'property.count': { link: 'count' },
+        'outlets.count': { ref: 'count' },
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/title: ['"]Updated Welcome['"]/)
+    expect(source).toMatch(/text: ['"]Hi['"]/)
+    expect(source).toContain('count: linkData(() => data.dCount)')
+    expect(source).toContain('count: () => data.dCount')
+    const audit = await readAudit(projectDir)
+    expect(audit.at(-1).summary).toContain('edited bWelcome')
+    const gitignore = await readProjectFile(projectDir, '.gitignore')
+    expect(gitignore).toContain('.bricks/edits.jsonl')
+  })
+
+  test('edit_entry removes the correct elements when unsetting multiple array indices', async () => {
+    // Regression: unset paths were applied in input order, but unsetPathValue
+    // splices arrays in place — removing items[1] shifts items[2] down, so the
+    // second unset hit the wrong element (or no-op'd). Both requested elements
+    // must be removed regardless of order.
+    projectDir = await writeFixtureProject()
+    const target = { file: 'subspaces/subspace-0/bricks.ts', entry: 'bButton', verify: false }
+
+    const built = await __test__.editEntry(projectDir, {
+      ...target,
+      set: {
+        'property.list[0]': 'ITEM_A',
+        'property.list[1]': 'ITEM_B',
+        'property.list[2]': 'ITEM_C',
+      },
+    })
+    expect(built.outcome).toBe('ok')
+
+    const unset = await __test__.editEntry(projectDir, {
+      ...target,
+      unset: ['property.list[1]', 'property.list[2]'],
+    })
+    expect(unset.outcome).toBe('ok')
+
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toContain('ITEM_A')
+    expect(source).not.toContain('ITEM_B') // items[1] removed
+    expect(source).not.toContain('ITEM_C') // items[2] removed (survived before the fix)
+  })
+
+  test('edit_events adds a typed system event action', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editEvents(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      event: 'onPress',
+      op: 'add',
+      action: {
+        handler: 'system',
+        name: 'CHANGE_CANVAS',
+        params: {
+          canvasId: { ref: 'main' },
+        },
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toContain('SystemActionChangeCanvas')
+    expect(source).toMatch(/handler: ['"]system['"]/)
+    expect(source).toMatch(/__actionName: ['"]CHANGE_CANVAS['"]/)
+    expect(source).toContain('value: () => canvases.cMain')
+    expect(source).toMatch(/import \* as canvases from ['"]\.\/canvases['"]/)
+  })
+
+  test('edit_canvas_items places a brick on a canvas', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editCanvasItems(projectDir, {
+      file: 'subspaces/subspace-0/canvases.ts',
+      entry: 'cMain',
+      op: 'add',
+      item: {
+        ref: 'welcome',
+        frame: { x: 1, y: 2, width: 10, height: 5 },
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/canvases.ts')
+    expect(source).toMatch(/import \* as bricks from ['"]\.\/bricks['"]/)
+    expect(source).toContain('item: () => bricks.bWelcome')
+    expect(source).toContain('width: 10')
+  })
+
+  test('edit_switches adds a switch with a data condition', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editSwitches(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      op: 'add',
+      switch: {
+        title: 'Count positive',
+        conds: [
+          {
+            method: '>',
+            cond: {
+              type: 'property_bank',
+              ref: 'count',
+              value: 0,
+            },
+          },
+        ],
+        override: { property: true },
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/title: ['"]Count positive['"]/)
+    expect(source).toMatch(/__typename: ['"]SwitchCondData['"]/)
+    expect(source).toContain('data: () => data.dCount')
+    expect(source).toMatch(/override:\s*{\s*property: true\s*}/)
+    expect((source.match(/id:\s*makeId\(['"]switch['"]\)/g) || []).length).toBe(2)
+  })
+
+  test('new_entry creates a standard skeleton and applies initial values', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.newEntry(projectDir, {
+      file: 'subspaces/subspace-0/generators.ts',
+      type: 'GeneratorHTTP',
+      templateKey: 'GENERATOR_HTTP',
+      alias: 'weatherApi',
+      title: 'Weather API',
+      set: {
+        'property.url': 'https://api.example.test',
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    expect(result.entry).toBe('weatherApi')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/generators.ts')
+    expect(source).toContain('export const weatherApi: GeneratorHTTP =')
+    expect(source).toMatch(/id: makeId\(['"]generator['"], ['"]weatherApi['"]\)/)
+    expect(source).toMatch(/templateKey: ['"]GENERATOR_HTTP['"]/)
+    expect(source).toMatch(/url: ['"]https:\/\/api\.example\.test['"]/)
+  })
+
+  test('new_entry can be retried with the same alias in one server session', async () => {
+    projectDir = await writeFixtureProject()
+
+    const first = await __test__.newEntry(projectDir, {
+      file: 'subspaces/subspace-0/generators.ts',
+      type: 'GeneratorHTTP',
+      templateKey: 'GENERATOR_HTTP',
+      alias: 'retryApi',
+      verify: false,
+    })
+    const second = await __test__.newEntry(projectDir, {
+      file: 'subspaces/subspace-0/generators.ts',
+      type: 'GeneratorHTTP',
+      templateKey: 'GENERATOR_HTTP',
+      alias: 'retryApi',
+      verify: false,
+    })
+
+    expect(first.outcome).toBe('ok')
+    expect(second.outcome).toBe('ok')
+    expect(second.entry).toBe('retryApi1')
+    expect(first.id).toBeUndefined()
+    expect(second.id).toBeUndefined()
+    // First use of the alias gets the order-stable aliased id; the duplicate falls
+    // back to the counter form so compile does not hit a makeId alias collision.
+    expect(first.idExpression).toBe("makeId('generator', 'retryApi')")
+    expect(second.idExpression).toBe("makeId('generator')")
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/generators.ts')
+    expect((source.match(/id:\s*makeId\(['"]generator['"]\)/g) || []).length).toBe(2)
+    expect(source).toMatch(/makeId\(['"]generator['"], ['"]retryApi['"]\)/)
+  })
+
+  test('entry targeting falls back to entity aliases', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'welcome',
+      set: { title: 'Aliased Edit' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    expect(result.entry).toBe('bWelcome')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/title: ['"]Aliased Edit['"]/)
+  })
+
+  test('parse failures tell the caller to use file tools', async () => {
+    projectDir = await writeFixtureProject()
+    await writeFile(path.join(projectDir, 'subspaces/subspace-0/bricks.ts'), 'export const =')
+
+    const result = await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bWelcome',
+      set: { title: 'Nope' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.isError).toBe(true)
+    expect(result.error.message).toContain('Edit this file directly')
+  })
+
+  test('edit_events accepts the compiled EventAction shape, supports move, and casts stay editable', async () => {
+    projectDir = await writeFixtureProject()
+    const target = {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      event: 'onPress',
+      verify: false,
+    }
+
+    const added = await __test__.editEvents(projectDir, {
+      ...target,
+      op: 'add',
+      action: { handler: 'system', name: 'CHANGE_CANVAS', params: { canvasId: { ref: 'main' } } },
+    })
+    expect(added.outcome).toBe('ok')
+
+    // Replace using the compiled source shape ({ handler, action: {...}, waitAsync }).
+    const replaced = await __test__.editEvents(projectDir, {
+      ...target,
+      op: 'replace',
+      index: 0,
+      action: {
+        handler: 'system',
+        action: {
+          __actionName: 'PROPERTY_BANK',
+          parent: 'System',
+          name: 'PROPERTY_BANK',
+          dataParams: [{ input: { ref: 'count' }, value: '1' }],
+        },
+        waitAsync: false,
+      },
+    })
+    expect(replaced.outcome).toBe('ok')
+    let source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/__actionName: ['"]PROPERTY_BANK['"]/)
+    expect(source).toContain('input: () => data.dCount')
+
+    // Deep edit_entry paths see through the `as SystemAction...` cast.
+    const deepEdit = await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      set: { 'events.onPress[0].action.dataParams[0].value': '2' },
+      verify: false,
+    })
+    expect(deepEdit.outcome).toBe('ok')
+    source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/value: ['"]2['"]/)
+    expect(source).toContain('as SystemActionPropertyBank')
+
+    const addedSecond = await __test__.editEvents(projectDir, {
+      ...target,
+      op: 'add',
+      action: { handler: 'system', name: 'CHANGE_CANVAS', params: { canvasId: { ref: 'main' } } },
+    })
+    expect(addedSecond.outcome).toBe('ok')
+
+    const moved = await __test__.editEvents(projectDir, { ...target, op: 'move', index: 1, to: 0 })
+    expect(moved.outcome).toBe('ok')
+    source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source.indexOf('CHANGE_CANVAS')).toBeLessThan(source.indexOf('PROPERTY_BANK'))
+  })
+
+  test('edit_canvas_items validates frames and accepts a top-level frame on add', async () => {
+    projectDir = await writeFixtureProject()
+    const target = { file: 'subspaces/subspace-0/canvases.ts', entry: 'cMain', verify: false }
+
+    const missingFrame = await __test__.editCanvasItems(projectDir, {
+      ...target,
+      op: 'add',
+      item: { ref: 'welcome' },
+    })
+    expect(missingFrame.outcome).toBe('error')
+    expect(missingFrame.error.message).toContain('requires frame')
+
+    const badFrame = await __test__.editCanvasItems(projectDir, {
+      ...target,
+      op: 'add',
+      item: { ref: 'welcome', frame: { x: 1, y: 2, width: 10 } },
+    })
+    expect(badFrame.outcome).toBe('error')
+    expect(badFrame.error.message).toContain('numeric height')
+
+    const topLevelFrame = await __test__.editCanvasItems(projectDir, {
+      ...target,
+      op: 'add',
+      item: { ref: 'welcome' },
+      frame: { x: 1, y: 2, width: 10, height: 5 },
+    })
+    expect(topLevelFrame.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/canvases.ts')
+    expect(source).toContain('item: () => bricks.bWelcome')
+    expect(source).toContain('height: 5')
+  })
+
+  test('edit_canvas_items move requires a frame', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editCanvasItems(projectDir, {
+      file: 'subspaces/subspace-0/canvases.ts',
+      entry: 'cMain',
+      op: 'move',
+      index: 0,
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.error.message).toContain('move requires frame')
+  })
+
+  test('inner-state outlet switch conditions require outlet or key', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editSwitches(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      op: 'add',
+      switch: {
+        conds: [
+          {
+            cond: {
+              type: 'inner_state',
+              value: true,
+            },
+          },
+        ],
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.error.message).toContain('requires outlet or key')
+  })
+
+  test('remove_entry cascades references and strict mode refuses referenced entries', async () => {
+    projectDir = await writeFixtureProject()
+
+    const strictResult = await __test__.removeEntry(projectDir, {
+      file: 'subspaces/subspace-0/data.ts',
+      entry: 'dMessage',
+      strict: true,
+      verify: false,
+    })
+    expect(strictResult.outcome).toBe('refused')
+    expect(strictResult.touchedSites.length).toBeGreaterThan(0)
+
+    const result = await __test__.removeEntry(projectDir, {
+      file: 'subspaces/subspace-0/data.ts',
+      entry: 'dMessage',
+      verify: false,
+    })
+    expect(result.outcome).toBe('ok')
+
+    const data = await readProjectFile(projectDir, 'subspaces/subspace-0/data.ts')
+    const bricks = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(data).not.toContain('dMessage')
+    expect(bricks).not.toContain('data.dMessage')
+    expect(bricks).toContain('source: undefined')
+    expect(bricks).not.toContain('response:')
+  })
+
+  test('remove_entry strict mode sees same-file references outside the target entry', async () => {
+    projectDir = await writeFixtureProject()
+    await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      set: {
+        'property.peer': { ref: 'welcome' },
+      },
+      verify: false,
+    })
+
+    const result = await __test__.removeEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bWelcome',
+      strict: true,
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('refused')
+    expect(result.touchedSites.some((site) => site.file === 'subspaces/subspace-0/bricks.ts')).toBe(
+      true,
+    )
+  })
+
+  test('edit_events validates indices and drops emptied event keys', async () => {
+    projectDir = await writeFixtureProject()
+    const target = {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      event: 'onPress',
+      verify: false,
+    }
+
+    const added = await __test__.editEvents(projectDir, {
+      ...target,
+      op: 'add',
+      action: { handler: 'system', name: 'CHANGE_CANVAS' },
+    })
+    expect(added.outcome).toBe('ok')
+
+    const outOfRange = await __test__.editEvents(projectDir, { ...target, op: 'remove', index: 5 })
+    expect(outOfRange.outcome).toBe('error')
+    expect(outOfRange.error.message).toContain('remove index out of range')
+
+    const removed = await __test__.editEvents(projectDir, { ...target, op: 'remove', index: 0 })
+    expect(removed.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).not.toContain('onPress')
+
+    const cleared = await __test__.editEvents(projectDir, {
+      ...target,
+      event: 'neverExisted',
+      op: 'clear',
+    })
+    expect(cleared.outcome).toBe('ok')
+    const clearedSource = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(clearedSource).not.toContain('neverExisted')
+  })
+
+  test('edit_events validates PROPERTY_BANK_EXPRESSION against the runtime fold rules', async () => {
+    projectDir = await writeFixtureProject()
+    const target = {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      event: 'onPress',
+      op: 'add',
+      verify: false,
+    }
+    const expressionAction = (expression) => ({
+      handler: 'system',
+      name: 'PROPERTY_BANK_EXPRESSION',
+      params: { expression, variables: [], result: { expr: '() => data.dCount' } },
+    })
+
+    const ifStatement = await __test__.editEvents(projectDir, {
+      ...target,
+      action: expressionAction('if (count > 0) { count + 1 } else { 0 }'),
+    })
+    expect(ifStatement.outcome).toBe('error')
+    expect(ifStatement.error.message).toContain('an if statement')
+    expect(ifStatement.error.message).toContain('ternaries')
+
+    const earlyReturn = await __test__.editEvents(projectDir, {
+      ...target,
+      action: expressionAction('(() => { if (count > 12) return count; return count + 1 })()'),
+    })
+    expect(earlyReturn.outcome).toBe('error')
+
+    const iife = await __test__.editEvents(projectDir, {
+      ...target,
+      action: expressionAction(
+        '(() => { const next = String(count); return next.length > 12 ? next.slice(0, 12) : next })()',
+      ),
+    })
+    expect(iife.outcome).toBe('ok')
+  })
+
+  test('edit_events rejects non-brick/generator action handlers', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editEvents(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      event: 'onPress',
+      op: 'add',
+      action: { handler: { ref: 'main' }, name: 'SHOW' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.error.message).toContain('must be a brick or generator')
+  })
+
+  test('edit_switches accepts compiled __typename cond shapes and switch facets', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editSwitches(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bButton',
+      op: 'add',
+      switch: {
+        title: 'Pressed shadow',
+        conds: [
+          {
+            method: '==',
+            cond: {
+              __typename: 'SwitchCondInnerStateOutlet',
+              outlet: 'brickPressing',
+              value: true,
+            },
+          },
+        ],
+        property: { opacity: 0.92 },
+        override: { property: false },
+      },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/__typename: ['"]SwitchCondInnerStateOutlet['"]/)
+    expect(source).toMatch(/outlet: ['"]brickPressing['"]/)
+    expect(source).toMatch(/Pressed shadow[\s\S]*?property:\s*{\s*opacity: 0\.92\s*}/)
+  })
+
+  test('edit_switches validates explicit ids and rejects events/unknown fields', async () => {
+    projectDir = await writeFixtureProject()
+    const target = { file: 'subspaces/subspace-0/bricks.ts', entry: 'bButton', verify: false }
+
+    const badId = await __test__.editSwitches(projectDir, {
+      ...target,
+      op: 'add',
+      switch: { id: 'SWITCH_pressed_shadow' },
+    })
+    expect(badId.outcome).toBe('error')
+    expect(badId.error.message).toContain('BRICK_STATE_GROUP_<uuid>')
+
+    const events = await __test__.editSwitches(projectDir, {
+      ...target,
+      op: 'add',
+      switch: { events: { onPress: [] } },
+    })
+    expect(events.outcome).toBe('error')
+    expect(events.error.message).toContain('edit_events')
+
+    const unknown = await __test__.editSwitches(projectDir, {
+      ...target,
+      op: 'add',
+      switch: { titel: 'typo' },
+    })
+    expect(unknown.outcome).toBe('error')
+    expect(unknown.error.message).toContain('Unknown switch field')
+    expect(unknown.input).toBeDefined()
+  })
+
+  test('edit_switches move rejects out-of-range indices', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.editSwitches(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      entry: 'bWelcome',
+      op: 'move',
+      index: 5,
+      to: 0,
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.error.message).toContain('valid switch id or index')
+  })
+
+  test('new_entry brick skeleton includes the animation facet', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.newEntry(projectDir, {
+      file: 'subspaces/subspace-0/bricks.ts',
+      type: 'BrickText',
+      templateKey: 'BRICK_TEXT',
+      alias: 'newBrick',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const source = await readProjectFile(projectDir, 'subspaces/subspace-0/bricks.ts')
+    expect(source).toMatch(/newBrick[\s\S]*animation: \{\}/)
+  })
+
+  test('remove_entry cleans data-calc IO references instead of breaking them', async () => {
+    projectDir = await writeFixtureProject()
+    const dataCalcDir = path.join(projectDir, 'subspaces/subspace-0/data-calc')
+    await mkdir(dataCalcDir, { recursive: true })
+    await writeFile(
+      path.join(dataCalcDir, 'data-calculation-calc.ts'),
+      `import type { DataCalculationScript } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+import * as data from '../data'
+
+export const dataCalculation: DataCalculationScript = {
+  __typename: 'DataCalculationScript',
+  id: makeId('property_bank_calc'),
+  alias: 'calc',
+  code: 'return inputs.message',
+  enableAsync: false,
+  inputs: [
+    { key: 'message', data: () => data.dMessage, trigger: true },
+    { key: 'count', data: () => data.dCount, trigger: true },
+  ],
+  output: () => data.dMessage,
+  outputs: [{ key: 'copy', data: () => data.dMessage }],
+  error: null,
+}
+`,
+    )
+
+    const result = await __test__.removeEntry(projectDir, {
+      file: 'subspaces/subspace-0/data.ts',
+      entry: 'dMessage',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const calc = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-calc.ts',
+    )
+    expect(calc).not.toContain('dMessage')
+    expect(calc).toContain('output: null')
+    expect(calc).toMatch(/key: ['"]count['"]/)
+    expect(result.touchedSites.some((site) => site.action === 'remove_io_item')).toBe(true)
+    expect(result.touchedSites.some((site) => site.action === 'null_output')).toBe(true)
+  })
+
+  test('non-standard entries return a fallback recommendation and are logged', async () => {
+    projectDir = await writeFixtureProject()
+    await writeFile(
+      path.join(projectDir, 'subspaces/subspace-0/data.ts'),
+      `import type { Data } from 'bricks-ctor'
+import { useSystemData } from 'bricks-ctor'
+
+export const dSystem: Data = useSystemData('currentTime')
+`,
+    )
+
+    const result = await __test__.editEntry(projectDir, {
+      file: 'subspaces/subspace-0/data.ts',
+      entry: 'dSystem',
+      set: { title: 'Current Time' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('fallback_recommended')
+    expect(result.error.message).toContain('not a top-level exported object literal')
+    const audit = await readAudit(projectDir)
+    expect(audit.at(-1).outcome).toBe('fallback_recommended')
+  })
+})