@fugood/bricks-ctor 2.25.0-beta.42 → 2.25.0-beta.45

package/skills/bricks-ctor/references/source-editing-tools.md

@@ -0,0 +1,81 @@
+# MCP Source-Editing Tools
+
+The project-local `bricks-ctor` MCP server exposes tools that edit `subspaces/**` via
+surgical AST edits, keeping files in the standard generated style. Prefer them over
+hand-editing entry files; they validate references, manage imports, compile-verify, and
+record every operation in `.bricks/edits.jsonl`.
+
+## Entry tools (bricks.ts / generators.ts / canvases.ts / data.ts / animations.ts)
+
+| Tool | Purpose |
+|------|---------|
+| `new_entry` | Create a standard entry skeleton (`file`, `type`, `templateKey`, `alias`, optional initial `set`/`events`) |
+| `edit_entry` | Set/unset dotted paths on an entry: `title`, `property.url`, `outlets.response`, `value`, `switches[0].property.text`, … |
+| `edit_events` | Add/remove/replace/move/clear EventAction items in `events.<eventKey>` |
+| `edit_canvas_items` | Add/replace/remove/move brick items on a Canvas `items` array (frames need numeric x/y/width/height) |
+| `edit_switches` | Add/replace/remove/move switches (id, title, conds, override, disabled, break) |
+| `remove_entry` | Delete an entry; cascades same-subspace references by default, `strict: true` refuses and lists sites |
+
+Addressing: `{ file, entry }` (export const name) is primary; `id` works as a global
+fallback (omit `file`). `edit_entry`/`edit_events` accept a `switch` parameter (switch id
+or index) to edit the facets inside one switch — `edit_switches` owns only the array and
+the conds/override shell.
+
+### Event actions
+
+```jsonc
+{
+  "handler": "system",            // or { "ref": "brickOrGeneratorRef" } or { "subspace": "SUBSPACE_id" }
+  "name": "CHANGE_CANVAS",
+  "params": { "canvasId": { "ref": "mainCanvas" } },   // template params, OR:
+  "dataParams": { "someData": 5 },                      // PROPERTY_BANK-style params
+  "waitAsync": false
+}
+```
+
+System actions derive their `as SystemAction...` cast automatically; entity-action casts
+are added only when passed via `cast`. The compiled source form
+`{ handler, action: { name, params: [...], dataParams: [...] }, waitAsync }` is also
+accepted, and `{ "expr": "<raw EventAction>" }` is the escape hatch for shapes the
+structured form cannot express. Handler refs must resolve to a brick or generator.
+`PROPERTY_BANK_EXPRESSION` expressions are validated against the runtime fold rules at
+edit time: only expression statements, simple `const`/`let` declarations, and a final
+return inside a zero-arg IIFE evaluate — no `if`/`for`/`while` (use ternaries, or a
+DataCalculationScript for branching logic).
+
+## Data-calc tools (DataCalculationScript only)
+
+| Tool | Purpose |
+|------|---------|
+| `new_data_calc` | Create `data-calc/data-calculation-{slug}.ts` + `.sandbox.js`, regenerate `data-calc/index.ts`, wire a minimal subspace root |
+| `edit_data_calc` | Set/unset scalar fields, `output`/`error` refs, replace whole `inputs`/`outputs`, or rewrite the sandbox `code` |
+| `edit_data_calc_io` | Add/remove/replace/clear single `inputs`/`outputs` items (input keys unique; output keys may repeat for fan-out) |
+| `remove_data_calc` | Delete the calc `.ts` + its sandbox file and regenerate the index |
+
+Addressing: `{ file }` or `{ subspace, calc }` where `calc` is alias, id, or filename
+slug (subspace defaults to `subspace-0`). Code is canonicalized to the sandbox file form
+(`export function main() { ... }` — wrapped automatically, `async` added when the body
+uses top-level `await`). `DataCalculationMap` (visual node graph) is out of scope and
+returns `fallback_recommended`.
+
+## Value grammar (everywhere a value appears)
+
+| You pass | Emits |
+|----------|-------|
+| JSON scalar/array/object | literal |
+| `{ "link": "dataRefOrAlias" }` | `linkData(() => data.dX)` (property data-links) |
+| `{ "ref": "idOrAliasOrVarName", "subspace"?: 1 }` | `() => namespace.varName` getter |
+| `{ "expr": "raw TypeScript" }` | spliced verbatim |
+
+References resolve by var name, id, or alias within the target subspace and fail loudly
+when missing or ambiguous — this doubles as reference validation.
+
+## Verification and audit
+
+- Every call compile-verifies by default and returns `verify.configChange` — the minimal
+  compiled-config delta (path-keyed set/unset ops). Skip with per-call `verify: false`
+  or `BRICKS_CTOR_MCP_EDIT_VERIFY=0` when batching, then finish with the `compile` tool.
+- All operations append to `.bricks/edits.jsonl` (gitignored) with inputs, outcomes, and
+  touched sites.
+- Non-standard files or entries (hand-written shapes the AST editor cannot safely
+  rewrite) return `fallback_recommended` — use plain file edits for those cases only.

package/skills/bricks-ctor/references/verification-toolchain.md

@@ -71,6 +71,8 @@ Useful flags:
 
 For ad-hoc CDP inspection against this local preview, connect any CDP client to `localhost:19852` — Chrome DevTools front-end works directly. For an agent-friendly CLI over CDP (screenshot, brick tree/query, input emulation, storage reads, runtime eval, network capture), the `bricks-cli` skill documents the `bricks devtools` command surface — read that skill if it is installed in this workspace. If it is not installed, run `bricks --help` and `bricks devtools --help`; the CLI's own help output is authoritative.
 
+To inspect Data / Property Bank or storage state, prefer the dedicated `bricks devtools storage` subcommands — `storage data-bank get <S_xxxx>` (saved Data values), `storage system persist|memory`, `storage system get <key>` — over hand-written `runtime eval`. Reach for `runtime eval` only for *live* store internals that aren't persisted to a data bank (e.g. a current transient value: `runtime eval "system.data.property('S_xxxx', '<alias>')"`); don't reverse-engineer the `system.*` globals.
+
 ### Project Automations
 
 E2E tests authored in TypeScript inside the project (`AutomationTest` / `TestCase`). Test cases include:

package/tools/_edits-log.ts

@@ -0,0 +1,41 @@
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const auditLogIgnoreEntry = '.bricks/edits.jsonl'
+
+// Ensure the project's .gitignore excludes the audit log. No-op when it is already
+// ignored directly or via a broader `.bricks` rule.
+const ensureAuditLogIgnored = async (projectDir: string) => {
+  const gitignorePath = path.join(projectDir, '.gitignore')
+  const content = await readFile(gitignorePath, 'utf8').catch((err: any) => {
+    if (err?.code === 'ENOENT') return ''
+    throw err
+  })
+  const ignored = content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .some((line) => line === auditLogIgnoreEntry || line === '.bricks/' || line === '.bricks')
+  if (ignored) return
+
+  const prefix = content && !content.endsWith('\n') ? '\n' : ''
+  await writeFile(
+    gitignorePath,
+    `${content}${prefix}\n# MCP entry-editing audit log\n${auditLogIgnoreEntry}\n`,
+  )
+}
+
+// Append one JSON record to `.bricks/edits.jsonl`, creating the directory and the
+// gitignore entry as needed. Shared by the source-editing tools and `compile()` so
+// every project mutation lands in the same audit log.
+export const appendEditRecord = async (projectDir: string, record: Record<string, unknown>) => {
+  const bricksDir = path.join(projectDir, '.bricks')
+  await mkdir(bricksDir, { recursive: true })
+  await ensureAuditLogIgnored(projectDir)
+  await appendFile(path.join(bricksDir, 'edits.jsonl'), `${JSON.stringify(record)}\n`)
+}
+
+// Provenance stamped on every audit record: which agent/session produced the change.
+export const editProvenance = () => ({
+  session: process.env.BRICKS_CTOR_SESSION_ID || process.env.CODEX_SESSION_ID,
+  agent: process.env.BRICKS_CTOR_AGENT_ID || process.env.USER,
+})

package/tools/mcp-env.ts

@@ -0,0 +1,13 @@
+const truthyEnvValues = new Set(['1', 'true', 'yes', 'on'])
+
+export function isTruthyEnv(value: string | undefined) {
+  return truthyEnvValues.has(
+    String(value || '')
+      .trim()
+      .toLowerCase(),
+  )
+}
+
+export function shouldRegisterEditingTools(env: Record<string, string | undefined> = process.env) {
+  return isTruthyEnv(env.BRICKS_CTOR_ENABLE_EDITING_TOOLS)
+}

package/tools/mcp-server.ts

@@ -6,6 +6,9 @@ import { register as registerLottie } from './mcp-tools/lottie'
 import { register as registerIcons } from './mcp-tools/icons'
 import { register as registerHuggingface } from './mcp-tools/huggingface'
 import { register as registerMedia } from './mcp-tools/media'
+import { register as registerEntryEditing } from './mcp-tools/entry-editing'
+import { register as registerDataCalcEditing } from './mcp-tools/data-calc-editing'
+import { shouldRegisterEditingTools } from './mcp-env'
 
 const server = new McpServer({
   name: 'bricks-ctor',
@@ -24,5 +27,10 @@ registerIcons(server)
 registerHuggingface(server)
 registerMedia(server, projectDir)
 
+if (shouldRegisterEditingTools()) {
+  registerEntryEditing(server, projectDir)
+  registerDataCalcEditing(server, projectDir)
+}
+
 const transport = new StdioServerTransport()
 await server.connect(transport)

package/tools/mcp-tools/__tests__/data-calc-editing.test.js

@@ -0,0 +1,516 @@
+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 '../data-calc-editing'
+
+const writeFixtureProject = async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), 'bricks-data-calc-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 dPrice: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'price',
+  title: 'Price',
+  type: 'number',
+  value: 5,
+}
+
+export const dQuantity: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'quantity',
+  title: 'Quantity',
+  type: 'number',
+  value: 2,
+}
+
+export const dTotal: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'total',
+  title: 'Total',
+  type: 'number',
+  value: 0,
+}
+
+export const dError: Data = {
+  __typename: 'Data',
+  id: makeId('data'),
+  alias: 'error',
+  title: 'Error',
+  type: 'string',
+  value: '',
+}
+`,
+  )
+  await writeFile(
+    path.join(subspaceDir, 'index.ts'),
+    `import type { Subspace } from 'bricks-ctor'
+
+export default {
+  __typename: 'Subspace',
+  id: 'SUBSPACE_TEST',
+  title: 'Main',
+  layout: { width: 96, height: 54 },
+  canvases: [],
+  rootCanvas: undefined,
+  animations: [],
+  bricks: [],
+  generators: [],
+  data: Object.values(data),
+  dataRouting: [],
+  dataCalculation: [],
+} as Subspace
+`,
+  )
+  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 data-calc editing tools', () => {
+  let projectDir
+
+  afterEach(async () => {
+    if (projectDir) await rm(projectDir, { recursive: true, force: true })
+    projectDir = null
+  })
+
+  test('registers the four data-calc MCP tools with descriptions', () => {
+    const calls = []
+    register(
+      {
+        tool(...args) {
+          calls.push(args)
+        },
+      },
+      '/tmp/project',
+    )
+
+    expect(calls.map(([name]) => name)).toEqual([
+      'new_data_calc',
+      'edit_data_calc',
+      'edit_data_calc_io',
+      'remove_data_calc',
+    ])
+    expect(
+      calls.every(([, description]) => typeof description === 'string' && description.length > 20),
+    ).toBe(true)
+    expect(calls[0][2].code.description).toContain('export function main')
+    expect(calls[2][2].data.description).toContain('{ ref')
+  })
+
+  test('new_data_calc creates script, sandbox, index, and minimal subspace wiring', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.newDataCalc(projectDir, {
+      alias: 'totalCalc',
+      title: 'Total Calc',
+      code: 'return { total: inputs.price * inputs.quantity }',
+      inputs: [
+        { key: 'price', data: 'price' },
+        { key: 'quantity', data: 'quantity', trigger: false },
+      ],
+      outputs: [{ key: 'total', data: 'total' }],
+      output: 'total',
+      error: 'error',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    expect(result.calc).toBe('total-calc')
+    const calc = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-total-calc.ts',
+    )
+    expect(calc).toMatch(/id:\s*makeId\(["']property_bank_calc["'], ["']totalCalc["']\)/)
+    expect(calc).toMatch(
+      /code:\s*await readFile\(new URL\(["']\.\/data-calculation-total-calc\.sandbox\.js["']/,
+    )
+    expect(calc).toContain('data: () => data.dPrice')
+    expect(calc).toContain('trigger: false')
+    expect(calc).toContain('output: () => data.dTotal')
+    expect(calc).toContain('error: () => data.dError')
+    const sandbox = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-total-calc.sandbox.js',
+    )
+    expect(sandbox).toContain('export function main()')
+    expect(sandbox).toContain('return { total: inputs.price * inputs.quantity }')
+    const index = await readProjectFile(projectDir, 'subspaces/subspace-0/data-calc/index.ts')
+    expect(index).toContain(
+      "import { dataCalculation as dataCalculation0 } from './data-calculation-total-calc'",
+    )
+    const subspaceIndex = await readProjectFile(projectDir, 'subspaces/subspace-0/index.ts')
+    expect(subspaceIndex).toMatch(/import \{ dataCalculation \} from ["']\.\/data-calc["']/)
+    expect(subspaceIndex).toMatch(/dataCalculation\s*\n\s*} as Subspace/)
+    const audit = await readAudit(projectDir)
+    expect(audit.at(-1).summary).toContain('created data calc total-calc')
+  })
+
+  test('records audit provenance from env', async () => {
+    projectDir = await writeFixtureProject()
+    const previousSessionId = process.env.BRICKS_CTOR_SESSION_ID
+    const previousAgentId = process.env.BRICKS_CTOR_AGENT_ID
+    process.env.BRICKS_CTOR_SESSION_ID = 'session-1'
+    process.env.BRICKS_CTOR_AGENT_ID = 'agent-1'
+
+    try {
+      const result = await __test__.newDataCalc(projectDir, {
+        alias: 'auditCalc',
+        verify: false,
+      })
+
+      expect(result.outcome).toBe('ok')
+      const audit = await readAudit(projectDir)
+      expect(audit.at(-1).provenance).toEqual({
+        session: 'session-1',
+        agent: 'agent-1',
+      })
+    } finally {
+      if (previousSessionId === undefined) delete process.env.BRICKS_CTOR_SESSION_ID
+      else process.env.BRICKS_CTOR_SESSION_ID = previousSessionId
+      if (previousAgentId === undefined) delete process.env.BRICKS_CTOR_AGENT_ID
+      else process.env.BRICKS_CTOR_AGENT_ID = previousAgentId
+    }
+  })
+
+  test('edit_data_calc updates scalars, refs, and migrates inline code to sandbox form', 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-inline.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: 'inline',
+  code: 'return inputs.price',
+  enableAsync: false,
+  inputs: [],
+  output: null,
+  outputs: [],
+  error: null,
+}
+`,
+    )
+
+    const result = await __test__.editDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'inline',
+      set: {
+        title: 'Edited Inline',
+        enableAsync: true,
+        output: 'total',
+        error: 'error',
+      },
+      code: 'return { total: inputs.price }',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const calc = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-inline.ts',
+    )
+    expect(calc).toMatch(/import \{ readFile \} from ["']node:fs\/promises["']/)
+    expect(calc).toMatch(/title:\s*["']Edited Inline["']/)
+    expect(calc).toContain('enableAsync: true')
+    expect(calc).toMatch(
+      /code:\s*await readFile\(new URL\(["']\.\/data-calculation-inline\.sandbox\.js["']/,
+    )
+    expect(calc).toContain('output: () => data.dTotal')
+    expect(calc).toContain('error: () => data.dError')
+    const sandbox = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-inline.sandbox.js',
+    )
+    expect(sandbox).toContain('return { total: inputs.price }')
+  })
+
+  test('edit_data_calc_io edits inputs and outputs with input-key uniqueness', async () => {
+    projectDir = await writeFixtureProject()
+    await __test__.newDataCalc(projectDir, {
+      alias: 'ioCalc',
+      inputs: [{ key: 'price', data: 'price' }],
+      outputs: [{ key: 'total', data: 'total' }],
+      verify: false,
+    })
+
+    const duplicate = await __test__.editDataCalcIo(projectDir, {
+      subspace: 0,
+      calc: 'io-calc',
+      field: 'inputs',
+      op: 'add',
+      key: 'price',
+      data: 'quantity',
+      verify: false,
+    })
+    expect(duplicate.outcome).toBe('error')
+    expect(duplicate.error.code).toBe('duplicate_key')
+
+    const addInput = await __test__.editDataCalcIo(projectDir, {
+      subspace: 0,
+      calc: 'io-calc',
+      field: 'inputs',
+      op: 'add',
+      key: 'quantity',
+      data: 'quantity',
+      trigger: false,
+      verify: false,
+    })
+    expect(addInput.outcome).toBe('ok')
+
+    const fanOut = await __test__.editDataCalcIo(projectDir, {
+      subspace: 0,
+      calc: 'io-calc',
+      field: 'outputs',
+      op: 'add',
+      key: 'total',
+      data: 'total',
+      verify: false,
+    })
+    expect(fanOut.outcome).toBe('ok')
+
+    const calc = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-io-calc.ts',
+    )
+    expect(calc).toMatch(/key:\s*["']quantity["']/)
+    expect(calc).toContain('trigger: false')
+    expect((calc.match(/key:\s*["']total["']/g) || []).length).toBe(2)
+  })
+
+  test('new_data_calc wraps top-level await bodies in an async main', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.newDataCalc(projectDir, {
+      alias: 'asyncCalc',
+      enableAsync: true,
+      code: 'const value = await Promise.resolve(inputs.price)\nreturn value',
+      inputs: [{ key: 'price', data: 'price' }],
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    const sandbox = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-async-calc.sandbox.js',
+    )
+    expect(sandbox).toContain('export async function main()')
+  })
+
+  test('new_data_calc rejects sandbox code that does not parse', async () => {
+    projectDir = await writeFixtureProject()
+
+    const result = await __test__.newDataCalc(projectDir, {
+      alias: 'broken',
+      code: 'return {',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('error')
+    expect(result.error.code).toBe('invalid_code')
+  })
+
+  test('edit_data_calc set routes inputs/outputs through the IO builder and guards required fields', async () => {
+    projectDir = await writeFixtureProject()
+    await __test__.newDataCalc(projectDir, { alias: 'setCalc', verify: false })
+
+    const ioViaSet = await __test__.editDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'set-calc',
+      set: { inputs: [{ key: 'price', data: 'price' }] },
+      verify: false,
+    })
+    expect(ioViaSet.outcome).toBe('ok')
+    const calc = await readProjectFile(
+      projectDir,
+      'subspaces/subspace-0/data-calc/data-calculation-set-calc.ts',
+    )
+    expect(calc).toContain('data: () => data.dPrice')
+
+    const codeViaSet = await __test__.editDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'set-calc',
+      set: { code: 'return 1' },
+      verify: false,
+    })
+    expect(codeViaSet.outcome).toBe('error')
+    expect(codeViaSet.error.code).toBe('invalid_field')
+
+    const badUnset = await __test__.editDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'set-calc',
+      unset: ['inputs'],
+      verify: false,
+    })
+    expect(badUnset.outcome).toBe('error')
+    expect(badUnset.error.code).toBe('invalid_field')
+  })
+
+  test('subspace+calc addressing tolerates non-Script calc files while scanning', 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-0.ts'),
+      `import type { DataCalculationMap } from 'bricks-ctor'
+
+export const dataCalculation: DataCalculationMap = {
+  __typename: 'DataCalculationMap',
+  id: 'PROPERTY_BANK_COMMAND_MAP_MAP',
+  nodes: [],
+  editorInfo: [],
+}
+`,
+    )
+    await __test__.newDataCalc(projectDir, { alias: 'realCalc', verify: false })
+
+    const result = await __test__.editDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'realCalc',
+      set: { title: 'Real' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    expect(result.file).toBe('subspaces/subspace-0/data-calc/data-calculation-real-calc.ts')
+  })
+
+  test('new_data_calc warns instead of overwriting a non-empty inline dataCalculation', async () => {
+    projectDir = await writeFixtureProject()
+    await writeFile(
+      path.join(projectDir, 'subspaces/subspace-0/index.ts'),
+      `import type { Subspace } from 'bricks-ctor'
+
+export default {
+  __typename: 'Subspace',
+  id: 'SUBSPACE_TEST',
+  title: 'Main',
+  dataCalculation: [{ __typename: 'DataCalculationScript' }],
+} as Subspace
+`,
+    )
+
+    const result = await __test__.newDataCalc(projectDir, { alias: 'warned', verify: false })
+
+    expect(result.outcome).toBe('ok')
+    expect(result.warnings?.[0]).toContain('non-empty dataCalculation')
+    const index = await readProjectFile(projectDir, 'subspaces/subspace-0/index.ts')
+    expect(index).not.toMatch(/import \{ dataCalculation \}/)
+    expect(index).toContain("dataCalculation: [{ __typename: 'DataCalculationScript' }]")
+  })
+
+  test('remove_data_calc ignores non-sibling sandbox filenames in code', async () => {
+    projectDir = await writeFixtureProject()
+    const dataCalcDir = path.join(projectDir, 'subspaces/subspace-0/data-calc')
+    await mkdir(dataCalcDir, { recursive: true })
+    await writeFile(path.join(projectDir, 'evil.sandbox.js'), 'export function main() {}\n')
+    await writeFile(
+      path.join(dataCalcDir, 'data-calculation-escape.ts'),
+      `import type { DataCalculationScript } from 'bricks-ctor'
+import { makeId } from 'bricks-ctor'
+import { readFile } from 'node:fs/promises'
+
+export const dataCalculation: DataCalculationScript = {
+  __typename: 'DataCalculationScript',
+  id: makeId('property_bank_calc'),
+  alias: 'escape',
+  code: await readFile(new URL('../../../evil.sandbox.js', import.meta.url), 'utf8'),
+  enableAsync: false,
+  inputs: [],
+  output: null,
+  outputs: [],
+  error: null,
+}
+`,
+    )
+
+    const result = await __test__.removeDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'escape',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    await expect(readProjectFile(projectDir, 'evil.sandbox.js')).resolves.toContain('main')
+  })
+
+  test('remove_data_calc deletes calc files and regenerates index', async () => {
+    projectDir = await writeFixtureProject()
+    await __test__.newDataCalc(projectDir, {
+      alias: 'removeMe',
+      code: 'return inputs.price',
+      verify: false,
+    })
+
+    const result = await __test__.removeDataCalc(projectDir, {
+      subspace: 0,
+      calc: 'remove-me',
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('ok')
+    await expect(
+      readProjectFile(projectDir, 'subspaces/subspace-0/data-calc/data-calculation-remove-me.ts'),
+    ).rejects.toThrow()
+    await expect(
+      readProjectFile(
+        projectDir,
+        'subspaces/subspace-0/data-calc/data-calculation-remove-me.sandbox.js',
+      ),
+    ).rejects.toThrow()
+    const index = await readProjectFile(projectDir, 'subspaces/subspace-0/data-calc/index.ts')
+    expect(index).not.toContain('remove-me')
+  })
+
+  test('DataCalculationMap returns fallback recommendation', 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-map.ts'),
+      `import type { DataCalculationMap } from 'bricks-ctor'
+
+export const dataCalculation: DataCalculationMap = {
+  __typename: 'DataCalculationMap',
+  id: 'PROPERTY_BANK_COMMAND_MAP_MAP',
+  nodes: [],
+  editorInfo: [],
+}
+`,
+    )
+
+    const result = await __test__.editDataCalc(projectDir, {
+      file: 'subspaces/subspace-0/data-calc/data-calculation-map.ts',
+      set: { title: 'Map' },
+      verify: false,
+    })
+
+    expect(result.outcome).toBe('fallback_recommended')
+    expect(result.isError).toBe(false)
+    expect(result.error.message).toContain('DataCalculationMap is out of scope')
+  })
+})