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

package/tools/_git-author.ts

@@ -15,7 +15,15 @@ async function hasGitIdentity(cwd: string): Promise<boolean> {
 // If no identity is configured (typical for non-tech users), CTOR becomes the
 // main author via per-command `-c user.name/-c user.email` overrides so the
 // user's git config is left untouched.
-export async function buildCommitArgs(cwd: string, messages: string[]): Promise<string[]> {
+//
+// `extraFlags` are inserted between `commit` and the `-m` args (e.g.
+// `['--no-verify']` to bypass pre-commit hooks for controlled cases like
+// committing merge-conflict markers).
+export async function buildCommitArgs(
+  cwd: string,
+  messages: string[],
+  extraFlags: string[] = [],
+): Promise<string[]> {
   const hasIdentity = await hasGitIdentity(cwd)
   const prefix = hasIdentity
     ? []
@@ -23,7 +31,7 @@ export async function buildCommitArgs(cwd: string, messages: string[]): Promise<
   const msgArgs: string[] = []
   for (const m of messages) msgArgs.push('-m', m)
   if (hasIdentity) msgArgs.push('-m', CTOR_COAUTHOR_TRAILER)
-  return [...prefix, 'commit', ...msgArgs]
+  return [...prefix, 'commit', ...extraFlags, ...msgArgs]
 }
 
 export { CTOR_NAME, CTOR_EMAIL, CTOR_COAUTHOR_TRAILER }

package/tools/_last-pushed-commit.ts

@@ -0,0 +1,28 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+
+// Local sync marker: the git commit hash that was on HEAD when we last
+// successfully pushed to the server (deploy or push-config) or pulled
+// from it. Stored at the `.bricks/` top level (gitignored explicitly) — it's
+// per-clone state, not a build artifact, so it doesn't belong under
+// `.bricks/build/`.
+//
+// Why this exists: server's `bricks_project_last_commit_id` can be an opaque
+// nanoid for content-only edits (config-editor saves), so it isn't a
+// reliable git anchor for `git checkout` during pull. The local marker is
+// always a real reachable commit hash from THIS clone.
+const REL_PATH = '.bricks/.last-pushed-commit'
+
+export async function readLastPushedCommit(cwd: string): Promise<string | null> {
+  try {
+    const content = await readFile(`${cwd}/${REL_PATH}`, 'utf8')
+    return content.trim() || null
+  } catch {
+    return null
+  }
+}
+
+export async function writeLastPushedCommit(cwd: string, commitId: string): Promise<void> {
+  if (!commitId) return
+  await mkdir(`${cwd}/.bricks`, { recursive: true })
+  await writeFile(`${cwd}/${REL_PATH}`, commitId)
+}

package/tools/_shell.ts

@@ -29,6 +29,7 @@ class Sh implements PromiseLike<ShResult> {
   private _cwd: string | undefined
   private _mode: Mode = 'default'
   private _throw = true
+  private _env: NodeJS.ProcessEnv | undefined
   private _promise: Promise<ShResult> | null = null
 
   constructor(private readonly args: string[]) {}
@@ -48,6 +49,11 @@ class Sh implements PromiseLike<ShResult> {
     return this
   }
 
+  env(extra: NodeJS.ProcessEnv): this {
+    this._env = { ...this._env, ...extra }
+    return this
+  }
+
   async text(): Promise<string> {
     // If no explicit quiet was requested, capture stdout/stderr without
     // forwarding them to the parent's streams (matches Bun's `.text()`).
@@ -79,7 +85,8 @@ class Sh implements PromiseLike<ShResult> {
           ? ['ignore', 'pipe', 'pipe']
           : ['inherit', 'pipe', 'pipe']
 
-    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio })
+    const env = this._env ? { ...process.env, ...this._env } : undefined
+    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio, env })
 
     const outChunks: Buffer[] = []
     const errChunks: Buffer[] = []

package/tools/deploy.ts

@@ -1,7 +1,13 @@
 import { access, readFile, writeFile } from 'node:fs/promises'
 import { parseArgs } from 'util'
 import { sh } from './_shell'
+import { extractCliErrorMessage } from './_cli-error'
 import { buildCommitArgs } from './_git-author'
+import { writeLastPushedCommit } from './_last-pushed-commit'
+
+if (!process.env.BRICKS_RELEASE_SIGN) {
+  process.env.BRICKS_RELEASE_SIGN = 'CTOR'
+}
 
 const cwd = process.cwd()
 
@@ -141,6 +147,10 @@ await writeFile(configPath, JSON.stringify(releaseConfig))
 
 const args = ['bricks', command, 'release', app.id, '-c', configPath, '--json']
 
+if (app.name) {
+  args.push('--name', app.name)
+}
+
 if (version) {
   args.push('--version', version)
 }
@@ -153,13 +163,14 @@ const result = await sh`${args}`.quiet().nothrow()
 
 if (result.exitCode !== 0) {
   const output = result.stderr.toString() || result.stdout.toString()
-  try {
-    const json = JSON.parse(output)
-    throw new Error(json.error || 'Release failed')
-  } catch {
-    throw new Error(output || 'Release failed')
-  }
+  throw new Error(extractCliErrorMessage(output, 'Release failed'))
 }
 
 const output = JSON.parse(result.stdout.toString())
+
+// Record the commit we just pushed from so a later pull can use it as the
+// merge base regardless of what the server stores in
+// bricks_project_last_commit_id.
+if (commitId) await writeLastPushedCommit(cwd, commitId)
+
 console.log(`${isModule ? 'Module' : 'App'} deployed: ${output.name}`)

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')
+  })
+})