@fugood/bricks-project 2.24.0-beta.8 → 2.24.0

package/compile/index.ts

@@ -1,9 +1,12 @@
 /* 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'
@@ -34,6 +37,40 @@ import type {
   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))
@@ -57,14 +94,39 @@ const compileProperty = (property, errorReference: string, 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[templateKey]
+  const tmplEventProperties = templateEventPropsMap[getTemplateName(templateKey)]
   const props = tmplEventProperties?.[eventKey]
   if (!props) return compileProperty(value, errorReference)
-  if (props.includes(value)) return value
-  if (typeof value === 'string' && value?.startsWith(templateKey)) {
+  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] Value start with template key but there is no event property: ${value} ${errorReference}`,
+      `[Warning] Event property "${value}" is not compatible with event "${eventKey}" of ${templateKey} ${errorReference}`,
     )
   }
   return compileProperty(value, errorReference)
@@ -79,8 +141,9 @@ const compileOutlets = (
   errorReference: string,
 ) =>
   Object.entries(outlets).reduce((acc, [key, data]) => {
-    if (!data()?.id) throw new Error(`Invalid data reference ${errorReference}`)
-    acc[convertOutletKey(templateKey, key)] = data().id
+    const dataInstance = data?.()
+    const dataId = assertEntryId(dataInstance?.id, 'PROPERTY_BANK_DATA_NODE', errorReference)
+    acc[convertOutletKey(templateKey, key)] = dataId
     return acc
   }, {})
 
@@ -95,9 +158,9 @@ const compileAnimations = (
   errorReference: string,
 ) =>
   Object.entries(animations).reduce((acc, [key, animation]) => {
-    if (!animation?.id) throw new Error(`Invalid animation reference ${errorReference}`)
+    const animationId = assertEntryId(animation?.id, 'ANIMATION', errorReference)
     acc[convertEventKey(basicAnimationEvents.includes(key) ? 'BRICK' : templateKey, key)] =
-      `ANIMATION#${animation.id}`
+      `ANIMATION#${animationId}`
     return acc
   }, {})
 
@@ -134,7 +197,7 @@ const compileEvents = (
       if (!handlerKey) throw new Error(`Invalid handler: ${handler} ${errorReference}`)
 
       const parameterList: Array<object> = []
-      if (Object.hasOwn(action, 'params')) {
+      if (Object.prototype.hasOwnProperty.call(action, 'params')) {
         const actionDef = action as ActionWithParams
         ;(actionDef.params || []).forEach(({ input, value, mapping }) => {
           const param = {
@@ -147,7 +210,7 @@ const compileEvents = (
           if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
           parameterList.push(param)
         })
-      } else if (Object.hasOwn(action, 'dataParams')) {
+      } else if (Object.prototype.hasOwnProperty.call(action, 'dataParams')) {
         const actionDef = action as ActionWithDataParams
         ;(actionDef.dataParams || []).forEach(({ input, value, mapping }) => {
           if (!input) return
@@ -231,6 +294,7 @@ const compileApplicationSettings = (settings: Application['settings']) => ({
         use_gemini_api_key_system_data: settings.ai.useGeminiApiKeySystemData,
       }
     : undefined,
+  hide_short_refs: settings?.hideShortRefs,
 })
 
 const animationTypeMap = {
@@ -299,10 +363,10 @@ const compileRemoteUpdate = (remoteUpdate: Data['remoteUpdate']) => {
 }
 
 const compileModule = (subspace: Subspace) => {
-  if (!subspace.module) return {}
+  if (!subspace.module?.id) return {}
   return {
     module: {
-      link: true,
+      link: subspace.module.link ?? false,
       id: subspace.module.id,
       version: subspace.module.version,
     },
@@ -350,20 +414,28 @@ function compileRunArray(run: unknown[]): unknown[] {
 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) => ({
-    type: cond.type,
-    status: cond.status,
-    variable: cond.variable,
-    operator: cond.operator,
-    value: cond.value,
-    jump_to: cond.jump_to,
-  })),
+  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,
+    }
+  }),
 })
 
 /**
@@ -381,60 +453,158 @@ const compileTestVariable = (variable: TestVariable) => ({
  */
 const arrayToIdMap = <T extends { id: string }, R>(
   items: T[],
-  transform: (item: T) => R,
-): Record<string, R> => Object.fromEntries(items.map((item) => [item.id, transform(item)]))
+  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) => ({
-  id: test.id,
-  title: test.title,
-  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),
-  var_map: arrayToIdMap(test.variables, compileTestVariable),
-})
+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) => ({
-  title: testMap.title,
-  createdAt: testMap.createdAt,
-  map: arrayToIdMap(testMap.tests, compileAutomationTest),
-})
+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]) => [
-      mapId,
-      compileAutomationTestMap(testMap),
-    ]),
+    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 config = {
     title: `${app.name || 'Unknown'}(${timestamp})`,
-    subspace_map: app.subspaces.reduce((subspaceMap, subspace) => {
-      subspaceMap[subspace.id] = {
+    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) => {
-                acc[canvas.id] = !canvas?.id
+              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,
@@ -451,32 +621,42 @@ export const compile = async (app: Application) => {
               change_canvas: subspace.localSyncChangeCanvas,
             }
           : undefined,
-        animation_map: subspace.animations.reduce((map, animation) => {
+        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[animationDef.id] = {
+            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: ${animation.id}, subspace ${subspace.id})`,
+                `(animation: ${animationId}, subspace ${subspaceId})`,
               ),
             }
           } else if (animation.__typename === 'AnimationCompose') {
             const animationDef = animation as AnimationComposeDef
-            map[animationDef.id] = {
+            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 ${subspace.id})`,
+                    `Invalid animation index: ${index} (animation: ${innerAnimation.id}, subspace ${subspaceId})`,
                   )
                 return { animation_id: innerAnimation.id }
               }),
@@ -484,10 +664,15 @@ export const compile = async (app: Application) => {
           }
           return map
         }, {}),
-        brick_map: subspace.bricks.reduce((map, brick) => {
+        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: ${brick.id}, subspace ${subspace.id})`,
+            `(brick: ${brickId}, subspace ${subspaceId})`,
           )
           if (brick.templateKey === 'BRICK_ITEMS') {
             const brickItems = brick as BrickItems
@@ -499,25 +684,31 @@ export const compile = async (app: Application) => {
               frame: itemBrick.frame,
               property: compileProperty(
                 itemBrick.property,
-                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
               ),
               propertyMapping: itemBrick.propertyMapping,
               animation: compileAnimations(
                 itemBrick.templateKey,
                 itemBrick.animation || {},
-                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
               ),
               outlet: compileOutlets(
                 itemBrick.templateKey,
                 itemBrick.outlets || {},
-                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+                `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
               ),
               eventMap: compileEvents(itemBrick.templateKey, itemBrick.eventMap || {}, {
                 camelCase: true,
-                errorReference: `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+                errorReference: `(brick: ${brickId}, ${key}: ${index}, subspace ${subspaceId})`,
               }),
-              stateGroup: itemBrick.stateGroup.reduce((acc, stateGroup) => {
-                acc[stateGroup.id] = {
+              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,
@@ -526,35 +717,40 @@ export const compile = async (app: Application) => {
                   conds: compileSwitchConds(
                     itemBrick.templateKey,
                     stateGroup.conds || [],
-                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
                   ),
                   property: compileProperty(
                     stateGroup.property,
-                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
                   ),
                   animation: compileAnimations(
                     itemBrick.templateKey,
                     stateGroup.animation || {},
-                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
                   ),
                   outlet: compileOutlets(
                     itemBrick.templateKey,
                     stateGroup.outlets || {},
-                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                    `(brick: ${brickId}, ${key}: ${index}, switch: ${stateGroupId}, subspace ${subspaceId})`,
                   ),
                   eventMap: compileEvents(itemBrick.templateKey, stateGroup.eventMap || {}, {
                     camelCase: true,
-                    errorReference: `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                    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')
@@ -564,32 +760,42 @@ export const compile = async (app: Application) => {
                 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[brick.id] = {
+          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: ${brick.id}, subspace ${subspace.id})`,
+              `(brick: ${brickId}, subspace ${subspaceId})`,
             ),
             event_map: compileEvents(brick.templateKey, brick.events || {}, {
               camelCase: false,
-              errorReference: `(brick: ${brick.id}, subspace ${subspace.id})`,
+              errorReference: `(brick: ${brickId}, subspace ${subspaceId})`,
             }),
             outlet: compileOutlets(
               brick.templateKey,
               brick.outlets || {},
-              `(brick: ${brick.id}, subspace ${subspace.id})`,
+              `(brick: ${brickId}, subspace ${subspaceId})`,
             ),
-            state_group: brick.switches?.reduce((acc, switchCase) => {
-              acc[switchCase.id] = {
+            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,
@@ -598,25 +804,25 @@ export const compile = async (app: Application) => {
                 conds: compileSwitchConds(
                   brick.templateKey,
                   switchCase.conds || [],
-                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 property: compileProperty(
                   switchCase.property,
-                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 outlet: compileOutlets(
                   brick.templateKey,
                   switchCase.outlets || {},
-                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 event_map: compileEvents(brick.templateKey, switchCase.events || {}, {
                   camelCase: false,
-                  errorReference: `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  errorReference: `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
                 }),
                 animation: compileAnimations(
                   brick.templateKey,
                   switchCase.animation || {},
-                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(brick: ${brickId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
               }
               return acc
@@ -624,21 +830,35 @@ export const compile = async (app: Application) => {
           }
           return map
         }, {}),
-        root_canvas_id: subspace.rootCanvas.id,
-        canvas_map: subspace.canvases.reduce((map, canvas) => {
-          map[canvas.id] = {
+        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: ${canvas.id}, subspace ${subspace.id})`,
+              `(canvas: ${canvasId}, subspace ${subspaceId})`,
             ),
             event_map: compileEvents('CANVAS', canvas.events || {}, {
               camelCase: false,
-              errorReference: `(canvas: ${canvas.id}, subspace ${subspace.id})`,
+              errorReference: `(canvas: ${canvasId}, subspace ${subspaceId})`,
             }),
-            state_group: canvas.switches?.reduce((acc, switchCase) => {
-              acc[switchCase.id] = {
+            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,
@@ -647,20 +867,20 @@ export const compile = async (app: Application) => {
                 conds: compileSwitchConds(
                   'CANVAS',
                   switchCase.conds || [],
-                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 property: compileProperty(
                   switchCase.property,
-                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 event_map: compileEvents('CANVAS', switchCase.events || {}, {
                   camelCase: false,
-                  errorReference: `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  errorReference: `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
                 }),
                 animation: compileAnimations(
                   'CANVAS',
                   switchCase.animation || {},
-                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(canvas: ${canvasId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
               }
               return acc
@@ -671,16 +891,16 @@ export const compile = async (app: Application) => {
                 const brick = (item.item as () => Brick)()
                 if (!brick?.id)
                   throw new Error(
-                    `Invalid canvas item index: ${index}, brick not found (canvas: ${canvas.id}, subspace ${subspace.id})`,
+                    `Invalid canvas item index: ${index}, brick not found (canvas: ${canvasId}, subspace ${subspaceId})`,
                   )
                 itemPayload = { brick_id: brick.id }
               } else {
-                const subspaceId = item.item
-                if (!app.subspaces.some((s) => s.id === subspaceId))
+                const targetSubspaceId = item.item
+                if (!subspaceIdSet.has(targetSubspaceId))
                   throw new Error(
-                    `Invalid canvas item index: ${index}, subspace not found (canvas: ${canvas.id}, subspace ${subspace.id})`,
+                    `Invalid canvas item index: ${index}, subspace not found (canvas: ${canvasId}, subspace ${subspaceId})`,
                   )
-                itemPayload = { subspace_id: subspaceId }
+                itemPayload = { subspace_id: targetSubspaceId }
               }
               return {
                 type: typeof item.item === 'function' ? 'brick' : 'subspace',
@@ -692,11 +912,19 @@ export const compile = async (app: Application) => {
           }
           return map
         }, {}),
-        generator_map: subspace.generators.reduce((map, generator) => {
-          map[generator.id] = {
+        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,
@@ -704,19 +932,25 @@ export const compile = async (app: Application) => {
               : undefined,
             property: compileProperty(
               generator.property || {},
-              `(generator: ${generator.id}, subspace ${subspace.id})`,
+              `(generator: ${generatorId}, subspace ${subspaceId})`,
             ),
             event_map: compileEvents(generator.templateKey, generator.events || {}, {
               camelCase: false,
-              errorReference: `(generator: ${generator.id}, subspace ${subspace.id})`,
+              errorReference: `(generator: ${generatorId}, subspace ${subspaceId})`,
             }),
             outlet: compileOutlets(
               generator.templateKey,
               generator.outlets || {},
-              `(generator: ${generator.id}, subspace ${subspace.id})`,
+              `(generator: ${generatorId}, subspace ${subspaceId})`,
             ),
-            state_group: generator.switches?.reduce((acc, switchCase) => {
-              acc[switchCase.id] = {
+            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,
@@ -725,25 +959,25 @@ export const compile = async (app: Application) => {
                 conds: compileSwitchConds(
                   generator.templateKey,
                   switchCase.conds || [],
-                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 property: compileProperty(
                   switchCase.property,
-                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 outlet: compileOutlets(
                   generator.templateKey,
                   switchCase.outlets || {},
-                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
                 event_map: compileEvents(generator.templateKey, switchCase.events || {}, {
                   camelCase: false,
-                  errorReference: `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  errorReference: `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
                 }),
                 animation: compileAnimations(
                   generator.templateKey,
                   switchCase.animation || {},
-                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                  `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
                 ),
               }
               return acc
@@ -751,10 +985,18 @@ export const compile = async (app: Application) => {
           }
           return map
         }, {}),
-        property_bank_map: subspace.data.reduce((map, data) => {
-          map[data.id] = {
+        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
@@ -768,35 +1010,72 @@ export const compile = async (app: Application) => {
             schema: data.schema,
             type: data.type,
             ...compileKind(data.kind),
-            value: compileProperty(data.value, `(data: ${data.id}, subspace ${subspace.id})`),
+            value: compileProperty(data.value, `(data: ${dataId}, subspace ${subspaceId})`),
             event_map: compileEvents('PROPERTY_BANK', data.events || {}, {
               camelCase: false,
-              errorReference: `(data: ${data.id}, subspace ${subspace.id})`,
+              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) => {
+        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) => {
+              inputs.reduce((acc, port, portIndex) => {
                 if (!acc[port.key]) acc[port.key] = null
 
                 let sourceId
                 const sourceNode = port.source()
-                if (sourceNode?.__typename === 'DataCalculationData')
-                  sourceId = (sourceNode as DataCalculationData).data().id
-                if (sourceNode?.__typename === 'DataCommand') sourceId = sourceNode.id
+                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] = []
@@ -810,14 +1089,17 @@ export const compile = async (app: Application) => {
               }, {})
 
             const generateOutputPorts = (outputs) =>
-              outputs.reduce((acc, port) => {
+              outputs.reduce((acc, port, portIndex) => {
                 if (!acc[port.key]) acc[port.key] = null
 
                 let targetId
                 const targetNode = port.target()
-                if (targetNode?.__typename === 'DataCalculationData')
-                  targetId = (targetNode as DataCalculationData).data().id
-                if (targetNode?.__typename === 'DataCommand') targetId = targetNode.id
+                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] = []
@@ -829,18 +1111,13 @@ export const compile = async (app: Application) => {
                 return acc
               }, {})
 
-            const getNodeId = (node) => {
-              if (node.__typename === 'DataCalculationData') return node.data().id
-              if (node.__typename === 'DataCommand') return node.id
-              throw new Error(`Invalid node: ${JSON.stringify(node)}`)
-            }
-
-            calc.map = mapCalc.nodes.reduce((acc, node) => {
+            calc.map = mapCalc.nodes.reduce((acc, node, nodeIndex) => {
               if (node.__typename === 'DataCalculationData') {
                 const dataNode = node as DataCalculationData
-                acc[getNodeId(dataNode)] = {
+                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),
@@ -863,9 +1140,10 @@ export const compile = async (app: Application) => {
                     (input.source()?.__typename === 'DataCalculationData' ||
                       input.source()?.__typename === 'DataCommand'),
                 )
-                acc[getNodeId(commandNode)] = {
+                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,
@@ -881,11 +1159,11 @@ export const compile = async (app: Application) => {
               return acc
             }, {})
             calc.editor_info = mapCalc.editorInfo.reduce((acc, editorInfo) => {
-              acc[getNodeId(editorInfo.node)] = {
+              acc[getNodeId(editorInfo.node, 'editor info node')] = {
                 position: editorInfo.position,
                 points: editorInfo.points.reduce((pointsAcc, point) => {
-                  const sourceId = getNodeId(point.source)
-                  const targetId = getNodeId(point.target)
+                  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
@@ -897,43 +1175,55 @@ export const compile = async (app: Application) => {
             const scriptCalc = dataCalc as DataCalculationScript
             calc.type = 'script'
 
-            let code: string
-            try {
-              const program = parseAST(scriptCalc.code, { sourceType: 'module', ecmaVersion: 2020 })
-              // export function main() { ... }
-              const declarationBody = (
-                (program.body[0] as ExportNamedDeclaration).declaration as FunctionDeclaration
-              )?.body
-              code = escodegen.generate(declarationBody, {
-                format: {
-                  indent: { style: '  ' },
-                  semicolons: false,
-                },
-                comment: true,
-              })
-            } catch {
-              code = scriptCalc.code || ''
-            }
+            const code = compileScriptCalculationCode(scriptCalc.code)
             calc.script_config = {
-              note: scriptCalc.note,
+              title: scriptCalc.title ?? '',
+              note: scriptCalc.note ?? '',
               code,
               enable_async: scriptCalc.enableAsync,
               trigger_mode: scriptCalc.triggerMode,
               inputs: scriptCalc.inputs.reduce((acc, input) => {
-                acc[input.data().id] = input.key
+                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) => {
-                acc[input.data().id] = !input.trigger
+                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?.().id,
+              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] = []
-                acc[output.key].push(output.data().id)
+                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?.().id,
+              error: scriptCalc.error
+                ? assertEntryId(
+                    scriptCalc.error()?.id,
+                    'PROPERTY_BANK_DATA_NODE',
+                    `(data calc: ${dataCalcId}, script error output, subspace: ${subspaceId})`,
+                  )
+                : null,
             }
 
             Object.assign(
@@ -943,25 +1233,32 @@ export const compile = async (app: Application) => {
               }),
             )
           }
-          map[dataCalc.id] = calc
+          map[dataCalcId] = calc
           return map
         }, {}),
         action_map: subspace.actions || undefined,
         event_map: compileEvents('', subspace.events || {}, {
           camelCase: false,
-          errorReference: `(subspace ${subspace.id})`,
+          errorReference: `(subspace ${subspaceId})`,
         }),
         routing: subspace.dataRouting.reduce((acc, data, index) => {
-          if (!data?.id)
-            throw new Error(`Invalid data routing index: ${index} (subspace ${subspace.id})`)
-          acc[data.id] = { enabled_routing: true }
+          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: app.rootSubspace.id,
+    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
@@ -975,3 +1272,8 @@ export const compile = async (app: Application) => {
   }
   return config
 }
+
+export const checkConfig = async (configPath: string) => {
+  const { $ } = await import('bun')
+  await $`bricks app check-config ${configPath}`
+}