@fugood/bricks-ctor 2.25.0-beta.45 → 2.25.0-beta.47

package/compile/__tests__/config-diff.test.js

@@ -54,6 +54,45 @@ describe('computeConfigChange', () => {
     })
   })
 
+  test('ignores object fields omitted by JSON.stringify', () => {
+    const before = { subspace_map: { S: { title: 'Home' } } }
+    const after = {
+      subspace_map: {
+        S: {
+          title: 'Home',
+          description: undefined,
+        },
+      },
+    }
+    expect(computeConfigChange(before, after)).toEqual({ status: 'ok', ops: [], opCount: 0 })
+  })
+
+  test('emits added values in JSON-compatible shape', () => {
+    const before = { m: {} }
+    const after = {
+      m: {
+        nested: {
+          keep: 1,
+          drop: undefined,
+        },
+        items: [undefined, 2],
+      },
+    }
+    const change = computeConfigChange(before, after)
+    expect(change.ops).toEqual([
+      { op: 'set', path: ['m', 'nested'], value: { keep: 1 } },
+      { op: 'set', path: ['m', 'items'], value: [null, 2] },
+    ])
+  })
+
+  test('compares array undefined entries like JSON nulls', () => {
+    expect(computeConfigChange({ items: [null] }, { items: [undefined] })).toEqual({
+      status: 'ok',
+      ops: [],
+      opCount: 0,
+    })
+  })
+
   test('reports no_baseline / unavailable for missing sides', () => {
     expect(computeConfigChange(null, { a: 1 })).toEqual({ status: 'no_baseline' })
     expect(computeConfigChange({ a: 1 }, null)).toEqual({ status: 'unavailable' })

package/compile/__tests__/util.test.js

@@ -64,6 +64,28 @@ describe('validateConfig', () => {
   test('does not throw when error/output are falsy and inputs are empty', () => {
     expect(() => validateConfig(baseConfig())).not.toThrow()
   })
+
+  test('throws when error and output target the same id', () => {
+    const config = baseConfig({ output: 'shared', error: 'shared' })
+    expect(() => validateConfig(config)).toThrow(/key: error\/output/)
+  })
+
+  test('throws when output collides with an outputs target id', () => {
+    const config = baseConfig({ output: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: output\/outputs/)
+  })
+
+  test('throws when error collides with an outputs target id', () => {
+    const config = baseConfig({ error: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: error\/outputs/)
+  })
+
+  // The same id reused across *different* outputs entries is a supported last-wins case
+  // (see generateCalulationMap test below) and must stay allowed.
+  test('allows the same id across multiple outputs entries', () => {
+    const config = baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } })
+    expect(() => validateConfig(config)).not.toThrow()
+  })
 })
 
 // generateCalulationMap now seeds command ids from the owning calc id; tests that don't

package/compile/config-diff.ts

@@ -27,17 +27,60 @@ export type ConfigChange =
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value)
 
+const isJsonDroppedValue = (value: unknown) =>
+  value === undefined || typeof value === 'function' || typeof value === 'symbol'
+
+const toJsonComparableScalar = (value: unknown) => {
+  if (typeof value === 'number' && !Number.isFinite(value)) return null
+  return value
+}
+
+const toJsonCompatibleValue = (value: unknown): unknown => {
+  if (isJsonDroppedValue(value)) return undefined
+  if (Array.isArray(value)) {
+    return value.map((item) => (isJsonDroppedValue(item) ? null : toJsonCompatibleValue(item)))
+  }
+  if (isRecord(value)) {
+    return Object.entries(value).reduce((acc, [key, item]) => {
+      if (!isJsonDroppedValue(item)) acc[key] = toJsonCompatibleValue(item)
+      return acc
+    }, {})
+  }
+  return toJsonComparableScalar(value)
+}
+
+const hasJsonObjectKey = (value: Record<string, unknown>, key: string) =>
+  Object.prototype.hasOwnProperty.call(value, key) && !isJsonDroppedValue(value[key])
+
+const getJsonArrayItem = (value: unknown[], index: number) => {
+  const item = value[index]
+  return isJsonDroppedValue(item) ? null : item
+}
+
 const deepEqual = (a: unknown, b: unknown): boolean => {
+  a = toJsonComparableScalar(a)
+  b = toJsonComparableScalar(b)
   if (a === b) return true
   if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))
+    if (a.length !== b.length) return false
+    for (let index = 0; index < a.length; index += 1) {
+      if (!deepEqual(getJsonArrayItem(a, index), getJsonArrayItem(b, index))) return false
+    }
+    return true
   }
   if (isRecord(a) && isRecord(b)) {
-    const aKeys = Object.keys(a)
-    return (
-      aKeys.length === Object.keys(b).length &&
-      aKeys.every((key) => key in b && deepEqual(a[key], b[key]))
-    )
+    let comparableAKeys = 0
+    for (const key of Object.keys(a)) {
+      if (isJsonDroppedValue(a[key])) continue
+      comparableAKeys += 1
+      if (!hasJsonObjectKey(b, key) || !deepEqual(a[key], b[key])) return false
+    }
+
+    let comparableBKeys = 0
+    for (const key of Object.keys(b)) {
+      if (!isJsonDroppedValue(b[key])) comparableBKeys += 1
+    }
+    return comparableAKeys === comparableBKeys
   }
   return false
 }
@@ -64,22 +107,32 @@ const diffInto = (
   if (isRecord(before) && isRecord(after)) {
     const keys = new Set([...Object.keys(before), ...Object.keys(after)])
     for (const key of keys) {
+      const beforeHasKey = hasJsonObjectKey(before, key)
+      const afterHasKey = hasJsonObjectKey(after, key)
+      if (!beforeHasKey && !afterHasKey) continue
+
       const nextPath = [...currentPath, key]
-      if (!(key in after)) ops.push({ op: 'unset', path: nextPath })
-      else if (!(key in before)) ops.push({ op: 'set', path: nextPath, value: after[key] })
-      else diffInto(before[key], after[key], nextPath, ops)
+      if (!afterHasKey) ops.push({ op: 'unset', path: nextPath })
+      else if (!beforeHasKey) {
+        ops.push({ op: 'set', path: nextPath, value: toJsonCompatibleValue(after[key]) })
+      } else diffInto(before[key], after[key], nextPath, ops)
     }
     return
   }
 
   if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
     for (let index = 0; index < after.length; index += 1) {
-      diffInto(before[index], after[index], [...currentPath, index], ops)
+      diffInto(
+        getJsonArrayItem(before, index),
+        getJsonArrayItem(after, index),
+        [...currentPath, index],
+        ops,
+      )
     }
     return
   }
 
-  ops.push({ op: 'set', path: currentPath, value: after })
+  ops.push({ op: 'set', path: currentPath, value: toJsonCompatibleValue(after) })
 }
 
 // Diff two compiled configs. `before == null` means there was no prior build to compare

package/compile/index.ts

@@ -714,9 +714,9 @@ const compileAutomation = (automationMap: AutomationMap) =>
 const recordConfigChange = async (previousConfig: unknown, config: unknown) => {
   if (previousConfig == null) return
   if (!isTruthyEnv(process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS)) return
-  // The baseline was parsed from JSON; round-trip the fresh config the same way so keys
-  // holding undefined (dropped by the artifact's JSON.stringify) don't diff as phantom sets.
-  const change = computeConfigChange(previousConfig, JSON.parse(JSON.stringify(config)))
+  // The baseline was parsed from JSON; `computeConfigChange` applies the same
+  // JSON-omitted-field rules lazily so compile avoids cloning the full config.
+  const change = computeConfigChange(previousConfig, config)
   if (change.status !== 'ok') return
   await appendEditRecord(process.cwd(), {
     ts: new Date().toISOString(),

package/compile/util.ts

@@ -27,6 +27,22 @@ export const validateConfig = (config: ScriptConfig) => {
   if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
     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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.45",
+  "version": "2.25.0-beta.47",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -11,7 +11,7 @@
     "@babel/parser": "7.28.5",
     "@babel/traverse": "7.28.5",
     "@babel/types": "7.28.5",
-    "@fugood/bricks-cli": "^2.25.0-beta.45",
+    "@fugood/bricks-cli": "^2.25.0-beta.46",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -29,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "37dd0194e56025e5fe727bab6af7e2b8eb1d7ae1"
+  "gitHead": "95f194a3fb6331c0f25a879e55675e3ff331a412"
 }

package/skills/bricks-ctor/references/simulator.md

@@ -46,7 +46,7 @@ These work, but with browser caveats:
 | WebView / WebCrawler | Subject to browser CORS — a load/fetch that works on device may be blocked |
 | On-device AI (LLM / STT / VAD / Vector Store / Reranker) | Runs **single-threaded** — far slower than the device, not representative of real latency. Also subject to the model fallbacks below |
 | On-device database (SQLite — `GENERATOR_SQLITE`) | Runs for real on the in-memory WASM `sqlite-vec` build — `execute` / `query` / `transaction` / batch all work. `storageType: file` is transparently treated as in-memory, so nothing persists across reloads (see above) |
-| Scene3D / Maps / Sketch / WebRTC | Supported |
+| Scene3D / Sketch / WebRTC | Supported |
 
 Feature availability also varies across the device platforms themselves (iOS / tvOS / Android / the desktop OSes). When a deployment targets a specific platform's capability, confirm it on that platform.
 
@@ -89,6 +89,7 @@ So that camera and AI features are usable without device permissions, multi-giga
 | Brick / Generator | In the Simulator | Does NOT prove |
 |-------------------|------------------|----------------|
 | Camera (`BRICK_CAMERA`) | A 3D mock canvas, no camera permission prompt. `takePicture` snapshots the canvas; recording produces a placeholder clip | Real camera feed, focus, recording, permission flow |
+| Maps (`BRICK_MAPS`) | A real interactive map on free OpenStreetMap-based tiles — no Google Maps API key needed. Markers, path polyline, the six themes / map types (approximated with free tile sets + CSS tints), and the zoom / pan / navigate / focus / reset / fit actions all work | Google / Apple Maps rendering, exact `customMapStyle` / theme styling (approximated), traffic / buildings / indoors layers, real device geolocation |
 | Thermal Printer (`GENERATOR_THERMAL_PRINTER`) | A simulated printer — `init` / `checkStatus` / `scan` fake per-driver status and discovered devices (ESC/POS, Star, TSC, Castles); `print` renders an approximate on-screen receipt. A bottom-left bubble shows live status with a fault toggle to exercise error wiring. Print results can be exported as PNG via `bricks-cli` (see below) | Real device connection, actual paper output, exact native driver status codes |
 | LLM (`GENERATOR_LLM`) | Swapped to a tiny local stand-in model | Output quality / latency of your real model |
 | Reranker — GGML (`GENERATOR_RERANKER`) | Swapped to a small local multilingual reranker model | Ranking quality / latency of your real model |
@@ -119,7 +120,7 @@ The PNG is the same approximate receipt the on-screen preview shows (rendered fr
 
 ### Running the real implementation instead
 
-Each substituted brick/generator can be switched back to its real implementation per item: open the **gear (Simulator settings)** in the editor's preview toolbar, uncheck the item, and **Apply**. Apply persists the choice and reloads the preview so it takes effect (a plain refresh won't). Use this to, e.g., point a Vector Store at a real API key in the preview. The browser limits above still apply, and **Buttress stays disabled regardless** — there's no backend for it here.
+Each substituted brick/generator can be switched back to its real implementation per item: open the **gear (Simulator settings)** in the editor's preview toolbar, uncheck the item, and **Apply**. Apply persists the choice and reloads the preview so it takes effect (a plain refresh won't). Use this to, e.g., point a Vector Store at a real API key in the preview, or render the real Google/Apple Maps brick (which needs a Maps API key on web). The browser limits above still apply, and **Buttress stays disabled regardless** — there's no backend for it here.
 
 The Thermal Printer is the exception: it has no real web implementation to switch to (the native drivers can't run in a browser), so it is **always simulated** and is not in the gear list.
 

package/tools/mcp-tools/__tests__/huggingface.test.ts

@@ -0,0 +1,49 @@
+import { buildGGUFSplitFiles } from '../huggingface'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => { toEqual: (expected: unknown) => void }
+
+describe('buildGGUFSplitFiles', () => {
+  it('builds split GGUF files with indexed sibling metadata lookup', () => {
+    const siblings = [
+      {
+        rfilename: 'other-file.txt',
+        size: 999,
+      },
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 22,
+        lfs: { sha256: 'two-late' },
+      },
+    ]
+
+    expect(buildGGUFSplitFiles('model-00001-of-00003.gguf', '00003', siblings)).toEqual([
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00003-of-00003.gguf',
+        size: undefined,
+        lfs: undefined,
+      },
+    ])
+  })
+})

package/tools/mcp-tools/__tests__/icons.test.ts

@@ -0,0 +1,21 @@
+import { searchIcons } from '../icons'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const test: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+  toHaveLength: (expected: number) => void
+}
+
+describe('icon_search helpers', () => {
+  test('searches the selected style corpus directly', () => {
+    const results = searchIcons('x', 10, 'brands')
+
+    expect(results).toHaveLength(10)
+    expect(results.every((result) => result.item.styles.includes('brands'))).toBe(true)
+  })
+
+  test('keeps unstyled searches capped by limit', () => {
+    expect(searchIcons('arrow', 5)).toHaveLength(5)
+  })
+})

package/tools/mcp-tools/huggingface.ts

@@ -269,6 +269,28 @@ const fetchHFModelDetails = async (modelId: string): Promise<HFModel> => {
 // Example: Mixtral-8x22B-v0.1.IQ3_XS-00001-of-00005.gguf
 const ggufSplitPattern = /-(\d{5})-of-(\d{5})\.gguf$/
 
+export const buildGGUFSplitFiles = (
+  filename: string,
+  splitTotal: string,
+  siblings: HFSibling[],
+): HFSibling[] => {
+  const siblingByFilename = new Map<string, HFSibling>()
+  for (const sibling of siblings) {
+    if (!siblingByFilename.has(sibling.rfilename)) siblingByFilename.set(sibling.rfilename, sibling)
+  }
+
+  return Array.from({ length: Number(splitTotal) }, (_, i) => {
+    const split = String(i + 1).padStart(5, '0')
+    const splitRFilename = filename.replace(ggufSplitPattern, `-${split}-of-${splitTotal}.gguf`)
+    const sibling = siblingByFilename.get(splitRFilename)
+    return {
+      rfilename: splitRFilename,
+      size: sibling?.size,
+      lfs: sibling?.lfs,
+    }
+  })
+}
+
 export function register(server: McpServer) {
   server.tool(
     'huggingface_search',
@@ -657,19 +679,7 @@ export function register(server: McpServer) {
 
         if (isSplit) {
           const [, , splitTotal] = matched!
-          const splitFiles = Array.from({ length: Number(splitTotal) }, (_, i) => {
-            const split = String(i + 1).padStart(5, '0')
-            const splitRFilename = filename.replace(
-              ggufSplitPattern,
-              `-${split}-of-${splitTotal}.gguf`,
-            )
-            const sibling = siblings.find((sb) => sb.rfilename === splitRFilename)
-            return {
-              rfilename: splitRFilename,
-              size: sibling?.size,
-              lfs: sibling?.lfs,
-            }
-          })
+          const splitFiles = buildGGUFSplitFiles(filename, splitTotal, siblings)
 
           const first = splitFiles[0]
           const rest = splitFiles.slice(1)

package/tools/mcp-tools/icons.ts

@@ -36,11 +36,31 @@ const iconList = Object.entries(glyphmap as Record<string, number>).map(([name,
   return { name, code, styles }
 })
 
-const iconFuse = new Fuse(iconList, {
+const fuseOptions = {
   keys: ['name'],
   threshold: 0.3,
   includeScore: true,
-})
+}
+
+const iconFuse = new Fuse(iconList, fuseOptions)
+const iconFuseByStyle = new Map<IconStyle, Fuse<(typeof iconList)[number]>>()
+
+function getStyleFuse(style: IconStyle) {
+  let fuse = iconFuseByStyle.get(style)
+  if (!fuse) {
+    fuse = new Fuse(
+      iconList.filter((icon) => icon.styles.includes(style)),
+      fuseOptions,
+    )
+    iconFuseByStyle.set(style, fuse)
+  }
+  return fuse
+}
+
+export function searchIcons(query: string, limit: number, style?: IconStyle) {
+  if (style) return getStyleFuse(style).search(query, { limit })
+  return iconFuse.search(query, { limit })
+}
 
 export function register(server: McpServer) {
   server.tool(
@@ -54,11 +74,7 @@ export function register(server: McpServer) {
         .describe('Filter by icon style'),
     },
     async ({ query, limit, style }) => {
-      let results = iconFuse.search(query, { limit: style ? limit * 3 : limit })
-
-      if (style) {
-        results = results.filter((r) => r.item.styles.includes(style)).slice(0, limit)
-      }
+      const results = searchIcons(query, limit, style)
 
       const icons = results.map((r) => ({
         name: r.item.name,