@fugood/bricks-project 2.25.0-beta.9 → 2.25.7

package/compile/index.ts

@@ -1,1458 +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 { ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
-import escodegen from 'escodegen'
-import { makeId } from '../utils/id'
-import { generateCalulationMap } from './util'
-import { templateActionNameMap } from './action-name-map'
-import { templateEventPropsMap } from '../utils/event-props'
-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
-}
-
-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 })
-    // export function main() { ... }
-    const declarationBody = (
-      (program.body[0] as ExportNamedDeclaration).declaration as FunctionDeclaration
-    )?.body
-    return escodegen.generate(declarationBody, {
-      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 },
-  errorReference: string,
-) =>
-  Object.entries(animations).reduce((acc, [key, animation]) => {
-    const animationId = assertEntryId(animation?.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 (handler === 'system' || typeof handler === 'string') {
-        if (handler.startsWith('SUBSPACE_')) handlerKey = handler
-        else handlerKey = handler.toUpperCase()
-        if (handlerKey === 'SYSTEM') handlerTemplateKey = 'SYSTEM'
-      } 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',
-  'ggml-model-asset',
-  'gguf-model-asset',
-  'binary-asset',
-]
-
-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 {}
-  if (remoteUpdate.type === 'auto') return { enable_remote_update: true }
-  return {
-    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)
- */
-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: 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,
-    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)]
-    }),
-  )
-
-export const compile = async (app: Application) => {
-  await new Promise((resolve) => setImmediate(resolve, 0))
-  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
-  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) {
-        const placeholderCanvasId = makeId('canvas')
-        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,
-            }
-          : undefined,
-        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: subspace.animations.reduce((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: subspace.bricks.reduce((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: subspace.canvases.reduce((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: subspace.generators.reduce((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: subspace.data.reduce((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,
-            ...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: subspace.dataCalculation.reduce((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 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, {
-                snapshotMode: process.env.BRICKS_SNAPSHOT_MODE === '1',
-              }),
-            )
-          }
-          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) => {
-          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: 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,
-  }
-  return config
-}
-
-export const checkConfig = async (configPath: string) => {
-  const { sh } = await import('../tools/_shell')
-  await sh`bricks app check-config ${configPath}`
-}