@fugood/bricks-project 2.25.0-beta.4 → 2.25.0-beta.41

package/compile/action-name-map.ts

@@ -350,6 +350,63 @@ export const templateActionNameMap = {
       strokeWidth: 'BRICK_SKETCH_STROKE_WIDTH',
     },
   },
+  BRICK_SCENE_3D: {
+    BRICK_SCENE_3D_ADD_OBJECT: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+      objectType: 'BRICK_SCENE_3D_OBJECT_TYPE',
+      objectUrl: 'BRICK_SCENE_3D_OBJECT_URL',
+      objectMd5: 'BRICK_SCENE_3D_OBJECT_MD5',
+      objectPosition: 'BRICK_SCENE_3D_OBJECT_POSITION',
+      objectRotation: 'BRICK_SCENE_3D_OBJECT_ROTATION',
+      objectScale: 'BRICK_SCENE_3D_OBJECT_SCALE',
+      objectColor: 'BRICK_SCENE_3D_OBJECT_COLOR',
+    },
+    BRICK_SCENE_3D_REMOVE_OBJECT: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+    },
+    BRICK_SCENE_3D_UPDATE_OBJECT: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+      objectPosition: 'BRICK_SCENE_3D_OBJECT_POSITION',
+      objectRotation: 'BRICK_SCENE_3D_OBJECT_ROTATION',
+      objectScale: 'BRICK_SCENE_3D_OBJECT_SCALE',
+      objectVisible: 'BRICK_SCENE_3D_OBJECT_VISIBLE',
+      objectColor: 'BRICK_SCENE_3D_OBJECT_COLOR',
+      objectNodes: 'BRICK_SCENE_3D_OBJECT_NODES',
+    },
+    BRICK_SCENE_3D_SET_CAMERA: {
+      cameraPosition: 'BRICK_SCENE_3D_CAMERA_POSITION',
+      cameraTarget: 'BRICK_SCENE_3D_CAMERA_TARGET',
+      cameraFov: 'BRICK_SCENE_3D_CAMERA_FOV',
+      cameraAnimateMs: 'BRICK_SCENE_3D_CAMERA_ANIMATE_MS',
+    },
+    BRICK_SCENE_3D_LOOK_AT: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+    },
+    BRICK_SCENE_3D_PLAY_ANIMATION: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+      animationName: 'BRICK_SCENE_3D_ANIMATION_NAME',
+      animationLoop: 'BRICK_SCENE_3D_ANIMATION_LOOP',
+      animationSpeed: 'BRICK_SCENE_3D_ANIMATION_SPEED',
+    },
+    BRICK_SCENE_3D_STOP_ANIMATION: {
+      objectId: 'BRICK_SCENE_3D_OBJECT_ID',
+      animationName: 'BRICK_SCENE_3D_ANIMATION_NAME',
+    },
+    BRICK_SCENE_3D_SET_BACKGROUND: {
+      backgroundColor: 'BRICK_SCENE_3D_BACKGROUND_COLOR',
+      backgroundHdrUrl: 'BRICK_SCENE_3D_BACKGROUND_HDR_URL',
+      backgroundMd5: 'BRICK_SCENE_3D_BACKGROUND_MD5',
+    },
+    BRICK_SCENE_3D_SET_CONTROLS: {
+      controlsEnabled: 'BRICK_SCENE_3D_CONTROLS_ENABLED',
+      controlsAutoRotate: 'BRICK_SCENE_3D_CONTROLS_AUTO_ROTATE',
+      controlsAutoRotateSpeed: 'BRICK_SCENE_3D_CONTROLS_AUTO_ROTATE_SPEED',
+    },
+    BRICK_SCENE_3D_SCREENSHOT: {
+      screenshotFormat: 'BRICK_SCENE_3D_SCREENSHOT_FORMAT',
+      screenshotQuality: 'BRICK_SCENE_3D_SCREENSHOT_QUALITY',
+    },
+  },
 
   GENERATOR_FILE: {
     GENERATOR_FILE_READ_CONTENT: {
@@ -782,6 +839,11 @@ export const templateActionNameMap = {
       seed: 'GENERATOR_LLM_SEED',
       typicalP: 'GENERATOR_LLM_TYPICAL_P',
       ignoreEos: 'GENERATOR_LLM_IGNORE_EOS',
+      mtpSpeculativeDecoding: 'GENERATOR_LLM_MTP_SPECULATIVE_DECODING',
+      mtpDraftTokens: 'GENERATOR_LLM_MTP_DRAFT_TOKENS',
+      mtpDraftMinTokens: 'GENERATOR_LLM_MTP_DRAFT_MIN_TOKENS',
+      mtpDraftMinProbability: 'GENERATOR_LLM_MTP_DRAFT_MIN_PROBABILITY',
+      mtpDraftSplitProbability: 'GENERATOR_LLM_MTP_DRAFT_SPLIT_PROBABILITY',
       functionCallEnabled: 'GENERATOR_LLM_FUNCTION_CALL_ENABLED',
       functionCallSchema: 'GENERATOR_LLM_FUNCTION_CALL_SCHEMA',
     },
@@ -894,10 +956,12 @@ export const templateActionNameMap = {
     GENERATOR_APPLE_STT_TRANSCRIBE_FILE: {
       fileUrl: 'GENERATOR_APPLE_STT_FILE_URL',
       language: 'GENERATOR_APPLE_STT_LANGUAGE',
+      contextualStrings: 'GENERATOR_APPLE_STT_CONTEXTUAL_STRINGS',
     },
     GENERATOR_APPLE_STT_TRANSCRIBE_DATA: {
       data: 'GENERATOR_APPLE_STT_DATA',
       language: 'GENERATOR_APPLE_STT_LANGUAGE',
+      contextualStrings: 'GENERATOR_APPLE_STT_CONTEXTUAL_STRINGS',
     },
   },
   GENERATOR_APPLE_TTS: {

package/compile/index.ts

@@ -154,11 +154,13 @@ const basicAnimationEvents = ['show', 'standby', 'breatheStart']
 
 const compileAnimations = (
   templateKey: string,
-  animations: { [key: string]: Animation },
+  animations: { [key: string]: Animation | (() => Animation) },
   errorReference: string,
 ) =>
   Object.entries(animations).reduce((acc, [key, animation]) => {
-    const animationId = assertEntryId(animation?.id, 'ANIMATION', errorReference)
+    // Animation events accept either a direct Animation or a getter; unwrap.
+    const resolved = typeof animation === 'function' ? animation() : animation
+    const animationId = assertEntryId(resolved?.id, 'ANIMATION', errorReference)
     acc[convertEventKey(basicAnimationEvents.includes(key) ? 'BRICK' : templateKey, key)] =
       `ANIMATION#${animationId}`
     return acc
@@ -301,6 +303,162 @@ const animationTypeMap = {
   AnimationTimingConfig: 'timing',
   AnimationSpringConfig: 'spring',
   AnimationDecayConfig: 'decay',
+} as const
+
+type CompiledAnimationType = (typeof animationTypeMap)[keyof typeof animationTypeMap]
+type WarningMetadata = Record<string, unknown>
+
+const animationProperties = new Set([
+  'transform.translateX',
+  'transform.translateY',
+  'transform.scale',
+  'transform.scaleX',
+  'transform.scaleY',
+  'transform.rotate',
+  'transform.rotateX',
+  'transform.rotateY',
+  'opacity',
+])
+
+const animationComposeTypes = new Set(['parallel', 'sequence'])
+const springConfigFamilies = [
+  ['stiffness', 'damping', 'mass'],
+  ['tension', 'friction'],
+  ['bounciness', 'speed'],
+]
+const springConfigFamilyKeys = new Set(springConfigFamilies.flat())
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
+const hasDefinedConfigValue = (config: Record<string, unknown>, key: string) =>
+  config[key] !== undefined
+
+const assertConfigValue = (
+  config: Record<string, unknown>,
+  key: string,
+  errorReference: string,
+) => {
+  if (!hasDefinedConfigValue(config, key)) {
+    throw new Error(`Invalid animation config ${errorReference}: missing "${key}"`)
+  }
+}
+
+const assertAnimationProperty = (property: unknown, errorReference: string) => {
+  if (typeof property !== 'string' || !animationProperties.has(property)) {
+    throw new Error(
+      `Invalid animation property${errorReference ? ` ${errorReference}` : ''}: ${String(
+        property,
+      )}`,
+    )
+  }
+  return property
+}
+
+const getAnimationType = (config: unknown, errorReference: string): CompiledAnimationType => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const animationType = animationTypeMap[config.__type as keyof typeof animationTypeMap]
+  if (!animationType) {
+    throw new Error(`Invalid animation config type ${errorReference}: ${String(config.__type)}`)
+  }
+  return animationType
+}
+
+const assertAnimationComposeType = (composeType: unknown, errorReference: string) => {
+  if (typeof composeType !== 'string' || !animationComposeTypes.has(composeType)) {
+    throw new Error(`Invalid animation compose type ${errorReference}: ${String(composeType)}`)
+  }
+  return composeType
+}
+
+const pickDefinedConfigValues = (config: Record<string, unknown>, keys: string[]) =>
+  keys.reduce((acc, key) => {
+    if (hasDefinedConfigValue(config, key)) acc[key] = config[key]
+    return acc
+  }, {})
+
+const getDefinedConfigKeys = (config: Record<string, unknown>, keys: string[]) =>
+  keys.filter((key) => hasDefinedConfigValue(config, key))
+
+const formatWarningMetadata = (metadata: WarningMetadata = {}) =>
+  Object.entries(metadata)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}: ${String(value)}`)
+    .join(', ')
+
+const formatWarningReference = (metadata?: WarningMetadata) => {
+  const metadataText = formatWarningMetadata(metadata)
+  return metadataText ? ` [${metadataText}]` : ''
+}
+
+const normalizeSpringConfig = (
+  config: Record<string, unknown>,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+): Record<string, unknown> => {
+  assertConfigValue(config, 'toValue', errorReference)
+
+  const usedFamilies = springConfigFamilies.filter((keys) =>
+    keys.some((key) => hasDefinedConfigValue(config, key)),
+  )
+  if (usedFamilies.length <= 1) return config
+
+  const configWithoutSpringFamily = Object.entries(config).reduce((acc, [key, value]) => {
+    if (!springConfigFamilyKeys.has(key)) acc[key] = value
+    return acc
+  }, {})
+
+  // Match runtime normalization: physical spring values are most explicit,
+  // otherwise preserve BRICKS' historical tension/friction controls.
+  const resolvedFamily =
+    usedFamilies.find((keys) => keys.includes('stiffness')) ||
+    usedFamilies.find((keys) => keys.includes('tension')) ||
+    usedFamilies[0]
+  const resolvedFamilyKeys = getDefinedConfigKeys(config, resolvedFamily)
+  const droppedFamilyKeys = usedFamilies
+    .filter((keys) => keys !== resolvedFamily)
+    .flatMap((keys) => getDefinedConfigKeys(config, keys))
+
+  console.warn(
+    `[Warning] Resolved animation spring config${formatWarningReference(
+      warningMetadata,
+    )}: using ${resolvedFamilyKeys.join('/')}, dropping ${droppedFamilyKeys.join('/')}`,
+  )
+
+  return {
+    ...configWithoutSpringFamily,
+    ...pickDefinedConfigValues(config, resolvedFamily),
+  }
+}
+
+const compileAnimationConfig = (
+  animationType: CompiledAnimationType,
+  config: unknown,
+  errorReference: string,
+  warningMetadata?: WarningMetadata,
+) => {
+  if (!isRecord(config)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must be an object`)
+  }
+
+  const compiledConfig = compileProperty(omit(config, '__type'), errorReference)
+
+  if (!isRecord(compiledConfig)) {
+    throw new Error(`Invalid animation config ${errorReference}: config must compile to an object`)
+  }
+
+  if (animationType === 'timing') {
+    assertConfigValue(compiledConfig, 'toValue', errorReference)
+  } else if (animationType === 'spring') {
+    return normalizeSpringConfig(compiledConfig, errorReference, warningMetadata)
+  } else if (animationType === 'decay') {
+    assertConfigValue(compiledConfig, 'velocity', errorReference)
+  }
+
+  return compiledConfig
 }
 
 const compileFrame = (frame: Canvas['items'][number]['frame']) => ({
@@ -327,6 +485,8 @@ const preloadTypes = [
   'ggml-model-asset',
   'gguf-model-asset',
   'binary-asset',
+  'mlx-model-asset',
+  'scene3d-objects',
 ]
 
 const compileKind = (kind: Data['kind']) => {
@@ -353,9 +513,10 @@ const compileKind = (kind: Data['kind']) => {
 }
 
 const compileRemoteUpdate = (remoteUpdate: Data['remoteUpdate']) => {
-  if (!remoteUpdate) return {}
-  if (remoteUpdate.type === 'auto') return { enable_remote_update: true }
+  if (!remoteUpdate) return { bank_type: 'none' }
+  if (remoteUpdate.type === 'auto') return { bank_type: 'create', enable_remote_update: true }
   return {
+    bank_type: remoteUpdate.type === 'device-specific' ? 'create-device-specific' : 'global',
     enable_remote_update: true,
     ...(remoteUpdate.type === 'device-specific' ? { use_remote_id_prefix: true } : {}),
     ...(remoteUpdate.type === 'global-data' ? { global_remote_update_prop: remoteUpdate.id } : {}),
@@ -485,6 +646,7 @@ const compileAutomationTest = (
 
   return {
     id: testId,
+    alias: test.alias,
     title: test.title,
     hide_short_ref: test.hideShortRef,
     timeout: test.timeout,
@@ -629,39 +791,63 @@ export const compile = async (app: Application) => {
             `(animation index: ${animationIndex}, subspace: ${subspaceId})`,
           )
 
-          if (animation.__typename === 'Animation') {
+          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: animationDef.property,
-              type: animationTypeMap[animationDef.config.__type],
-              config: compileProperty(
-                omit(animationDef.config, '__type'),
-                `(animation: ${animationId}, subspace ${subspaceId})`,
+              property: assertAnimationProperty(animationDef.property, animationErrorReference),
+              type: animationType,
+              config: compileAnimationConfig(
+                animationType,
+                animationDef.config,
+                animationErrorReference,
+                animationWarningMetadata,
               ),
             }
-          } else if (animation.__typename === 'AnimationCompose') {
+          } 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: animationDef.composeType,
+              compose_type: assertAnimationComposeType(
+                animationDef.composeType,
+                animationErrorReference,
+              ),
               item_list: animationDef.items.map((item, index) => {
                 const innerAnimation = item()
-                if (!innerAnimation?.id)
-                  throw new Error(
-                    `Invalid animation index: ${index} (animation: ${innerAnimation.id}, subspace ${subspaceId})`,
-                  )
-                return { animation_id: innerAnimation.id }
+                const innerAnimationId = assertEntryId(
+                  innerAnimation?.id,
+                  'ANIMATION',
+                  `(animation item index: ${index}, animation: ${animationId}, subspace ${subspaceId})`,
+                )
+                return { animation_id: innerAnimationId }
               }),
             }
+          } else {
+            throw new Error(
+              `Invalid animation typename (animation: ${animationId}, subspace ${subspaceId}): ${String(
+                animationTypename,
+              )}`,
+            )
           }
           return map
         }, {}),
@@ -1009,7 +1195,7 @@ export const compile = async (app: Application) => {
             ...compileRemoteUpdate(data.remoteUpdate),
             routing: data.routing,
             schema: data.schema,
-            type: data.type,
+            type: data.type === 'boolean' ? 'bool' : data.type,
             ...compileKind(data.kind),
             value: compileProperty(data.value, `(data: ${dataId}, subspace ${subspaceId})`),
             event_map: compileEvents('PROPERTY_BANK', data.events || {}, {
@@ -1029,6 +1215,7 @@ export const compile = async (app: Application) => {
           )
 
           const calc: any = {
+            alias: dataCalc.alias,
             title: dataCalc.title,
             description: dataCalc.description,
             hide_short_ref: dataCalc.hideShortRef,
@@ -1274,5 +1461,7 @@ export const compile = async (app: Application) => {
 
 export const checkConfig = async (configPath: string) => {
   const { sh } = await import('../tools/_shell')
-  await sh`bricks app check-config ${configPath}`
+  // --validate-automation surfaces broken automation_map / test_map refs early,
+  // which catches agent-authored automations that reference deleted bricks.
+  await sh`bricks app check-config --validate-automation ${configPath}`
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.4",
+  "version": "2.25.0-beta.41",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.4",
+    "@fugood/bricks-cli": "^2.25.0-beta.41",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -24,5 +24,6 @@
   },
   "peerDependencies": {
     "oxfmt": "^0.36.0"
-  }
+  },
+  "gitHead": "4ad8588eed6f0161b0aa66d863a36e6c623c4a83"
 }

package/package.json.bak

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.4",
+  "version": "2.25.0-beta.41",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.4",
+    "@fugood/bricks-cli": "^2.25.0-beta.41",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -24,5 +24,6 @@
   },
   "peerDependencies": {
     "oxfmt": "^0.36.0"
-  }
+  },
+  "gitHead": "4ad8588eed6f0161b0aa66d863a36e6c623c4a83"
 }

package/skills/bricks-ctor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: bricks-ctor
-description: Advanced BRICKS configuration knowledge. Covers Standby Transition, Automations (E2E testing), Data Calculation (JS sandbox libraries), Local Sync, Remote Data Bank, Media Flow, and Buttress (remote inference). Triggers on multi-device sync, cloud data, media assets, AI offloading, E2E testing, or canvas transitions.
+description: Advanced BRICKS configuration knowledge. Covers Standby Transition, Automations (E2E testing), Data Calculation (JS sandbox libraries), Local Sync, Remote Data Bank, Media Flow, Buttress (remote inference), and the verification toolchain (compile, harness-specific preview tool, on-device DevTools, definition-of-done gate). Triggers on multi-device sync, cloud data, media assets, AI offloading, E2E testing, canvas transitions, or verifying project work before declaring done.
 ---
 
 # BRICKS Ctor - Advanced Features
@@ -11,22 +11,26 @@ This skill covers advanced BRICKS features not in the main project instructions.
 
 | Rule | Description |
 |------|-------------|
-| [Architecture Patterns](rules/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
-| [Animation](rules/animation.md) | Animation system for brick transforms and opacity |
-| [Standby Transition](rules/standby-transition.md) | Canvas enter/exit animations |
-| [Automations](rules/automations.md) | E2E testing and scheduled tasks |
-| [Data Calculation](rules/data-calculation.md) | JS sandbox libraries (25+ available) |
-| [Local Sync](rules/local-sync.md) | LAN device synchronization |
-| [Remote Data Bank](rules/remote-data-bank.md) | Cloud data sync and API access |
-| [Media Flow](rules/media-flow.md) | Media asset management |
-| [Buttress](rules/buttress.md) | Remote inference for AI generators |
+| [Architecture Patterns](references/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
+| [Animation](references/animation.md) | Animation system for brick transforms and opacity |
+| [Standby Transition](references/standby-transition.md) | Canvas enter/exit animations |
+| [Automations](references/automations.md) | E2E testing and scheduled tasks |
+| [Data Calculation](references/data-calculation.md) | Wiring contract, trigger semantics, JS sandbox (25+ libraries) |
+| [Local Sync](references/local-sync.md) | LAN device synchronization |
+| [Remote Data Bank](references/remote-data-bank.md) | Cloud data sync and API access |
+| [Media Flow](references/media-flow.md) | Media asset management |
+| [Buttress](references/buttress.md) | Remote inference for AI generators |
+| [Verification Toolchain](references/verification-toolchain.md) | Definition of done, compile, preview tool selection, on-device DevTools, Path 1/2/3 decision rule |
+| [Simulator](references/simulator.md) | Path 1 fidelity — Simulator feature support, fallbacks (Camera/LLM/STT/Vector Store, Buttress disabled), when a green run is enough vs. Path 2 |
 
 ## Quick Reference
 
-- **Complex flows**: See [Architecture Patterns](rules/architecture-patterns.md) for decomposing multi-step workflows
-- **Multi-device**: See [Local Sync](rules/local-sync.md) for LAN coordination
-- **Cloud data**: See [Remote Data Bank](rules/remote-data-bank.md) for sync and API access
-- **Media assets**: See [Media Flow](rules/media-flow.md) for centralized asset management
-- **AI offloading**: See [Buttress](rules/buttress.md) for GPU server delegation
-- **E2E testing**: See [Automations](rules/automations.md) for test automation
-- **Enter animations**: See [Standby Transition](rules/standby-transition.md) for canvas transitions
+- **Complex flows**: See [Architecture Patterns](references/architecture-patterns.md) for decomposing multi-step workflows
+- **Multi-device**: See [Local Sync](references/local-sync.md) for LAN coordination
+- **Cloud data**: See [Remote Data Bank](references/remote-data-bank.md) for sync and API access
+- **Media assets**: See [Media Flow](references/media-flow.md) for centralized asset management
+- **AI offloading**: See [Buttress](references/buttress.md) for GPU server delegation
+- **E2E testing**: See [Automations](references/automations.md) for test automation
+- **Enter animations**: See [Standby Transition](references/standby-transition.md) for canvas transitions
+- **Verification before done**: See [Verification Toolchain](references/verification-toolchain.md) for the definition-of-done gate and Path 1/2/3 decision rule
+- **Simulator fidelity**: See [Simulator](references/simulator.md) for what the Simulator fakes (Camera, AI generators, Buttress) and when to escalate to a real device

package/skills/bricks-ctor/{rules → references}/animation.md

@@ -41,12 +41,13 @@ const bounce: AnimationDef = {
     toValue: 1,
     friction: 7,
     tension: 40,
-    speed: 12,
-    bounciness: 8,
   },
 }
 ```
 
+Use one spring parameter family per config: `tension/friction`, `speed/bounciness`, or
+`stiffness/damping/mass`.
+
 ### Decay Animation
 Velocity-based deceleration animation.
 

package/skills/bricks-ctor/{rules → references}/architecture-patterns.md

@@ -26,6 +26,8 @@ The primary way to orchestrate multi-step flows. A single event can contain an a
 - Use `dataParams` + `mapping` to pass event data downstream
 - This is the "glue" that wires generators, state, and UI together
 
+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.
+
 ### System Actions (Priority 3)
 Built-in commands for direct state and UI changes.
 - **PROPERTY_BANK**: set data value
@@ -67,3 +69,13 @@ Only actual data derivation maps to Data Calculation:
 
 ### Step 4: Wire with Event Action Chains
 Connect the pieces through events on generators and bricks.
+
+## Recipe: user-driven state machine (calculator, form wizard, picker)
+
+A brief like "state vars X, Y, Z; button A updates X from X+Y; button B resets" is a state machine. The shape:
+
+- Each state variable is its own `Data` entity. Displays read it via `linkData(() => data.dFoo)`.
+- Each button's `onPress` is an Event Action Chain. For every state var that changes, append one `PROPERTY_BANK_EXPRESSION` whose `expression` reads the current state and returns the new value.
+- Use `Data Calculation` only for reusable pure derivations referenced as inputs to those expressions.
+
+A 10-button calculator with 4 state vars is ~10 small chains of 1–4 inline expressions. If you find yourself writing a single auto-mode `DataCalculationScript` that consumes all state vars and emits all-new state through mirror `dFooResult` data — or pinging a `dLastInput` field to force an auto calc to re-run — the chain shape was the right answer.

package/skills/bricks-ctor/{rules → references}/automations.md

@@ -118,6 +118,16 @@ const testLoginFlow: AutomationTest = {
 | `match_screenshot`           | `[name, threshold?, maxRetry?]`                  | Screenshot compare   |
 | `delay`                      | `[subspace?, property?, defaultValue?]`          | Delay execution      |
 
+In project TypeScript source, pass entity getters for BRICKS entities:
+
+```typescript
+run: ['brick_press', () => mainSubspace, () => bricks.bSubmitButton]
+run: ['wait_until_canvas_change', () => mainSubspace, () => canvases.cDone, 5000]
+run: ['assert_property', () => mainSubspace, () => data.dStep, 'done']
+```
+
+The compiler resolves these getters to the current generated IDs.
+
 ### execute_action Params
 
 The `params` object in `execute_action` uses **runtime event property keys** from `event-props.ts`, NOT the action config `input` names from type definitions.
@@ -208,6 +218,7 @@ Automations work with Modules. Use Manual Run in Preview mode for module testing
 
 - **Automation map key**: Always use `'AUTOMATION_MAP_DEFAULT'` as the automation map ID (not `makeId()`). The preview test runner reads from `automationMap['AUTOMATION_MAP_DEFAULT']?.map`.
 - **Valid makeId types**: Use `'test'` for AutomationTest, `'test_case'` for TestCase, `'test_var'` for TestVariable. Do NOT use `'automation_test'` or `'automation_test_map'`.
+- **Entity references in run arrays**: Use getter references (`() => subspace`, `() => bricks.bButton`, `() => data.dValue`) in TypeScript source so compile resolves fresh IDs.
 - **handler in execute_action**: Pass the entity's `.id` string (e.g., `bricks.bInput.id`), not a getter function.
 
 ## Best Practices