@fugood/bricks-project 2.25.0-beta.37 → 2.25.0-beta.39

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.37",
+  "version": "2.25.0-beta.39",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.35",
+    "@fugood/bricks-cli": "^2.25.0-beta.38",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/package.json.bak

@@ -1,13 +1,13 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.37",
+  "version": "2.25.0-beta.39",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.35",
+    "@fugood/bricks-cli": "^2.25.0-beta.38",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/skills/bricks-ctor/SKILL.md

@@ -11,24 +11,26 @@ This skill covers advanced BRICKS features not in the main project instructions.
 
 | 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 |
-| [Verification Toolchain](rules/verification-toolchain.md) | Definition of done, compile, preview tool selection, on-device DevTools, Path 1/2/3 decision rule |
+| [Architecture Patterns](references/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
+| [Animation](references/animation.md) | Animation system for brick transforms and opacity |
+| [Standby Transition](references/standby-transition.md) | Canvas enter/exit animations |
+| [Automations](references/automations.md) | E2E testing and scheduled tasks |
+| [Data Calculation](references/data-calculation.md) | JS sandbox libraries (25+ available) |
+| [Local Sync](references/local-sync.md) | LAN device synchronization |
+| [Remote Data Bank](references/remote-data-bank.md) | Cloud data sync and API access |
+| [Media Flow](references/media-flow.md) | Media asset management |
+| [Buttress](references/buttress.md) | Remote inference for AI generators |
+| [Verification Toolchain](references/verification-toolchain.md) | Definition of done, compile, preview tool selection, on-device DevTools, Path 1/2/3 decision rule |
+| [Simulator](references/simulator.md) | Path 1 fidelity — Simulator feature support, fallbacks (Camera/LLM/STT/Vector Store, Buttress disabled), when a green run is enough vs. Path 2 |
 
 ## 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
-- **Verification before done**: See [Verification Toolchain](rules/verification-toolchain.md) for the definition-of-done gate and Path 1/2/3 decision rule
+- **Complex flows**: See [Architecture Patterns](references/architecture-patterns.md) for decomposing multi-step workflows
+- **Multi-device**: See [Local Sync](references/local-sync.md) for LAN coordination
+- **Cloud data**: See [Remote Data Bank](references/remote-data-bank.md) for sync and API access
+- **Media assets**: See [Media Flow](references/media-flow.md) for centralized asset management
+- **AI offloading**: See [Buttress](references/buttress.md) for GPU server delegation
+- **E2E testing**: See [Automations](references/automations.md) for test automation
+- **Enter animations**: See [Standby Transition](references/standby-transition.md) for canvas transitions
+- **Verification before done**: See [Verification Toolchain](references/verification-toolchain.md) for the definition-of-done gate and Path 1/2/3 decision rule
+- **Simulator fidelity**: See [Simulator](references/simulator.md) for what the Simulator fakes (Camera, AI generators, Buttress) and when to escalate to a real device

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

@@ -0,0 +1,98 @@
+# Simulator
+
+What the Simulator can and can't faithfully reproduce — so a passing Simulator run means what you think it means. This is the fidelity companion to Path 1 in [Verification Toolchain](verification-toolchain.md); read that for how to *drive* the Simulator (compile, screenshot, Automations).
+
+## What it is
+
+- The default Path 1 target: it renders your compiled project on your computer, with no device required.
+- It runs in Chromium/Electron — a browser-class runtime, not the device runtime. Two consequences to design verification around: it has a browser's capabilities and limits (below), and its JavaScript engine differs from the device's (iOS runs JSC, Android runs Hermes), so engine-specific behavior won't surface here.
+
+A Simulator screenshot proves **layout, navigation, Standby Transitions, Data wiring, and generator/Automation wiring**. It does *not* prove anything that depends on real hardware, real models, or capabilities the preview runtime lacks.
+
+## What the Simulator can't reproduce
+
+Because it runs in a browser-class preview rather than on device hardware, the Simulator cannot exercise these — a green run says nothing about them. Verify on a real device (Path 2):
+
+| Area | In the Simulator |
+|------|------------------|
+| BLE (Central / Peripheral), Video Streaming | Not available |
+| Raw network sockets — UDP, TCP, TCP Server, MQTT Broker | Not available (also why Buttress LAN discovery is a no-op — see [Buttress](buttress.md)) |
+| Android Intent | Not available (Android-only) |
+| On-device database **persistence** (SQLite / Vector Store) | Not available — both run in-memory in the Simulator (see caveats below), so data never survives a reload |
+| GGML Text-to-Speech | No vocoder in the preview — use an ONNX TTS model to hear speech |
+
+These work, but with browser caveats:
+
+| Area | Caveat |
+|------|--------|
+| Serial Port | Works via WebSerial — requires browser support and a user gesture |
+| 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 |
+
+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.
+
+## Network security
+
+The Simulator blocks insecure connections from `applicationPreview` by default: `http://` and `ws://` requests fail, while `https://` and `wss://` are allowed. The Simulator internally allows its own preview host when running the development preview.
+
+Generated projects include this project-level setting:
+
+```json
+{
+  "allowedInsecureHosts": []
+}
+```
+
+Add explicit entries only when you deliberately need to test an insecure endpoint in the Simulator. A bare `host:port` allows both `http://` and `ws://` for that host:
+
+```json
+{
+  "allowedInsecureHosts": ["localhost:8080"]
+}
+```
+
+Use a URL form when only one insecure protocol should be allowed:
+
+```json
+{
+  "allowedInsecureHosts": ["http://localhost:8080"]
+}
+```
+
+In that example, `http://localhost:8080` is allowed and `ws://localhost:8080` remains blocked.
+
+Prefer HTTPS/WSS for anything that is not local development.
+
+## Feature fallbacks — what the Simulator fakes
+
+So that camera and AI features are usable without device permissions, multi-gigabyte downloads, API keys, or a remote inference backend, the Simulator **transparently substitutes a lightweight stand-in** for a few bricks/generators. The config you author is untouched — only the Simulator's runtime behavior differs. **A fallback render proves wiring and layout, not the real feature.**
+
+| 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 |
+| 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 | 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 |
+| Speech-to-Text — GGML (`GENERATOR_SPEECH_INFERENCE`) | Swapped to a tiny local model | Accuracy / latency of your real model |
+| Speech-to-Text — ONNX (`GENERATOR_ONNX_STT`) | Swapped to a tiny whisper model | Accuracy / latency of your real model |
+| Text-to-Speech — ONNX (`GENERATOR_TTS`) | Swapped to a tiny VITS model (no vocoder or speaker embedding) | Voice / quality / latency of your real model |
+| Vector Store (`GENERATOR_VECTOR_STORE`) | Runs with a tiny local embedding model — an OpenAI-source config works **without a key** | Real embeddings / dimensions / recall (and no persistence — see above) |
+| Buttress (all generators) | **Disabled** — there is no remote inference backend in the Simulator | The Buttress offload path — see [Buttress](buttress.md) |
+| MLX LLM (`GENERATOR_MLX_LLM`) | Runs as authored, except Buttress is disabled | The MLX / Buttress path |
+
+These swaps make the AI generators runnable in the Simulator for wiring checks — validate real models, quality, and latency on a device (Path 2).
+
+### 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.
+
+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.
+
+## Enough vs. escalate
+
+- **Simulator is enough for:** layout, navigation, Standby Transitions, Data wiring, Automation / state-machine happy paths, and confirming a generator fires and handles its events.
+- **Escalate to a real device for:** anything in the "can't reproduce" tables, real camera / peripherals / payment / identity, real model quality & latency, multi-device Local Sync, on-device persistence, the Buttress offload path, and engine-specific behavior.
+
+The full Path 1/2/3 decision rule lives in [Verification Toolchain](verification-toolchain.md).

package/skills/bricks-ctor/{rules → references}/verification-toolchain.md

@@ -26,10 +26,12 @@ What does **not** count as done:
 
 If any item is unmet, the work is mid-iteration. Say so explicitly to the user; offer a precise list of what remains.
 
-## Path 1 — Electron preview (no device required)
+## Path 1 — Simulator (no device required)
 
 The default loop. Always available; deterministic; no device wear; safe for side-effecting flows because nothing real fires.
 
+Before trusting a Simulator screenshot, know what it can and can't reproduce: it runs in the Electron preview (a browser-class runtime, not the device — and not the device's JS engine), can't exercise hardware/peripheral features (BLE, printers, raw sockets, SQLite, …), and substitutes fallbacks for Camera and the AI generators (LLM/STT/Vector Store) with Buttress disabled. See [Simulator](simulator.md) for the fidelity boundaries and the per-item gear to run the real implementation — it's what tells you when a green run is enough vs. when to escalate to Path 2.
+
 `bun update-app` and `bun deploy-app` publish to the BRICKS portal. The local preview reads `.bricks/build/application-config.json` (produced by `compile`) directly.
 
 ### Compile tool
@@ -38,12 +40,12 @@ Typecheck + compile the project. Gate every iteration on this; everything below
 
 Agent invocation: call the MCP tool `compile` exposed by the `bricks-ctor` MCP server registered for the project. No arguments.
 
-### Preview tool
+### Simulator tool
 
 Use the preview implementation exposed by the current harness:
 
-- **CTOR Desktop agent session:** use `preview_invoke`. CTOR Desktop disables the `bricks-ctor` MCP `preview` tool and routes screenshots/automation through the desktop preview pane instead. If the user already opened the simulator pane, `preview_invoke` should reuse it rather than start a separate preview.
-- **Pure `bricks-ctor` project / other agent harness:** use the `bricks-ctor` MCP `preview` tool when `preview_invoke` is not available.
+- **CTOR Desktop agent session:** use `simulator_invoke`. CTOR Desktop disables the `bricks-ctor` MCP `simulator` tool and routes screenshots/automation through the desktop preview pane instead. If the user already opened the simulator pane, `simulator_invoke` should reuse it rather than start a separate preview.
+- **Pure `bricks-ctor` project / other agent harness:** use the `bricks-ctor` MCP `simulator` tool when `simulator_invoke` is not available.
 
 Both forms are the same verification primitive: launch or reuse Electron preview, take a screenshot, and optionally run a named Automation test by id or partial title. Do not hard-code one tool name into the workflow; choose the available preview tool for the environment.
 
@@ -55,7 +57,7 @@ Common arguments:
 
 Returns text log + saved screenshot path + image content when supported.
 
-### `bun preview` (project script)
+### `bun invoke-simulator` (project script)
 
 Sustained dev session — watches `subspaces/`, recompiles on save, exposes CDP at `localhost:19852` (configurable via `--cdp-port`), writes `.bricks/devtools.json` with port/pid for downstream tooling.
 
@@ -83,7 +85,7 @@ Trigger types: `launch` (runs on app start), `anytime` (manual), `cron` (schedul
 
 Important: the automation map id must be `'AUTOMATION_MAP_DEFAULT'` (not a generated id) — the preview test runner reads from `automationMap['AUTOMATION_MAP_DEFAULT']?.map`.
 
-Run a single test from the agent: call the available preview tool (`preview_invoke` in CTOR Desktop, otherwise `bricks-ctor` MCP `preview`) with `testId` or `testTitleLike`.
+Run a single test from the agent: call the available preview tool (`simulator_invoke` in CTOR Desktop, otherwise `bricks-ctor` MCP `preview`) with `testId` or `testTitleLike`.
 
 ## Path 2 — Real device with DevTools enabled
 
@@ -147,7 +149,7 @@ if user is off-LAN
 
 ### Static signage (single-canvas glance loop)
 - Path 1 screenshot captures the loop frame.
-- Watch one full rotation in `bun preview` to see all queue items.
+- Watch one full rotation in `bun invoke-simulator` to see all queue items.
 - Cut network mid-loop; confirm cached media plays.
 - Path 2 only if the panel is OLED / has burn-in concerns or specific color profile.
 

package/skills/bricks-design/SKILL.md

@@ -142,7 +142,7 @@ A single hero-Canvas screenshot is **not** done. A "looks roughly like the refer
 
 **Self-critique pass before declaring done** — every Canvas scored on 5 dimensions (system commitment / visual hierarchy / craft / functional fit / originality), anti-slop top-10 swept clean, < 8 scores either fixed or surfaced as accepted trade-offs. See [`references/design-critique.md`](references/design-critique.md). Verification proves it runs; critique proves it's good — both required.
 
-For the toolchain itself — `compile` / `preview` MCP usage, `bun preview` flags, Project Automation cases, on-device DevTools setup, the Path 1/2/3 decision rule, and per-deployment-shape verification checklists — see the `bricks-ctor` skill's `rules/verification-toolchain.md`.
+For the toolchain itself — `compile` / `simulator` MCP usage, `bun invoke-simulator` flags, Project Automation cases, on-device DevTools setup, the Path 1/2/3 decision rule, and per-deployment-shape verification checklists — see the `bricks-ctor` skill's `rules/verification-toolchain.md`.
 
 ## Boundaries
 

package/tools/mcp-tools/compile.ts

@@ -27,7 +27,7 @@ export function register(server: McpServer, projectDir: string) {
   if (process.env.BRICKS_CTOR_MCP_DISABLE_PREVIEW === '1') return
 
   server.tool(
-    'preview',
+    'simulator',
     {
       delay: z
         .number()
@@ -68,7 +68,7 @@ export function register(server: McpServer, projectDir: string) {
         ]
         if (testId) args.push('--test-id', testId)
         if (testTitleLike) args.push('--test-title-like', testTitleLike)
-        log = await sh`bunx --bun electron ${toolsDir}/preview-main.mjs ${args}`
+        log = await sh`bunx --bun electron ${toolsDir}/simulator-main.mjs ${args}`
           .cwd(projectDir)
           .env(noColorEnv)
           .text()

package/tools/{preview-main.mjs → simulator-main.mjs}

@@ -28,6 +28,81 @@ const { values } = parseArgs({
 })
 
 const cwd = process.cwd()
+const DEFAULT_SIMULATOR_SECURITY_SETTINGS = Object.freeze({
+  allowedInsecureHosts: [],
+})
+
+const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value)
+
+const normalizeSimulatorSecuritySettings = (settings = {}) => {
+  const source = isObject(settings) ? settings : {}
+  const allowedHosts = Array.isArray(source.allowedInsecureHosts)
+    ? source.allowedInsecureHosts
+    : DEFAULT_SIMULATOR_SECURITY_SETTINGS.allowedInsecureHosts
+
+  return {
+    allowedInsecureHosts: allowedHosts
+      .filter((host) => typeof host === 'string')
+      .map((host) => host.trim().toLowerCase())
+      .filter(Boolean),
+  }
+}
+
+const normalizeAllowedConnection = (value) => {
+  const raw = String(value || '')
+    .trim()
+    .toLowerCase()
+  if (!raw) return null
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return { host: raw, protocol: null }
+  try {
+    const url = new URL(raw)
+    return {
+      host: url.host.toLowerCase(),
+      protocol: url.protocol,
+    }
+  } catch {
+    return null
+  }
+}
+
+const shouldBlockInsecureConnection = (rawUrl, settings = {}) => {
+  const normalized = normalizeSimulatorSecuritySettings(settings)
+
+  try {
+    const url = new URL(String(rawUrl || ''))
+    if (url.protocol !== 'http:' && url.protocol !== 'ws:') return false
+    const host = url.host.toLowerCase()
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '')
+    return !normalized.allowedInsecureHosts.some((allowedHost) => {
+      const allowed = normalizeAllowedConnection(allowedHost)
+      if (!allowed) return false
+      if (allowed.protocol && allowed.protocol !== url.protocol) return false
+      return allowed.host === host || allowed.host === hostname
+    })
+  } catch {
+    return false
+  }
+}
+
+const getUnsecureConnectionHost = (rawUrl) => {
+  try {
+    const url = new URL(String(rawUrl || ''))
+    if (url.protocol !== 'http:' && url.protocol !== 'ws:') return null
+    return url.host.toLowerCase()
+  } catch {
+    return null
+  }
+}
+
+const readSimulatorProjectSettings = async () => {
+  try {
+    return normalizeSimulatorSecuritySettings(
+      JSON.parse(await readFile(`${cwd}/simulator.json`, 'utf8')),
+    )
+  } catch {
+    return normalizeSimulatorSecuritySettings()
+  }
+}
 
 let takeScreenshotConfig = null
 try {
@@ -45,6 +120,7 @@ try {
 }
 
 let config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
+let simulatorSettings = await readSimulatorProjectSettings()
 
 // Resolve testId from testTitleLike
 let testId = values['test-id'] || null
@@ -77,6 +153,13 @@ const previewUrlMap = {
 
 const previewUrl = previewUrlMap[stage]
 if (!previewUrl) throw new Error(`Invalid BRICKS_STAGE: ${stage}`)
+simulatorSettings = normalizeSimulatorSecuritySettings({
+  ...simulatorSettings,
+  allowedInsecureHosts: [
+    ...simulatorSettings.allowedInsecureHosts,
+    getUnsecureConnectionHost(previewUrl),
+  ].filter(Boolean),
+})
 
 // --- CDP WebSocket Server ---
 // Bridges external CDP clients to the preview's postMessage-based CDP bridge.
@@ -142,9 +225,9 @@ const startCdpServer = async (mainWindow, port) => {
       res.end(
         JSON.stringify([
           {
-            description: 'BRICKS Preview (CTOR Preview)',
-            id: 'bricks-preview',
-            title: 'BRICKS Preview',
+            description: 'BRICKS Simulator',
+            id: 'bricks-simulator',
+            title: 'BRICKS Simulator',
             type: 'page',
             url: previewUrl,
             webSocketDebuggerUrl: `ws://localhost:${actualPort}/ws`,
@@ -155,7 +238,7 @@ const startCdpServer = async (mainWindow, port) => {
     }
     if (req.url === '/json/version') {
       res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ Browser: 'BRICKS Preview', 'Protocol-Version': '1.3' }))
+      res.end(JSON.stringify({ Browser: 'BRICKS Simulator', 'Protocol-Version': '1.3' }))
       return
     }
     // bricks-cli discovery endpoint
@@ -163,7 +246,7 @@ const startCdpServer = async (mainWindow, port) => {
       res.writeHead(200, { 'Content-Type': 'application/json' })
       res.end(
         JSON.stringify({
-          name: 'BRICKS Preview',
+          name: 'BRICKS Simulator',
           port: actualPort,
           protocols: ['cdp'],
           hasPasscode: false,
@@ -215,6 +298,12 @@ app.on('ready', () => {
     show,
   })
   mainWindow.setBackgroundColor('#333')
+  mainWindow.webContents.session.webRequest.onBeforeRequest(
+    { urls: ['http://*/*', 'ws://*/*'] },
+    (details, callback) => {
+      callback({ cancel: shouldBlockInsecureConnection(details.url, simulatorSettings) })
+    },
+  )
   mainWindow.loadURL(previewUrl)
 
   const sendConfig = () => {
@@ -300,7 +389,34 @@ app.on('ready', () => {
     async () => {
       console.log('Detected config changed')
       config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
+      const nextSimulatorSettings = await readSimulatorProjectSettings()
+      simulatorSettings = normalizeSimulatorSecuritySettings({
+        ...nextSimulatorSettings,
+        allowedInsecureHosts: [
+          ...nextSimulatorSettings.allowedInsecureHosts,
+          getUnsecureConnectionHost(previewUrl),
+        ].filter(Boolean),
+      })
       sendConfig()
     },
   )
+  watchFile(
+    `${cwd}/simulator.json`,
+    {
+      bigint: false,
+      persistent: true,
+      interval: 1000,
+    },
+    async () => {
+      console.log('Detected simulator settings changed')
+      const nextSimulatorSettings = await readSimulatorProjectSettings()
+      simulatorSettings = normalizeSimulatorSecuritySettings({
+        ...nextSimulatorSettings,
+        allowedInsecureHosts: [
+          ...nextSimulatorSettings.allowedInsecureHosts,
+          getUnsecureConnectionHost(previewUrl),
+        ].filter(Boolean),
+      })
+    },
+  )
 })

package/tools/{preview.ts → simulator.ts}

@@ -98,7 +98,7 @@ const cleanupDevtoolsInfo = () => {
   } catch {}
 }
 
-// Kill existing preview process if devtools.json contains a stale pid
+// Kill existing simulator process if devtools.json contains a stale pid
 try {
   const devtoolsInfo = JSON.parse(await readFile(devtoolsInfoPath, 'utf8'))
   if (devtoolsInfo.pid) {
@@ -111,7 +111,7 @@ try {
 
 const proc = spawn(
   'bunx',
-  ['--bun', 'electron', `${import.meta.dirname}/preview-main.mjs`, ...args],
+  ['--bun', 'electron', `${import.meta.dirname}/simulator-main.mjs`, ...args],
   {
     env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
     stdio: ['inherit', 'pipe', 'inherit'],
@@ -127,14 +127,14 @@ rl.on('line', (line) => {
     return
   }
   if (!line) return
-  // Detect CDP server startup from preview-main output
+  // Detect CDP server startup from simulator-main output
   const cdpMatch = line.match(/^CDP server: ws:\/\/localhost:(\d+)/)
   if (cdpMatch) {
     const info = {
       port: parseInt(cdpMatch[1], 10),
       pid: proc.pid,
       address: 'localhost',
-      name: `${app.name || 'Unnamed'} (CTOR Preview)`,
+      name: `${app.name || 'Unnamed'} (CTOR Simulator)`,
       startedAt: new Date().toISOString(),
     }
     writeFile(devtoolsInfoPath, JSON.stringify(info, null, 2))