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

package/compile/__tests__/index.test.js

@@ -0,0 +1,152 @@
+import { compile } from '../index'
+
+const SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000001'
+const CANVAS_ID = 'CANVAS_00000000-0000-0000-0000-000000000001'
+const ANIMATION_ID = 'ANIMATION_00000000-0000-0000-0000-000000000001'
+const DATA_ID = 'PROPERTY_BANK_DATA_NODE_00000000-0000-0000-0000-000000000001'
+
+const makeApp = (animations = [], data = []) => {
+  const rootCanvas = {
+    __typename: 'Canvas',
+    id: CANVAS_ID,
+    items: [],
+  }
+  const rootSubspace = {
+    __typename: 'Subspace',
+    id: SUBSPACE_ID,
+    title: 'Main Subspace',
+    layout: {
+      width: 96,
+      height: 54,
+    },
+    rootCanvas,
+    canvases: [rootCanvas],
+    animations,
+    bricks: [],
+    generators: [],
+    data,
+    dataRouting: [],
+    dataCalculation: [],
+  }
+
+  return {
+    name: 'Compile animation test',
+    rootSubspace,
+    subspaces: [rootSubspace],
+  }
+}
+
+const makeData = (remoteUpdate) => ({
+  __typename: 'Data',
+  id: DATA_ID,
+  type: 'string',
+  remoteUpdate,
+})
+
+describe('compile animations', () => {
+  test('normalizes mixed legacy spring config', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const config = await compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            alias: 'btnPressOut',
+            title: 'Button Press Out',
+            property: 'transform.scale',
+            config: {
+              __type: 'AnimationSpringConfig',
+              toValue: 1,
+              friction: 5,
+              tension: 200,
+              speed: 14,
+              bounciness: 8,
+            },
+          },
+        ]),
+      )
+
+      expect(config.subspace_map[SUBSPACE_ID].animation_map[ANIMATION_ID].config).toEqual({
+        toValue: 1,
+        friction: 5,
+        tension: 200,
+      })
+      const warning = warnSpy.mock.calls[0][0]
+      expect(warning).toContain('Resolved animation spring config')
+      expect(warning).toContain('Button Press Out')
+      expect(warning).toContain('btnPressOut')
+      expect(warning).toContain('transform.scale')
+      expect(warning).toContain('Main Subspace')
+      expect(warning).not.toContain('ANIMATION_')
+      expect(warning).not.toContain('SUBSPACE_')
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  test('rejects invalid animation property', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'transform.skewX',
+            config: {
+              __type: 'AnimationTimingConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation property/)
+  })
+
+  test('rejects invalid animation config type', async () => {
+    await expect(
+      compile(
+        makeApp([
+          {
+            __typename: 'Animation',
+            id: ANIMATION_ID,
+            property: 'opacity',
+            config: {
+              __type: 'AnimationUnknownConfig',
+              toValue: 1,
+            },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/Invalid animation config type/)
+  })
+})
+
+describe('compile data remote update', () => {
+  test.each([
+    [undefined, { bank_type: 'none' }],
+    [{ type: 'auto' }, { bank_type: 'create', enable_remote_update: true }],
+    [
+      { type: 'device-specific' },
+      {
+        bank_type: 'create-device-specific',
+        enable_remote_update: true,
+        use_remote_id_prefix: true,
+      },
+    ],
+    [
+      { type: 'global-data', id: 'GLOBAL_PROP_1' },
+      {
+        bank_type: 'global',
+        enable_remote_update: true,
+        global_remote_update_prop: 'GLOBAL_PROP_1',
+      },
+    ],
+  ])('emits bank_type for %p', async (remoteUpdate, expectedRemoteUpdate) => {
+    const config = await compile(makeApp([], [makeData(remoteUpdate)]))
+
+    expect(config.subspace_map[SUBSPACE_ID].property_bank_map[DATA_ID]).toMatchObject(
+      expectedRemoteUpdate,
+    )
+  })
+})

package/compile/__tests__/util.test.js

@@ -0,0 +1,278 @@
+import { generateCalulationMap, validateConfig } from '../util'
+
+const baseConfig = (overrides = {}) => ({
+  inputs: {},
+  enable_async: false,
+  disabled_triggers: {},
+  output: null,
+  outputs: {},
+  error: null,
+  code: 'return inputs',
+  ...overrides,
+})
+
+const SANDBOX_PREFIX = 'PROPERTY_BANK_COMMAND_NODE_'
+
+const sandboxNodeIds = (map) =>
+  Object.entries(map)
+    .filter(([id, node]) => id.startsWith(SANDBOX_PREFIX) && node.type === 'command-node-sandbox')
+    .map(([id, node]) => ({ id, command: node.properties.command }))
+
+const findSandboxIds = (map) => {
+  const sandbox = sandboxNodeIds(map)
+  return {
+    run: sandbox.find((s) => s.command === 'SANDBOX_RUN_JAVASCRIPT')?.id,
+    error: sandbox.find((s) => s.command === 'SANDBOX_GET_ERROR')?.id,
+    result: sandbox.find((s) => s.command === 'SANDBOX_GET_RETURN_VALUE')?.id,
+  }
+}
+
+describe('validateConfig', () => {
+  test('returns without throwing for a clean config', () => {
+    expect(() => validateConfig(baseConfig({ inputs: { a: 'foo' } }))).not.toThrow()
+  })
+
+  test('skips overlap checks in manual trigger mode', () => {
+    const config = baseConfig({
+      trigger_mode: 'manual',
+      inputs: { a: 'foo' },
+      output: 'a',
+      error: 'a',
+      outputs: { x: ['a'] },
+    })
+    expect(() => validateConfig(config)).not.toThrow()
+  })
+
+  test('throws when error key collides with an input id', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, error: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: error/)
+  })
+
+  test('throws when output key collides with an input id', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, output: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: output/)
+  })
+
+  test('throws when any outputs entry references an input id', () => {
+    const config = baseConfig({
+      inputs: { a: 'foo', b: 'bar' },
+      outputs: { x: ['c', 'b'] },
+    })
+    expect(() => validateConfig(config)).toThrow(/key: outputs/)
+  })
+
+  test('does not throw when error/output are falsy and inputs are empty', () => {
+    expect(() => validateConfig(baseConfig())).not.toThrow()
+  })
+})
+
+describe('generateCalulationMap', () => {
+  test('produces only the three sandbox nodes for an empty config', () => {
+    const result = generateCalulationMap(baseConfig())
+
+    expect(Object.keys(result.map)).toHaveLength(3)
+    const { run, error, result: returnValue } = findSandboxIds(result.map)
+
+    expect(result.map[run].in.inputs).toEqual([])
+    expect(result.map[error].out.result).toEqual([])
+    expect(result.map[returnValue].out.result).toEqual([])
+    expect(Object.keys(result.editor_info)).toHaveLength(3)
+  })
+
+  test('chains multiple inputs through OBJECT_SET commands', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
+
+    const { run } = findSandboxIds(result.map)
+
+    // Each input gets a data-node + an OBJECT_SET command-node.
+    expect(result.map.a.type).toBe('data-node')
+    expect(result.map.b.type).toBe('data-node')
+
+    const aCommandId = result.map.a.out.value[0].id
+    const bCommandId = result.map.b.out.value[0].id
+    expect(aCommandId).not.toBe(bCommandId)
+
+    const aCmd = result.map[aCommandId]
+    const bCmd = result.map[bCommandId]
+    expect(aCmd.properties.command).toBe('OBJECT_SET')
+    expect(aCmd.properties.args.path).toBe('foo.bar')
+    expect(bCmd.properties.command).toBe('OBJECT_SET')
+    expect(bCmd.properties.args.path).toBe('baz')
+
+    // First command has no upstream obj; second command's obj input is the first command.
+    expect(aCmd.in.obj).toBeNull()
+    expect(bCmd.in.obj).toEqual([{ id: aCommandId, port: 'result' }])
+    // First command forwards its result to the second command's `obj` input.
+    expect(aCmd.out.result).toEqual([{ id: bCommandId, port: 'obj' }])
+    // The last command feeds the SANDBOX_RUN_JAVASCRIPT `inputs` port.
+    expect(bCmd.out.result).toEqual([{ id: run, port: 'inputs' }])
+    expect(result.map[run].in.inputs).toEqual([{ id: bCommandId, port: 'result' }])
+  })
+
+  test('builds OBJECT_GET commands and target data-nodes for outputs', () => {
+    const result = generateCalulationMap(baseConfig({ outputs: { resultPath: ['pb1', 'pb2'] } }))
+
+    const { result: returnValue } = findSandboxIds(result.map)
+
+    // Both target property-bank nodes are created as data-nodes.
+    expect(result.map.pb1.type).toBe('data-node')
+    expect(result.map.pb2.type).toBe('data-node')
+
+    // The SANDBOX_GET_RETURN_VALUE forwards to the OBJECT_GET command for the output entry.
+    const objectGetRefs = result.map[returnValue].out.result
+    expect(objectGetRefs).toHaveLength(1)
+    const getCommandId = objectGetRefs[0].id
+    expect(objectGetRefs[0].port).toBe('obj')
+
+    const getCmd = result.map[getCommandId]
+    expect(getCmd.type).toBe('command-node-object')
+    expect(getCmd.properties.command).toBe('OBJECT_GET')
+    expect(getCmd.properties.args.path).toBe('resultPath')
+    expect(getCmd.in.obj).toEqual([{ id: returnValue, port: 'result' }])
+
+    // OBJECT_GET feeds both target data-nodes' `change` ports.
+    expect(getCmd.out.result).toEqual([
+      { id: 'pb1', port: 'change' },
+      { id: 'pb2', port: 'change' },
+    ])
+    // Target data-nodes consume the OBJECT_GET result via their `change` port.
+    expect(result.map.pb1.in.change).toEqual([{ id: getCommandId, port: 'result' }])
+    expect(result.map.pb2.in.change).toEqual([{ id: getCommandId, port: 'result' }])
+
+    // Without input usage their `out.value` defaults to null.
+    expect(result.map.pb1.out.value).toBeNull()
+    expect(result.map.pb2.out.value).toBeNull()
+  })
+
+  // Manual mode is the only mode that lets an output target reuse an input id
+  // (see validateConfig tests). When that happens, generateCalulationMap must
+  // keep the input-side `out.value` so the data-node remains a usable input.
+  test.each([
+    ['outputs', { outputs: { result: ['shared'] } }],
+    ['output', { output: 'shared' }],
+    ['error', { error: 'shared' }],
+  ])('preserves input out.value when %s target reuses an input id', (_, overrides) => {
+    const result = generateCalulationMap(
+      baseConfig({ trigger_mode: 'manual', inputs: { shared: 'foo' }, ...overrides }),
+    )
+    expect(Array.isArray(result.map.shared.out.value)).toBe(true)
+    expect(result.map[result.map.shared.out.value[0].id].properties.command).toBe('OBJECT_SET')
+  })
+
+  test('also rewires in.change to OBJECT_GET when an outputs target reuses an input id', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { shared: 'foo' },
+        outputs: { result: ['shared'] },
+      }),
+    )
+    expect(result.map.shared.in.change).toHaveLength(1)
+    expect(result.map[result.map.shared.in.change[0].id].properties.command).toBe('OBJECT_GET')
+  })
+
+  test('preserves out.value when the same pb appears in multiple outputs entries', () => {
+    // Two outputs entries both target `pb1`. The reduce visits each entry in turn
+    // and must preserve the accumulated `out.value` from the first iteration via
+    // `acc.map[pb]` rather than wiping it on the second.
+    const result = generateCalulationMap(
+      baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } }),
+    )
+    expect(result.map.pb1.type).toBe('data-node')
+    // Without an input, out.value remains null after both passes.
+    expect(result.map.pb1.out.value).toBeNull()
+    // The latest OBJECT_GET wins as the change source — each iteration overwrites
+    // `in.change`, so we end up pointing at the second outputs entry's command.
+    expect(result.map.pb1.in.change).toHaveLength(1)
+  })
+
+  test('wires the error data-node when error is configured', () => {
+    const result = generateCalulationMap(baseConfig({ error: 'errNode' }))
+
+    const { error } = findSandboxIds(result.map)
+    // SANDBOX_GET_ERROR now broadcasts to the error data-node's `change` port.
+    expect(result.map[error].out.result).toEqual([{ id: 'errNode', port: 'change' }])
+    expect(result.map.errNode.type).toBe('data-node')
+    expect(result.map.errNode.in.change).toEqual([{ id: error, port: 'result' }])
+    // No upstream input → out.value falls back to null.
+    expect(result.map.errNode.out.value).toBeNull()
+    // editor_info contains the new node.
+    expect(result.editor_info.errNode).toBeDefined()
+  })
+
+  test('wires the output data-node when output is configured', () => {
+    const result = generateCalulationMap(baseConfig({ output: 'outNode' }))
+
+    const { result: returnValue } = findSandboxIds(result.map)
+    expect(result.map[returnValue].out.result).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(result.map.outNode.type).toBe('data-node')
+    expect(result.map.outNode.in.change).toEqual([{ id: returnValue, port: 'result' }])
+    expect(result.editor_info.outNode).toBeDefined()
+  })
+
+  test('manual trigger mode sets disable_trigger_command on input value ports', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { a: 'foo', b: 'bar' },
+      }),
+    )
+    const aCmdId = result.map.a.out.value[0].id
+    const bCmdId = result.map.b.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
+    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBe(true)
+  })
+
+  test('auto trigger mode honours per-key disabled_triggers', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        inputs: { a: 'foo', b: 'bar' },
+        disabled_triggers: { a: true, b: false },
+      }),
+    )
+    const aCmdId = result.map.a.out.value[0].id
+    const bCmdId = result.map.b.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBe(true)
+    // Falsy disabled_triggers entry → property is not set (or set to undefined).
+    expect(result.map[bCmdId].in.value[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('auto trigger mode without disabled_triggers leaves disable_trigger_command undefined', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }))
+    const aCmdId = result.map.a.out.value[0].id
+    expect(result.map[aCmdId].in.value[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('snapshotMode forwards to makeId so generated ids are deterministic v4 uuids', () => {
+    const result = generateCalulationMap(baseConfig({ inputs: { a: 'foo' } }), {
+      snapshotMode: true,
+    })
+    const sandboxIds = sandboxNodeIds(result.map).map((s) => s.id)
+    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
+    sandboxIds.forEach((id) => {
+      expect(id).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
+    })
+  })
+
+  test('validateConfig errors propagate out of generateCalulationMap', () => {
+    expect(() => generateCalulationMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(
+      /key: error/,
+    )
+  })
+
+  test('SANDBOX_GET_RETURN_VALUE broadcasts to both output target and outputs commands', () => {
+    const result = generateCalulationMap(
+      baseConfig({
+        output: 'outNode',
+        outputs: { foo: ['pb1'] },
+      }),
+    )
+    const { result: returnValue } = findSandboxIds(result.map)
+    const refs = result.map[returnValue].out.result
+    // First entry is the output data-node's `change` port; remainder are OBJECT_GET ids.
+    expect(refs[0]).toEqual({ id: 'outNode', port: 'change' })
+    expect(refs).toHaveLength(2)
+    expect(refs[1].port).toBe('obj')
+    expect(result.map[refs[1].id].properties.command).toBe('OBJECT_GET')
+  })
+})

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: {