@fugood/bricks-ctor 2.25.0-beta.6 → 2.25.0-beta.60

package/compile/index.ts

@@ -4,12 +4,16 @@ import upperFirst from 'lodash/upperFirst'
 import snakeCase from 'lodash/snakeCase'
 import omit from 'lodash/omit'
 import { parse as parseAST } from 'acorn'
-import type { ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
+import type { BlockStatement, ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
 import escodegen from 'escodegen'
-import { makeId } from '../utils/id'
+import { makeSeededId } 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,
@@ -71,6 +75,31 @@ const assertEntryId = (
   return id
 }
 
+// Per-compile error collection. Instead of throwing on the first bad entity, record the
+// message and skip that entity, so a single compile surfaces every entity's first error
+// (e.g. an invalid brick id, generator id and data-calc id all in one run). `errors` is
+// local to each compile() call — no shared state — and compile throws an aggregated error
+// at the end when any were collected, so a failed compile still rejects and never returns
+// or writes a partial config.
+const collect = <T>(errors: string[], fn: () => T, fallback: T): T => {
+  try {
+    return fn()
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error))
+    return fallback
+  }
+}
+
+// reduce() into an id-keyed map, recording a per-item compile error and skipping that item
+// instead of aborting the whole compile. The callback is the last argument (and the init is
+// always {}) so the formatter keeps its body inline rather than re-indenting it.
+const collectReduce = <T>(
+  errors: string[],
+  items: T[],
+  fn: (acc: Record<string, unknown>, item: T, index: number) => Record<string, unknown>,
+): Record<string, unknown> =>
+  items.reduce((acc, item, index) => collect(errors, () => fn(acc, item, index), acc), {})
+
 const compileProperty = (property, errorReference: string, result = {}) => {
   if (Array.isArray(property)) {
     return property.map((p) => compileProperty(p, errorReference))
@@ -97,17 +126,28 @@ const compileProperty = (property, errorReference: string, result = {}) => {
 const compileScriptCalculationCode = (code = '') => {
   try {
     const program = parseAST(code, { sourceType: 'module', ecmaVersion: 2020 })
-    // export function main() { ... }
-    const declarationBody = (
-      (program.body[0] as ExportNamedDeclaration).declaration as FunctionDeclaration
-    )?.body
-    return escodegen.generate(declarationBody, {
-      format: {
-        indent: { style: '  ' },
-        semicolons: false,
+    // The stored config holds the bare function body, which codegen re-wraps as
+    // `export function main() { <code> }`. Unwrap it back to that body here.
+    let block = ((program.body[0] as ExportNamedDeclaration).declaration as FunctionDeclaration)
+      ?.body as BlockStatement | undefined
+    if (!block) return code || ''
+    // Earlier versions emitted the whole BlockStatement (braces included), so every
+    // compile -> codegen round-trip nested the body in one more `{ }`. Emit the inner
+    // statements instead, collapsing any wrapper blocks previous round-trips added so
+    // existing over-wrapped sandboxes heal on the next compile.
+    while (block.body.length === 1 && block.body[0].type === 'BlockStatement') {
+      block = block.body[0] as BlockStatement
+    }
+    return escodegen.generate(
+      { type: 'Program', body: block.body },
+      {
+        format: {
+          indent: { style: '  ' },
+          semicolons: false,
+        },
+        comment: true,
       },
-      comment: true,
-    })
+    )
   } catch {
     return code || ''
   }
@@ -154,11 +194,13 @@ const basicAnimationEvents = ['show', 'standby', 'breatheStart']
 
 const compileAnimations = (
   templateKey: string,
-  animations: { [key: string]: Animation },
+  animations: { [key: string]: Animation | (() => Animation) },
   errorReference: string,
 ) =>
   Object.entries(animations).reduce((acc, [key, animation]) => {
-    const animationId = assertEntryId(animation?.id, 'ANIMATION', errorReference)
+    // Animation events accept either a direct Animation or a getter; unwrap.
+    const resolved = typeof animation === 'function' ? animation() : animation
+    const animationId = assertEntryId(resolved?.id, 'ANIMATION', errorReference)
     acc[convertEventKey(basicAnimationEvents.includes(key) ? 'BRICK' : templateKey, key)] =
       `ANIMATION#${animationId}`
     return acc
@@ -179,10 +221,17 @@ const compileEvents = (
 
       let handlerKey
       let handlerTemplateKey
-      if (handler === 'system' || typeof handler === 'string') {
-        if (handler.startsWith('SUBSPACE_')) handlerKey = handler
-        else handlerKey = handler.toUpperCase()
-        if (handlerKey === 'SYSTEM') handlerTemplateKey = 'SYSTEM'
+      if (typeof handler === 'string') {
+        // Only the literal 'system' handler is normalized to the SYSTEM template key.
+        // SubspaceID (SUBSPACE_*) and ItemBrickID handlers are kept verbatim: the runtime
+        // resolves them case-sensitively (see mapEventMapHandlersWithNewId), so uppercasing
+        // a mixed-case ItemBrickID would break handler-to-item event wiring.
+        if (handler === 'system') {
+          handlerKey = 'SYSTEM'
+          handlerTemplateKey = 'SYSTEM'
+        } else {
+          handlerKey = handler
+        }
       } else if (typeof handler === 'function') {
         let instance = handler()
         if (instance?.id) {
@@ -301,6 +350,162 @@ const animationTypeMap = {
   AnimationTimingConfig: 'timing',
   AnimationSpringConfig: 'spring',
   AnimationDecayConfig: 'decay',
+} as const
+
+type CompiledAnimationType = (typeof animationTypeMap)[keyof typeof animationTypeMap]
+type WarningMetadata = Record<string, unknown>
+
+const animationProperties = new Set([
+  'transform.translateX',
+  'transform.translateY',
+  'transform.scale',
+  'transform.scaleX',
+  'transform.scaleY',
+  'transform.rotate',
+  'transform.rotateX',
+  'transform.rotateY',
+  'opacity',
+])
+
+const animationComposeTypes = new Set(['parallel', 'sequence'])
+const springConfigFamilies = [
+  ['stiffness', 'damping', 'mass'],
+  ['tension', 'friction'],
+  ['bounciness', 'speed'],
+]
+const springConfigFamilyKeys = new Set(springConfigFamilies.flat())
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
+const hasDefinedConfigValue = (config: Record<string, unknown>, key: string) =>
+  config[key] !== undefined
+
+const assertConfigValue = (
+  config: Record<string, unknown>,
+  key: string,
+  errorReference: string,
+) => {
+  if (!hasDefinedConfigValue(config, key)) {
+    throw new Error(`Invalid animation config ${errorReference}: missing "${key}"`)
+  }
+}
+
+const assertAnimationProperty = (property: unknown, errorReference: string) => {
+  if (typeof property !== 'string' || !animationProperties.has(property)) {
+    throw new Error(
+      `Invalid animation property${errorReference ? ` ${errorReference}` : ''}: ${String(
+        property,
+      )}`,
+    )
+  }
+  return property
+}
+
+const getAnimationType = (config: unknown, errorReference: string): CompiledAnimationType => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const animationType = animationTypeMap[config.__type as keyof typeof animationTypeMap]
+  if (!animationType) {
+    throw new Error(`Invalid animation config type ${errorReference}: ${String(config.__type)}`)
+  }
+  return animationType
+}
+
+const assertAnimationComposeType = (composeType: unknown, errorReference: string) => {
+  if (typeof composeType !== 'string' || !animationComposeTypes.has(composeType)) {
+    throw new Error(`Invalid animation compose type ${errorReference}: ${String(composeType)}`)
+  }
+  return composeType
+}
+
+const pickDefinedConfigValues = (config: Record<string, unknown>, keys: string[]) =>
+  keys.reduce((acc, key) => {
+    if (hasDefinedConfigValue(config, key)) acc[key] = config[key]
+    return acc
+  }, {})
+
+const getDefinedConfigKeys = (config: Record<string, unknown>, keys: string[]) =>
+  keys.filter((key) => hasDefinedConfigValue(config, key))
+
+const formatWarningMetadata = (metadata: WarningMetadata = {}) =>
+  Object.entries(metadata)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}: ${String(value)}`)
+    .join(', ')
+
+const formatWarningReference = (metadata?: WarningMetadata) => {
+  const metadataText = formatWarningMetadata(metadata)
+  return metadataText ? ` [${metadataText}]` : ''
+}
+
+const normalizeSpringConfig = (
+  config: Record<string, unknown>,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+): Record<string, unknown> => {
+  assertConfigValue(config, 'toValue', errorReference)
+
+  const usedFamilies = springConfigFamilies.filter((keys) =>
+    keys.some((key) => hasDefinedConfigValue(config, key)),
+  )
+  if (usedFamilies.length <= 1) return config
+
+  const configWithoutSpringFamily = Object.entries(config).reduce((acc, [key, value]) => {
+    if (!springConfigFamilyKeys.has(key)) acc[key] = value
+    return acc
+  }, {})
+
+  // Match runtime normalization: physical spring values are most explicit,
+  // otherwise preserve BRICKS' historical tension/friction controls.
+  const resolvedFamily =
+    usedFamilies.find((keys) => keys.includes('stiffness')) ||
+    usedFamilies.find((keys) => keys.includes('tension')) ||
+    usedFamilies[0]
+  const resolvedFamilyKeys = getDefinedConfigKeys(config, resolvedFamily)
+  const droppedFamilyKeys = usedFamilies
+    .filter((keys) => keys !== resolvedFamily)
+    .flatMap((keys) => getDefinedConfigKeys(config, keys))
+
+  console.warn(
+    `[Warning] Resolved animation spring config${formatWarningReference(
+      warningMetadata,
+    )}: using ${resolvedFamilyKeys.join('/')}, dropping ${droppedFamilyKeys.join('/')}`,
+  )
+
+  return {
+    ...configWithoutSpringFamily,
+    ...pickDefinedConfigValues(config, resolvedFamily),
+  }
+}
+
+const compileAnimationConfig = (
+  animationType: CompiledAnimationType,
+  config: unknown,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+) => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const compiledConfig = compileProperty(omit(config, '__type'), errorReference)
+
+  if (!isRecord(compiledConfig)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must compile to an object`)
+  }
+
+  if (animationType === 'timing') {
+    assertConfigValue(compiledConfig, 'toValue', errorReference)
+  } else if (animationType === 'spring') {
+    return normalizeSpringConfig(compiledConfig, errorReference, warningMetadata)
+  } else if (animationType === 'decay') {
+    assertConfigValue(compiledConfig, 'velocity', errorReference)
+  }
+
+  return compiledConfig
 }
 
 const compileFrame = (frame: Canvas['items'][number]['frame']) => ({
@@ -324,9 +529,12 @@ const preloadTypes = [
   'media-resource-audio',
   'media-resource-file',
   'lottie-file-uri',
+  'rive-file-uri',
   'ggml-model-asset',
   'gguf-model-asset',
   'binary-asset',
+  'mlx-model-asset',
+  'scene3d-objects',
 ]
 
 const compileKind = (kind: Data['kind']) => {
@@ -353,9 +561,10 @@ const compileKind = (kind: Data['kind']) => {
 }
 
 const compileRemoteUpdate = (remoteUpdate: Data['remoteUpdate']) => {
-  if (!remoteUpdate) return {}
-  if (remoteUpdate.type === 'auto') return { enable_remote_update: true }
+  if (!remoteUpdate) return { bank_type: 'none' }
+  if (remoteUpdate.type === 'auto') return { bank_type: 'create', enable_remote_update: true }
   return {
+    bank_type: remoteUpdate.type === 'device-specific' ? 'create-device-specific' : 'global',
     enable_remote_update: true,
     ...(remoteUpdate.type === 'device-specific' ? { use_remote_id_prefix: true } : {}),
     ...(remoteUpdate.type === 'global-data' ? { global_remote_update_prop: remoteUpdate.id } : {}),
@@ -411,7 +620,7 @@ function compileRunArray(run: unknown[]): unknown[] {
 /**
  * Compile typed TestCase to raw format (strips __typename)
  */
-const compileTestCase = (testCase: TestCase) => ({
+export const compileTestCase = (testCase: TestCase) => ({
   id: testCase.id,
   name: testCase.name,
   hide_short_ref: testCase.hideShortRef,
@@ -433,7 +642,10 @@ const compileTestCase = (testCase: TestCase) => ({
       variable: cond.variable,
       operator: cond.operator,
       value: cond.value,
-      jump_to: cond.jump_to,
+      // `jump_to` may be a getter (() => TestCase) for dynamic case ids (the project generator
+      // emits this form). Resolve it to its id like the `run` array does — otherwise the function
+      // is JSON-serialized to nothing and the conditional jump silently vanishes from the config.
+      jump_to: compileRunElement(cond.jump_to),
     }
   }),
 })
@@ -485,6 +697,7 @@ const compileAutomationTest = (
 
   return {
     id: testId,
+    alias: test.alias,
     title: test.title,
     hide_short_ref: test.hideShortRef,
     timeout: test.timeout,
@@ -538,12 +751,60 @@ const compileAutomation = (automationMap: AutomationMap) =>
     }),
   )
 
+const buildDefaultExpandedState = (subspace: Subspace) => ({
+  brick: false,
+  generator: true,
+  canvas: (subspace.canvases || []).reduce((acc, canvas) => {
+    if (canvas?.id) acc[canvas.id] = false
+    return acc
+  }, {}),
+  property_bank: false,
+  property_bank_calc: true,
+})
+
+// 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; `computeConfigChange` applies the same
+  // JSON-omitted-field rules lazily so compile avoids cloning the full config.
+  const change = computeConfigChange(previousConfig, 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))
+  // Collected entity-level compile errors (see collect/collectReduce). Aggregated and
+  // thrown at the end so one compile reports every entity's first error.
+  const errors: string[] = []
+  // 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))
-  const compiledAutomationMap = app.automationMap ? compileAutomation(app.automationMap) : null
+  let compiledAutomationMap: ReturnType<typeof compileAutomation> | null = null
+  if (app.automationMap) {
+    const { automationMap } = app
+    compiledAutomationMap = collect(errors, () => compileAutomation(automationMap), null)
+  }
   const config = {
     title: `${app.name || 'Unknown'}(${timestamp})`,
     subspace_map: app.subspaces.reduce((subspaceMap, subspace, subspaceIndex) => {
@@ -559,7 +820,14 @@ export const compile = async (app: Application) => {
       // validation (root_canvas_id is required before the conditional
       // schema fix is published).
       if (subspace.module?.link) {
-        const placeholderCanvasId = makeId('canvas')
+        // Seed the placeholder id from the (stable) subspace id. `makeId('canvas')` would take
+        // the count-fallback branch (a process-global counter that is never reset), so the
+        // placeholder id depended on how many prior count-fallback ids had been minted — making
+        // it differ between recompiles and breaking compile's byte-stable-output contract
+        // (phantom config-change ops). `makeSeededId` keeps no global state, so identical source
+        // recompiles to an identical id. (`makeId('canvas', alias)` would instead throw
+        // "Duplicate makeId alias" on the second compile in a long-lived process.)
+        const placeholderCanvasId = makeSeededId('canvas', `${subspaceId}:module-placeholder`)
         subspaceMap[subspaceId] = {
           title: subspace.title,
           description: subspace.description,
@@ -611,7 +879,7 @@ export const compile = async (app: Application) => {
               property_bank: !subspace.unexpanded.data,
               property_bank_calc: !subspace.unexpanded.dataCalculation,
             }
-          : undefined,
+          : buildDefaultExpandedState(subspace),
         layout: {
           width: subspace.layout?.width,
           height: subspace.layout?.height,
@@ -622,50 +890,78 @@ export const compile = async (app: Application) => {
               change_canvas: subspace.localSyncChangeCanvas,
             }
           : undefined,
-        animation_map: subspace.animations.reduce((map, animation, animationIndex) => {
-          const animationId = assertEntryId(
-            animation?.id,
-            'ANIMATION',
-            `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
-          )
+        animation_map: collectReduce(
+          errors,
+          subspace.animations,
+          (map, animation, animationIndex) => {
+            const animationId = assertEntryId(
+              animation?.id,
+              'ANIMATION',
+              `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
+            )
 
-          if (animation.__typename === 'Animation') {
-            const animationDef = animation as AnimationDef
-            map[animationId] = {
-              alias: animationDef.alias,
-              title: animationDef.title,
-              description: animationDef.description,
-              hide_short_ref: animationDef.hideShortRef,
-              animationRunType: animationDef.runType,
-              property: animationDef.property,
-              type: animationTypeMap[animationDef.config.__type],
-              config: compileProperty(
-                omit(animationDef.config, '__type'),
-                `(animation: ${animationId}, subspace ${subspaceId})`,
-              ),
-            }
-          } else if (animation.__typename === 'AnimationCompose') {
-            const animationDef = animation as AnimationComposeDef
-            map[animationId] = {
-              alias: animationDef.alias,
-              title: animationDef.title,
-              description: animationDef.description,
-              hide_short_ref: animationDef.hideShortRef,
-              animationRunType: animationDef.runType,
-              compose_type: animationDef.composeType,
-              item_list: animationDef.items.map((item, index) => {
-                const innerAnimation = item()
-                if (!innerAnimation?.id)
-                  throw new Error(
-                    `Invalid animation index: ${index} (animation: ${innerAnimation.id}, subspace ${subspaceId})`,
+            const animationTypename = animation.__typename
+            if (animationTypename === 'Animation') {
+              const animationDef = animation as AnimationDef
+              const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
+              const animationWarningMetadata = {
+                animationIndex,
+                animationTitle: animationDef.title,
+                animationAlias: animationDef.alias,
+                animationProperty: animationDef.property,
+                subspaceIndex,
+                subspaceTitle: subspace.title,
+              }
+              const animationType = getAnimationType(animationDef.config, animationErrorReference)
+              map[animationId] = {
+                alias: animationDef.alias,
+                title: animationDef.title,
+                description: animationDef.description,
+                hide_short_ref: animationDef.hideShortRef,
+                animationRunType: animationDef.runType,
+                property: assertAnimationProperty(animationDef.property, animationErrorReference),
+                type: animationType,
+                config: compileAnimationConfig(
+                  animationType,
+                  animationDef.config,
+                  animationErrorReference,
+                  animationWarningMetadata,
+                ),
+              }
+            } else if (animationTypename === 'AnimationCompose') {
+              const animationDef = animation as AnimationComposeDef
+              const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
+              map[animationId] = {
+                alias: animationDef.alias,
+                title: animationDef.title,
+                description: animationDef.description,
+                hide_short_ref: animationDef.hideShortRef,
+                animationRunType: animationDef.runType,
+                compose_type: assertAnimationComposeType(
+                  animationDef.composeType,
+                  animationErrorReference,
+                ),
+                item_list: animationDef.items.map((item, index) => {
+                  const innerAnimation = item()
+                  const innerAnimationId = assertEntryId(
+                    innerAnimation?.id,
+                    'ANIMATION',
+                    `(animation item index: ${index}, animation: ${animationId}, subspace ${subspaceId})`,
                   )
-                return { animation_id: innerAnimation.id }
-              }),
+                  return { animation_id: innerAnimationId }
+                }),
+              }
+            } else {
+              throw new Error(
+                `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
+                  animationTypename,
+                )}`,
+              )
             }
-          }
-          return map
-        }, {}),
-        brick_map: subspace.bricks.reduce((map, brick, brickIndex) => {
+            return map
+          },
+        ),
+        brick_map: collectReduce(errors, subspace.bricks, (map, brick, brickIndex) => {
           const brickId = assertEntryId(
             brick.id,
             'BRICK',
@@ -830,9 +1126,9 @@ export const compile = async (app: Application) => {
             }, {}),
           }
           return map
-        }, {}),
+        }),
         root_canvas_id: rootCanvasId,
-        canvas_map: subspace.canvases.reduce((map, canvas, canvasIndex) => {
+        canvas_map: collectReduce(errors, subspace.canvases, (map, canvas, canvasIndex) => {
           const canvasId = assertEntryId(
             canvas.id,
             'CANVAS',
@@ -912,81 +1208,85 @@ export const compile = async (app: Application) => {
             }),
           }
           return map
-        }, {}),
-        generator_map: subspace.generators.reduce((map, generator, generatorIndex) => {
-          const generatorId = assertEntryId(
-            generator.id,
-            'GENERATOR',
-            `(generator index: ${generatorIndex}, subspace: ${subspaceId})`,
-          )
+        }),
+        generator_map: collectReduce(
+          errors,
+          subspace.generators,
+          (map, generator, generatorIndex) => {
+            const generatorId = assertEntryId(
+              generator.id,
+              'GENERATOR',
+              `(generator index: ${generatorIndex}, subspace: ${subspaceId})`,
+            )
 
-          map[generatorId] = {
-            template_key: generator.templateKey,
-            alias: generator.alias,
-            title: generator.title,
-            description: generator.description,
-            hide_short_ref: generator.hideShortRef,
-            local_sync: generator.localSyncRunMode
-              ? {
-                  run_mode: generator.localSyncRunMode,
-                }
-              : undefined,
-            property: compileProperty(
-              generator.property || {},
-              `(generator: ${generatorId}, subspace ${subspaceId})`,
-            ),
-            event_map: compileEvents(generator.templateKey, generator.events || {}, {
-              camelCase: false,
-              errorReference: `(generator: ${generatorId}, subspace ${subspaceId})`,
-            }),
-            outlet: compileOutlets(
-              generator.templateKey,
-              generator.outlets || {},
-              `(generator: ${generatorId}, subspace ${subspaceId})`,
-            ),
-            state_group: generator.switches?.reduce((acc, switchCase, switchIndex) => {
-              const switchId = assertEntryId(
-                switchCase.id,
-                'BRICK_STATE_GROUP',
-                `(generator: ${generatorId}, switch index: ${switchIndex}, subspace ${subspaceId})`,
-              )
+            map[generatorId] = {
+              template_key: generator.templateKey,
+              alias: generator.alias,
+              title: generator.title,
+              description: generator.description,
+              hide_short_ref: generator.hideShortRef,
+              local_sync: generator.localSyncRunMode
+                ? {
+                    run_mode: generator.localSyncRunMode,
+                  }
+                : undefined,
+              property: compileProperty(
+                generator.property || {},
+                `(generator: ${generatorId}, subspace ${subspaceId})`,
+              ),
+              event_map: compileEvents(generator.templateKey, generator.events || {}, {
+                camelCase: false,
+                errorReference: `(generator: ${generatorId}, subspace ${subspaceId})`,
+              }),
+              outlet: compileOutlets(
+                generator.templateKey,
+                generator.outlets || {},
+                `(generator: ${generatorId}, subspace ${subspaceId})`,
+              ),
+              state_group: generator.switches?.reduce((acc, switchCase, switchIndex) => {
+                const switchId = assertEntryId(
+                  switchCase.id,
+                  'BRICK_STATE_GROUP',
+                  `(generator: ${generatorId}, switch index: ${switchIndex}, subspace ${subspaceId})`,
+                )
 
-              acc[switchId] = {
-                title: switchCase.title,
-                description: switchCase.description,
-                break: switchCase.break,
-                override: switchCase.override,
-                commented: switchCase.disabled,
-                conds: compileSwitchConds(
-                  generator.templateKey,
-                  switchCase.conds || [],
-                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                property: compileProperty(
-                  switchCase.property,
-                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                outlet: compileOutlets(
-                  generator.templateKey,
-                  switchCase.outlets || {},
-                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                event_map: compileEvents(generator.templateKey, switchCase.events || {}, {
-                  camelCase: false,
-                  errorReference: `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
-                }),
-                animation: compileAnimations(
-                  generator.templateKey,
-                  switchCase.animation || {},
-                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-              }
-              return acc
-            }, {}),
-          }
-          return map
-        }, {}),
-        property_bank_map: subspace.data.reduce((map, data, dataIndex) => {
+                acc[switchId] = {
+                  title: switchCase.title,
+                  description: switchCase.description,
+                  break: switchCase.break,
+                  override: switchCase.override,
+                  commented: switchCase.disabled,
+                  conds: compileSwitchConds(
+                    generator.templateKey,
+                    switchCase.conds || [],
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  property: compileProperty(
+                    switchCase.property,
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  outlet: compileOutlets(
+                    generator.templateKey,
+                    switchCase.outlets || {},
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  event_map: compileEvents(generator.templateKey, switchCase.events || {}, {
+                    camelCase: false,
+                    errorReference: `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  }),
+                  animation: compileAnimations(
+                    generator.templateKey,
+                    switchCase.animation || {},
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                }
+                return acc
+              }, {}),
+            }
+            return map
+          },
+        ),
+        property_bank_map: collectReduce(errors, subspace.data, (map, data, dataIndex) => {
           const dataId = assertEntryId(
             data.id,
             'PROPERTY_BANK_DATA_NODE',
@@ -1009,7 +1309,7 @@ export const compile = async (app: Application) => {
             ...compileRemoteUpdate(data.remoteUpdate),
             routing: data.routing,
             schema: data.schema,
-            type: data.type,
+            type: data.type === 'boolean' ? 'bool' : data.type,
             ...compileKind(data.kind),
             value: compileProperty(data.value, `(data: ${dataId}, subspace ${subspaceId})`),
             event_map: compileEvents('PROPERTY_BANK', data.events || {}, {
@@ -1020,229 +1320,229 @@ export const compile = async (app: Application) => {
             hit_regex: data.hit_regex,
           }
           return map
-        }, {}),
-        property_bank_calc_map: subspace.dataCalculation.reduce((map, dataCalc, dataCalcIndex) => {
-          const dataCalcId = assertEntryId(
-            dataCalc.id,
-            'PROPERTY_BANK_COMMAND_MAP',
-            `(data calc index: ${dataCalcIndex}, subspace: ${subspaceId})`,
-          )
+        }),
+        property_bank_calc_map: collectReduce(
+          errors,
+          subspace.dataCalculation,
+          (map, dataCalc, dataCalcIndex) => {
+            const dataCalcId = assertEntryId(
+              dataCalc.id,
+              'PROPERTY_BANK_COMMAND_MAP',
+              `(data calc index: ${dataCalcIndex}, subspace: ${subspaceId})`,
+            )
 
-          const calc: any = {
-            title: dataCalc.title,
-            description: dataCalc.description,
-            hide_short_ref: dataCalc.hideShortRef,
-          }
-          if (dataCalc.triggerMode) calc.trigger_type = dataCalc.triggerMode
-          if (dataCalc.__typename === 'DataCalculationMap') {
-            calc.type = 'general'
-            const mapCalc = dataCalc as DataCalculationMap
-
-            const getNodeId = (
-              node: DataCalculationData | DataCommand,
-              reference = '',
-              nodeIndex?: number,
-            ) => {
-              const nodeReference = [
-                `data calc: ${dataCalcId}`,
-                `subspace: ${subspaceId}`,
-                typeof nodeIndex === 'number' ? `node index: ${nodeIndex}` : undefined,
-                reference || undefined,
-              ]
-                .filter(Boolean)
-                .join(', ')
-
-              if (node.__typename === 'DataCalculationData') {
-                return assertEntryId(
-                  node.data()?.id,
-                  'PROPERTY_BANK_DATA_NODE',
-                  `(${nodeReference})`,
-                )
-              }
-              if (node.__typename === 'DataCommand') {
-                return assertEntryId(node.id, 'PROPERTY_BANK_COMMAND_NODE', `(${nodeReference})`)
-              }
-              throw new Error(`Invalid node: ${JSON.stringify(node)}`)
+            const calc: any = {
+              alias: dataCalc.alias,
+              title: dataCalc.title,
+              description: dataCalc.description,
+              hide_short_ref: dataCalc.hideShortRef,
             }
-
-            const generateInputPorts = (inputs) =>
-              inputs.reduce((acc, port, portIndex) => {
-                if (!acc[port.key]) acc[port.key] = null
-
-                let sourceId
-                const sourceNode = port.source()
-                if (
-                  sourceNode?.__typename === 'DataCalculationData' ||
-                  sourceNode?.__typename === 'DataCommand'
-                ) {
-                  sourceId = getNodeId(sourceNode, `input port index: ${portIndex}`)
+            if (dataCalc.triggerMode) calc.trigger_type = dataCalc.triggerMode
+            if (dataCalc.__typename === 'DataCalculationMap') {
+              calc.type = 'general'
+              const mapCalc = dataCalc as DataCalculationMap
+
+              const getNodeId = (
+                node: DataCalculationData | DataCommand,
+                reference = '',
+                nodeIndex?: number,
+              ) => {
+                const nodeReference = [
+                  `data calc: ${dataCalcId}`,
+                  `subspace: ${subspaceId}`,
+                  typeof nodeIndex === 'number' ? `node index: ${nodeIndex}` : undefined,
+                  reference || undefined,
+                ]
+                  .filter(Boolean)
+                  .join(', ')
+
+                if (node.__typename === 'DataCalculationData') {
+                  return assertEntryId(
+                    node.data()?.id,
+                    'PROPERTY_BANK_DATA_NODE',
+                    `(${nodeReference})`,
+                  )
                 }
+                if (node.__typename === 'DataCommand') {
+                  return assertEntryId(node.id, 'PROPERTY_BANK_COMMAND_NODE', `(${nodeReference})`)
+                }
+                throw new Error(`Invalid node: ${JSON.stringify(node)}`)
+              }
 
-                if (!sourceId) return acc
-                if (!acc[port.key]) acc[port.key] = []
-
-                acc[port.key].push({
-                  id: sourceId,
-                  port: port.sourceKey,
-                  disable_trigger_command: !port.trigger ? true : undefined,
-                })
+              const generateInputPorts = (inputs) =>
+                inputs.reduce((acc, port, portIndex) => {
+                  if (!acc[port.key]) acc[port.key] = null
+
+                  let sourceId
+                  const sourceNode = port.source()
+                  if (
+                    sourceNode?.__typename === 'DataCalculationData' ||
+                    sourceNode?.__typename === 'DataCommand'
+                  ) {
+                    sourceId = getNodeId(sourceNode, `input port index: ${portIndex}`)
+                  }
+
+                  if (!sourceId) return acc
+                  if (!acc[port.key]) acc[port.key] = []
+
+                  acc[port.key].push({
+                    id: sourceId,
+                    port: port.sourceKey,
+                    disable_trigger_command: !port.trigger ? true : undefined,
+                  })
+                  return acc
+                }, {})
+
+              const generateOutputPorts = (outputs) =>
+                outputs.reduce((acc, port, portIndex) => {
+                  if (!acc[port.key]) acc[port.key] = null
+
+                  let targetId
+                  const targetNode = port.target()
+                  if (
+                    targetNode?.__typename === 'DataCalculationData' ||
+                    targetNode?.__typename === 'DataCommand'
+                  ) {
+                    targetId = getNodeId(targetNode, `output port index: ${portIndex}`)
+                  }
+
+                  if (!targetId) return acc
+                  if (!acc[port.key]) acc[port.key] = []
+
+                  acc[port.key].push({
+                    id: targetId,
+                    port: port.targetKey,
+                  })
+                  return acc
+                }, {})
+
+              calc.map = mapCalc.nodes.reduce((acc, node, nodeIndex) => {
+                if (node.__typename === 'DataCalculationData') {
+                  const dataNode = node as DataCalculationData
+                  acc[getNodeId(dataNode, 'data node', nodeIndex)] = {
+                    title: dataNode.title,
+                    description: dataNode.description,
+                    hide_short_ref: dataNode.hideShortRef,
+                    type: 'data-node',
+                    properties: {},
+                    in: generateInputPorts(dataNode.inputs),
+                    out: generateOutputPorts(dataNode.outputs),
+                  }
+                } else if (node.__typename === 'DataCommand') {
+                  const commandNode = node as DataCommand
+                  const commandName = commandNode.__commandName
+                  const type = commandName.split('_')[0].toLowerCase()
+
+                  const args = commandNode.inputs.filter(
+                    (input) =>
+                      typeof input.source !== 'function' ||
+                      (input.source()?.__typename !== 'DataCalculationData' &&
+                        input.source()?.__typename !== 'DataCommand'),
+                  )
+                  const inputs = commandNode.inputs.filter(
+                    (input) =>
+                      typeof input.source === 'function' &&
+                      (input.source()?.__typename === 'DataCalculationData' ||
+                        input.source()?.__typename === 'DataCommand'),
+                  )
+                  acc[getNodeId(commandNode, 'command node', nodeIndex)] = {
+                    title: commandNode.title,
+                    description: commandNode.description,
+                    hide_short_ref: commandNode.hideShortRef,
+                    type: `command-node-${type}`,
+                    properties: {
+                      command: commandNode.__commandName,
+                      args: args.reduce((argsAcc, input) => {
+                        argsAcc[input.key] = input.source
+                        return argsAcc
+                      }, {}),
+                    },
+                    in: generateInputPorts(inputs),
+                    out: generateOutputPorts(commandNode.outputs),
+                  }
+                }
                 return acc
               }, {})
-
-            const generateOutputPorts = (outputs) =>
-              outputs.reduce((acc, port, portIndex) => {
-                if (!acc[port.key]) acc[port.key] = null
-
-                let targetId
-                const targetNode = port.target()
-                if (
-                  targetNode?.__typename === 'DataCalculationData' ||
-                  targetNode?.__typename === 'DataCommand'
-                ) {
-                  targetId = getNodeId(targetNode, `output port index: ${portIndex}`)
+              calc.editor_info = mapCalc.editorInfo.reduce((acc, editorInfo) => {
+                acc[getNodeId(editorInfo.node, 'editor info node')] = {
+                  position: editorInfo.position,
+                  points: editorInfo.points.reduce((pointsAcc, point) => {
+                    const sourceId = getNodeId(point.source, 'editor info point source')
+                    const targetId = getNodeId(point.target, 'editor info point target')
+                    const key = `${sourceId}-${point.sourceOutputKey}-${targetId}-${point.targetInputKey}`
+                    pointsAcc[key] = point.positions
+                    return pointsAcc
+                  }, {}),
                 }
-
-                if (!targetId) return acc
-                if (!acc[port.key]) acc[port.key] = []
-
-                acc[port.key].push({
-                  id: targetId,
-                  port: port.targetKey,
-                })
                 return acc
               }, {})
-
-            calc.map = mapCalc.nodes.reduce((acc, node, nodeIndex) => {
-              if (node.__typename === 'DataCalculationData') {
-                const dataNode = node as DataCalculationData
-                acc[getNodeId(dataNode, 'data node', nodeIndex)] = {
-                  title: dataNode.title,
-                  description: dataNode.description,
-                  hide_short_ref: dataNode.hideShortRef,
-                  type: 'data-node',
-                  properties: {},
-                  in: generateInputPorts(dataNode.inputs),
-                  out: generateOutputPorts(dataNode.outputs),
-                }
-              } else if (node.__typename === 'DataCommand') {
-                const commandNode = node as DataCommand
-                const commandName = commandNode.__commandName
-                const type = commandName.split('_')[0].toLowerCase()
-
-                const args = commandNode.inputs.filter(
-                  (input) =>
-                    typeof input.source !== 'function' ||
-                    (input.source()?.__typename !== 'DataCalculationData' &&
-                      input.source()?.__typename !== 'DataCommand'),
-                )
-                const inputs = commandNode.inputs.filter(
-                  (input) =>
-                    typeof input.source === 'function' &&
-                    (input.source()?.__typename === 'DataCalculationData' ||
-                      input.source()?.__typename === 'DataCommand'),
-                )
-                acc[getNodeId(commandNode, 'command node', nodeIndex)] = {
-                  title: commandNode.title,
-                  description: commandNode.description,
-                  hide_short_ref: commandNode.hideShortRef,
-                  type: `command-node-${type}`,
-                  properties: {
-                    command: commandNode.__commandName,
-                    args: args.reduce((argsAcc, input) => {
-                      argsAcc[input.key] = input.source
-                      return argsAcc
-                    }, {}),
-                  },
-                  in: generateInputPorts(inputs),
-                  out: generateOutputPorts(commandNode.outputs),
-                }
-              }
-              return acc
-            }, {})
-            calc.editor_info = mapCalc.editorInfo.reduce((acc, editorInfo) => {
-              acc[getNodeId(editorInfo.node, 'editor info node')] = {
-                position: editorInfo.position,
-                points: editorInfo.points.reduce((pointsAcc, point) => {
-                  const sourceId = getNodeId(point.source, 'editor info point source')
-                  const targetId = getNodeId(point.target, 'editor info point target')
-                  const key = `${sourceId}-${point.sourceOutputKey}-${targetId}-${point.targetInputKey}`
-                  pointsAcc[key] = point.positions
-                  return pointsAcc
+            } else if (dataCalc.__typename === 'DataCalculationScript') {
+              const scriptCalc = dataCalc as DataCalculationScript
+              calc.type = 'script'
+
+              const code = compileScriptCalculationCode(scriptCalc.code)
+              calc.script_config = {
+                title: scriptCalc.title ?? '',
+                note: scriptCalc.note ?? '',
+                code,
+                enable_async: scriptCalc.enableAsync,
+                trigger_mode: scriptCalc.triggerMode,
+                inputs: scriptCalc.inputs.reduce((acc, input) => {
+                  const inputId = assertEntryId(
+                    input.data()?.id,
+                    'PROPERTY_BANK_DATA_NODE',
+                    `(data calc: ${dataCalcId}, script input: ${input.key}, subspace: ${subspaceId})`,
+                  )
+                  acc[inputId] = input.key
+                  return acc
                 }, {}),
-              }
-              return acc
-            }, {})
-          } else if (dataCalc.__typename === 'DataCalculationScript') {
-            const scriptCalc = dataCalc as DataCalculationScript
-            calc.type = 'script'
-
-            const code = compileScriptCalculationCode(scriptCalc.code)
-            calc.script_config = {
-              title: scriptCalc.title ?? '',
-              note: scriptCalc.note ?? '',
-              code,
-              enable_async: scriptCalc.enableAsync,
-              trigger_mode: scriptCalc.triggerMode,
-              inputs: scriptCalc.inputs.reduce((acc, input) => {
-                const inputId = assertEntryId(
-                  input.data()?.id,
-                  'PROPERTY_BANK_DATA_NODE',
-                  `(data calc: ${dataCalcId}, script input: ${input.key}, subspace: ${subspaceId})`,
-                )
-                acc[inputId] = input.key
-                return acc
-              }, {}),
-              disabled_triggers: scriptCalc.inputs.reduce((acc, input) => {
-                const inputId = assertEntryId(
-                  input.data()?.id,
-                  'PROPERTY_BANK_DATA_NODE',
-                  `(data calc: ${dataCalcId}, script trigger input: ${input.key}, subspace: ${subspaceId})`,
-                )
-                acc[inputId] = !input.trigger
-                return acc
-              }, {}),
-              output: scriptCalc.output
-                ? assertEntryId(
-                    scriptCalc.output()?.id,
+                disabled_triggers: scriptCalc.inputs.reduce((acc, input) => {
+                  const inputId = assertEntryId(
+                    input.data()?.id,
                     'PROPERTY_BANK_DATA_NODE',
-                    `(data calc: ${dataCalcId}, script output, subspace: ${subspaceId})`,
+                    `(data calc: ${dataCalcId}, script trigger input: ${input.key}, subspace: ${subspaceId})`,
                   )
-                : null,
-              outputs: scriptCalc.outputs.reduce((acc, output) => {
-                if (!acc[output.key]) acc[output.key] = []
-                const outputId = assertEntryId(
-                  output.data()?.id,
-                  'PROPERTY_BANK_DATA_NODE',
-                  `(data calc: ${dataCalcId}, script outputs key: ${output.key}, subspace: ${subspaceId})`,
-                )
-                acc[output.key].push(outputId)
-                return acc
-              }, {}),
-              error: scriptCalc.error
-                ? assertEntryId(
-                    scriptCalc.error()?.id,
+                  acc[inputId] = !input.trigger
+                  return acc
+                }, {}),
+                output: scriptCalc.output
+                  ? assertEntryId(
+                      scriptCalc.output()?.id,
+                      'PROPERTY_BANK_DATA_NODE',
+                      `(data calc: ${dataCalcId}, script output, subspace: ${subspaceId})`,
+                    )
+                  : null,
+                outputs: scriptCalc.outputs.reduce((acc, output) => {
+                  if (!acc[output.key]) acc[output.key] = []
+                  const outputId = assertEntryId(
+                    output.data()?.id,
                     'PROPERTY_BANK_DATA_NODE',
-                    `(data calc: ${dataCalcId}, script error output, subspace: ${subspaceId})`,
+                    `(data calc: ${dataCalcId}, script outputs key: ${output.key}, subspace: ${subspaceId})`,
                   )
-                : null,
-            }
+                  acc[output.key].push(outputId)
+                  return acc
+                }, {}),
+                error: scriptCalc.error
+                  ? assertEntryId(
+                      scriptCalc.error()?.id,
+                      'PROPERTY_BANK_DATA_NODE',
+                      `(data calc: ${dataCalcId}, script error output, subspace: ${subspaceId})`,
+                    )
+                  : null,
+              }
 
-            Object.assign(
-              calc,
-              generateCalulationMap(calc.script_config, {
-                snapshotMode: process.env.BRICKS_SNAPSHOT_MODE === '1',
-              }),
-            )
-          }
-          map[dataCalcId] = calc
-          return map
-        }, {}),
+              Object.assign(calc, generateCalulationMap(calc.script_config, dataCalcId))
+            }
+            map[dataCalcId] = calc
+            return map
+          },
+        ),
         action_map: subspace.actions || undefined,
         event_map: compileEvents('', subspace.events || {}, {
           camelCase: false,
           errorReference: `(subspace ${subspaceId})`,
         }),
-        routing: subspace.dataRouting.reduce((acc, data, index) => {
+        routing: collectReduce(errors, subspace.dataRouting, (acc, data, index) => {
           const dataId = assertEntryId(
             data?.id,
             'PROPERTY_BANK_DATA_NODE',
@@ -1250,15 +1550,15 @@ export const compile = async (app: Application) => {
           )
           acc[dataId] = { enabled_routing: true }
           return acc
-        }, {}),
+        }),
         ...compileModule(subspace),
       }
       return subspaceMap
     }, {}),
-    root_subspace_id: assertEntryId(
-      app.rootSubspace?.id,
-      'SUBSPACE',
-      '(application root subspace)',
+    root_subspace_id: collect(
+      errors,
+      () => assertEntryId(app.rootSubspace?.id, 'SUBSPACE', '(application root subspace)'),
+      '',
     ),
     fonts: app.fonts,
     ...compileApplicationSettings(app.settings),
@@ -1269,10 +1569,26 @@ export const compile = async (app: Application) => {
     automation_map: compiledAutomationMap || app.metadata?.TEMP_automation_map || {},
     update_timestamp: timestamp,
   }
+  if (errors.length > 0) {
+    throw new Error(
+      `Compile failed with ${errors.length} error(s):\n` +
+        errors.map((message, index) => `  ${index + 1}. ${message}`).join('\n'),
+    )
+  }
+  await recordConfigChange(previousConfig, config)
   return config
 }
 
 export const checkConfig = async (configPath: string) => {
-  const { sh } = await import('../tools/_shell')
-  await sh`bricks app check-config ${configPath}`
+  // --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. Older published
+  // bricks-cli builds lack `app doctor` — skip rather than fail the compile.
+  const doctor = await sh`bricks app doctor --validate-automation ${configPath}`.nothrow()
+  if (doctor.exitCode !== 0) {
+    if (/unknown command/i.test(doctor.stderr?.toString() ?? '')) return
+    throw new Error(`bricks app doctor failed with exit ${doctor.exitCode}`)
+  }
 }