@fugood/bricks-ctor 2.25.0-beta.8 → 2.25.0-beta.81

package/compile/util.ts

@@ -1,358 +0,0 @@
-import { makeId } 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
-  if (config.error && config.inputs[config.error]) {
-    throw new Error(`${errorMsg}. key: error`)
-  }
-  if (config.output && config.inputs[config.output]) {
-    throw new Error(`${errorMsg}. key: output`)
-  }
-  if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
-    throw new Error(`${errorMsg}. key: outputs`)
-  }
-}
-
-const padding = 15
-const layerXInterval = 300
-const layerYInterval = 150
-
-export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMode?: boolean }) => {
-  validateConfig(config)
-  const sandboxId = makeId('property_bank_command', opts)
-  const sandboxErrorId = makeId('property_bank_command', opts)
-  const sandboxResultId = makeId('property_bank_command', opts)
-
-  const inputs = Object.entries(config.inputs).reduce(
-    (acc, [key, value], index) => {
-      const commandId = makeId('property_bank_command', opts)
-      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 = makeId('property_bank_command', opts)
-      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 {
-    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,32 +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, and Buttress (remote inference). Triggers on multi-device sync, cloud data, media assets, AI offloading, E2E testing, or canvas transitions.
----
-
-# BRICKS Ctor - Advanced Features
-
-This skill covers advanced BRICKS features not in the main project instructions.
-
-## Rules Index
-
-| 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 |
-
-## 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

package/skills/bricks-ctor/rules/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

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

@@ -1,69 +0,0 @@
-# Architecture Patterns
-
-How to decompose complex flows into the right combination of BRICKS patterns.
-
-## Pattern Selection Priority
-
-Prefer higher-priority patterns; only fall to lower when they genuinely can't solve the sub-problem:
-
-| Priority | Pattern | Use For |
-|----------|---------|---------|
-| 1 | Generator + Events | I/O, AI inference, external data |
-| 2 | Event Action Chains | Orchestration, sequential steps |
-| 3 | System Actions | State changes, navigation, UI triggers |
-| 4 | Data Calculation | Pure data transformation ONLY |
-
-### Generators (Priority 1)
-For all external I/O and AI inference. Each generator emits events that naturally chain into actions.
-- **GeneratorAssistant**: multi-turn LLM conversations, function calling, built-in message history
-- **GeneratorLLM**: single-shot local inference (GGML)
-- **GeneratorHttp**: REST API calls
-- **GeneratorMqtt / GeneratorWebSocket**: real-time messaging
-
-### Event Action Chains (Priority 2)
-The primary way to orchestrate multi-step flows. A single event can contain an array of EventActions executed sequentially.
-- 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
-
-### System Actions (Priority 3)
-Built-in commands for direct state and UI changes.
-- **PROPERTY_BANK**: set data value
-- **PROPERTY_BANK_EXPRESSION**: inline JS expression for simple compute
-- **CHANGE_CANVAS**: navigate to another canvas
-- **DYNAMIC_ANIMATION**: trigger animation
-- **ALERT / MESSAGE**: system feedback
-
-### Data Calculation (Priority 4)
-ONLY for deriving, formatting, or aggregating values from other data. Not for orchestration, side effects, or flow control.
-
-## Entity Aliases
-
-Set `alias` on entities to give them a stable, human-readable name:
-- Code generation uses alias as the variable name (e.g., `alias: 'submitBtn'` → `export const submitBtn`)
-- At runtime, devtools MCP tools accept alias instead of short ID and selectors can match by alias. Note: bricks-ctor does not directly interact with devtools MCP — aliases here primarily affect code generation
-- Aliases must be unique across the application — duplicates are excluded from resolution
-
-## Flow Decomposition
-
-When the user describes a complex flow, decompose it BEFORE writing code:
-
-### Step 1: Extract I/O boundaries
-Every external interaction maps to a Generator:
-- "call LLM" → GeneratorAssistant or GeneratorLLM
-- "fetch API" → GeneratorHttp
-- "speech to text" → GeneratorSpeechInference
-
-### Step 2: Extract state transitions
-Every UI change maps to a System Action in an event chain:
-- "show loading" → PROPERTY_BANK on a boolean data
-- "go to result screen" → CHANGE_CANVAS
-- "animate in" → DYNAMIC_ANIMATION
-
-### Step 3: Extract pure transformations
-Only actual data derivation maps to Data Calculation:
-- "format the response" → DataCalculationScript
-- "compute a score" → DataCalculationScript or DataCalculationMap
-
-### Step 4: Wire with Event Action Chains
-Connect the pieces through events on generators and bricks.