@fugood/bricks-ctor 2.24.0-beta.40

package/compile/index.ts

@@ -0,0 +1,1245 @@
+/* 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 { 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',
+}
+
+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) return {}
+  return {
+    module: {
+      link: true,
+      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()
+  const config = {
+    title: `${app.name || 'Unknown'}(${timestamp})`,
+    subspace_map: app.subspaces.reduce((subspaceMap, subspace, subspaceIndex) => {
+      const subspaceId = assertEntryId(
+        subspace.id,
+        'SUBSPACE',
+        `(subspace index: ${subspaceIndex})`,
+      )
+      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})`,
+          )
+
+          if (animation.__typename === 'Animation') {
+            const animationDef = animation as AnimationDef
+            map[animationId] = {
+              alias: animationDef.alias,
+              title: animationDef.title,
+              description: animationDef.description,
+              hide_short_ref: animationDef.hideShortRef,
+              animationRunType: animationDef.runType,
+              property: animationDef.property,
+              type: animationTypeMap[animationDef.config.__type],
+              config: compileProperty(
+                omit(animationDef.config, '__type'),
+                `(animation: ${animationId}, subspace ${subspaceId})`,
+              ),
+            }
+          } else if (animation.__typename === 'AnimationCompose') {
+            const animationDef = animation as AnimationComposeDef
+            map[animationId] = {
+              alias: animationDef.alias,
+              title: animationDef.title,
+              description: animationDef.description,
+              hide_short_ref: animationDef.hideShortRef,
+              animationRunType: animationDef.runType,
+              compose_type: animationDef.composeType,
+              item_list: animationDef.items.map((item, index) => {
+                const innerAnimation = item()
+                if (!innerAnimation?.id)
+                  throw new Error(
+                    `Invalid animation index: ${index} (animation: ${innerAnimation.id}, subspace ${subspaceId})`,
+                  )
+                return { animation_id: innerAnimation.id }
+              }),
+            }
+          }
+          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 (!app.subspaces.some((s) => s.id === 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: app.automationMap
+      ? compileAutomation(app.automationMap)['AUTOMATION_MAP_DEFAULT']?.map || {}
+      : app.metadata?.TEMP_test_map || {},
+    automation_map: app.automationMap
+      ? compileAutomation(app.automationMap)
+      : app.metadata?.TEMP_automation_map || {},
+    update_timestamp: timestamp,
+  }
+  return config
+}
+
+export const checkConfig = async (configPath: string) => {
+  const { $ } = await import('bun')
+  await $`bricks app check-config ${configPath}`
+}