@fugood/bricks-ctor 2.25.0-beta.55 → 2.25.0-beta.58

package/compile/__tests__/index.test.js

@@ -249,6 +249,37 @@ describe('compile event handlers', () => {
   })
 })
 
+describe('compile expanded state', () => {
+  test('defaults canvas, bricks, and data collapsed for generated configs', async () => {
+    const config = await compile(makeApp([], [makeData(undefined)]))
+
+    expect(config.subspace_map[SUBSPACE_ID]._expanded).toEqual({
+      brick: false,
+      generator: true,
+      canvas: { [CANVAS_ID]: false },
+      property_bank: false,
+      property_bank_calc: true,
+    })
+  })
+
+  test('preserves explicit source unexpanded state when present', async () => {
+    const app = makeApp()
+    app.rootSubspace.unexpanded = {
+      generator: true,
+      dataCalculation: true,
+    }
+
+    const config = await compile(app)
+    const expanded = config.subspace_map[SUBSPACE_ID]._expanded
+
+    expect(expanded.brick).toBe(true)
+    expect(expanded.generator).toBe(false)
+    expect(expanded.canvas).toBeUndefined()
+    expect(expanded.property_bank).toBe(true)
+    expect(expanded.property_bank_calc).toBe(false)
+  })
+})
+
 describe('compile data remote update', () => {
   test.each([
     [undefined, { bank_type: 'none' }],

package/compile/__tests__/util.test.js

@@ -335,3 +335,116 @@ describe('generateCalulationMap', () => {
     expect(result.map[refs[1].id].properties.command).toBe('OBJECT_GET')
   })
 })
+
+// Direction A: generateCalulationMap also emits a single-node `script_map` the new runtime
+// prefers. These assert that derived graph, independent of the legacy `map` above.
+const scriptNode = (scriptMap) =>
+  Object.entries(scriptMap).find(([, node]) => node.type === 'command-node-script')
+
+describe('generateScriptMap (script_map)', () => {
+  test('empty config produces a single command-node-script node', () => {
+    const { script_map } = genMap(baseConfig())
+    expect(Object.values(script_map)).toHaveLength(1)
+    const [, node] = scriptNode(script_map)
+    expect(node.properties.command).toBe('SCRIPT_RUN')
+    expect(node.properties.args.code).toBe('return inputs')
+    expect(node.properties.args.inputs).toEqual({})
+    expect(node.properties.args.outputs).toEqual({})
+    expect(node.in).toEqual({})
+    expect(node.out).toEqual({})
+  })
+
+  test('wires keyed input ports and input data nodes, preserving order', () => {
+    const { script_map } = genMap(baseConfig({ inputs: { a: 'foo.bar', b: 'baz' } }))
+    const [scriptId, node] = scriptNode(script_map)
+    expect(script_map.a.out.value).toEqual([{ id: scriptId, port: 'a' }])
+    expect(script_map.b.out.value).toEqual([{ id: scriptId, port: 'b' }])
+    expect(script_map.a.in.change).toBeNull()
+    expect(node.in.a).toEqual([{ id: 'a', port: 'value' }])
+    expect(node.in.b).toEqual([{ id: 'b', port: 'value' }])
+    // args.inputs maps each input port (data-node id) to its inputs-object path, in order.
+    expect(node.properties.args.inputs).toEqual({ a: 'foo.bar', b: 'baz' })
+    expect(Object.keys(node.properties.args.inputs)).toEqual(['a', 'b'])
+  })
+
+  test('fans out output / error / outputs to distinct ports and target data nodes', () => {
+    const { script_map } = genMap(
+      baseConfig({ output: 'outNode', error: 'errNode', outputs: { sum: ['pb1', 'pb2'] } }),
+    )
+    const [scriptId, node] = scriptNode(script_map)
+    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(node.out.error).toEqual([{ id: 'errNode', port: 'change' }])
+    expect(node.out['out:sum']).toEqual([
+      { id: 'pb1', port: 'change' },
+      { id: 'pb2', port: 'change' },
+    ])
+    expect(node.properties.args.outputs).toEqual({ 'out:sum': 'sum' })
+    expect(script_map.outNode.in.change).toEqual([{ id: scriptId, port: 'output' }])
+    expect(script_map.errNode.in.change).toEqual([{ id: scriptId, port: 'error' }])
+    expect(script_map.pb1.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+    expect(script_map.pb2.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+  })
+
+  test('manual mode disables every input edge', () => {
+    const { script_map } = genMap(
+      baseConfig({ trigger_mode: 'manual', inputs: { a: 'foo', b: 'bar' } }),
+    )
+    const [, node] = scriptNode(script_map)
+    expect(node.in.a[0].disable_trigger_command).toBe(true)
+    expect(node.in.b[0].disable_trigger_command).toBe(true)
+  })
+
+  test('auto mode honours per-key disabled_triggers', () => {
+    const { script_map } = genMap(
+      baseConfig({ inputs: { a: 'foo', b: 'bar' }, disabled_triggers: { a: true, b: false } }),
+    )
+    const [, node] = scriptNode(script_map)
+    expect(node.in.a[0].disable_trigger_command).toBe(true)
+    expect(node.in.b[0].disable_trigger_command).toBeUndefined()
+  })
+
+  test('a node reused as input and output keeps both edges (manual mode)', () => {
+    const { script_map } = genMap(
+      baseConfig({
+        trigger_mode: 'manual',
+        inputs: { shared: 'foo' },
+        outputs: { sum: ['shared'] },
+      }),
+    )
+    const [scriptId] = scriptNode(script_map)
+    // Input side (out.value) is preserved alongside the output side (in.change).
+    expect(script_map.shared.out.value).toEqual([{ id: scriptId, port: 'shared' }])
+    expect(script_map.shared.in.change).toEqual([{ id: scriptId, port: 'out:sum' }])
+  })
+
+  test('outputs port names never collide with the reserved output port', () => {
+    const { script_map } = genMap(baseConfig({ output: 'outNode', outputs: { output: ['pb1'] } }))
+    const [, node] = scriptNode(script_map)
+    // The whole-return-value port stays `output`; an outputs path literally named "output"
+    // is namespaced to `out:output`.
+    expect(node.out.output).toEqual([{ id: 'outNode', port: 'change' }])
+    expect(node.out['out:output']).toEqual([{ id: 'pb1', port: 'change' }])
+    expect(node.properties.args.outputs).toEqual({ 'out:output': 'output' })
+  })
+
+  test('script node id is byte-stable across recompiles and unique per calc', () => {
+    const config = baseConfig({ inputs: { a: 'foo' }, outputs: { out: ['pb1'] } })
+    const first = generateCalulationMap(config, CALC_ID)
+    const second = generateCalulationMap(config, CALC_ID)
+    expect(Object.keys(second.script_map)).toEqual(Object.keys(first.script_map))
+    const [idA] = scriptNode(first.script_map)
+    const [idB] = scriptNode(
+      generateCalulationMap(
+        config,
+        'PROPERTY_BANK_COMMAND_MAP_bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      ).script_map,
+    )
+    expect(idA).not.toBe(idB)
+    const uuid = '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}'
+    expect(idA).toMatch(new RegExp(`^PROPERTY_BANK_COMMAND_NODE_${uuid}$`))
+  })
+
+  test('validateConfig still guards the script_map path (auto mode overlap)', () => {
+    expect(() => genMap(baseConfig({ inputs: { a: 'foo' }, error: 'a' }))).toThrow(/key: error/)
+  })
+})

package/compile/index.ts

@@ -751,6 +751,17 @@ const compileAutomation = (automationMap: AutomationMap) =>
     }),
   )
 
+const buildDefaultExpandedState = (subspace: Subspace) => ({
+  brick: false,
+  generator: true,
+  canvas: (subspace.canvases || []).reduce((acc, canvas) => {
+    if (canvas?.id) acc[canvas.id] = false
+    return acc
+  }, {}),
+  property_bank: false,
+  property_bank_calc: true,
+})
+
 // Record the minimal compiled-config delta this compile produced to the shared audit
 // log (`.bricks/edits.jsonl`), so editing files directly and running `bun compile`
 // leaves the same trail as the MCP source-editing tools. Maintained only in the
@@ -868,7 +879,7 @@ export const compile = async (app: Application) => {
               property_bank: !subspace.unexpanded.data,
               property_bank_calc: !subspace.unexpanded.dataCalculation,
             }
-          : undefined,
+          : buildDefaultExpandedState(subspace),
         layout: {
           width: subspace.layout?.width,
           height: subspace.layout?.height,

package/compile/util.ts

@@ -54,6 +54,104 @@ const padding = 15
 const layerXInterval = 300
 const layerYInterval = 150
 
+// Direction A — first-class script node (see local-plan/PLAN-data-calculation-refactor.md).
+//
+// `generateCalulationMap` keeps emitting the legacy OBJECT_SET → SANDBOX_RUN_JAVASCRIPT →
+// SANDBOX_GET_*/OBJECT_GET expansion in `map` (consumed by older runtimes). In parallel,
+// `generateScriptMap` derives an equivalent single-node graph in `script_map` that a newer
+// runtime prefers: one `command-node-script` node that assembles `inputs` from keyed input
+// ports and fans out `error` / `output` / each `outputs` path directly to the target data
+// nodes. Both are byte-stable functions of `script_config`, so codegen (which only reads
+// `script_config`) round-trips losslessly and recompiling unchanged source re-derives an
+// identical `script_map`.
+//
+// Trigger semantics stay edge-level (`disable_trigger_command` on the script node's input
+// edges, same as the legacy OBJECT_SET inputs) so the circular-reference check and the
+// manual-trigger overlay keep working unchanged — only the node count collapses N+3 → 1.
+const generateScriptMap = (config: ScriptConfig, calcId: string) => {
+  const scriptId = makeSeededId('property_bank_command', `${calcId}:script`)
+  const map: Record<string, any> = {}
+
+  // Compiled run-time config for the script node. `inputs` maps each input port name (the
+  // source data-node id) to its OBJECT_SET path; `outputs` maps each fan-out port name to the
+  // OBJECT_GET path it extracts from the return value. The runtime reads these from
+  // properties.args, keeping the node `value` reserved purely for incoming input-port values.
+  const inputArgs: Record<string, string> = {}
+  const outputArgs: Record<string, string> = {}
+
+  const scriptIn: Record<string, any> = {}
+  const scriptOut: Record<string, any> = {}
+
+  // One in-port per input, keyed by the source data-node id (unique per input, so each input
+  // keeps its own `disable_trigger_command` flag — a shared path could not). Manual mode
+  // disables every input edge; auto mode honours per-key `disabled_triggers`.
+  Object.entries(config.inputs).forEach(([dataNodeId, path]) => {
+    inputArgs[dataNodeId] = path
+    scriptIn[dataNodeId] = [
+      {
+        id: dataNodeId,
+        port: 'value',
+        disable_trigger_command:
+          config.trigger_mode === 'manual' || config.disabled_triggers?.[dataNodeId] || undefined,
+      },
+    ]
+    map[dataNodeId] = {
+      type: 'data-node',
+      properties: {},
+      in: { change: null },
+      out: { value: [{ id: scriptId, port: dataNodeId }] },
+    }
+  })
+
+  // Wire an output target data-node's `change` port back from a script out-port, preserving
+  // any `out.value` it already has (a node reused as both input and output — allowed in manual
+  // mode). Mirrors the last-wins reuse handling in generateCalulationMap's outputs section.
+  const wireOutputTarget = (dataNodeId: string, scriptPort: string) => {
+    const existing = map[dataNodeId]
+    map[dataNodeId] = {
+      type: 'data-node',
+      properties: {},
+      in: { change: [{ id: scriptId, port: scriptPort }] },
+      out: { value: existing?.out?.value ?? null },
+    }
+  }
+
+  if (config.error) {
+    scriptOut.error = [{ id: config.error, port: 'change' }]
+    wireOutputTarget(config.error, 'error')
+  }
+  if (config.output) {
+    scriptOut.output = [{ id: config.output, port: 'change' }]
+    wireOutputTarget(config.output, 'output')
+  }
+  // `out:`-prefixed port names keep `outputs` paths from colliding with the reserved
+  // `error` / `output` ports (a path could legitimately be the string "output").
+  Object.entries(config.outputs).forEach(([path, pbList]) => {
+    const portName = `out:${path}`
+    outputArgs[portName] = path
+    scriptOut[portName] = pbList.map((pb) => ({ id: pb, port: 'change' }))
+    pbList.forEach((pb) => wireOutputTarget(pb, portName))
+  })
+
+  map[scriptId] = {
+    type: 'command-node-script',
+    title: 'Command: SCRIPT_RUN',
+    properties: {
+      command: 'SCRIPT_RUN',
+      args: {
+        code: config.code,
+        enable_async: config.enable_async,
+        inputs: inputArgs,
+        outputs: outputArgs,
+      },
+    },
+    in: scriptIn,
+    out: scriptOut,
+  }
+
+  return map
+}
+
 // `calcId` (the owning script calc's stable id) seeds every derived command-node id, so an
 // unchanged calc recompiles to identical ids and editing one calc never shifts another's —
 // keeping the compiled config byte-stable for change detection. See makeSeededId in utils/id.
@@ -219,6 +317,8 @@ export const generateCalulationMap = (config: ScriptConfig, calcId: string) => {
   )
 
   return {
+    // Newer runtimes prefer this single-node graph; older runtimes fall back to `map` below.
+    script_map: generateScriptMap(config, calcId),
     map: {
       ...inputs.map,
       [sandboxId]: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.55",
+  "version": "2.25.0-beta.58",
   "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.53",
+    "@fugood/bricks-cli": "^2.25.0-beta.58",
     "@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": "08f3ae4a88db84f682384ecfa94e9d4583371bda"
+  "gitHead": "355da5754f1136c10e073460af4727dae94f7e30"
 }

package/tools/__tests__/pull.test.ts

@@ -0,0 +1,108 @@
+import { execFile as execFileCallback } from 'node:child_process'
+import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { promisify } from 'node:util'
+
+// bricks-project's tsconfig has no @types/jest, so declare the globals this test uses
+// (mirrors tools/__tests__/_mcp-config.test.ts).
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void | Promise<void>, timeout?: number) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+}
+
+const execFile = promisify(execFileCallback)
+
+async function run(cmd: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv) {
+  return execFile(cmd, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    maxBuffer: 1024 * 1024,
+  })
+}
+
+async function initGitProject(projectDir: string) {
+  await run('git', ['init', '--initial-branch=master'], projectDir)
+  await run('git', ['config', 'user.email', 'test@example.com'], projectDir)
+  await run('git', ['config', 'user.name', 'Test User'], projectDir)
+  await writeFile(join(projectDir, 'application.json'), JSON.stringify({ id: 'app-1' }))
+  await run('git', ['add', '.'], projectDir)
+  await run('git', ['commit', '-m', 'init'], projectDir)
+}
+
+async function writeFakeBricks(binDir: string) {
+  const payload = {
+    files: [
+      {
+        name: 'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+        input: 'export const value = 1\n',
+        formatable: false,
+      },
+    ],
+    lastCommitId: 'server-commit',
+  }
+  const bricksPath = join(binDir, 'bricks')
+  await writeFile(
+    bricksPath,
+    `#!/usr/bin/env node\nprocess.stdout.write(${JSON.stringify(JSON.stringify(payload))})\n`,
+  )
+  await chmod(bricksPath, 0o755)
+}
+
+describe('pull.ts', () => {
+  it('creates parent directories before writing pulled project files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'bricks-project-pull-'))
+    const projectDir = join(root, 'project')
+    const binDir = join(root, 'bin')
+
+    try {
+      await mkdir(projectDir)
+      await mkdir(binDir)
+      await initGitProject(projectDir)
+      await writeFakeBricks(binDir)
+
+      const pullScript = resolve(__dirname, '../pull.ts')
+      await run('bun', [pullScript, '--force'], projectDir, {
+        PATH: `${binDir}:${process.env.PATH || ''}`,
+      })
+
+      const pulledFile = join(
+        projectDir,
+        'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+      )
+      expect(await readFile(pulledFile, 'utf8')).toBe('export const value = 1\n')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }, 30000)
+
+  it('merges pulled project files back into the starting branch', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'bricks-project-pull-'))
+    const projectDir = join(root, 'project')
+    const binDir = join(root, 'bin')
+
+    try {
+      await mkdir(projectDir)
+      await mkdir(binDir)
+      await initGitProject(projectDir)
+      await writeFakeBricks(binDir)
+
+      const pullScript = resolve(__dirname, '../pull.ts')
+      await run('bun', [pullScript], projectDir, {
+        PATH: `${binDir}:${process.env.PATH || ''}`,
+      })
+
+      const { stdout: branch } = await run('git', ['branch', '--show-current'], projectDir)
+      const pulledFile = join(
+        projectDir,
+        'subspaces/subspace-13/data-calc/data-calculation-0.sandbox.js',
+      )
+
+      expect(branch.trim()).toBe('master')
+      expect(await readFile(pulledFile, 'utf8')).toBe('export const value = 1\n')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }, 30000)
+})

package/tools/mcp-tools/_editing-helpers.ts

@@ -56,3 +56,43 @@ export const removeObjectProperty = (object: t.ObjectExpression, key: string) =>
   })
   if (index >= 0) object.properties.splice(index, 1)
 }
+
+export const insertImport = (ast: t.File, declaration: t.ImportDeclaration) => {
+  const body = ast.program.body
+  const lastImportIndex = body.findLastIndex((statement) => t.isImportDeclaration(statement))
+  body.splice(lastImportIndex + 1, 0, declaration)
+}
+
+export const ensureBricksCtorImport = (
+  ast: t.File,
+  importKind: 'type' | 'value',
+  names: Iterable<string>,
+) => {
+  const missing = new Set(Array.from(names).filter(Boolean))
+  if (missing.size === 0) return
+
+  for (const statement of ast.program.body) {
+    if (!t.isImportDeclaration(statement) || statement.source.value !== 'bricks-ctor') continue
+    const isTypeImport = statement.importKind === 'type'
+    if ((importKind === 'type') !== isTypeImport) continue
+
+    statement.specifiers.forEach((specifier) => {
+      if (!t.isImportSpecifier(specifier)) return
+      const imported = specifier.imported
+      if (t.isIdentifier(imported)) missing.delete(imported.name)
+      if (t.isStringLiteral(imported)) missing.delete(imported.value)
+    })
+
+    missing.forEach((name) => {
+      statement.specifiers.push(t.importSpecifier(t.identifier(name), t.identifier(name)))
+    })
+    return
+  }
+
+  const declaration = t.importDeclaration(
+    Array.from(missing).map((name) => t.importSpecifier(t.identifier(name), t.identifier(name))),
+    t.stringLiteral('bricks-ctor'),
+  )
+  if (importKind === 'type') declaration.importKind = 'type'
+  insertImport(ast, declaration)
+}

package/tools/mcp-tools/data-calc-editing.ts

@@ -10,8 +10,10 @@ import { z } from 'zod'
 
 import { verifyProject } from './_verify'
 import {
+  ensureBricksCtorImport,
   getObjectProperty,
   getStringProperty,
+  insertImport,
   isRecord,
   makeObjectKey,
   oxfmtOptions,
@@ -328,12 +330,6 @@ const relativeImportSource = (fromFile: string, toFile: string) => {
   return rel.replace(/\.(ts|tsx|js|jsx)$/, '')
 }
 
-const insertImport = (ast: t.File, declaration: t.ImportDeclaration) => {
-  const body = ast.program.body
-  const lastImportIndex = body.findLastIndex((statement) => t.isImportDeclaration(statement))
-  body.splice(lastImportIndex + 1, 0, declaration)
-}
-
 const ensureNamespaceImport = (parsed: ParsedFile, source: string, preferredLocal: string) => {
   for (const statement of parsed.ast.program.body) {
     if (!t.isImportDeclaration(statement) || statement.source.value !== source) continue
@@ -352,40 +348,6 @@ const ensureNamespaceImport = (parsed: ParsedFile, source: string, preferredLoca
   return preferredLocal
 }
 
-const ensureBricksCtorImport = (
-  ast: t.File,
-  importKind: 'type' | 'value',
-  names: Iterable<string>,
-) => {
-  const missing = new Set(Array.from(names).filter(Boolean))
-  if (missing.size === 0) return
-
-  for (const statement of ast.program.body) {
-    if (!t.isImportDeclaration(statement) || statement.source.value !== 'bricks-ctor') continue
-    const isTypeImport = statement.importKind === 'type'
-    if ((importKind === 'type') !== isTypeImport) continue
-
-    statement.specifiers.forEach((specifier) => {
-      if (!t.isImportSpecifier(specifier)) return
-      const imported = specifier.imported
-      if (t.isIdentifier(imported)) missing.delete(imported.name)
-      if (t.isStringLiteral(imported)) missing.delete(imported.value)
-    })
-
-    missing.forEach((name) => {
-      statement.specifiers.push(t.importSpecifier(t.identifier(name), t.identifier(name)))
-    })
-    return
-  }
-
-  const declaration = t.importDeclaration(
-    Array.from(missing).map((name) => t.importSpecifier(t.identifier(name), t.identifier(name))),
-    t.stringLiteral('bricks-ctor'),
-  )
-  if (importKind === 'type') declaration.importKind = 'type'
-  insertImport(ast, declaration)
-}
-
 const ensureReadFileImport = (ast: t.File) => {
   for (const statement of ast.program.body) {
     if (!t.isImportDeclaration(statement) || statement.source.value !== 'node:fs/promises') {

package/tools/mcp-tools/entry-editing.ts

@@ -11,9 +11,11 @@ import { z } from 'zod'
 
 import { verifyProject } from './_verify'
 import {
+  ensureBricksCtorImport,
   getObjectProperty,
   getPropertyKeyName,
   getStringProperty,
+  insertImport,
   isRecord,
   makeObjectKey,
   oxfmtOptions,
@@ -576,13 +578,6 @@ const getTopLevelNames = (ast: t.File) => {
   return names
 }
 
-const insertImport = (ast: t.File, declaration: t.ImportDeclaration) => {
-  const lastImportIndex = ast.program.body.findLastIndex((statement) =>
-    t.isImportDeclaration(statement),
-  )
-  ast.program.body.splice(lastImportIndex + 1, 0, declaration)
-}
-
 const ensureNamespaceImport = (
   parsed: ParsedFile,
   namespace: string,
@@ -611,40 +606,6 @@ const ensureNamespaceImport = (
   return localName
 }
 
-const ensureBricksCtorImport = (
-  ast: t.File,
-  importKind: 'type' | 'value',
-  names: Iterable<string>,
-) => {
-  const missing = new Set(Array.from(names).filter(Boolean))
-  if (missing.size === 0) return
-
-  for (const statement of ast.program.body) {
-    if (!t.isImportDeclaration(statement) || statement.source.value !== 'bricks-ctor') continue
-    const isTypeImport = statement.importKind === 'type'
-    if ((importKind === 'type') !== isTypeImport) continue
-
-    statement.specifiers.forEach((specifier) => {
-      if (!t.isImportSpecifier(specifier)) return
-      const imported = specifier.imported
-      if (t.isIdentifier(imported)) missing.delete(imported.name)
-      if (t.isStringLiteral(imported)) missing.delete(imported.value)
-    })
-
-    missing.forEach((name) => {
-      statement.specifiers.push(t.importSpecifier(t.identifier(name), t.identifier(name)))
-    })
-    return
-  }
-
-  const declaration = t.importDeclaration(
-    Array.from(missing).map((name) => t.importSpecifier(t.identifier(name), t.identifier(name))),
-    t.stringLiteral('bricks-ctor'),
-  )
-  if (importKind === 'type') declaration.importKind = 'type'
-  insertImport(ast, declaration)
-}
-
 const applyPendingImports = (ctx: EditContext) => {
   ensureBricksCtorImport(ctx.parsed.ast, 'type', ctx.typeImports)
   ensureBricksCtorImport(ctx.parsed.ast, 'value', ctx.valueImports)

package/tools/pull.ts

@@ -1,6 +1,6 @@
-import { readdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { join, relative } from 'node:path'
+import { dirname, join, relative } from 'node:path'
 import { format } from 'oxfmt'
 import { sh } from './_shell'
 import { extractCliErrorMessage } from './_cli-error'
@@ -86,7 +86,11 @@ const branchName = isModule
   ? 'BRICKS_PROJECT_try-pull-module'
   : 'BRICKS_PROJECT_try-pull-application'
 
+let landingBranch = ''
 if (isGitRepo && !force) {
+  landingBranch = (await sh`cd ${cwd} && git branch --show-current`.text()).trim()
+  if (!landingBranch) throw new Error('Cannot pull from a detached HEAD')
+
   console.log(`Checking commit ${baseCommitId}...`)
   const found = (await sh`cd ${cwd} && git rev-list -1 ${baseCommitId}`.nothrow().text())
     .trim()
@@ -100,8 +104,8 @@ if (isGitRepo && !force) {
 
   // When the base commit isn't reachable in this clone (server stored a
   // nanoid, or the commit was pruned), fall back to forking from current
-  // HEAD. The downstream merge into main collapses both paths into the
-  // same result, just with different merge bases.
+  // HEAD. The downstream merge into the starting branch collapses both paths
+  // into the same result, just with different merge bases.
   if (found) {
     await sh`cd ${cwd} && git checkout -b ${branchName} ${baseCommitId}`.nothrow()
   } else {
@@ -143,7 +147,9 @@ await Promise.all(
       const result = await format(file.name, file.input, oxfmtConfig)
       content = result.code
     }
-    return writeFile(`${cwd}/${file.name}`, content)
+    const target = join(cwd, file.name)
+    await mkdir(dirname(target), { recursive: true })
+    return writeFile(target, content)
   }),
 )
 
@@ -160,11 +166,11 @@ if (isGitRepo) {
     await sh`cd ${cwd} && git ${commitArgs}`
   }
   if (!force) {
-    // Land the pulled commits on main with a single 3-way merge using
+    // Land the pulled commits on the starting branch with a single 3-way merge using
     // baseCommit as the merge base. The user doesn't have to manage a side
-    // branch, and conflicts (if any) land in the working tree on main where
+    // branch, and conflicts (if any) land in the working tree on the starting branch where
     // auto-compile surfaces them as typecheck errors to resolve in-place.
-    await sh`cd ${cwd} && git checkout main`
+    await sh`cd ${cwd} && git checkout ${landingBranch}`
     const mergeResult = await sh`cd ${cwd} && git merge ${branchName} --no-edit`.nothrow()
     if (mergeResult.exitCode !== 0) {
       // Conflict markers are in the working tree — commit them so the tree
@@ -174,7 +180,7 @@ if (isGitRepo) {
       await sh`cd ${cwd} && git add .`
       const conflictArgs = await buildCommitArgs(
         cwd,
-        ['chore(project): merge with conflicts (resolve in main)'],
+        [`chore(project): merge with conflicts (resolve in ${landingBranch})`],
         ['--no-verify'],
       )
       await sh`cd ${cwd} && git ${conflictArgs}`

package/types/bricks/Items.d.ts

@@ -269,6 +269,7 @@ Default property:
                   y?: number | DataLink
                   width?: number | DataLink
                   height?: number | DataLink
+                  type?: string | DataLink
                   standbyMode?: 'custom' | 'top' | 'bottom' | 'left' | 'right' | DataLink
                   standbyFrame?: DataLink | {}
                   standbyOpacity?: number | DataLink
@@ -319,6 +320,7 @@ Default property:
                 }
             show?: string | DataLink
             pressToOpenDetail?: boolean | DataLink
+            pressToBackList?: boolean | DataLink
           }
       >
     | DataLink
@@ -346,6 +348,7 @@ Default property:
                   y?: number | DataLink
                   width?: number | DataLink
                   height?: number | DataLink
+                  type?: string | DataLink
                   standbyMode?: 'custom' | 'top' | 'bottom' | 'left' | 'right' | DataLink
                   standbyFrame?: DataLink | {}
                   standbyOpacity?: number | DataLink
@@ -395,6 +398,7 @@ Default property:
                   renderOutOfViewport?: boolean | DataLink
                 }
             show?: string | DataLink
+            pressToOpenDetail?: boolean | DataLink
             pressToBackList?: boolean | DataLink
           }
       >