@dfosco/storyboard-react 2.0.0 → 2.1.0

package/src/hooks/useScene.js

@@ -2,27 +2,36 @@ import { useContext, useCallback } from 'react'
 import { StoryboardContext } from '../StoryboardContext.js'
 
 /**
- * Read the current scene name and programmatically switch scenes.
+ * Read the current flow name and programmatically switch flows.
  *
- * @returns {{ sceneName: string, switchScene: (name: string) => void }}
- *   - sceneName   – current active scene (e.g. "default")
- *   - switchScene – navigate to a different scene by updating ?scene= param
+ * @returns {{ flowName: string, switchFlow: (name: string) => void }}
+ *   - flowName    – current active flow (e.g. "default")
+ *   - switchFlow  – navigate to a different flow by updating ?scene= param
  */
-export function useScene() {
+export function useFlow() {
   const context = useContext(StoryboardContext)
   if (context === null) {
-    throw new Error('useScene must be used within a <StoryboardProvider>')
+    throw new Error('useFlow must be used within a <StoryboardProvider>')
   }
 
-  const switchScene = useCallback((name) => {
+  const switchFlow = useCallback((name) => {
     const url = new URL(window.location.href)
     url.searchParams.set('scene', name)
-    // Preserve hash params across scene switches
+    // Preserve hash params across flow switches
     window.location.href = url.toString()
   }, [])
 
   return {
-    sceneName: context.sceneName,
-    switchScene,
+    flowName: context.flowName,
+    switchFlow,
+  }
+}
+
+/** @deprecated Use useFlow() */
+export function useScene() {
+  const { flowName, switchFlow } = useFlow()
+  return {
+    sceneName: flowName,
+    switchScene: switchFlow,
   }
 }

package/src/hooks/useScene.test.js

@@ -1,39 +1,66 @@
 import { renderHook } from '@testing-library/react'
+import { useFlow } from './useScene.js'
 import { useScene } from './useScene.js'
-import { seedTestData, createWrapper, TEST_SCENES } from '../test-utils.js'
+import { seedTestData, createWrapper, TEST_FLOWS } from '../test-utils.js'
 
-const sceneData = TEST_SCENES.default
+const flowData = TEST_FLOWS.default
 
 beforeEach(() => {
   seedTestData()
 })
 
-describe('useScene', () => {
+describe('useFlow', () => {
+  it('returns { flowName, switchFlow }', () => {
+    const { result } = renderHook(() => useFlow(), {
+      wrapper: createWrapper(flowData),
+    })
+    expect(result.current).toHaveProperty('flowName')
+    expect(result.current).toHaveProperty('switchFlow')
+  })
+
+  it('flowName matches the value from context', () => {
+    const { result } = renderHook(() => useFlow(), {
+      wrapper: createWrapper(flowData, 'other'),
+    })
+    expect(result.current.flowName).toBe('other')
+  })
+
+  it('switchFlow is a function', () => {
+    const { result } = renderHook(() => useFlow(), {
+      wrapper: createWrapper(flowData),
+    })
+    expect(typeof result.current.switchFlow).toBe('function')
+  })
+
+  it('throws when used outside StoryboardProvider', () => {
+    expect(() => {
+      renderHook(() => useFlow())
+    }).toThrow('useFlow must be used within a <StoryboardProvider>')
+  })
+})
+
+// ── useScene (deprecated alias) ──
+
+describe('useScene (deprecated alias)', () => {
   it('returns { sceneName, switchScene }', () => {
     const { result } = renderHook(() => useScene(), {
-      wrapper: createWrapper(sceneData),
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toHaveProperty('sceneName')
     expect(result.current).toHaveProperty('switchScene')
   })
 
-  it('sceneName matches the value from context', () => {
+  it('sceneName matches the flow name from context', () => {
     const { result } = renderHook(() => useScene(), {
-      wrapper: createWrapper(sceneData, 'other'),
+      wrapper: createWrapper(flowData, 'other'),
     })
     expect(result.current.sceneName).toBe('other')
   })
 
   it('switchScene is a function', () => {
     const { result } = renderHook(() => useScene(), {
-      wrapper: createWrapper(sceneData),
+      wrapper: createWrapper(flowData),
     })
     expect(typeof result.current.switchScene).toBe('function')
   })
-
-  it('throws when used outside StoryboardProvider', () => {
-    expect(() => {
-      renderHook(() => useScene())
-    }).toThrow('useScene must be used within a <StoryboardProvider>')
-  })
 })

package/src/hooks/useSceneData.js

@@ -7,24 +7,24 @@ import { isHideMode, getShadow, getAllShadows } from '@dfosco/storyboard-core'
 import { subscribeToStorage, getStorageSnapshot } from '@dfosco/storyboard-core'
 
 /**
- * Access scene data by dot-notation path.
- * Hash params override scene data — both exact matches and nested paths.
+ * Access flow data by dot-notation path.
+ * Hash params override flow data — both exact matches and nested paths.
  *
  * Examples:
- *   useSceneData('user.name') with #user.name=Alice → "Alice"
- *   useSceneData('repositories') with #repositories.0.name=Foo
+ *   useFlowData('user.name') with #user.name=Alice → "Alice"
+ *   useFlowData('repositories') with #repositories.0.name=Foo
  *     → deep clone of repositories array with [0].name overridden to "Foo"
  *
  * @param {string} [path] - Dot-notation path (e.g. 'user.profile.name').
- *                          Omit to get the entire scene object.
+ *                          Omit to get the entire flow object.
  * @returns {*} The resolved value. Returns {} if path is missing after loading.
  * @throws If used outside a StoryboardProvider.
  */
-export function useSceneData(path) {
+export function useFlowData(path) {
   const context = useContext(StoryboardContext)
 
   if (context === null) {
-    throw new Error('useSceneData must be used within a <StoryboardProvider>')
+    throw new Error('useFlowData must be used within a <StoryboardProvider>')
   }
 
   const { data, loading, error } = context
@@ -73,7 +73,7 @@ export function useSceneData(path) {
     }
 
     if (sceneValue === undefined) {
-      console.warn(`[useSceneData] Path "${path}" not found in scene data.`)
+      console.warn(`[useFlowData] Path "${path}" not found in flow data.`)
       return {}
     }
 
@@ -83,15 +83,21 @@ export function useSceneData(path) {
   return result
 }
 
+/** @deprecated Use useFlowData() */
+export const useSceneData = useFlowData
+
 /**
- * Returns true while scene data is still loading.
+ * Returns true while flow data is still loading.
  */
-export function useSceneLoading() {
+export function useFlowLoading() {
   const context = useContext(StoryboardContext)
 
   if (context === null) {
-    throw new Error('useSceneLoading must be used within a <StoryboardProvider>')
+    throw new Error('useFlowLoading must be used within a <StoryboardProvider>')
   }
 
   return context.loading
 }
+
+/** @deprecated Use useFlowLoading() */
+export const useSceneLoading = useFlowLoading

package/src/hooks/useSceneData.test.js

@@ -1,38 +1,38 @@
 import { renderHook } from '@testing-library/react'
-import { useSceneData, useSceneLoading } from './useSceneData.js'
-import { seedTestData, createWrapper, TEST_SCENES } from '../test-utils.js'
+import { useFlowData, useFlowLoading, useSceneData, useSceneLoading } from './useSceneData.js'
+import { seedTestData, createWrapper, TEST_FLOWS } from '../test-utils.js'
 
-const sceneData = TEST_SCENES.default
+const flowData = TEST_FLOWS.default
 
 beforeEach(() => {
   seedTestData()
 })
 
-describe('useSceneData', () => {
-  it('returns entire scene object when no path given', () => {
-    const { result } = renderHook(() => useSceneData(), {
-      wrapper: createWrapper(sceneData),
+describe('useFlowData', () => {
+  it('returns entire flow object when no path given', () => {
+    const { result } = renderHook(() => useFlowData(), {
+      wrapper: createWrapper(flowData),
     })
-    expect(result.current).toEqual(sceneData)
+    expect(result.current).toEqual(flowData)
   })
 
   it('returns nested value by dot-notation path', () => {
-    const { result } = renderHook(() => useSceneData('user.name'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('user.name'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toBe('Jane')
   })
 
   it('returns deep nested value', () => {
-    const { result } = renderHook(() => useSceneData('user.profile.bio'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('user.profile.bio'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toBe('Dev')
   })
 
   it('returns array by path', () => {
-    const { result } = renderHook(() => useSceneData('projects'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('projects'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toEqual([
       { id: 1, name: 'alpha' },
@@ -41,16 +41,16 @@ describe('useSceneData', () => {
   })
 
   it('returns array element by index path', () => {
-    const { result } = renderHook(() => useSceneData('projects.0'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('projects.0'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toEqual({ id: 1, name: 'alpha' })
   })
 
   it('returns empty object and warns for missing path', () => {
     const spy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const { result } = renderHook(() => useSceneData('nonexistent.path'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('nonexistent.path'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toEqual({})
     expect(spy).toHaveBeenCalledWith(
@@ -61,48 +61,76 @@ describe('useSceneData', () => {
 
   it('throws when used outside StoryboardProvider', () => {
     expect(() => {
-      renderHook(() => useSceneData())
-    }).toThrow('useSceneData must be used within a <StoryboardProvider>')
+      renderHook(() => useFlowData())
+    }).toThrow('useFlowData must be used within a <StoryboardProvider>')
   })
 
   it('returns hash override value when param matches path', () => {
     window.location.hash = '#user.name=Alice'
-    const { result } = renderHook(() => useSceneData('user.name'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('user.name'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toBe('Alice')
   })
 
   it('applies child overrides to arrays', () => {
     window.location.hash = '#projects.0.name=gamma'
-    const { result } = renderHook(() => useSceneData('projects'), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData('projects'), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current[0].name).toBe('gamma')
     expect(result.current[1].name).toBe('beta')
   })
 
-  it('returns full scene with all overrides applied when no path', () => {
+  it('returns full flow with all overrides applied when no path', () => {
     window.location.hash = '#user.name=Alice'
-    const { result } = renderHook(() => useSceneData(), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowData(), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current.user.name).toBe('Alice')
     expect(result.current.settings.theme).toBe('dark')
   })
 })
 
-describe('useSceneLoading', () => {
+describe('useFlowLoading', () => {
   it('returns false when not loading', () => {
-    const { result } = renderHook(() => useSceneLoading(), {
-      wrapper: createWrapper(sceneData),
+    const { result } = renderHook(() => useFlowLoading(), {
+      wrapper: createWrapper(flowData),
     })
     expect(result.current).toBe(false)
   })
 
   it('throws when used outside StoryboardProvider', () => {
     expect(() => {
-      renderHook(() => useSceneLoading())
-    }).toThrow('useSceneLoading must be used within a <StoryboardProvider>')
+      renderHook(() => useFlowLoading())
+    }).toThrow('useFlowLoading must be used within a <StoryboardProvider>')
+  })
+})
+
+// ── Deprecated aliases ──
+
+describe('useSceneData (deprecated alias)', () => {
+  it('is the same function as useFlowData', () => {
+    expect(useSceneData).toBe(useFlowData)
+  })
+
+  it('returns flow data', () => {
+    const { result } = renderHook(() => useSceneData(), {
+      wrapper: createWrapper(flowData),
+    })
+    expect(result.current).toEqual(flowData)
+  })
+})
+
+describe('useSceneLoading (deprecated alias)', () => {
+  it('is the same function as useFlowLoading', () => {
+    expect(useSceneLoading).toBe(useFlowLoading)
+  })
+
+  it('returns loading state', () => {
+    const { result } = renderHook(() => useSceneLoading(), {
+      wrapper: createWrapper(flowData),
+    })
+    expect(result.current).toBe(false)
   })
 })

package/src/index.js

@@ -10,10 +10,12 @@ export { default as StoryboardProvider } from './context.jsx'
 export { StoryboardContext } from './StoryboardContext.js'
 
 // Hooks
+export { useFlowData, useFlowLoading } from './hooks/useSceneData.js'
+// Deprecated aliases
 export { useSceneData, useSceneLoading } from './hooks/useSceneData.js'
 export { useOverride } from './hooks/useOverride.js'
 export { useOverride as useSession } from './hooks/useOverride.js' // deprecated alias
-export { useScene } from './hooks/useScene.js'
+export { useFlow, useScene } from './hooks/useScene.js'
 export { useRecord, useRecords } from './hooks/useRecord.js'
 export { useObject } from './hooks/useObject.js'
 export { useLocalStorage } from './hooks/useLocalStorage.js'

package/src/test-utils.js

@@ -3,7 +3,7 @@ import { StoryboardContext } from './StoryboardContext.js'
 import { init } from '@dfosco/storyboard-core'
 
 // Default test data
-export const TEST_SCENES = {
+export const TEST_FLOWS = {
   default: {
     user: { name: 'Jane', profile: { bio: 'Dev' } },
     settings: { theme: 'dark' },
@@ -15,6 +15,9 @@ export const TEST_SCENES = {
   },
 }
 
+/** @deprecated Use TEST_FLOWS */
+export const TEST_SCENES = TEST_FLOWS
+
 export const TEST_OBJECTS = {
   'jane-doe': { name: 'Jane Doe', role: 'admin' },
 }
@@ -27,15 +30,15 @@ export const TEST_RECORDS = {
 }
 
 export function seedTestData() {
-  init({ scenes: TEST_SCENES, objects: TEST_OBJECTS, records: TEST_RECORDS })
+  init({ flows: TEST_FLOWS, objects: TEST_OBJECTS, records: TEST_RECORDS })
 }
 
-// Wrapper that provides StoryboardContext with given scene data
-export function createWrapper(sceneData, sceneName = 'default') {
+// Wrapper that provides StoryboardContext with given flow data
+export function createWrapper(flowData, flowName = 'default') {
   return function Wrapper({ children }) {
     return createElement(
       StoryboardContext.Provider,
-      { value: { data: sceneData, error: null, loading: false, sceneName } },
+      { value: { data: flowData, error: null, loading: false, flowName, sceneName: flowName } },
       children
     )
   }

package/src/vite/data-plugin.js

@@ -1,24 +1,68 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import { execSync } from 'node:child_process'
 import { globSync } from 'glob'
 import { parse as parseJsonc } from 'jsonc-parser'
 
 const VIRTUAL_MODULE_ID = 'virtual:storyboard-data-index'
 const RESOLVED_ID = '\0' + VIRTUAL_MODULE_ID
 
-const SUFFIXES = ['scene', 'object', 'record']
-const GLOB_PATTERN = '**/*.{scene,object,record}.{json,jsonc}'
+const GLOB_PATTERN = '**/*.{flow,scene,object,record,prototype}.{json,jsonc}'
 
 /**
  * Extract the data name and type suffix from a file path.
- * e.g. "src/data/default.scene.json" → { name: "default", suffix: "scene" }
- *      "anywhere/posts.record.jsonc" → { name: "posts", suffix: "record" }
+ * Flows and records inside src/prototypes/{Name}/ get prefixed with the
+ * prototype name (e.g. "Dashboard/default"). Objects are never prefixed.
+ *
+ * e.g. "src/data/default.flow.json"                → { name: "default",           suffix: "flow" }
+ *      "src/prototypes/Dashboard/default.flow.json" → { name: "Dashboard/default", suffix: "flow" }
+ *      "src/prototypes/Dashboard/helpers.object.json"→ { name: "helpers",           suffix: "object" }
  */
 function parseDataFile(filePath) {
   const base = path.basename(filePath)
-  const match = base.match(/^(.+)\.(scene|object|record)\.(jsonc?)$/)
+  const match = base.match(/^(.+)\.(flow|scene|object|record|prototype)\.(jsonc?)$/)
   if (!match) return null
-  return { name: match[1], suffix: match[2], ext: match[3] }
+  // Normalize .scene → .flow for backward compatibility
+  const suffix = match[2] === 'scene' ? 'flow' : match[2]
+  let name = match[1]
+
+  // Prototype metadata files are keyed by their prototype directory name
+  if (suffix === 'prototype') {
+    const normalized = filePath.replace(/\\/g, '/')
+    const protoMatch = normalized.match(/(?:^|\/)src\/prototypes\/([^/]+)\//)
+    if (protoMatch) {
+      name = protoMatch[1]
+    }
+    return { name, suffix, ext: match[3] }
+  }
+
+  // Scope flows and records inside src/prototypes/{Name}/ with a prefix
+  if (suffix !== 'object') {
+    const normalized = filePath.replace(/\\/g, '/')
+    const protoMatch = normalized.match(/(?:^|\/)src\/prototypes\/([^/]+)\//)
+    if (protoMatch) {
+      name = `${protoMatch[1]}/${name}`
+    }
+  }
+
+  return { name, suffix, ext: match[3] }
+}
+
+/**
+ * Look up the git author who first created a file.
+ * Used to auto-fill the author field in .prototype.json when missing.
+ */
+function getGitAuthor(root, filePath) {
+  try {
+    const result = execSync(
+      `git log --follow --diff-filter=A --format="%aN" -- "${filePath}"`,
+      { cwd: root, encoding: 'utf-8', timeout: 5000 },
+    ).trim()
+    const lines = result.split('\n').filter(Boolean)
+    return lines.length > 0 ? lines[lines.length - 1] : null
+  } catch {
+    return null
+  }
 }
 
 /**
@@ -28,7 +72,7 @@ function buildIndex(root) {
   const ignore = ['node_modules/**', 'dist/**', '.git/**']
   const files = globSync(GLOB_PATTERN, { cwd: root, ignore, absolute: false })
 
-  const index = { scene: {}, object: {}, record: {} }
+  const index = { flow: {}, object: {}, record: {}, prototype: {} }
   const seen = {} // "name.suffix" → absolute path (for duplicate detection)
 
   for (const relPath of files) {
@@ -39,11 +83,17 @@ function buildIndex(root) {
     const absPath = path.resolve(root, relPath)
 
     if (seen[key]) {
+      const hint = parsed.suffix === 'object'
+        ? '  Objects are globally scoped — even inside src/prototypes/ they share a single namespace.\n' +
+          '  Rename one of the files to avoid the collision.'
+        : '  Flows and records are scoped to their prototype directory.\n' +
+          '  If both files are global (outside src/prototypes/), rename one to avoid the collision.'
+
       throw new Error(
-        `[storyboard-data] Duplicate data file: "${key}.json"\n` +
+        `[storyboard-data] Duplicate ${parsed.suffix} "${parsed.name}"\n` +
         `  Found at: ${seen[key]}\n` +
         `  And at:   ${absPath}\n` +
-        `  Every data file name+suffix must be unique across the repo.`
+        hint
       )
     }
 
@@ -77,23 +127,70 @@ function readConfig(root) {
   }
 }
 
+/**
+ * Read modes.config.json from @dfosco/storyboard-core.
+ * Returns the full config object { modes, tools }.
+ * Falls back to hardcoded defaults if not found.
+ */
+function readModesConfig(root) {
+  const fallback = {
+    modes: [
+      { name: 'prototype', label: 'Navigate' },
+      { name: 'inspect', label: 'Develop' },
+      { name: 'present', label: 'Collaborate' },
+      { name: 'plan', label: 'Canvas' },
+    ],
+    tools: {},
+  }
+
+  // Try local workspace path first (monorepo), then node_modules
+  const candidates = [
+    path.resolve(root, 'packages/core/modes.config.json'),
+    path.resolve(root, 'node_modules/@dfosco/storyboard-core/modes.config.json'),
+  ]
+
+  for (const filePath of candidates) {
+    try {
+      const raw = fs.readFileSync(filePath, 'utf-8')
+      const parsed = JSON.parse(raw)
+      if (Array.isArray(parsed.modes) && parsed.modes.length > 0) {
+        return { modes: parsed.modes, tools: parsed.tools ?? {} }
+      }
+    } catch {
+      // try next candidate
+    }
+  }
+
+  return fallback
+}
+
 function generateModule(index, root) {
   const declarations = []
-  const entries = { scene: [], object: [], record: [] }
+  const INDEX_KEYS = ['flow', 'object', 'record', 'prototype']
+  const entries = { flow: [], object: [], record: [], prototype: [] }
   let i = 0
 
-  for (const suffix of SUFFIXES) {
+  for (const suffix of INDEX_KEYS) {
     for (const [name, absPath] of Object.entries(index[suffix])) {
       const varName = `_d${i++}`
       const raw = fs.readFileSync(absPath, 'utf-8')
-      const parsed = parseJsonc(raw)
+      let parsed = parseJsonc(raw)
+
+      // Auto-fill gitAuthor for prototype metadata from git history
+      if (suffix === 'prototype' && parsed && !parsed.gitAuthor) {
+        const gitAuthor = getGitAuthor(root, absPath)
+        if (gitAuthor) {
+          parsed = { ...parsed, gitAuthor }
+        }
+      }
+
       declarations.push(`const ${varName} = ${JSON.stringify(parsed)}`)
       entries[suffix].push(`  ${JSON.stringify(name)}: ${varName}`)
     }
   }
 
   const imports = [`import { init } from '@dfosco/storyboard-core'`]
-  const initCalls = [`init({ scenes, objects, records })`]
+  const initCalls = [`init({ flows, objects, records, prototypes })`]
 
   // Feature flags from storyboard.config.json
   const { config } = readConfig(root)
@@ -110,8 +207,25 @@ function generateModule(index, root) {
 
   // Modes configuration from storyboard.config.json
   if (config?.modes) {
-    imports.push(`import { initModesConfig } from '@dfosco/storyboard-core'`)
+    imports.push(`import { initModesConfig, registerMode, syncModeClasses, initTools } from '@dfosco/storyboard-core'`)
     initCalls.push(`initModesConfig(${JSON.stringify(config.modes)})`)
+
+    if (config.modes.enabled) {
+      imports.push(`import '@dfosco/storyboard-core/modes.css'`)
+
+      const modesConfig = readModesConfig(root)
+      const modes = config.modes.defaults || modesConfig.modes
+      for (const m of modes) {
+        initCalls.push(`registerMode(${JSON.stringify(m.name)}, { label: ${JSON.stringify(m.label)} })`)
+      }
+
+      // Seed tool registry from modes.config.json
+      if (Object.keys(modesConfig.tools).length > 0) {
+        initCalls.push(`initTools(${JSON.stringify(modesConfig.tools)})`)
+      }
+
+      initCalls.push(`syncModeClasses()`)
+    }
   }
 
   return [
@@ -119,14 +233,18 @@ function generateModule(index, root) {
     '',
     declarations.join('\n'),
     '',
-    `const scenes = {\n${entries.scene.join(',\n')}\n}`,
+    `const flows = {\n${entries.flow.join(',\n')}\n}`,
     `const objects = {\n${entries.object.join(',\n')}\n}`,
     `const records = {\n${entries.record.join(',\n')}\n}`,
+    `const prototypes = {\n${entries.prototype.join(',\n')}\n}`,
+    '',
+    '// Backward-compatible alias',
+    'const scenes = flows',
     '',
     initCalls.join('\n'),
     '',
-    `export { scenes, objects, records }`,
-    `export const index = { scenes, objects, records }`,
+    `export { flows, scenes, objects, records, prototypes }`,
+    `export const index = { flows, scenes, objects, records, prototypes }`,
     `export default index`,
   ].join('\n')
 }
@@ -134,7 +252,7 @@ function generateModule(index, root) {
 /**
  * Vite plugin for storyboard data discovery.
  *
- * - Scans the repo for *.scene.json, *.object.json, *.record.json
+ * - Scans the repo for *.flow.json, *.scene.json (compat), *.object.json, *.record.json
  * - Validates no two files share the same name+suffix (hard build error)
  * - Generates a virtual module `virtual:storyboard-data-index`
  * - Watches for file additions/removals in dev mode