@fugood/bricks-project 2.23.2 → 2.23.4

package/compile/index.ts

@@ -34,6 +34,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))
@@ -79,8 +113,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 +130,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
   }, {})
 
@@ -381,43 +416,87 @@ 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,
+    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,
+    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) => {
@@ -425,16 +504,32 @@ export const compile = async (app: Application) => {
   const timestamp = Date.now()
   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})`,
+      )
+      const rootCanvasId = assertEntryId(
+        subspace.rootCanvas?.id,
+        'CANVAS',
+        `(subspace: ${subspaceId}, root canvas)`,
+      )
+
+      subspaceMap[subspaceId] = {
         title: subspace.title,
         description: subspace.description,
         _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,10 +546,16 @@ 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] = {
               title: animationDef.title,
               description: animationDef.description,
               animationRunType: animationDef.runType,
@@ -462,12 +563,12 @@ export const compile = async (app: Application) => {
               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] = {
               title: animationDef.title,
               description: animationDef.description,
               animationRunType: animationDef.runType,
@@ -476,7 +577,7 @@ export const compile = async (app: Application) => {
                 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 +585,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 +605,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,29 +638,32 @@ 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) =>
@@ -569,7 +684,7 @@ export const compile = async (app: Application) => {
               throw new TypeError('Not supported Data for brickList directly')
             }
           }
-          map[brick.id] = {
+          map[brickId] = {
             template_key: brick.templateKey,
             title: brick.title,
             description: brick.description,
@@ -577,19 +692,25 @@ export const compile = async (app: Application) => {
             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 +719,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 +745,33 @@ 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] = {
             title: canvas.title,
             description: canvas.description,
             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 +780,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 +804,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 (!app.subspaces.some((s) => s.id === 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,8 +825,14 @@ 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,
             title: generator.title,
             description: generator.description,
@@ -704,19 +843,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 +870,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,8 +896,14 @@ 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] = {
             title: data.title,
             description: data.description,
             linked: data.metadata?.linked,
@@ -768,17 +919,23 @@ 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,
@@ -788,15 +945,45 @@ export const compile = async (app: Application) => {
             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 +997,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,16 +1019,10 @@ 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,
                   type: 'data-node',
@@ -863,7 +1047,7 @@ 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,
                   type: `command-node-${type}`,
@@ -881,11 +1065,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
@@ -911,7 +1095,7 @@ export const compile = async (app: Application) => {
                 },
                 comment: true,
               })
-            } catch (e) {
+            } catch {
               code = scriptCalc.code || ''
             }
             calc.script_config = {
@@ -920,20 +1104,47 @@ export const compile = async (app: Application) => {
               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})`,
+                  )
+                : undefined,
               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})`,
+                  )
+                : undefined,
             }
 
             Object.assign(
@@ -943,25 +1154,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