@fugood/bricks-ctor 2.25.0-beta.7 → 2.25.0-beta.9

package/compile/__tests__/index.test.js

@@ -0,0 +1,115 @@
+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 makeApp = (animations) => {
+  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],
+  }
+}
+
+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/)
+  })
+})

package/compile/index.ts

@@ -301,6 +301,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']) => ({
@@ -629,39 +785,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
         }, {}),

package/package.json

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

package/skills/bricks-ctor/rules/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/tools/preview-main.mjs

@@ -6,6 +6,12 @@ import { createServer } from 'http'
 import { parseArgs } from 'util'
 import * as TOON from '@toon-format/toon'
 
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on('error', (err) => {
+    if (err.code !== 'EPIPE') throw err
+  })
+}
+
 const { values } = parseArgs({
   args: process.argv,
   options: {
@@ -224,16 +230,23 @@ app.on('ready', () => {
     )
     if (takeScreenshotConfig) {
       const { delay, width, height, path } = takeScreenshotConfig
-      setTimeout(() => {
+      setTimeout(async () => {
+        let screenshotFailed = false
         console.log('Taking screenshot')
-        mainWindow.webContents.capturePage().then((image) => {
+        try {
+          const image = await mainWindow.webContents.capturePage()
           console.log('Writing screenshot to', path)
-          writeFile(path, image.resize({ width, height }).toJPEG(75))
+          await writeFile(path, image.resize({ width, height }).toJPEG(75))
+        } catch (err) {
+          screenshotFailed = true
+          console.error('Screenshot capture/write failed', err)
+        } finally {
           if (noKeepOpen) {
             console.log('Closing app')
-            app.quit()
+            if (screenshotFailed) app.exit(1)
+            else app.quit()
           }
-        })
+        }
       }, delay)
     }
   }

package/types/animation.ts

@@ -44,10 +44,21 @@ export interface AnimationTimingConfig {
 export interface AnimationSpringConfig {
   __type: 'AnimationSpringConfig'
   toValue: number // BRICKS Grid unit
-  friction: number
-  tension: number
-  speed: number
-  bounciness: number
+  // Use one spring parameter family: tension/friction, speed/bounciness,
+  // or stiffness/damping/mass.
+  friction?: number
+  tension?: number
+  speed?: number
+  bounciness?: number
+  stiffness?: number
+  damping?: number
+  mass?: number
+  velocity?: number
+  delay?: number
+  isInteraction?: boolean
+  overshootClamping?: boolean
+  restDisplacementThreshold?: number
+  restSpeedThreshold?: number
 }
 
 export interface AnimationDecayConfig {

package/types/generators/LlmGgml.ts

@@ -713,6 +713,7 @@ Default property:
       | {
           enabled?: boolean | DataLink
           url?: string | DataLink
+          autoDiscoverType?: 'manual' | 'auto' | DataLink
           fallbackType?: 'use-local' | 'no-op' | DataLink
           strategy?: 'prefer-local' | 'prefer-buttress' | 'prefer-best' | DataLink
         }

package/types/generators/LlmMlx.ts

@@ -158,6 +158,7 @@ Default property:
       | {
           enabled?: boolean | DataLink
           url?: string | DataLink
+          autoDiscoverType?: 'manual' | 'auto' | DataLink
           fallbackType?: 'use-local' | 'no-op' | DataLink
           strategy?: 'prefer-local' | 'prefer-buttress' | 'prefer-best' | DataLink
         }

package/types/generators/SpeechToTextGgml.ts

@@ -323,6 +323,7 @@ Default property:
       | {
           enabled?: boolean | DataLink
           url?: string | DataLink
+          autoDiscoverType?: 'manual' | 'auto' | DataLink
           fallbackType?: 'use-local' | 'no-op' | DataLink
           strategy?: 'prefer-local' | 'prefer-buttress' | 'prefer-best' | DataLink
         }

package/utils/__tests__/id.test.js

@@ -0,0 +1,58 @@
+import { makeId } from '../id'
+
+const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
+const UUID_ONLY_RE = new RegExp(`^${UUID}$`)
+
+describe('makeId', () => {
+  describe('type prefixes', () => {
+    const cases = [
+      ['animation', 'ANIMATION_'],
+      ['brick', 'BRICK_'],
+      ['dynamic-brick', 'DYNAMIC_BRICK_'],
+      ['canvas', 'CANVAS_'],
+      ['generator', 'GENERATOR_'],
+      ['data', 'PROPERTY_BANK_DATA_NODE_'],
+      ['switch', 'BRICK_STATE_GROUP_'],
+      ['property_bank_command', 'PROPERTY_BANK_COMMAND_NODE_'],
+      ['property_bank_calc', 'PROPERTY_BANK_COMMAND_MAP_'],
+      ['automation_map', 'AUTOMATION_MAP_'],
+      ['test', 'TEST_'],
+      ['test_case', 'TEST_CASE_'],
+      ['test_var', 'TEST_VAR_'],
+    ]
+
+    test.each(cases)('produces %p prefix', (type, prefix) => {
+      expect(makeId(type)).toMatch(new RegExp(`^${prefix}${UUID}$`))
+    })
+
+    test('returns unique random uuids across calls', () => {
+      expect(makeId('brick')).not.toBe(makeId('brick'))
+    })
+
+    test('unknown type falls through to an unprefixed uuid', () => {
+      expect(makeId('not-a-real-type')).toMatch(UUID_ONLY_RE)
+    })
+  })
+
+  describe('subspace', () => {
+    test('throws because subspace IDs must be fixed', () => {
+      expect(() => makeId('subspace')).toThrow(/subspace is not supported/)
+    })
+  })
+
+  describe('snapshotMode', () => {
+    test('produces sequential, deterministic uuids', () => {
+      const a = makeId('brick', { snapshotMode: true })
+      const b = makeId('brick', { snapshotMode: true })
+      expect(a).toMatch(/^BRICK_00000000-0000-0000-0000-\d{12}$/)
+      expect(b).toMatch(/^BRICK_00000000-0000-0000-0000-\d{12}$/)
+      expect(Number(b.slice(-12))).toBe(Number(a.slice(-12)) + 1)
+    })
+
+    test('snapshotMode false falls back to random uuid', () => {
+      const id = makeId('canvas', { snapshotMode: false })
+      expect(id).toMatch(new RegExp(`^CANVAS_${UUID}$`))
+      expect(id).not.toMatch(/CANVAS_00000000-0000-0000-0000-/)
+    })
+  })
+})