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

package/compile/index.ts

@@ -1,1594 +0,0 @@
-/* eslint-disable no-underscore-dangle -- Uses __typename, __actionName, etc. for type system */
-import camelCase from 'lodash/camelCase'
-import upperFirst from 'lodash/upperFirst'
-import snakeCase from 'lodash/snakeCase'
-import omit from 'lodash/omit'
-import { parse as parseAST } from 'acorn'
-import type { BlockStatement, ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
-import escodegen from 'escodegen'
-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,
-  DataAssetKind,
-  Animation,
-  AnimationDef,
-  AnimationComposeDef,
-  ActionWithDataParams,
-  ActionWithParams,
-  BrickItems,
-  SwitchCondData,
-  SwitchCondInnerStateCurrentCanvas,
-  SwitchCondPropertyBankByItemKey,
-  DataCalculationMap,
-  DataCalculationScript,
-  DataCalculationData,
-  DataCommand,
-  Brick,
-  Canvas,
-  Subspace,
-  AutomationMap,
-  AutomationTestMap,
-  AutomationTest,
-  TestCase,
-  TestVariable,
-} from '../types'
-
-const uuidPattern = '[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}'
-
-const entryIdPatterns = {
-  SUBSPACE: new RegExp(`^SUBSPACE_${uuidPattern}$`),
-  CANVAS: new RegExp(`^CANVAS_${uuidPattern}$`),
-  BRICK: new RegExp(`^BRICK_${uuidPattern}$`),
-  GENERATOR: new RegExp(`^(GENERATOR|AUTO_GENERATOR)_${uuidPattern}$`),
-  ANIMATION: new RegExp(`^ANIMATION_${uuidPattern}$`),
-  PROPERTY_BANK_DATA_NODE: new RegExp(`^PROPERTY_BANK_DATA_NODE_${uuidPattern}$`),
-  PROPERTY_BANK_COMMAND_NODE: new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuidPattern}$`),
-  PROPERTY_BANK_COMMAND_MAP: new RegExp(`^PROPERTY_BANK_COMMAND_MAP_${uuidPattern}$`),
-  BRICK_STATE_GROUP: new RegExp(`^BRICK_STATE_GROUP_${uuidPattern}$`),
-  TEST: new RegExp(`^TEST_${uuidPattern}$`),
-  TEST_CASE: new RegExp(`^TEST_CASE_${uuidPattern}$`),
-  TEST_VAR: new RegExp(`^TEST_VAR_${uuidPattern}$`),
-  AUTOMATION_MAP: /^AUTOMATION_MAP_.*/,
-} as const
-
-type EntryIdPatternKey = keyof typeof entryIdPatterns
-
-const assertEntryId = (
-  id: unknown,
-  patternKey: EntryIdPatternKey,
-  errorReference: string = '',
-): string => {
-  const pattern = entryIdPatterns[patternKey]
-  if (typeof id !== 'string' || !pattern.test(id)) {
-    throw new Error(
-      `Invalid ${patternKey} id${errorReference ? ` ${errorReference}` : ''}: ${String(id)}`,
-    )
-  }
-  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))
-  }
-  if (property?.__typename === 'DataLink') {
-    const data = property.data?.()
-    if (!data?.id) throw new Error(`Invalid DataLink reference ${errorReference}`)
-    return `PROPERTY_BANK#${data.id}`
-  }
-  if (typeof property === 'function') {
-    const instance = property()
-    if (!instance?.id) throw new Error(`Invalid ID reference ${errorReference}`)
-    return instance?.id // defined type instance getter
-  }
-  if (property && typeof property === 'object') {
-    return Object.entries(property).reduce((acc, [key, value]) => {
-      acc[key] = compileProperty(value, errorReference)
-      return acc
-    }, result)
-  }
-  return property
-}
-
-const compileScriptCalculationCode = (code = '') => {
-  try {
-    const program = parseAST(code, { sourceType: 'module', ecmaVersion: 2020 })
-    // 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,
-      },
-    )
-  } catch {
-    return code || ''
-  }
-}
-
-const getTemplateName = (key: string) =>
-  upperFirst(camelCase(key.replace(/^(BRICK|GENERATOR)_/, '')))
-
-const compileEventActionValue = (templateKey, eventKey, value, errorReference) => {
-  const tmplEventProperties = templateEventPropsMap[getTemplateName(templateKey)]
-  const props = tmplEventProperties?.[eventKey]
-  if (!props) return compileProperty(value, errorReference)
-  if (typeof value === 'string' && value in props) {
-    const expectedType = props[value]
-    if (expectedType) return value
-  }
-  if (typeof value === 'string' && /^(BRICK|GENERATOR)_/.test(value)) {
-    console.warn(
-      `[Warning] Event property "${value}" is not compatible with event "${eventKey}" of ${templateKey} ${errorReference}`,
-    )
-  }
-  return compileProperty(value, errorReference)
-}
-
-const convertOutletKey = (templateKey: string, key: string) =>
-  `${templateKey}_${snakeCase(key).toUpperCase()}`
-
-const compileOutlets = (
-  templateKey: string,
-  outlets: { [key: string]: () => Data },
-  errorReference: string,
-) =>
-  Object.entries(outlets).reduce((acc, [key, data]) => {
-    const dataInstance = data?.()
-    const dataId = assertEntryId(dataInstance?.id, 'PROPERTY_BANK_DATA_NODE', errorReference)
-    acc[convertOutletKey(templateKey, key)] = dataId
-    return acc
-  }, {})
-
-const convertEventKey = (templateKey: string, key: string) =>
-  `${templateKey ? `${templateKey}_` : ''}${snakeCase(key).toUpperCase()}`
-
-const basicAnimationEvents = ['show', 'standby', 'breatheStart']
-
-const compileAnimations = (
-  templateKey: string,
-  animations: { [key: string]: Animation | (() => Animation) },
-  errorReference: string,
-) =>
-  Object.entries(animations).reduce((acc, [key, animation]) => {
-    // 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
-  }, {})
-
-const compileActionParam = (templateKey: string, actionName: string, paramName: string) =>
-  templateActionNameMap[templateKey]?.[actionName]?.[paramName] || paramName
-
-const compileEvents = (
-  templateKey: string,
-  eventMap: { [key: string]: Array<any> },
-  options = { camelCase: false, errorReference: '' },
-) => {
-  const { camelCase, errorReference } = options
-  return Object.entries(eventMap).reduce((acc, [key, events]) => {
-    acc[convertEventKey(templateKey, key)] = events.map((event) => {
-      const { handler, action } = event
-
-      let handlerKey
-      let handlerTemplateKey
-      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) {
-          instance = instance as { id: string }
-          handlerKey = instance?.id
-        } else if (instance?.brickId) {
-          instance = instance as { brickId: string; templateKey: string }
-          handlerKey = instance.brickId
-        }
-        handlerTemplateKey = instance?.templateKey
-      }
-      if (!handlerKey) throw new Error(`Invalid handler: ${handler} ${errorReference}`)
-
-      const parameterList: Array<object> = []
-      if (Object.prototype.hasOwnProperty.call(action, 'params')) {
-        const actionDef = action as ActionWithParams
-        ;(actionDef.params || []).forEach(({ input, value, mapping }) => {
-          const param = {
-            [camelCase ? 'inputToReceiver' : 'input_to_receiver']: handlerTemplateKey
-              ? compileActionParam(handlerTemplateKey, action.__actionName, input)
-              : input,
-            [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileEventActionValue(handlerTemplateKey, key, value, errorReference),
-          }
-          if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
-          parameterList.push(param)
-        })
-      } else if (Object.prototype.hasOwnProperty.call(action, 'dataParams')) {
-        const actionDef = action as ActionWithDataParams
-        ;(actionDef.dataParams || []).forEach(({ input, value, mapping }) => {
-          if (!input) return
-          const param = {
-            [camelCase ? 'inputToReceiver' : 'input_to_receiver']: input().id,
-            [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileEventActionValue(handlerTemplateKey, key, value, errorReference),
-          }
-          if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
-          parameterList.push(param)
-        })
-      }
-      return {
-        handler: handlerKey,
-        action: action.__actionName,
-        [camelCase ? 'parameterList' : 'parameter_list']: parameterList,
-        [camelCase ? 'waitAsync' : 'wait_async']: event.waitAsync,
-      }
-    })
-    return acc
-  }, {})
-}
-
-const compileSwitchConds = (templateKey, conds, errorReference) =>
-  (conds || []).map((item: any, index) => {
-    const result: any = { method: item.method }
-    if (!item.cond) return result
-    if (item.cond.__typename === 'SwitchCondData') {
-      const cond = item.cond as SwitchCondData
-      result.type = 'property_bank'
-      if (!cond.data().id)
-        throw new Error(`Invalid data reference in conds index: ${index} ${errorReference}`)
-      result.key = cond.data().id
-      result.value = cond.value
-    } else if (item.cond.__typename === 'SwitchCondPropertyBankByItemKey') {
-      const cond = item.cond as SwitchCondPropertyBankByItemKey
-      result.type = 'property_bank_by_item_key'
-      if (!cond.data().id)
-        throw new Error(`Invalid data reference in conds index: ${index} ${errorReference}`)
-      result.key = cond.data().id
-      result.value = cond.value
-    } else if (item.cond.__typename === 'SwitchCondInnerStateOutlet') {
-      const { cond } = item
-      result.type = 'inner_state'
-      result.key = convertOutletKey(templateKey, cond.outlet)
-      result.value = cond.value
-    } else if (item.cond.__typename === 'SwitchCondInnerStateCurrentCanvas') {
-      const cond = item.cond as SwitchCondInnerStateCurrentCanvas
-      result.type = 'inner_state'
-      result.key = 'current_canvas'
-      if (!cond.value().id)
-        throw new Error(`Invalid canvas reference in conds index: ${index} ${errorReference}`)
-      result.value = cond.value().id
-    }
-    return result
-  })
-
-const compileApplicationSettings = (settings: Application['settings']) => ({
-  internet_reachability_url: settings?.internetReachabilityUrl,
-  enable_data_lock: settings?.enableDataLock,
-  show_deprecated_features: settings?.showDeprecatedFeatures,
-  enable_unstable_bricks: settings?.enableUnstableFeatures,
-  runtime_cache_options: settings?.runtimeCacheOptions
-    ? {
-        disabled: settings.runtimeCacheOptions.disabled,
-        behavior: settings.runtimeCacheOptions.behavior,
-        retry_attempt_for_failure: settings.runtimeCacheOptions.retryAttemptForFailure,
-      }
-    : undefined,
-  tv_options: settings?.tvOptions
-    ? {
-        disabled_selectable: settings.tvOptions.disabledSelectable,
-        selectable_color: settings.tvOptions.selectableColor,
-        selectable_border: settings.tvOptions.selectableBorder,
-      }
-    : undefined,
-  ai: settings?.ai
-    ? {
-        use_anthropic_api_key_system_data: settings.ai.useAnthropicApiKeySystemData,
-        use_openai_api_key_system_data: settings.ai.useOpenAiApiKeySystemData,
-        use_gemini_api_key_system_data: settings.ai.useGeminiApiKeySystemData,
-      }
-    : undefined,
-  hide_short_refs: settings?.hideShortRefs,
-})
-
-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']) => ({
-  x: frame.x,
-  y: frame.y,
-  width: frame.width,
-  height: frame.height,
-  standby_mode: frame.standbyMode,
-  standby_frame: frame.standbyFrame,
-  standby_opacity: frame.standbyOpacity,
-  standby_delay: frame.standbyDelay,
-  standby_delay_random: frame.standbyDelayRandom,
-  standby_easing: frame.standbyEasing,
-  showing_delay: frame.showingDelay,
-  render_out_of_viewport: frame.renderOutOfViewport,
-})
-
-const preloadTypes = [
-  'media-resource-image',
-  'media-resource-video',
-  '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']) => {
-  const { type, ...rest } = kind || {}
-  if (!type) return {}
-  if (preloadTypes.includes(type)) {
-    const { preload, metadata } = kind as DataAssetKind
-    const result: any = { kind: type, ...rest }
-    if (preload) {
-      result.preload = {
-        type: preload.type,
-        hashType: preload.hashType,
-      }
-      if (preload.hashType) result.preload[preload.hashType] = preload.hash
-    }
-    // Handle metadata
-    if (type === 'gguf-model-asset') {
-      result._hfRepoInfo = metadata?.hfRepoInfo
-    }
-    return result
-  }
-
-  return { kind: type, ...rest }
-}
-
-const compileRemoteUpdate = (remoteUpdate: Data['remoteUpdate']) => {
-  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 } : {}),
-  }
-}
-
-const compileModule = (subspace: Subspace) => {
-  if (!subspace.module?.id) return {}
-  return {
-    module: {
-      link: subspace.module.link ?? false,
-      id: subspace.module.id,
-      version: subspace.module.version,
-    },
-    selected_requirements: subspace.module.selectedRequirements?.reduce((acc, requirement) => {
-      acc[requirement.subspace] = {
-        id: requirement.id,
-        version: requirement.version,
-      }
-      return acc
-    }, {}),
-    requirements: subspace.module.requirements?.reduce((acc, requirement) => {
-      acc[requirement.subspace] = {
-        id: requirement.id,
-        version: requirement.version,
-      }
-      return acc
-    }, {}),
-  }
-}
-
-/**
- * Compile a run array element - if it's a getter function, call it and extract the id
- * Note: All entity ids already include their prefix (e.g., SUBSPACE_xxx, BRICK_xxx, PROPERTY_BANK_DATA_NODE_xxx)
- */
-function compileRunElement(element: unknown): unknown {
-  if (typeof element !== 'function') return element
-
-  const result = element()
-  if (result && typeof result === 'object' && 'id' in result) {
-    return (result as { id: string }).id
-  }
-  return result
-}
-
-/**
- * Compile a run array - resolve getter functions and extract ids with prefixes
- */
-function compileRunArray(run: unknown[]): unknown[] {
-  return run.map(compileRunElement)
-}
-
-/**
- * Compile typed TestCase to raw format (strips __typename)
- */
-export const compileTestCase = (testCase: TestCase) => ({
-  id: testCase.id,
-  name: testCase.name,
-  hide_short_ref: testCase.hideShortRef,
-  run: compileRunArray(testCase.run),
-  exit_on_failed: testCase.exit_on_failed,
-  commented: testCase.commented,
-  pre_delay: testCase.pre_delay,
-  post_delay: testCase.post_delay,
-  post_delay_rule: testCase.post_delay_rule,
-  jump_cond: testCase.jump_cond.map((cond) => {
-    if (cond.jump_to == null) {
-      console.warn(
-        `[Warning] jump_cond is missing jump_to in test case "${testCase.name}" (${testCase.id})`,
-      )
-    }
-    return {
-      type: cond.type,
-      status: cond.status,
-      variable: cond.variable,
-      operator: cond.operator,
-      value: cond.value,
-      // `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),
-    }
-  }),
-})
-
-/**
- * Compile typed TestVariable to raw format (strips __typename)
- */
-const compileTestVariable = (variable: TestVariable) => ({
-  id: variable.id,
-  name: variable.name,
-  type: variable.type,
-  value: variable.value,
-})
-
-/**
- * Convert an array of items with id property to an id-keyed record
- */
-const arrayToIdMap = <T extends { id: string }, R>(
-  items: T[],
-  transform: (item: T, index: number) => R,
-  options: {
-    patternKey: EntryIdPatternKey
-    getErrorReference: (item: T, index: number) => string
-  },
-): Record<string, R> =>
-  Object.fromEntries(
-    items.map((item, index) => {
-      const itemId = assertEntryId(
-        item.id,
-        options.patternKey,
-        options.getErrorReference(item, index),
-      )
-      return [itemId, transform(item, index)]
-    }),
-  )
-
-/**
- * Compile typed AutomationTest to raw format
- */
-const compileAutomationTest = (
-  test: AutomationTest,
-  options: { mapId: string; testIndex: number },
-) => {
-  const testId = assertEntryId(
-    test.id,
-    'TEST',
-    `(automation map: ${options.mapId}, test index: ${options.testIndex})`,
-  )
-
-  return {
-    id: testId,
-    alias: test.alias,
-    title: test.title,
-    hide_short_ref: test.hideShortRef,
-    timeout: test.timeout,
-    trigger_type: test.trigger_type,
-    cron: test.cron,
-    skip_trigger_type_check: test.skip_trigger_type_check,
-    local_sync: test.local_sync,
-    meta: test.meta,
-    case_map: arrayToIdMap(test.cases, compileTestCase, {
-      patternKey: 'TEST_CASE',
-      getErrorReference: (_, index) =>
-        `(automation map: ${options.mapId}, test: ${testId}, case index: ${index})`,
-    }),
-    var_map: arrayToIdMap(test.variables, compileTestVariable, {
-      patternKey: 'TEST_VAR',
-      getErrorReference: (_, index) =>
-        `(automation map: ${options.mapId}, test: ${testId}, variable index: ${index})`,
-    }),
-  }
-}
-
-/**
- * Compile typed AutomationTestMap to raw format
- */
-const compileAutomationTestMap = (testMap: AutomationTestMap, mapId: string) => {
-  assertEntryId(testMap.id, 'AUTOMATION_MAP', `(automation map id field: ${mapId})`)
-
-  return {
-    title: testMap.title,
-    hide_short_ref: testMap.hideShortRef,
-    createdAt: testMap.createdAt,
-    map: arrayToIdMap(
-      testMap.tests,
-      (test, index) => compileAutomationTest(test, { mapId, testIndex: index }),
-      {
-        patternKey: 'TEST',
-        getErrorReference: (_, index) => `(automation map: ${mapId}, test index: ${index})`,
-      },
-    ),
-  }
-}
-
-/**
- * Compile typed AutomationMap to raw automation_map format
- */
-const compileAutomation = (automationMap: AutomationMap) =>
-  Object.fromEntries(
-    Object.entries(automationMap).map(([mapId, testMap]) => {
-      const automationMapId = assertEntryId(mapId, 'AUTOMATION_MAP', '(automation map key)')
-      return [automationMapId, compileAutomationTestMap(testMap, automationMapId)]
-    }),
-  )
-
-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))
-  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) => {
-      const subspaceId = assertEntryId(
-        subspace.id,
-        'SUBSPACE',
-        `(subspace index: ${subspaceIndex})`,
-      )
-
-      // Linked module subspaces reference external content — only include
-      // module metadata, not local canvas/brick/data compilation.
-      // Include a placeholder root canvas so the config passes schema
-      // validation (root_canvas_id is required before the conditional
-      // schema fix is published).
-      if (subspace.module?.link) {
-        // 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,
-          unused: subspace.unused,
-          portal: subspace.portal,
-          layout: {
-            width: subspace.layout?.width,
-            height: subspace.layout?.height,
-            resize_mode: subspace.layout?.resizeMode,
-          },
-          root_canvas_id: placeholderCanvasId,
-          property_bank_map: {},
-          brick_map: {},
-          generator_map: {},
-          animation_map: {},
-          canvas_map: {
-            [placeholderCanvasId]: { item_list: [] },
-          },
-          ...compileModule(subspace),
-        }
-        return subspaceMap
-      }
-
-      const rootCanvasId = assertEntryId(
-        subspace.rootCanvas?.id,
-        'CANVAS',
-        `(subspace: ${subspaceId}, root canvas)`,
-      )
-
-      subspaceMap[subspaceId] = {
-        title: subspace.title,
-        description: subspace.description,
-        hide_short_ref: subspace.hideShortRef,
-        unused: subspace.unused,
-        portal: subspace.portal,
-        _expanded: subspace.unexpanded
-          ? {
-              brick: !subspace.unexpanded.brick,
-              generator: !subspace.unexpanded.generator,
-              canvas: subspace.unexpanded.canvas?.reduce((acc, canvas, canvasIndex) => {
-                const unexpandedCanvasId = assertEntryId(
-                  canvas?.id,
-                  'CANVAS',
-                  `(subspace: ${subspaceId}, unexpanded canvas index: ${canvasIndex})`,
-                )
-                acc[unexpandedCanvasId] = !canvas?.id
-                return acc
-              }, {}),
-              property_bank: !subspace.unexpanded.data,
-              property_bank_calc: !subspace.unexpanded.dataCalculation,
-            }
-          : buildDefaultExpandedState(subspace),
-        layout: {
-          width: subspace.layout?.width,
-          height: subspace.layout?.height,
-          resize_mode: subspace.layout?.resizeMode,
-        },
-        local_sync: subspace.localSyncChangeCanvas
-          ? {
-              change_canvas: subspace.localSyncChangeCanvas,
-            }
-          : undefined,
-        animation_map: collectReduce(
-          errors,
-          subspace.animations,
-          (map, animation, animationIndex) => {
-            const animationId = assertEntryId(
-              animation?.id,
-              'ANIMATION',
-              `(animation index: ${animationIndex}, 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: innerAnimationId }
-                }),
-              }
-            } else {
-              throw new Error(
-                `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
-                  animationTypename,
-                )}`,
-              )
-            }
-            return map
-          },
-        ),
-        brick_map: collectReduce(errors, subspace.bricks, (map, brick, brickIndex) => {
-          const brickId = assertEntryId(
-            brick.id,
-            'BRICK',
-            `(brick index: ${brickIndex}, subspace: ${subspaceId})`,
-          )
-          const property = compileProperty(
-            brick.property || {},
-            `(brick: ${brickId}, subspace ${subspaceId})`,
-          )
-          if (brick.templateKey === 'BRICK_ITEMS') {
-            const brickItems = brick as BrickItems
-            const buildList = (itemBrick, index, key) => ({
-              title: itemBrick.title,
-              brickId: itemBrick.brickId,
-              brickIdPrefix: itemBrick.brickIdPrefix,
-              templateKey: itemBrick.templateKey,
-              frame: itemBrick.frame,
-              property: compileProperty(
-                itemBrick.property,
-                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
-              ),
-              propertyMapping: itemBrick.propertyMapping,
-              animation: compileAnimations(
-                itemBrick.templateKey,
-                itemBrick.animation || {},
-                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
-              ),
-              outlet: compileOutlets(
-                itemBrick.templateKey,
-                itemBrick.outlets || {},
-                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
-              ),
-              eventMap: compileEvents(itemBrick.templateKey, itemBrick.eventMap || {}, {
-                camelCase: true,
-                errorReference: `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
-              }),
-              stateGroup: itemBrick.stateGroup.reduce((acc, stateGroup, stateGroupIndex) => {
-                const stateGroupId = assertEntryId(
-                  stateGroup.id,
-                  'BRICK_STATE_GROUP',
-                  `(brick: ${brickId}, ${key}: ${index}, switch index: ${stateGroupIndex}, subspace ${subspaceId})`,
-                )
-
-                acc[stateGroupId] = {
-                  title: stateGroup.title,
-                  description: stateGroup.description,
-                  override: stateGroup.override,
-                  break: stateGroup.break,
-                  commented: stateGroup.disabled,
-                  conds: compileSwitchConds(
-                    itemBrick.templateKey,
-                    stateGroup.conds || [],
-                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
-                  ),
-                  property: compileProperty(
-                    stateGroup.property,
-                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
-                  ),
-                  animation: compileAnimations(
-                    itemBrick.templateKey,
-                    stateGroup.animation || {},
-                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
-                  ),
-                  outlet: compileOutlets(
-                    itemBrick.templateKey,
-                    stateGroup.outlets || {},
-                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
-                  ),
-                  eventMap: compileEvents(itemBrick.templateKey, stateGroup.eventMap || {}, {
-                    camelCase: true,
-                    errorReference: `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
-                  }),
-                }
-                return acc
-              }, {}),
-              show: itemBrick.show,
-              pressToOpenDetail: itemBrick.pressToOpenDetail,
-              pressToBackList: itemBrick.pressToBackList,
-            })
-            if (Array.isArray(brickItems.brickList)) {
-              const brickList = (brickItems.brickList || []).map((item, index) =>
-                buildList(item, index, 'brickList'),
-              )
-              property.brickList = brickList
-            } else if (!brickItems.brickList) {
-              property.brickList = []
-            } else {
-              // Not supported Data for brickList
-              throw new TypeError('Not supported Data for brickList directly')
-            }
-            if (Array.isArray(brickItems.brickDetails)) {
-              const brickDetails = (brickItems.brickDetails || []).map((item, index) =>
-                buildList(item, index, 'brickDetails'),
-              )
-              property.brickDetails = brickDetails
-            } else if (!brickItems.brickDetails) {
-              property.brickDetails = []
-            } else {
-              // Not supported Data for brickList
-              throw new TypeError('Not supported Data for brickList directly')
-            }
-          }
-          map[brickId] = {
-            template_key: brick.templateKey,
-            alias: brick.alias,
-            title: brick.title,
-            description: brick.description,
-            hide_short_ref: brick.hideShortRef,
-            property,
-            animation: compileAnimations(
-              brick.templateKey,
-              brick.animation || {},
-              `(brick: ${brickId}, subspace ${subspaceId})`,
-            ),
-            event_map: compileEvents(brick.templateKey, brick.events || {}, {
-              camelCase: false,
-              errorReference: `(brick: ${brickId}, subspace ${subspaceId})`,
-            }),
-            outlet: compileOutlets(
-              brick.templateKey,
-              brick.outlets || {},
-              `(brick: ${brickId}, subspace ${subspaceId})`,
-            ),
-            state_group: brick.switches?.reduce((acc, switchCase, switchIndex) => {
-              const switchId = assertEntryId(
-                switchCase.id,
-                'BRICK_STATE_GROUP',
-                `(brick: ${brickId}, switch index: ${switchIndex}, subspace ${subspaceId})`,
-              )
-
-              acc[switchId] = {
-                title: switchCase.title,
-                description: switchCase.description,
-                break: switchCase.break,
-                override: switchCase.override,
-                commented: switchCase.disabled,
-                conds: compileSwitchConds(
-                  brick.templateKey,
-                  switchCase.conds || [],
-                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                property: compileProperty(
-                  switchCase.property,
-                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                outlet: compileOutlets(
-                  brick.templateKey,
-                  switchCase.outlets || {},
-                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                event_map: compileEvents(brick.templateKey, switchCase.events || {}, {
-                  camelCase: false,
-                  errorReference: `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
-                }),
-                animation: compileAnimations(
-                  brick.templateKey,
-                  switchCase.animation || {},
-                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-              }
-              return acc
-            }, {}),
-          }
-          return map
-        }),
-        root_canvas_id: rootCanvasId,
-        canvas_map: collectReduce(errors, subspace.canvases, (map, canvas, canvasIndex) => {
-          const canvasId = assertEntryId(
-            canvas.id,
-            'CANVAS',
-            `(canvas index: ${canvasIndex}, subspace: ${subspaceId})`,
-          )
-
-          map[canvasId] = {
-            alias: canvas.alias,
-            title: canvas.title,
-            description: canvas.description,
-            hide_short_ref: canvas.hideShortRef,
-            property: compileProperty(
-              canvas.property,
-              `(canvas: ${canvasId}, subspace ${subspaceId})`,
-            ),
-            event_map: compileEvents('CANVAS', canvas.events || {}, {
-              camelCase: false,
-              errorReference: `(canvas: ${canvasId}, subspace ${subspaceId})`,
-            }),
-            state_group: canvas.switches?.reduce((acc, switchCase, switchIndex) => {
-              const switchId = assertEntryId(
-                switchCase.id,
-                'BRICK_STATE_GROUP',
-                `(canvas: ${canvasId}, switch index: ${switchIndex}, subspace ${subspaceId})`,
-              )
-
-              acc[switchId] = {
-                title: switchCase.title,
-                description: switchCase.description,
-                break: switchCase.break,
-                override: switchCase.override,
-                commented: switchCase.disabled,
-                conds: compileSwitchConds(
-                  'CANVAS',
-                  switchCase.conds || [],
-                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                property: compileProperty(
-                  switchCase.property,
-                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-                event_map: compileEvents('CANVAS', switchCase.events || {}, {
-                  camelCase: false,
-                  errorReference: `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
-                }),
-                animation: compileAnimations(
-                  'CANVAS',
-                  switchCase.animation || {},
-                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
-                ),
-              }
-              return acc
-            }, {}),
-            item_list: canvas.items.map((item, index) => {
-              let itemPayload = {}
-              if (typeof item.item === 'function') {
-                const brick = (item.item as () => Brick)()
-                if (!brick?.id)
-                  throw new Error(
-                    `Invalid canvas item index: ${index}, brick not found (canvas: ${canvasId}, subspace ${subspaceId})`,
-                  )
-                itemPayload = { brick_id: brick.id }
-              } else {
-                const targetSubspaceId = item.item
-                if (!subspaceIdSet.has(targetSubspaceId))
-                  throw new Error(
-                    `Invalid canvas item index: ${index}, subspace not found (canvas: ${canvasId}, subspace ${subspaceId})`,
-                  )
-                itemPayload = { subspace_id: targetSubspaceId }
-              }
-              return {
-                type: typeof item.item === 'function' ? 'brick' : 'subspace',
-                ...itemPayload,
-                frame: compileFrame(item.frame),
-                hidden: item.hidden,
-              }
-            }),
-          }
-          return map
-        }),
-        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})`,
-                )
-
-                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',
-            `(data index: ${dataIndex}, subspace: ${subspaceId})`,
-          )
-
-          map[dataId] = {
-            alias: data.alias,
-            title: data.title,
-            description: data.description,
-            hide_short_ref: data.hideShortRef,
-            linked: data.metadata?.linked,
-            linkedFrom: data.metadata?.linkedFrom,
-            local_sync: data.localSyncUpdateMode
-              ? {
-                  update_mode: data.localSyncUpdateMode,
-                }
-              : undefined,
-            persist_data: data.persistData,
-            ...compileRemoteUpdate(data.remoteUpdate),
-            routing: data.routing,
-            schema: data.schema,
-            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 || {}, {
-              camelCase: false,
-              errorReference: `(data: ${dataId}, subspace ${subspaceId})`,
-            }),
-            hit_equal: data.hit_equal,
-            hit_regex: data.hit_regex,
-          }
-          return map
-        }),
-        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 = {
-              alias: dataCalc.alias,
-              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 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
-              }, {})
-              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
-                  }, {}),
-                }
-                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,
-                      '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 outputs key: ${output.key}, subspace: ${subspaceId})`,
-                  )
-                  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, dataCalcId))
-            }
-            map[dataCalcId] = calc
-            return map
-          },
-        ),
-        action_map: subspace.actions || undefined,
-        event_map: compileEvents('', subspace.events || {}, {
-          camelCase: false,
-          errorReference: `(subspace ${subspaceId})`,
-        }),
-        routing: collectReduce(errors, subspace.dataRouting, (acc, data, index) => {
-          const dataId = assertEntryId(
-            data?.id,
-            'PROPERTY_BANK_DATA_NODE',
-            `(data routing index: ${index}, subspace ${subspaceId})`,
-          )
-          acc[dataId] = { enabled_routing: true }
-          return acc
-        }),
-        ...compileModule(subspace),
-      }
-      return subspaceMap
-    }, {}),
-    root_subspace_id: collect(
-      errors,
-      () => assertEntryId(app.rootSubspace?.id, 'SUBSPACE', '(application root subspace)'),
-      '',
-    ),
-    fonts: app.fonts,
-    ...compileApplicationSettings(app.settings),
-    // Use typed automationMap if available, otherwise fall back to TEMP metadata
-    test_map: compiledAutomationMap
-      ? compiledAutomationMap['AUTOMATION_MAP_DEFAULT']?.map || {}
-      : app.metadata?.TEMP_test_map || {},
-    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) => {
-  // --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}`)
-  }
-}