@fugood/bricks-ctor 2.25.0-beta.60 → 2.25.0-beta.62

package/compile/util.ts

@@ -1,482 +0,0 @@
-import { makeSeededId } from '../utils/id'
-
-type ScriptConfig = {
-  title?: string
-  note?: string
-  inputs: Record<string, string>
-  enable_async: boolean
-  trigger_mode?: 'auto' | 'manual'
-  disabled_triggers: Record<string, boolean>
-  output: string | null
-  outputs: Record<string, string[]>
-  error: string | null
-  code: string
-}
-
-const errorMsg = 'Not allow duplicate set property id between inputs / outputs / output / error.'
-
-export const validateConfig = (config: ScriptConfig) => {
-  // Skip input/output overlap validation in manual mode (allows same data node in both)
-  if (config.trigger_mode === 'manual') return
-  // `inputs` is keyed by data-node id with the OBJECT_SET path as the *value*. The overlap
-  // check is "is this id also an input?" — a key-existence question — so test key presence,
-  // not the path's truthiness. An empty path ('' = OBJECT_SET's default "set whole object")
-  // is a legitimate input value that would otherwise slip the overlap guard.
-  const isInput = (id: string) => Object.prototype.hasOwnProperty.call(config.inputs, id)
-  if (config.error && isInput(config.error)) {
-    throw new Error(`${errorMsg}. key: error`)
-  }
-  if (config.output && isInput(config.output)) {
-    throw new Error(`${errorMsg}. key: output`)
-  }
-  if (Object.values(config.outputs).some((value) => value.some(isInput))) {
-    throw new Error(`${errorMsg}. key: outputs`)
-  }
-  // The same data-node id reused across the output-side targets (output / error / outputs)
-  // also collides: generateCalulationMap spreads their node objects last-wins, so the later
-  // one silently overwrites the earlier wiring (e.g. error == output drops the error change
-  // link). The checks above only compare against `inputs`, so guard the output-side pairs
-  // too. (The same id appearing in multiple `outputs` entries is a supported last-wins case
-  // and stays allowed.)
-  if (config.error && config.output && config.error === config.output) {
-    throw new Error(`${errorMsg}. key: error/output`)
-  }
-  const outputsIds = Object.values(config.outputs).flat()
-  if (config.output && outputsIds.includes(config.output)) {
-    throw new Error(`${errorMsg}. key: output/outputs`)
-  }
-  if (config.error && outputsIds.includes(config.error)) {
-    throw new Error(`${errorMsg}. key: error/outputs`)
-  }
-}
-
-const padding = 15
-const layerXInterval = 300
-const layerYInterval = 150
-
-// Direction A — first-class script node (see local-plan/PLAN-data-calculation-refactor.md).
-//
-// `generateCalulationMap` keeps emitting the legacy OBJECT_SET → SANDBOX_RUN_JAVASCRIPT →
-// SANDBOX_GET_*/OBJECT_GET expansion in `map` (consumed by older runtimes). In parallel,
-// `generateScriptMap` derives an equivalent single-node graph in `script_map` that a newer
-// runtime prefers: one `command-node-script` node that assembles `inputs` from keyed input
-// ports and fans out `error` / `output` / each `outputs` path directly to the target data
-// nodes. Both are byte-stable functions of `script_config`, so codegen (which only reads
-// `script_config`) round-trips losslessly and recompiling unchanged source re-derives an
-// identical `script_map`.
-//
-// Trigger semantics stay edge-level (`disable_trigger_command` on the script node's input
-// edges, same as the legacy OBJECT_SET inputs) so the circular-reference check and the
-// manual-trigger overlay keep working unchanged — only the node count collapses N+3 → 1.
-const generateScriptMap = (config: ScriptConfig, calcId: string) => {
-  const scriptId = makeSeededId('property_bank_command', `${calcId}:script`)
-  const map: Record<string, any> = {}
-
-  // Compiled run-time config for the script node. `inputs` maps each input port name (the
-  // source data-node id) to its OBJECT_SET path; `outputs` maps each fan-out port name to the
-  // OBJECT_GET path it extracts from the return value. The runtime reads these from
-  // properties.args, keeping the node `value` reserved purely for incoming input-port values.
-  const inputArgs: Record<string, string> = {}
-  const outputArgs: Record<string, string> = {}
-
-  const scriptIn: Record<string, any> = {}
-  const scriptOut: Record<string, any> = {}
-
-  // One in-port per input, keyed by the source data-node id (unique per input, so each input
-  // keeps its own `disable_trigger_command` flag — a shared path could not). Manual mode
-  // disables every input edge; auto mode honours per-key `disabled_triggers`.
-  Object.entries(config.inputs).forEach(([dataNodeId, path]) => {
-    inputArgs[dataNodeId] = path
-    scriptIn[dataNodeId] = [
-      {
-        id: dataNodeId,
-        port: 'value',
-        disable_trigger_command:
-          config.trigger_mode === 'manual' || config.disabled_triggers?.[dataNodeId] || undefined,
-      },
-    ]
-    map[dataNodeId] = {
-      type: 'data-node',
-      properties: {},
-      in: { change: null },
-      out: { value: [{ id: scriptId, port: dataNodeId }] },
-    }
-  })
-
-  // Wire an output target data-node's `change` port back from a script out-port, preserving
-  // any `out.value` it already has (a node reused as both input and output — allowed in manual
-  // mode). Mirrors the last-wins reuse handling in generateCalulationMap's outputs section.
-  const wireOutputTarget = (dataNodeId: string, scriptPort: string) => {
-    const existing = map[dataNodeId]
-    map[dataNodeId] = {
-      type: 'data-node',
-      properties: {},
-      in: { change: [{ id: scriptId, port: scriptPort }] },
-      out: { value: existing?.out?.value ?? null },
-    }
-  }
-
-  if (config.error) {
-    scriptOut.error = [{ id: config.error, port: 'change' }]
-    wireOutputTarget(config.error, 'error')
-  }
-  if (config.output) {
-    scriptOut.output = [{ id: config.output, port: 'change' }]
-    wireOutputTarget(config.output, 'output')
-  }
-  // `out:`-prefixed port names keep `outputs` paths from colliding with the reserved
-  // `error` / `output` ports (a path could legitimately be the string "output").
-  Object.entries(config.outputs).forEach(([path, pbList]) => {
-    const portName = `out:${path}`
-    outputArgs[portName] = path
-    scriptOut[portName] = pbList.map((pb) => ({ id: pb, port: 'change' }))
-    pbList.forEach((pb) => wireOutputTarget(pb, portName))
-  })
-
-  map[scriptId] = {
-    type: 'command-node-script',
-    title: 'Command: SCRIPT_RUN',
-    properties: {
-      command: 'SCRIPT_RUN',
-      args: {
-        code: config.code,
-        enable_async: config.enable_async,
-        inputs: inputArgs,
-        outputs: outputArgs,
-      },
-    },
-    in: scriptIn,
-    out: scriptOut,
-  }
-
-  return map
-}
-
-// `calcId` (the owning script calc's stable id) seeds every derived command-node id, so an
-// unchanged calc recompiles to identical ids and editing one calc never shifts another's —
-// keeping the compiled config byte-stable for change detection. See makeSeededId in utils/id.
-export const generateCalulationMap = (config: ScriptConfig, calcId: string) => {
-  validateConfig(config)
-  const sandboxId = makeSeededId('property_bank_command', `${calcId}:sandbox-run`)
-  const sandboxErrorId = makeSeededId('property_bank_command', `${calcId}:sandbox-error`)
-  const sandboxResultId = makeSeededId('property_bank_command', `${calcId}:sandbox-result`)
-
-  const inputs = Object.entries(config.inputs).reduce(
-    (acc, [key, value], index) => {
-      const commandId = makeSeededId('property_bank_command', `${calcId}:input:${key}`)
-      acc.map[key] = {
-        type: 'data-node',
-        properties: {},
-        in: {
-          change: null,
-        },
-        out: {
-          value: [
-            {
-              id: commandId,
-              port: 'value',
-            },
-          ],
-        },
-      }
-      acc.editorInfo[key] = {
-        position: { x: padding, y: index * layerYInterval + padding },
-        points: {},
-      }
-      if (acc.prevCommandId) {
-        acc.map[acc.prevCommandId].out.result = [
-          {
-            id: commandId,
-            port: 'obj',
-          },
-        ]
-      }
-      acc.map[commandId] = {
-        type: 'command-node-object',
-        title: 'Command: OBJECT_SET',
-        properties: {
-          command: 'OBJECT_SET',
-          args: {
-            path: value,
-          },
-        },
-        in: {
-          obj: acc.prevCommandId
-            ? [
-                {
-                  id: acc.prevCommandId,
-                  port: 'result',
-                },
-              ]
-            : null,
-          path: null,
-          value: [
-            {
-              id: key,
-              port: 'value',
-              disable_trigger_command:
-                config.trigger_mode === 'manual' || config.disabled_triggers?.[key] || undefined,
-            },
-          ],
-        },
-        out: {
-          result: [
-            {
-              id: sandboxId,
-              port: 'inputs',
-            },
-          ],
-        },
-      }
-      acc.editorInfo[commandId] = {
-        position: { x: layerXInterval, y: index * layerYInterval + padding },
-        points: {},
-      }
-      acc.prevCommandId = commandId
-      return acc
-    },
-    { map: {}, editorInfo: {}, prevCommandId: null } as {
-      map: Record<string, any>
-      editorInfo: Record<string, any>
-      prevCommandId: string | null
-    },
-  )
-
-  let y = 0
-  const outputs = Object.entries(config.outputs).reduce(
-    (acc, [key, pbList], index) => {
-      const commandId = makeSeededId('property_bank_command', `${calcId}:output:${key}`)
-      acc.commandIdList.push(commandId)
-      acc.map[commandId] = {
-        type: 'command-node-object',
-        title: 'Command: OBJECT_GET',
-        properties: {
-          command: 'OBJECT_GET',
-          args: {
-            path: key,
-          },
-        },
-        in: {
-          obj: [
-            {
-              id: sandboxResultId,
-              port: 'result',
-            },
-          ],
-          path: null,
-        },
-        out: {
-          result: pbList.map((pb) => ({
-            id: pb,
-            port: 'change',
-          })),
-        },
-      }
-      acc.editorInfo[commandId] = {
-        position: {
-          x: layerXInterval * 3,
-          y: index * layerYInterval + padding,
-        },
-        points: {},
-      }
-      pbList.forEach((pb, pbIndex) => {
-        // Check if this data node already exists (it might be used as both input and output)
-        const existingNode = acc.map[pb] || inputs.map[pb]
-        acc.map[pb] = {
-          type: 'data-node',
-          properties: {},
-          in: {
-            change: [
-              {
-                id: commandId,
-                port: 'result',
-              },
-            ],
-          },
-          out: {
-            // Preserve existing out.value if node is also used as input
-            value: existingNode?.out?.value ?? null,
-          },
-        }
-        acc.editorInfo[pb] = {
-          position: {
-            x: layerXInterval * 4,
-            y: padding + y + index * layerYInterval + pbIndex * layerYInterval,
-          },
-          points: {},
-        }
-        if (pbIndex > 0) y += layerYInterval
-      })
-      return acc
-    },
-    { map: {}, editorInfo: {}, commandIdList: [] } as {
-      map: Record<string, any>
-      editorInfo: Record<string, any>
-      commandIdList: string[]
-    },
-  )
-
-  return {
-    // Newer runtimes prefer this single-node graph; older runtimes fall back to `map` below.
-    script_map: generateScriptMap(config, calcId),
-    map: {
-      ...inputs.map,
-      [sandboxId]: {
-        type: 'command-node-sandbox',
-        title: 'Command: SANDBOX_RUN_JAVASCRIPT',
-        properties: {
-          command: 'SANDBOX_RUN_JAVASCRIPT',
-          args: {
-            code: config.code,
-            enable_async: config.enable_async,
-          },
-        },
-        in: {
-          code: null,
-          inputs: inputs.prevCommandId
-            ? [
-                {
-                  id: inputs.prevCommandId,
-                  port: 'result',
-                },
-              ]
-            : [],
-        },
-        out: {
-          result: [
-            {
-              id: sandboxErrorId,
-              port: 'result',
-            },
-            {
-              id: sandboxResultId,
-              port: 'result',
-            },
-          ],
-        },
-      },
-      [sandboxErrorId]: {
-        type: 'command-node-sandbox',
-        title: 'Command: SANDBOX_GET_ERROR',
-        properties: {
-          command: 'SANDBOX_GET_ERROR',
-        },
-        in: {
-          result: [
-            {
-              id: sandboxId,
-              port: 'result',
-            },
-          ],
-        },
-        out: {
-          result: config.error
-            ? [
-                {
-                  id: config.error,
-                  port: 'change',
-                },
-              ]
-            : [],
-        },
-      },
-      [sandboxResultId]: {
-        type: 'command-node-sandbox',
-        title: 'Command: SANDBOX_GET_RETURN_VALUE',
-        properties: {
-          command: 'SANDBOX_GET_RETURN_VALUE',
-        },
-        in: {
-          result: [
-            {
-              id: sandboxId,
-              port: 'result',
-            },
-          ],
-        },
-        out: {
-          result: (config.output
-            ? [
-                {
-                  id: config.output,
-                  port: 'change',
-                },
-              ]
-            : []
-          ).concat(
-            outputs.commandIdList.map((commandId) => ({
-              id: commandId,
-              port: 'obj',
-            })),
-          ),
-        },
-      },
-
-      ...(config.error && {
-        [config.error]: {
-          type: 'data-node',
-          properties: {},
-          in: {
-            change: [
-              {
-                id: sandboxErrorId,
-                port: 'result',
-              },
-            ],
-          },
-          out: {
-            // Preserve existing out.value if node is also used as input
-            value: inputs.map[config.error]?.out?.value ?? null,
-          },
-        },
-      }),
-      ...(config.output && {
-        [config.output]: {
-          type: 'data-node',
-          properties: {},
-          in: {
-            change: [
-              {
-                id: sandboxResultId,
-                port: 'result',
-              },
-            ],
-          },
-          out: {
-            // Preserve existing out.value if node is also used as input
-            value: inputs.map[config.output]?.out?.value ?? null,
-          },
-        },
-      }),
-      ...outputs.map,
-    },
-    editor_info: {
-      ...inputs.editorInfo,
-      [sandboxId]: {
-        position: { x: layerXInterval * 2, y: padding },
-        points: {},
-      },
-      [sandboxErrorId]: {
-        position: { x: layerXInterval * 2, y: layerYInterval },
-        points: {},
-      },
-      [sandboxResultId]: {
-        position: { x: layerXInterval * 2, y: layerYInterval * 2 },
-        points: {},
-      },
-      ...(config.error && {
-        [config.error]: {
-          position: { x: layerXInterval * 2, y: layerYInterval * 3 },
-          points: {},
-        },
-      }),
-      ...(config.output && {
-        [config.output]: {
-          position: { x: layerXInterval * 2, y: layerYInterval * 4 },
-          points: {},
-        },
-      }),
-      ...outputs.editorInfo,
-    },
-  }
-}

package/index.ts

@@ -1,6 +0,0 @@
-export type * from './types'
-
-export { makeId } from './utils/id'
-export { generateDataCalculationMapEditorInfo } from './utils/calc'
-export { linkData, useSystemData, createCanvasIdRef } from './utils/data'
-export { templateEventPropsMap } from './utils/event-props'

package/skills/bricks-ctor/SKILL.md

@@ -1,38 +0,0 @@
----
-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, 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
-
-This skill covers advanced BRICKS features not in the main project instructions.
-
-## Rules Index
-
-| Rule | Description |
-|------|-------------|
-| [Architecture Patterns](references/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
-| [Source-Editing Tools](references/source-editing-tools.md) | MCP tools for editing entries and data-calcs by AST (new/edit/remove, value grammar, verify) |
-| [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](references/architecture-patterns.md) for decomposing multi-step workflows
-- **Editing entries/data-calcs**: See [Source-Editing Tools](references/source-editing-tools.md) — prefer the MCP editing tools over hand-editing `subspaces/**`
-- **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/references/animation.md

@@ -1,160 +0,0 @@
-# Animation
-
-BRICKS Animation system for animating brick transforms and opacity. Animations are defined at the Subspace level and triggered via events or Dynamic Animation actions.
-
-## Animation Types
-
-### Timing Animation
-Standard duration-based animation with easing.
-
-```typescript
-import { makeId } from 'bricks-ctor'
-
-const fadeIn: AnimationDef = {
-  __typename: 'Animation',
-  id: makeId('animation'),
-  title: 'Fade In',
-  runType: 'once', // 'once' | 'loop'
-  property: 'opacity',
-  config: {
-    __type: 'AnimationTimingConfig',
-    toValue: 1,
-    duration: 300, // ms
-    easing: 'easeOutCubic',
-    delay: 0, // ms
-    isInteraction: true,
-  },
-}
-```
-
-### Spring Animation
-Physics-based spring animation.
-
-```typescript
-const bounce: AnimationDef = {
-  __typename: 'Animation',
-  id: makeId('animation'),
-  title: 'Bounce In',
-  property: 'transform.scale',
-  config: {
-    __type: 'AnimationSpringConfig',
-    toValue: 1,
-    friction: 7,
-    tension: 40,
-  },
-}
-```
-
-Use one spring parameter family per config: `tension/friction`, `speed/bounciness`, or
-`stiffness/damping/mass`.
-
-### Decay Animation
-Velocity-based deceleration animation.
-
-```typescript
-const slideOut: AnimationDef = {
-  __typename: 'Animation',
-  id: makeId('animation'),
-  title: 'Slide Out',
-  property: 'transform.translateX',
-  config: {
-    __type: 'AnimationDecayConfig',
-    toValue: 500,
-    velocity: 0.5,
-    deceleration: 0.997,
-    isInteraction: true,
-  },
-}
-```
-
-## Animatable Properties
-
-| Property | Description |
-|----------|-------------|
-| `transform.translateX` | Horizontal position offset |
-| `transform.translateY` | Vertical position offset |
-| `transform.scale` | Uniform scale |
-| `transform.scaleX` | Horizontal scale |
-| `transform.scaleY` | Vertical scale |
-| `transform.rotate` | Rotation (degrees) |
-| `transform.rotateX` | X-axis rotation |
-| `transform.rotateY` | Y-axis rotation |
-| `opacity` | Transparency (0-1) |
-
-## Easing Functions
-
-Standard easing from [easings.net](https://easings.net):
-- `easeInSine`, `easeOutSine`, `easeInOutSine`
-- `easeInQuad`, `easeOutQuad`, `easeInOutQuad`
-- `easeInCubic`, `easeOutCubic`, `easeInOutCubic`
-- `easeInQuart`, `easeOutQuart`, `easeInOutQuart`
-- `easeInQuint`, `easeOutQuint`, `easeInOutQuint`
-- `easeInExpo`, `easeOutExpo`, `easeInOutExpo`
-- `easeInCirc`, `easeOutCirc`, `easeInOutCirc`
-- `easeInBack`, `easeOutBack`, `easeInOutBack`
-- `easeInElastic`, `easeOutElastic`, `easeInOutElastic`
-- `easeInBounce`, `easeOutBounce`, `easeInOutBounce`
-- Custom: `'cubic-bezier(x1, y1, x2, y2)'`
-
-## Composed Animations
-
-Combine multiple animations in parallel or sequence.
-
-```typescript
-const enterAnimation: AnimationComposeDef = {
-  __typename: 'AnimationCompose',
-  id: makeId('animation'),
-  title: 'Enter Animation',
-  runType: 'once',
-  composeType: 'parallel', // 'parallel' | 'sequence'
-  items: [
-    () => fadeIn,
-    () => scaleUp,
-  ],
-}
-```
-
-## Brick Animation Events
-
-Bricks support automatic animation binding:
-
-```typescript
-// In brick definition
-animations: {
-  showStart: () => fadeInAnimation,  // On brick first render
-  standby: () => standbyAnimation,   // After standby transition
-  breatheStart: () => pulseAnimation, // Breathing effect (looping)
-}
-```
-
-## Dynamic Animation (Runtime)
-
-Trigger animations programmatically via System Action:
-
-```typescript
-const runAnimation: EventAction = {
-  handler: 'system',
-  action: {
-    __actionName: 'DYNAMIC_ANIMATION',
-    parent: 'System',
-    params: [
-      { input: 'brickId', value: () => targetBrick },
-      { input: 'animationId', value: () => pulseAnimation },
-      { input: 'runType', value: 'once' }, // 'once' | 'loop'
-      { input: 'resetInitialValue', value: false },
-    ],
-  },
-}
-```
-
-Related actions:
-- `DYNAMIC_ANIMATION_RESET` - Reset animation state
-- `DYNAMIC_ANIMATION_STOP` - Stop running animation
-
-## Best Practices
-
-1. **Performance**: Keep animations simple, prefer `opacity` and `transform` over layout changes
-2. **Timing**: Use `easeOut` for enter animations, `easeIn` for exit
-3. **Spring animations**: Good for natural, bouncy UI elements
-4. **Looping**: Use `runType: 'loop'` for attention-grabbing elements
-5. **Composition**: Use `sequence` for staged reveals, `parallel` for coordinated effects