@fugood/bricks-ctor 2.25.0-beta.52 → 2.25.0-beta.55

package/compile/__tests__/index.test.js

@@ -171,6 +171,50 @@ describe('compile animations', () => {
   })
 })
 
+describe('compile error collection', () => {
+  test('reports every entity error in a single failure instead of bailing on the first', async () => {
+    const app = makeApp()
+    // Invalid ids across three independent entity loops — a fail-fast compile would only
+    // surface the first; collection must report all three in one run.
+    app.rootSubspace.bricks = [{ id: 'bad-brick', templateKey: 'BRICK_TEXT' }]
+    app.rootSubspace.generators = [{ id: 'bad-generator', templateKey: 'GENERATOR_HTTP' }]
+    app.rootSubspace.data = [{ __typename: 'Data', id: 'bad-data', type: 'string' }]
+
+    let error
+    try {
+      await compile(app)
+    } catch (caught) {
+      error = caught
+    }
+
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toContain('Compile failed with 3 error(s)')
+    expect(error.message).toContain('Invalid BRICK id (brick index: 0')
+    expect(error.message).toContain('Invalid GENERATOR id (generator index: 0')
+    expect(error.message).toContain('Invalid PROPERTY_BANK_DATA_NODE id (data index: 0')
+  })
+
+  test('skipping a bad entity does not block compiling its siblings', async () => {
+    const app = makeApp()
+    app.rootSubspace.data = [
+      { __typename: 'Data', id: 'bad-data', type: 'string' },
+      makeData(undefined), // valid DATA_ID sibling
+    ]
+
+    let error
+    try {
+      await compile(app)
+    } catch (caught) {
+      error = caught
+    }
+
+    // Only the bad sibling is reported; the valid one compiled past it in the same pass.
+    expect(error.message).toContain('Compile failed with 1 error(s)')
+    expect(error.message).toContain('bad-data')
+    expect(error.message).not.toContain(DATA_ID)
+  })
+})
+
 describe('compile event handlers', () => {
   const BRICK_ID = 'BRICK_00000000-0000-0000-0000-000000000002'
 

package/compile/index.ts

@@ -4,7 +4,7 @@ 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 type { BlockStatement, ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
 import escodegen from 'escodegen'
 import { makeSeededId } from '../utils/id'
 import { generateCalulationMap } from './util'
@@ -75,6 +75,31 @@ const assertEntryId = (
   return id
 }
 
+// Per-compile error collection. Instead of throwing on the first bad entity, record the
+// message and skip that entity, so a single compile surfaces every entity's first error
+// (e.g. an invalid brick id, generator id and data-calc id all in one run). `errors` is
+// local to each compile() call — no shared state — and compile throws an aggregated error
+// at the end when any were collected, so a failed compile still rejects and never returns
+// or writes a partial config.
+const collect = <T>(errors: string[], fn: () => T, fallback: T): T => {
+  try {
+    return fn()
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error))
+    return fallback
+  }
+}
+
+// reduce() into an id-keyed map, recording a per-item compile error and skipping that item
+// instead of aborting the whole compile. The callback is the last argument (and the init is
+// always {}) so the formatter keeps its body inline rather than re-indenting it.
+const collectReduce = <T>(
+  errors: string[],
+  items: T[],
+  fn: (acc: Record<string, unknown>, item: T, index: number) => Record<string, unknown>,
+): Record<string, unknown> =>
+  items.reduce((acc, item, index) => collect(errors, () => fn(acc, item, index), acc), {})
+
 const compileProperty = (property, errorReference: string, result = {}) => {
   if (Array.isArray(property)) {
     return property.map((p) => compileProperty(p, errorReference))
@@ -101,17 +126,28 @@ const compileProperty = (property, errorReference: string, result = {}) => {
 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,
+    // The stored config holds the bare function body, which codegen re-wraps as
+    // `export function main() { <code> }`. Unwrap it back to that body here.
+    let block = ((program.body[0] as ExportNamedDeclaration).declaration as FunctionDeclaration)
+      ?.body as BlockStatement | undefined
+    if (!block) return code || ''
+    // Earlier versions emitted the whole BlockStatement (braces included), so every
+    // compile -> codegen round-trip nested the body in one more `{ }`. Emit the inner
+    // statements instead, collapsing any wrapper blocks previous round-trips added so
+    // existing over-wrapped sandboxes heal on the next compile.
+    while (block.body.length === 1 && block.body[0].type === 'BlockStatement') {
+      block = block.body[0] as BlockStatement
+    }
+    return escodegen.generate(
+      { type: 'Program', body: block.body },
+      {
+        format: {
+          indent: { style: '  ' },
+          semicolons: false,
+        },
+        comment: true,
       },
-      comment: true,
-    })
+    )
   } catch {
     return code || ''
   }
@@ -744,13 +780,20 @@ const recordConfigChange = async (previousConfig: unknown, config: unknown) => {
 
 export const compile = async (app: Application) => {
   await new Promise((resolve) => setImmediate(resolve, 0))
+  // Collected entity-level compile errors (see collect/collectReduce). Aggregated and
+  // thrown at the end so one compile reports every entity's first error.
+  const errors: string[] = []
   // Snapshot the prior build artifact before the caller's compile.ts overwrites it, so
   // the config change introduced by this compile can be recorded on return.
   const previousConfig = await readBuildConfig(process.cwd())
   const timestamp = Date.now()
   // Pre-index subspace ids so the canvas-item validation below stays O(1).
   const subspaceIdSet = new Set(app.subspaces.map((s) => s.id))
-  const compiledAutomationMap = app.automationMap ? compileAutomation(app.automationMap) : null
+  let compiledAutomationMap: ReturnType<typeof compileAutomation> | null = null
+  if (app.automationMap) {
+    const { automationMap } = app
+    compiledAutomationMap = collect(errors, () => compileAutomation(automationMap), null)
+  }
   const config = {
     title: `${app.name || 'Unknown'}(${timestamp})`,
     subspace_map: app.subspaces.reduce((subspaceMap, subspace, subspaceIndex) => {
@@ -836,74 +879,78 @@ export const compile = async (app: Application) => {
               change_canvas: subspace.localSyncChangeCanvas,
             }
           : undefined,
-        animation_map: subspace.animations.reduce((map, animation, animationIndex) => {
-          const animationId = assertEntryId(
-            animation?.id,
-            'ANIMATION',
-            `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
-          )
+        animation_map: collectReduce(
+          errors,
+          subspace.animations,
+          (map, animation, animationIndex) => {
+            const animationId = assertEntryId(
+              animation?.id,
+              'ANIMATION',
+              `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
+            )
 
-          const animationTypename = animation.__typename
-          if (animationTypename === 'Animation') {
-            const animationDef = animation as AnimationDef
-            const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
-            const animationWarningMetadata = {
-              animationIndex,
-              animationTitle: animationDef.title,
-              animationAlias: animationDef.alias,
-              animationProperty: animationDef.property,
-              subspaceIndex,
-              subspaceTitle: subspace.title,
-            }
-            const animationType = getAnimationType(animationDef.config, animationErrorReference)
-            map[animationId] = {
-              alias: animationDef.alias,
-              title: animationDef.title,
-              description: animationDef.description,
-              hide_short_ref: animationDef.hideShortRef,
-              animationRunType: animationDef.runType,
-              property: assertAnimationProperty(animationDef.property, animationErrorReference),
-              type: animationType,
-              config: compileAnimationConfig(
-                animationType,
-                animationDef.config,
-                animationErrorReference,
-                animationWarningMetadata,
-              ),
-            }
-          } else if (animationTypename === 'AnimationCompose') {
-            const animationDef = animation as AnimationComposeDef
-            const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
-            map[animationId] = {
-              alias: animationDef.alias,
-              title: animationDef.title,
-              description: animationDef.description,
-              hide_short_ref: animationDef.hideShortRef,
-              animationRunType: animationDef.runType,
-              compose_type: assertAnimationComposeType(
-                animationDef.composeType,
-                animationErrorReference,
-              ),
-              item_list: animationDef.items.map((item, index) => {
-                const innerAnimation = item()
-                const innerAnimationId = assertEntryId(
-                  innerAnimation?.id,
-                  'ANIMATION',
-                  `(animation item index: ${index}, animation: ${animationId}, subspace ${subspaceId})`,
-                )
-                return { animation_id: innerAnimationId }
-              }),
+            const animationTypename = animation.__typename
+            if (animationTypename === 'Animation') {
+              const animationDef = animation as AnimationDef
+              const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
+              const animationWarningMetadata = {
+                animationIndex,
+                animationTitle: animationDef.title,
+                animationAlias: animationDef.alias,
+                animationProperty: animationDef.property,
+                subspaceIndex,
+                subspaceTitle: subspace.title,
+              }
+              const animationType = getAnimationType(animationDef.config, animationErrorReference)
+              map[animationId] = {
+                alias: animationDef.alias,
+                title: animationDef.title,
+                description: animationDef.description,
+                hide_short_ref: animationDef.hideShortRef,
+                animationRunType: animationDef.runType,
+                property: assertAnimationProperty(animationDef.property, animationErrorReference),
+                type: animationType,
+                config: compileAnimationConfig(
+                  animationType,
+                  animationDef.config,
+                  animationErrorReference,
+                  animationWarningMetadata,
+                ),
+              }
+            } else if (animationTypename === 'AnimationCompose') {
+              const animationDef = animation as AnimationComposeDef
+              const animationErrorReference = `(animation: ${animationId}, subspace ${subspaceId})`
+              map[animationId] = {
+                alias: animationDef.alias,
+                title: animationDef.title,
+                description: animationDef.description,
+                hide_short_ref: animationDef.hideShortRef,
+                animationRunType: animationDef.runType,
+                compose_type: assertAnimationComposeType(
+                  animationDef.composeType,
+                  animationErrorReference,
+                ),
+                item_list: animationDef.items.map((item, index) => {
+                  const innerAnimation = item()
+                  const innerAnimationId = assertEntryId(
+                    innerAnimation?.id,
+                    'ANIMATION',
+                    `(animation item index: ${index}, animation: ${animationId}, subspace ${subspaceId})`,
+                  )
+                  return { animation_id: innerAnimationId }
+                }),
+              }
+            } else {
+              throw new Error(
+                `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
+                  animationTypename,
+                )}`,
+              )
             }
-          } else {
-            throw new Error(
-              `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
-                animationTypename,
-              )}`,
-            )
-          }
-          return map
-        }, {}),
-        brick_map: subspace.bricks.reduce((map, brick, brickIndex) => {
+            return map
+          },
+        ),
+        brick_map: collectReduce(errors, subspace.bricks, (map, brick, brickIndex) => {
           const brickId = assertEntryId(
             brick.id,
             'BRICK',
@@ -1068,9 +1115,9 @@ export const compile = async (app: Application) => {
             }, {}),
           }
           return map
-        }, {}),
+        }),
         root_canvas_id: rootCanvasId,
-        canvas_map: subspace.canvases.reduce((map, canvas, canvasIndex) => {
+        canvas_map: collectReduce(errors, subspace.canvases, (map, canvas, canvasIndex) => {
           const canvasId = assertEntryId(
             canvas.id,
             'CANVAS',
@@ -1150,81 +1197,85 @@ export const compile = async (app: Application) => {
             }),
           }
           return map
-        }, {}),
-        generator_map: subspace.generators.reduce((map, generator, generatorIndex) => {
-          const generatorId = assertEntryId(
-            generator.id,
-            'GENERATOR',
-            `(generator index: ${generatorIndex}, subspace: ${subspaceId})`,
-          )
+        }),
+        generator_map: collectReduce(
+          errors,
+          subspace.generators,
+          (map, generator, generatorIndex) => {
+            const generatorId = assertEntryId(
+              generator.id,
+              'GENERATOR',
+              `(generator index: ${generatorIndex}, subspace: ${subspaceId})`,
+            )
 
-          map[generatorId] = {
-            template_key: generator.templateKey,
-            alias: generator.alias,
-            title: generator.title,
-            description: generator.description,
-            hide_short_ref: generator.hideShortRef,
-            local_sync: generator.localSyncRunMode
-              ? {
-                  run_mode: generator.localSyncRunMode,
-                }
-              : undefined,
-            property: compileProperty(
-              generator.property || {},
-              `(generator: ${generatorId}, subspace ${subspaceId})`,
-            ),
-            event_map: compileEvents(generator.templateKey, generator.events || {}, {
-              camelCase: false,
-              errorReference: `(generator: ${generatorId}, subspace ${subspaceId})`,
-            }),
-            outlet: compileOutlets(
-              generator.templateKey,
-              generator.outlets || {},
-              `(generator: ${generatorId}, subspace ${subspaceId})`,
-            ),
-            state_group: generator.switches?.reduce((acc, switchCase, switchIndex) => {
-              const switchId = assertEntryId(
-                switchCase.id,
-                'BRICK_STATE_GROUP',
-                `(generator: ${generatorId}, switch index: ${switchIndex}, subspace ${subspaceId})`,
-              )
+            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) => {
+                acc[switchId] = {
+                  title: switchCase.title,
+                  description: switchCase.description,
+                  break: switchCase.break,
+                  override: switchCase.override,
+                  commented: switchCase.disabled,
+                  conds: compileSwitchConds(
+                    generator.templateKey,
+                    switchCase.conds || [],
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  property: compileProperty(
+                    switchCase.property,
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  outlet: compileOutlets(
+                    generator.templateKey,
+                    switchCase.outlets || {},
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                  event_map: compileEvents(generator.templateKey, switchCase.events || {}, {
+                    camelCase: false,
+                    errorReference: `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  }),
+                  animation: compileAnimations(
+                    generator.templateKey,
+                    switchCase.animation || {},
+                    `(generator: ${generatorId}, switch: ${switchId}, subspace ${subspaceId})`,
+                  ),
+                }
+                return acc
+              }, {}),
+            }
+            return map
+          },
+        ),
+        property_bank_map: collectReduce(errors, subspace.data, (map, data, dataIndex) => {
           const dataId = assertEntryId(
             data.id,
             'PROPERTY_BANK_DATA_NODE',
@@ -1258,225 +1309,229 @@ export const compile = async (app: Application) => {
             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})`,
-          )
+        }),
+        property_bank_calc_map: collectReduce(
+          errors,
+          subspace.dataCalculation,
+          (map, dataCalc, dataCalcIndex) => {
+            const dataCalcId = assertEntryId(
+              dataCalc.id,
+              'PROPERTY_BANK_COMMAND_MAP',
+              `(data calc index: ${dataCalcIndex}, subspace: ${subspaceId})`,
+            )
 
-          const calc: any = {
-            alias: dataCalc.alias,
-            title: dataCalc.title,
-            description: dataCalc.description,
-            hide_short_ref: dataCalc.hideShortRef,
-          }
-          if (dataCalc.triggerMode) calc.trigger_type = dataCalc.triggerMode
-          if (dataCalc.__typename === 'DataCalculationMap') {
-            calc.type = 'general'
-            const mapCalc = dataCalc as DataCalculationMap
-
-            const getNodeId = (
-              node: DataCalculationData | DataCommand,
-              reference = '',
-              nodeIndex?: number,
-            ) => {
-              const nodeReference = [
-                `data calc: ${dataCalcId}`,
-                `subspace: ${subspaceId}`,
-                typeof nodeIndex === 'number' ? `node index: ${nodeIndex}` : undefined,
-                reference || undefined,
-              ]
-                .filter(Boolean)
-                .join(', ')
-
-              if (node.__typename === 'DataCalculationData') {
-                return assertEntryId(
-                  node.data()?.id,
-                  'PROPERTY_BANK_DATA_NODE',
-                  `(${nodeReference})`,
-                )
-              }
-              if (node.__typename === 'DataCommand') {
-                return assertEntryId(node.id, 'PROPERTY_BANK_COMMAND_NODE', `(${nodeReference})`)
-              }
-              throw new Error(`Invalid node: ${JSON.stringify(node)}`)
+            const calc: any = {
+              alias: dataCalc.alias,
+              title: dataCalc.title,
+              description: dataCalc.description,
+              hide_short_ref: dataCalc.hideShortRef,
             }
-
-            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 (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)}`)
+              }
 
-                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,
-                })
+              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
               }, {})
-
-            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}`)
+              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
+                  }, {}),
                 }
-
-                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
+            } 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
                 }, {}),
-              }
-              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,
+                disabled_triggers: scriptCalc.inputs.reduce((acc, input) => {
+                  const inputId = assertEntryId(
+                    input.data()?.id,
                     'PROPERTY_BANK_DATA_NODE',
-                    `(data calc: ${dataCalcId}, script output, subspace: ${subspaceId})`,
+                    `(data calc: ${dataCalcId}, script trigger input: ${input.key}, 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,
+                  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 error output, subspace: ${subspaceId})`,
+                    `(data calc: ${dataCalcId}, script outputs key: ${output.key}, subspace: ${subspaceId})`,
                   )
-                : null,
-            }
+                  acc[output.key].push(outputId)
+                  return acc
+                }, {}),
+                error: scriptCalc.error
+                  ? assertEntryId(
+                      scriptCalc.error()?.id,
+                      'PROPERTY_BANK_DATA_NODE',
+                      `(data calc: ${dataCalcId}, script error output, subspace: ${subspaceId})`,
+                    )
+                  : null,
+              }
 
-            Object.assign(calc, generateCalulationMap(calc.script_config, dataCalcId))
-          }
-          map[dataCalcId] = calc
-          return map
-        }, {}),
+              Object.assign(calc, generateCalulationMap(calc.script_config, dataCalcId))
+            }
+            map[dataCalcId] = calc
+            return map
+          },
+        ),
         action_map: subspace.actions || undefined,
         event_map: compileEvents('', subspace.events || {}, {
           camelCase: false,
           errorReference: `(subspace ${subspaceId})`,
         }),
-        routing: subspace.dataRouting.reduce((acc, data, index) => {
+        routing: collectReduce(errors, subspace.dataRouting, (acc, data, index) => {
           const dataId = assertEntryId(
             data?.id,
             'PROPERTY_BANK_DATA_NODE',
@@ -1484,15 +1539,15 @@ export const compile = async (app: Application) => {
           )
           acc[dataId] = { enabled_routing: true }
           return acc
-        }, {}),
+        }),
         ...compileModule(subspace),
       }
       return subspaceMap
     }, {}),
-    root_subspace_id: assertEntryId(
-      app.rootSubspace?.id,
-      'SUBSPACE',
-      '(application root subspace)',
+    root_subspace_id: collect(
+      errors,
+      () => assertEntryId(app.rootSubspace?.id, 'SUBSPACE', '(application root subspace)'),
+      '',
     ),
     fonts: app.fonts,
     ...compileApplicationSettings(app.settings),
@@ -1503,6 +1558,12 @@ export const compile = async (app: Application) => {
     automation_map: compiledAutomationMap || app.metadata?.TEMP_automation_map || {},
     update_timestamp: timestamp,
   }
+  if (errors.length > 0) {
+    throw new Error(
+      `Compile failed with ${errors.length} error(s):\n` +
+        errors.map((message, index) => `  ${index + 1}. ${message}`).join('\n'),
+    )
+  }
   await recordConfigChange(previousConfig, config)
   return config
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.52",
+  "version": "2.25.0-beta.55",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -11,7 +11,7 @@
     "@babel/parser": "7.28.5",
     "@babel/traverse": "7.28.5",
     "@babel/types": "7.28.5",
-    "@fugood/bricks-cli": "^2.25.0-beta.52",
+    "@fugood/bricks-cli": "^2.25.0-beta.53",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -29,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "f6869285ea21123990934411ea190d9fbf12ea7f"
+  "gitHead": "08f3ae4a88db84f682384ecfa94e9d4583371bda"
 }

package/skills/bricks-ctor/references/architecture-patterns.md

@@ -25,6 +25,7 @@ The primary way to orchestrate multi-step flows. A single event can contain an a
 - Use `waitAsync: true` to await async actions before the next step
 - Use `dataParams` + `mapping` to pass event data downstream
 - This is the "glue" that wires generators, state, and UI together
+- For Generator result UI: await Generator, write done/version Data; route/current Data stays identity.
 
 Sequential `PROPERTY_BANK` / `PROPERTY_BANK_EXPRESSION` actions in one chain read the data values that existed when the chain started. If a later action needs to read what an earlier action wrote, set `waitAsync: true` on the earlier action.
 

package/skills/bricks-ctor/references/data-calculation.md

@@ -87,6 +87,17 @@ const triggerCalc: EventAction = {
 - When a **later action reads the calc's outputs**, set `waitAsync: true` on the `PROPERTY_BANK_COMMAND` action itself — it awaits the full calc chain including output writes.
 - A dataParam's `value` acts as an execution gate: `{ input: () => d, value: false }` skips that trigger (combine with `mapping` for conditional runs).
 
+## One trigger source per result panel
+
+A panel that shows the result of an async action (Generator HTTP/LLM response, request telemetry) reads from a calc whose **trigger should come from a single source**: either the live async outlet, or a completion marker the action chain writes — not both.
+
+- **Outlet-triggered** (`{ data: () => dResponse, trigger: true }`): the calc reruns as outlets land. Use when each outlet is only written once its value is final.
+- **Marker-triggered**: run the generator with `waitAsync: true`, then write a `done` Data the calc triggers on. Use when several outlets settle separately and the panel must wait for all of them.
+
+Wiring both at once — triggering on the live outlet _and_ gating on a separately-written marker — lets the calc run before the outlets have settled (it renders `undefined`/stale) while the marker path masks it intermittently. A panel that updates "sometimes" usually has two competing triggers: pick one, and order it with `waitAsync` so the trigger fires after the values it reads are written.
+
+Scope the panel's calc to the **single value it derives** (the formatted display string), and write sibling status labels — running/done, progress, selected route — imperatively in the event chain with `PROPERTY_BANK`. A calc rewrites _every_ one of its outputs on each run, so a return that omits a key writes `undefined` to that output Data (see [Field Rules](#field-rules-defaults-and-constraints)): folding status labels into a multi-output result calc resets them to `undefined` on any run that returns only the derived value. If a calc genuinely must drive several outputs, return all of their keys every run.
+
 ## Script Sandbox
 
 Scripts run in `use strict` mode as a function body — top-level `return` returns the calc result. No `fetch`, `XMLHttpRequest`, or `require` in any mode: I/O belongs to Generators.
@@ -220,6 +231,8 @@ const appendHistory: DataCalculationScript = {
 | `PROPERTY_BANK_COMMAND` does nothing | Auto calc + `trigger: false` input, or `input` doesn't reference an input Data of the calc | Command a `trigger: true` input (auto) or any input (manual) |
 | Compile error `Not allow duplicate set property id...` | Auto mode with same Data as input and output | Use `triggerMode: 'manual'`, or split into separate Data |
 | Calc reads stale value written earlier in the same chain | Missing `waitAsync: true` on the preceding write | Set `waitAsync: true` on the write action |
+| Result/telemetry panel shows `undefined` or stale data intermittently | Calc triggered by two sources at once (live outlet + a separately-written marker) | Trigger from one source — see [One trigger source per result panel](#one-trigger-source-per-result-panel) |
+| Sibling status Data (selected/progress) resets to `undefined` after a calc runs | Multi-output result calc whose return omitted those keys on that run | Scope the calc to one output and write status labels imperatively, or return every output key each run — see [One trigger source per result panel](#one-trigger-source-per-result-panel) |
 | Works in Simulator, fails on device | V8 vs Hermes/JSC engine difference | Verify on device (Path 2); avoid engine-sensitive parsing |
 | `console.log` shows nothing | Console only emits during DevTools debug sessions | Attach DevTools, or write debug values to an output Data |
 | `Promise`/`setTimeout` undefined, or `Async mode is required` error | `enableAsync: false` | Set `enableAsync: true` |

package/types/generators/HttpServer.d.ts

@@ -1,6 +1,6 @@
 /* Auto generated by build script
  *
- * Embedded HTTP/HTTPS server with route matching, CORS, auth (Basic/Bearer), SSE streaming, file upload, and async response mode
+ * Embedded HTTP/HTTPS server with route matching, CORS, auth (Basic/Bearer), SSE streaming, file upload, async response mode, and JS Sandbox route handlers
  */
 import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from '../switch'
 import type { Data, DataLink } from '../data'
@@ -42,6 +42,7 @@ Default property:
   "init": false,
   "method": "GET",
   "path": "/",
+  "methods": [],
   "idleTimeout": 10000,
   "authType": "none",
   "asyncMode": false,
@@ -70,6 +71,59 @@ Default property:
       | DataLink
     /* Path of HTTP request */
     path?: string | DataLink
+    /* Additional route methods handled by JS Sandbox scripts. The script receives `inputs.request`, `inputs.query`, `inputs.headers`, `inputs.body`, and configured `additionalParams`. `scriptConfig.members` can expose generator or brick script-member functions, same as MCP Server. */
+    methods?:
+      | Array<
+          | DataLink
+          | {
+              enabled?: boolean | DataLink
+              name?: string | DataLink
+              method?:
+                | 'GET'
+                | 'POST'
+                | 'PUT'
+                | 'DELETE'
+                | 'HEAD'
+                | 'PATCH'
+                | 'OPTIONS'
+                | 'CONNECT'
+                | 'TRACE'
+                | DataLink
+              path?: string | DataLink
+              resStatusCode?: number | DataLink
+              resContentType?:
+                | 'text/plain'
+                | 'text/html'
+                | 'text/javascript'
+                | 'text/css'
+                | 'text/xml'
+                | 'application/xml'
+                | 'application/json'
+                | 'application/octet-stream'
+                | 'text/event-stream'
+                | DataLink
+              resHeader?: {} | DataLink
+              resBody?: any
+              sseEvent?: string | DataLink
+              scriptConfig?:
+                | DataLink
+                | {
+                    code?: string | DataLink
+                    timeout?: number | DataLink
+                    members?:
+                      | Array<
+                          | DataLink
+                          | {
+                              handler?: string | DataLink
+                              varName?: string | DataLink
+                            }
+                        >
+                      | DataLink
+                    additionalParams?: {} | DataLink
+                  }
+            }
+        >
+      | DataLink
     /* Max connection idle time, 0 is disable */
     idleTimeout?: number | DataLink
     /* HTTP request body limit, 0 is unlimited */
@@ -153,7 +207,7 @@ Default property:
   }
 }
 
-/* Embedded HTTP/HTTPS server with route matching, CORS, auth (Basic/Bearer), SSE streaming, file upload, and async response mode */
+/* Embedded HTTP/HTTPS server with route matching, CORS, auth (Basic/Bearer), SSE streaming, file upload, async response mode, and JS Sandbox route handlers */
 export type GeneratorHTTPServer = Generator &
   GeneratorHTTPServerDef & {
     templateKey: 'GENERATOR_HTTP_SERVER'

package/utils/data.ts

@@ -83,7 +83,7 @@ type SystemDataName =
 type SystemDataInfo = {
   name: SystemDataName
   id: string
-  type: 'string' | 'number' | 'bool' | 'boolean' | 'array' | 'object' | 'any'
+  type: Data['type']
   title?: string
   description?: string
   schema?: object