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

package/compile/__tests__/config-diff.test.js

@@ -0,0 +1,61 @@
+import { computeConfigChange } from '../config-diff'
+
+describe('computeConfigChange', () => {
+  test('ignores the volatile top-level title and update_timestamp', () => {
+    const before = { title: 'App(1)', update_timestamp: 1, subspace_map: {} }
+    const after = { title: 'App(2)', update_timestamp: 2, subspace_map: {} }
+    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
+  })
+
+  test('still diffs nested (subspace/brick) titles', () => {
+    const before = { title: 'App(1)', subspace_map: { S: { title: 'Home' } } }
+    const after = { title: 'App(2)', subspace_map: { S: { title: 'Start' } } }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['subspace_map', 'S', 'title'], value: 'Start' },
+    ])
+  })
+
+  test('emits a leaf set for a scalar property change', () => {
+    const wrap = (url) => ({ subspace_map: { S: { brick_map: { B: { property: { url } } } } } })
+    expect(computeConfigChange(wrap('a'), wrap('b')).ops).toEqual([
+      { op: 'set', path: ['subspace_map', 'S', 'brick_map', 'B', 'property', 'url'], value: 'b' },
+    ])
+  })
+
+  test('added key → set, removed key → unset', () => {
+    const change = computeConfigChange({ m: { a: 1 } }, { m: { b: 2 } })
+    expect(change.opCount).toBe(2)
+    expect(change.ops).toContainEqual({ op: 'unset', path: ['m', 'a'] })
+    expect(change.ops).toContainEqual({ op: 'set', path: ['m', 'b'], value: 2 })
+  })
+
+  test('equal-length arrays diff element-wise', () => {
+    const before = { items: [{ x: 1 }, { x: 2 }] }
+    const after = { items: [{ x: 1 }, { x: 9 }] }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['items', 1, 'x'], value: 9 },
+    ])
+  })
+
+  test('length-changed arrays emit a single whole-array set', () => {
+    const before = { items: [1, 2] }
+    const after = { items: [1, 2, 3] }
+    expect(computeConfigChange(before, after).ops).toEqual([
+      { op: 'set', path: ['items'], value: [1, 2, 3] },
+    ])
+  })
+
+  test('identical configs produce no ops', () => {
+    const config = { subspace_map: { S: { brick_map: { B: { property: { a: 1, b: [1, 2] } } } } } }
+    expect(computeConfigChange(config, structuredClone(config))).toEqual({
+      status: 'ok',
+      ops: [],
+      opCount: 0,
+    })
+  })
+
+  test('reports no_baseline / unavailable for missing sides', () => {
+    expect(computeConfigChange(null, { a: 1 })).toEqual({ status: 'no_baseline' })
+    expect(computeConfigChange({ a: 1 }, null)).toEqual({ status: 'unavailable' })
+  })
+})

package/compile/__tests__/index.test.js

@@ -1,4 +1,13 @@
-import { compile } from '../index'
+jest.mock('../../tools/_shell', () => ({
+  sh: jest.fn(() => Promise.resolve({})),
+}))
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import { sh } from '../../tools/_shell'
+import { checkConfig, compile } from '../index'
 
 const SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000001'
 const CANVAS_ID = 'CANVAS_00000000-0000-0000-0000-000000000001'
@@ -43,6 +52,24 @@ const makeData = (remoteUpdate) => ({
   remoteUpdate,
 })
 
+const commandOf = ([strings, ...values]) =>
+  strings.reduce((acc, chunk, index) => `${acc}${chunk}${values[index] ?? ''}`, '')
+
+describe('checkConfig', () => {
+  beforeEach(() => {
+    sh.mockClear()
+  })
+
+  test('runs doctor after check-config', async () => {
+    await checkConfig('.bricks/build/application-config.json')
+
+    expect(sh.mock.calls.map(commandOf)).toEqual([
+      'bricks app check-config --validate-automation .bricks/build/application-config.json',
+      'bricks app doctor --validate-automation .bricks/build/application-config.json',
+    ])
+  })
+})
+
 describe('compile animations', () => {
   test('normalizes mixed legacy spring config', async () => {
     const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
@@ -150,3 +177,67 @@ describe('compile data remote update', () => {
     )
   })
 })
+
+describe('compile config-change audit log', () => {
+  const readAudit = async (projectDir) =>
+    (await readFile(path.join(projectDir, '.bricks/edits.jsonl'), 'utf8'))
+      .trim()
+      .split('\n')
+      .map((line) => JSON.parse(line))
+
+  const seedArtifact = async (projectDir, config) => {
+    const artifactPath = path.join(projectDir, '.bricks/build/application-config.json')
+    await mkdir(path.dirname(artifactPath), { recursive: true })
+    await writeFile(artifactPath, JSON.stringify(config))
+  }
+
+  test('records the config delta only in the editing-tools context', async () => {
+    const prevCwd = process.cwd()
+    const prevEnv = process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+    let projectDir
+    try {
+      projectDir = await mkdtemp(path.join(os.tmpdir(), 'bricks-compile-audit-'))
+      process.chdir(projectDir)
+
+      // (1) Editing tools disabled: even a real delta against a baseline is not recorded.
+      delete process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+      const empty = await compile(makeApp([], []))
+      await seedArtifact(projectDir, empty)
+      await compile(makeApp([], [makeData(undefined)]))
+      await expect(readFile(path.join(projectDir, '.bricks/edits.jsonl'))).rejects.toThrow()
+
+      // (2) Editing tools enabled: the compiled-config delta is recorded.
+      process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = '1'
+      await seedArtifact(projectDir, empty)
+      const withData = await compile(makeApp([], [makeData(undefined)]))
+      const audit = await readAudit(projectDir)
+      expect(audit).toHaveLength(1)
+      expect(audit[0].tool).toBe('compile')
+      expect(audit[0].outcome).toBe('ok')
+      expect(audit[0].summary).toMatch(/compile: \d+ config op\(s\)/)
+      expect(JSON.stringify(audit[0].configChange)).toContain('property_bank_map')
+      // The audit log gets gitignored on first write.
+      const gitignore = await readFile(path.join(projectDir, '.gitignore'), 'utf8')
+      expect(gitignore).toContain('.bricks/edits.jsonl')
+
+      // (3) Recompiling with no source change records a "no config change" entry.
+      await seedArtifact(projectDir, withData)
+      await compile(makeApp([], [makeData(undefined)]))
+      const afterNoop = await readAudit(projectDir)
+      expect(afterNoop).toHaveLength(2)
+      expect(afterNoop[1].summary).toBe('compile: no config change')
+
+      // (4) Turning the flag off again (as the editing tools do for their verify compiles)
+      // suppresses the record even though there is a real delta.
+      process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = '0'
+      await seedArtifact(projectDir, withData)
+      await compile(makeApp([], []))
+      expect(await readAudit(projectDir)).toHaveLength(2)
+    } finally {
+      if (prevEnv === undefined) delete process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS
+      else process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS = prevEnv
+      process.chdir(prevCwd)
+      if (projectDir) await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+})

package/compile/__tests__/util.test.js

@@ -66,9 +66,14 @@ describe('validateConfig', () => {
   })
 })
 
+// generateCalulationMap now seeds command ids from the owning calc id; tests that don't
+// assert id values share one fixed id (ids stay deterministic with no global state).
+const CALC_ID = 'PROPERTY_BANK_COMMAND_MAP_00000000-0000-4000-8000-000000000000'
+const genMap = (config, calcId = CALC_ID) => generateCalulationMap(config, calcId)
+
 describe('generateCalulationMap', () => {
   test('produces only the three sandbox nodes for an empty config', () => {
-    const result = generateCalulationMap(baseConfig())
+    const result = genMap(baseConfig())
 
     expect(Object.keys(result.map)).toHaveLength(3)
     const { run, error, result: returnValue } = findSandboxIds(result.map)
@@ -80,7 +85,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('chains multiple inputs through OBJECT_SET commands', () => {
-    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
+    const result = genMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
 
     const { run } = findSandboxIds(result.map)
 
@@ -110,7 +115,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('builds OBJECT_GET commands and target data-nodes for outputs', () => {
-    const result = generateCalulationMap(baseConfig({ outputs: { resultPath: ['pb1', 'pb2'] } }))
+    const result = genMap(baseConfig({ outputs: { resultPath: ['pb1', 'pb2'] } }))
 
     const { result: returnValue } = findSandboxIds(result.map)
 
@@ -152,7 +157,7 @@ describe('generateCalulationMap', () => {
     ['output', { output: 'shared' }],
     ['error', { error: 'shared' }],
   ])('preserves input out.value when %s target reuses an input id', (_, overrides) => {
-    const result = generateCalulationMap(
+    const result = genMap(
       baseConfig({ trigger_mode: 'manual', inputs: { shared: 'foo' }, ...overrides }),
     )
     expect(Array.isArray(result.map.shared.out.value)).toBe(true)
@@ -160,7 +165,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('also rewires in.change to OBJECT_GET when an outputs target reuses an input id', () => {
-    const result = generateCalulationMap(
+    const result = genMap(
       baseConfig({
         trigger_mode: 'manual',
         inputs: { shared: 'foo' },
@@ -175,9 +180,7 @@ describe('generateCalulationMap', () => {
     // Two outputs entries both target `pb1`. The reduce visits each entry in turn
     // and must preserve the accumulated `out.value` from the first iteration via
     // `acc.map[pb]` rather than wiping it on the second.
-    const result = generateCalulationMap(
-      baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } }),
-    )
+    const result = genMap(baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } }))
     expect(result.map.pb1.type).toBe('data-node')
     // Without an input, out.value remains null after both passes.
     expect(result.map.pb1.out.value).toBeNull()
@@ -187,7 +190,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('wires the error data-node when error is configured', () => {
-    const result = generateCalulationMap(baseConfig({ error: 'errNode' }))
+    const result = genMap(baseConfig({ error: 'errNode' }))
 
     const { error } = findSandboxIds(result.map)
     // SANDBOX_GET_ERROR now broadcasts to the error data-node's `change` port.
@@ -201,7 +204,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('wires the output data-node when output is configured', () => {
-    const result = generateCalulationMap(baseConfig({ output: 'outNode' }))
+    const result = genMap(baseConfig({ output: 'outNode' }))
 
     const { result: returnValue } = findSandboxIds(result.map)
     expect(result.map[returnValue].out.result).toEqual([{ id: 'outNode', port: 'change' }])
@@ -211,7 +214,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('manual trigger mode sets disable_trigger_command on input value ports', () => {
-    const result = generateCalulationMap(
+    const result = genMap(
       baseConfig({
         trigger_mode: 'manual',
         inputs: { a: 'foo', b: 'bar' },
@@ -224,7 +227,7 @@ describe('generateCalulationMap', () => {
   })
 
   test('auto trigger mode honours per-key disabled_triggers', () => {
-    const result = generateCalulationMap(
+    const result = genMap(
       baseConfig({
         inputs: { a: 'foo', b: 'bar' },
         disabled_triggers: { a: true, b: false },
@@ -238,30 +241,44 @@ describe('generateCalulationMap', () => {
   })
 
   test('auto trigger mode without disabled_triggers leaves disable_trigger_command undefined', () => {
-    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }))
+    const result = genMap(baseConfig({ inputs: { a: 'foo' } }))
     const aCmdId = result.map.a.out.value[0].id
     expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBeUndefined()
   })
 
-  test('snapshotMode forwards to makeId so generated ids are deterministic v4 uuids', () => {
-    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }), {
-      snapshotMode: true,
-    })
-    const sandboxIds = sandboxNodeIds(result.map).map((s) => s.id)
+  test('derives command ids deterministically from the calc id (stable across compiles)', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, outputs: { out: ['pb1'] } })
+    const first = generateCalulationMap(config, CALC_ID)
+    const second = generateCalulationMap(config, CALC_ID)
+    // Same calc id + same config must yield byte-identical ids, so recompiling unchanged
+    // source produces no spurious property_bank_calc_map diff.
+    expect(Object.keys(second.map)).toEqual(Object.keys(first.map))
+
     const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
-    sandboxIds.forEach((id) => {
+    sandboxNodeIds(first.map).forEach(({ id }) => {
       expect(id).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
     })
   })
 
-  test('validateConfig errors propagate out of generateCalulationMap', () => {
-    expect(() => generateCalulationMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(
-      /key: error/,
+  test('seeds command ids per calc so different calcs never collide (edit isolation)', () => {
+    const config = baseConfig({ inputs: { a: 'foo' } })
+    const a = generateCalulationMap(
+      config,
+      'PROPERTY_BANK_COMMAND_MAP_aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
     )
+    const b = generateCalulationMap(
+      config,
+      'PROPERTY_BANK_COMMAND_MAP_bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+    )
+    expect(findSandboxIds(a.map).run).not.toBe(findSandboxIds(b.map).run)
+  })
+
+  test('validateConfig errors propagate out of generateCalulationMap', () => {
+    expect(() => genMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(/key: error/)
   })
 
   test('SANDBOX_GET_RETURN_VALUE broadcasts to both output target and outputs commands', () => {
-    const result = generateCalulationMap(
+    const result = genMap(
       baseConfig({
         output: 'outNode',
         outputs: { foo: ['pb1'] },

package/compile/config-diff.ts

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+// The compiled config artifact written by `bun compile` (see the generated
+// project's `compile.ts`; bricks-project-generator/index.js:762).
+export const BUILD_CONFIG_RELATIVE = '.bricks/build/application-config.json'
+
+// `compile()` derives these top-level fields from `Date.now()`
+// (compile/index.ts `title: \`${app.name}(${timestamp})\`` and `update_timestamp`),
+// so they differ on every run regardless of source. Excluded from the comparison —
+// only the *top-level* keys are dropped, so nested subspace/brick `title`s still diff.
+const VOLATILE_TOP_LEVEL_FIELDS = ['title', 'update_timestamp']
+
+// A minimal, path-keyed config change (Option A): a generic patch, not coupled to
+// bricks-config-editor's action vocabulary. `path` is an array of object keys /
+// array indices, ready for the editor's `setYValueAtPath` (or a delete) so applying
+// the patch is a single Yjs `'local'` transaction == one undo/redo entry.
+export type ConfigPatchOp =
+  | { op: 'set'; path: Array<string | number>; value: unknown }
+  | { op: 'unset'; path: Array<string | number> }
+
+export type ConfigChange =
+  | { status: 'ok'; ops: ConfigPatchOp[]; opCount: number }
+  | { status: 'no_baseline' }
+  | { status: 'unavailable' }
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const deepEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const aKeys = Object.keys(a)
+    return (
+      aKeys.length === Object.keys(b).length &&
+      aKeys.every((key) => key in b && deepEqual(a[key], b[key]))
+    )
+  }
+  return false
+}
+
+const normalizeConfig = (config: unknown) => {
+  if (!isRecord(config)) return config
+  const normalized = { ...config }
+  for (const field of VOLATILE_TOP_LEVEL_FIELDS) delete normalized[field]
+  return normalized
+}
+
+// Objects recurse key-wise; equal-length arrays recurse element-wise; everything else
+// (scalars, type changes, length-changed arrays) emits one whole-value `set` at that
+// path. The editor's `applyJsonDiffToYType` minimizes the actual Yjs ops downstream,
+// so a whole-array `set` on insert/remove still yields a minimal CRDT mutation.
+const diffInto = (
+  before: unknown,
+  after: unknown,
+  currentPath: Array<string | number>,
+  ops: ConfigPatchOp[],
+) => {
+  if (deepEqual(before, after)) return
+
+  if (isRecord(before) && isRecord(after)) {
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)])
+    for (const key of keys) {
+      const nextPath = [...currentPath, key]
+      if (!(key in after)) ops.push({ op: 'unset', path: nextPath })
+      else if (!(key in before)) ops.push({ op: 'set', path: nextPath, value: after[key] })
+      else diffInto(before[key], after[key], nextPath, ops)
+    }
+    return
+  }
+
+  if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
+    for (let index = 0; index < after.length; index += 1) {
+      diffInto(before[index], after[index], [...currentPath, index], ops)
+    }
+    return
+  }
+
+  ops.push({ op: 'set', path: currentPath, value: after })
+}
+
+// Diff two compiled configs. `before == null` means there was no prior build to compare
+// (first compile); `after == null` means the fresh artifact could not be read.
+export const computeConfigChange = (before: unknown, after: unknown): ConfigChange => {
+  if (before == null) return { status: 'no_baseline' }
+  if (after == null) return { status: 'unavailable' }
+  const ops: ConfigPatchOp[] = []
+  diffInto(normalizeConfig(before), normalizeConfig(after), [], ops)
+  return { status: 'ok', ops, opCount: ops.length }
+}
+
+// Read the last-compiled config artifact. Returns null when it is absent or unreadable.
+export const readBuildConfig = async (projectDir: string): Promise<unknown> => {
+  try {
+    return JSON.parse(await readFile(path.join(projectDir, BUILD_CONFIG_RELATIVE), 'utf8'))
+  } catch {
+    return null
+  }
+}

package/compile/index.ts

@@ -10,6 +10,10 @@ import { makeId } from '../utils/id'
 import { generateCalulationMap } from './util'
 import { templateActionNameMap } from './action-name-map'
 import { templateEventPropsMap } from '../utils/event-props'
+import { sh } from '../tools/_shell'
+import { computeConfigChange, readBuildConfig } from './config-diff'
+import { appendEditRecord, editProvenance } from '../tools/_edits-log'
+import { isTruthyEnv } from '../tools/mcp-env'
 import type {
   Application,
   Data,
@@ -700,8 +704,38 @@ const compileAutomation = (automationMap: AutomationMap) =>
     }),
   )
 
+// Record the minimal compiled-config delta this compile produced to the shared audit
+// log (`.bricks/edits.jsonl`), so editing files directly and running `bun compile`
+// leaves the same trail as the MCP source-editing tools. Maintained only in the
+// editing-tools context (`BRICKS_CTOR_ENABLE_EDITING_TOOLS`); the source-editing tools
+// turn it off for their verify compiles (see _verify.ts) so a tool edit records one
+// richer entry instead of an extra generic compile entry. Also silent when there is no
+// prior build to diff against (fresh projects, package tests, tooling outside a project).
+const recordConfigChange = async (previousConfig: unknown, config: unknown) => {
+  if (previousConfig == null) return
+  if (!isTruthyEnv(process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS)) return
+  // The baseline was parsed from JSON; round-trip the fresh config the same way so keys
+  // holding undefined (dropped by the artifact's JSON.stringify) don't diff as phantom sets.
+  const change = computeConfigChange(previousConfig, JSON.parse(JSON.stringify(config)))
+  if (change.status !== 'ok') return
+  await appendEditRecord(process.cwd(), {
+    ts: new Date().toISOString(),
+    tool: 'compile',
+    provenance: editProvenance(),
+    outcome: 'ok',
+    summary:
+      change.opCount === 0
+        ? 'compile: no config change'
+        : `compile: ${change.opCount} config op(s)`,
+    configChange: change,
+  }).catch(() => undefined)
+}
+
 export const compile = async (app: Application) => {
   await new Promise((resolve) => setImmediate(resolve, 0))
+  // Snapshot the prior build artifact before the caller's compile.ts overwrites it, so
+  // the config change introduced by this compile can be recorded on return.
+  const previousConfig = await readBuildConfig(process.cwd())
   const timestamp = Date.now()
   // Pre-index subspace ids so the canvas-item validation below stays O(1).
   const subspaceIdSet = new Set(app.subspaces.map((s) => s.id))
@@ -1414,12 +1448,7 @@ export const compile = async (app: Application) => {
                 : null,
             }
 
-            Object.assign(
-              calc,
-              generateCalulationMap(calc.script_config, {
-                snapshotMode: process.env.BRICKS_SNAPSHOT_MODE === '1',
-              }),
-            )
+            Object.assign(calc, generateCalulationMap(calc.script_config, dataCalcId))
           }
           map[dataCalcId] = calc
           return map
@@ -1456,12 +1485,15 @@ export const compile = async (app: Application) => {
     automation_map: compiledAutomationMap || app.metadata?.TEMP_automation_map || {},
     update_timestamp: timestamp,
   }
+  await recordConfigChange(previousConfig, config)
   return config
 }
 
 export const checkConfig = async (configPath: string) => {
-  const { sh } = await import('../tools/_shell')
   // --validate-automation surfaces broken automation_map / test_map refs early,
   // which catches agent-authored automations that reference deleted bricks.
   await sh`bricks app check-config --validate-automation ${configPath}`
+  // Doctor adds semantic lint checks after structural validation. Warnings are
+  // surfaced in the compile log, but only errors fail by default.
+  await sh`bricks app doctor --validate-automation ${configPath}`
 }

package/compile/util.ts

@@ -1,4 +1,4 @@
-import { makeId } from '../utils/id'
+import { makeSeededId } from '../utils/id'
 
 type ScriptConfig = {
   title?: string
@@ -33,15 +33,18 @@ const padding = 15
 const layerXInterval = 300
 const layerYInterval = 150
 
-export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMode?: boolean }) => {
+// `calcId` (the owning script calc's stable id) seeds every derived command-node id, so an
+// unchanged calc recompiles to identical ids and editing one calc never shifts another's —
+// keeping the compiled config byte-stable for change detection. See makeSeededId in utils/id.
+export const generateCalulationMap = (config: ScriptConfig, calcId: string) => {
   validateConfig(config)
-  const sandboxId = makeId('property_bank_command', opts)
-  const sandboxErrorId = makeId('property_bank_command', opts)
-  const sandboxResultId = makeId('property_bank_command', opts)
+  const sandboxId = makeSeededId('property_bank_command', `${calcId}:sandbox-run`)
+  const sandboxErrorId = makeSeededId('property_bank_command', `${calcId}:sandbox-error`)
+  const sandboxResultId = makeSeededId('property_bank_command', `${calcId}:sandbox-result`)
 
   const inputs = Object.entries(config.inputs).reduce(
     (acc, [key, value], index) => {
-      const commandId = makeId('property_bank_command', opts)
+      const commandId = makeSeededId('property_bank_command', `${calcId}:input:${key}`)
       acc.map[key] = {
         type: 'data-node',
         properties: {},
@@ -123,7 +126,7 @@ export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMod
   let y = 0
   const outputs = Object.entries(config.outputs).reduce(
     (acc, [key, pbList], index) => {
-      const commandId = makeId('property_bank_command', opts)
+      const commandId = makeSeededId('property_bank_command', `${calcId}:output:${key}`)
       acc.commandIdList.push(commandId)
       acc.map[commandId] = {
         type: 'command-node-object',

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.42",
+  "version": "2.25.0-beta.45",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.42",
+    "@babel/generator": "7.28.5",
+    "@babel/parser": "7.28.5",
+    "@babel/traverse": "7.28.5",
+    "@babel/types": "7.28.5",
+    "@fugood/bricks-cli": "^2.25.0-beta.45",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -25,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "ef7ddb9d131b8e0f429f68d16585eb254f85e8e1"
+  "gitHead": "37dd0194e56025e5fe727bab6af7e2b8eb1d7ae1"
 }

package/skills/bricks-ctor/SKILL.md

@@ -12,6 +12,7 @@ This skill covers advanced BRICKS features not in the main project instructions.
 | Rule | Description |
 |------|-------------|
 | [Architecture Patterns](references/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
+| [Source-Editing Tools](references/source-editing-tools.md) | MCP tools for editing entries and data-calcs by AST (new/edit/remove, value grammar, verify) |
 | [Animation](references/animation.md) | Animation system for brick transforms and opacity |
 | [Standby Transition](references/standby-transition.md) | Canvas enter/exit animations |
 | [Automations](references/automations.md) | E2E testing and scheduled tasks |
@@ -26,6 +27,7 @@ This skill covers advanced BRICKS features not in the main project instructions.
 ## Quick Reference
 
 - **Complex flows**: See [Architecture Patterns](references/architecture-patterns.md) for decomposing multi-step workflows
+- **Editing entries/data-calcs**: See [Source-Editing Tools](references/source-editing-tools.md) — prefer the MCP editing tools over hand-editing `subspaces/**`
 - **Multi-device**: See [Local Sync](references/local-sync.md) for LAN coordination
 - **Cloud data**: See [Remote Data Bank](references/remote-data-bank.md) for sync and API access
 - **Media assets**: See [Media Flow](references/media-flow.md) for centralized asset management

package/skills/bricks-ctor/references/architecture-patterns.md

@@ -32,6 +32,12 @@ Sequential `PROPERTY_BANK` / `PROPERTY_BANK_EXPRESSION` actions in one chain rea
 Built-in commands for direct state and UI changes.
 - **PROPERTY_BANK**: set data value
 - **PROPERTY_BANK_EXPRESSION**: inline JS expression for simple compute
+  - The expression engine folds statements into a single expression: only expression
+    statements, simple `const`/`let` declarations, and a final return/expression are
+    supported — **no `if`/`for`/`while`/`switch`** (use ternaries). The same limit
+    applies inside a zero-arg IIFE body. Unsupported statements fail at runtime with
+    the error visible only in a DevTools session, so prefer ternary chains or move the
+    logic to a DataCalculationScript.
 - **CHANGE_CANVAS**: navigate to another canvas
 - **DYNAMIC_ANIMATION**: trigger animation
 - **ALERT / MESSAGE**: system feedback