Merge branch 'codex/design-diff-engine' into codex/design-diff-benchmark-v3

Author: Bill Leoutsakos

scripts/design-diff/README.md

@@ -102,6 +102,7 @@ scripts/design-diff/
   infrastructure.ts                     Rendering lockfile dependency closure
   report.ts                             Value previews and bounded JSON serialization
   benchmark.ts                          Immutable-engine historical replay
+  process.ts                            Native Bun process status and bounded diagnostics
   benchmark/comparisons.json            Frozen original/holdout comparison manifest
   memory.ts                             Bun parser-batch garbage collection
   tailwind.ts                           Pinned compiler and trusted merge convention
@@ -149,7 +150,9 @@ does not establish equivalence of arbitrary interactive behavior.
 
 The resolver supports immutable constants, object properties, arrays, primitive template
 strings, simple arithmetic, conditional branches, static imports/re-exports, namespace
-imports, workspace exports and project `paths` aliases. It records CVA bases, variants,
+imports, workspace exports and project `paths` aliases. Static array selections and awaited
+`Promise.all` results trace the selected value independently; arbitrary promise failure and
+scheduling effects are not modeled. It records CVA bases, variants,
 defaults, compound variants and selections; runtime selections remain symbolic. Recognized
 `cn`/`clsx` helpers are interpreted as data. The trusted EMCN `cn` merge convention includes
 the repository's custom font-size groups. A helper with an unrecognized origin is not trusted
@@ -339,6 +342,8 @@ bun --no-env-file scripts/design-diff/benchmark.ts \
 Fetch manifest commit objects beforehand; missing history fails explicitly. The runner verifies
 the frozen comparison commits and GitHub file sets. Cache identity includes engine SHA, trusted
 config, lockfile, runtime and comparison commits, with report-content verification before reuse.
-It records per-comparison elapsed time and peak RSS separately from deterministic reports.
+It awaits native Bun process exit status and records per-comparison elapsed time and peak RSS
+separately from deterministic reports. Failed runs retain bounded stderr diagnostics in a
+separate file, without printing source findings to logs.
 `/usr/bin/time` is required (macOS or Linux); source findings are not printed. Review original
 and holdout rates separately, and inspect every disagreement against the source label.

scripts/design-diff/benchmark.ts

@@ -1,8 +1,9 @@
-import { execFileSync, spawn } from 'node:child_process'
+import { execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { parseArgs } from 'node:util'
+import { runProcess } from '#design-diff/process'
 import type { Report } from '#design-diff/types'
 
 interface Comparison {
@@ -150,10 +151,11 @@ export async function benchmark(args = process.argv.slice(2)): Promise<void> {
       const started = performance.now()
       const env = { ...process.env }
       for (const key of ['DESIGN_DIFF_PR', 'DESIGN_DIFF_ENGINE_SHA', 'HEAD_SHA']) delete env[key]
-      const timeArgs = process.platform === 'darwin' ? ['-l'] : ['-v']
-      const proc = spawn(
-        '/usr/bin/time',
+      const metricsFile = `${stem}.time.txt`
+      const timeArgs = process.platform === 'darwin' ? ['-l'] : ['-v', '-o', metricsFile]
+      const execution = await runProcess(
         [
+          '/usr/bin/time',
           ...timeArgs,
           process.execPath,
           '--no-env-file',
@@ -165,22 +167,20 @@ export async function benchmark(args = process.argv.slice(2)): Promise<void> {
           '--output',
           reportFile,
         ],
-        { cwd: engine, env, stdio: ['ignore', 'ignore', 'pipe'], detached: true }
+        engine,
+        env
       )
-      let metrics = ''
-      proc.stderr.on('data', (chunk: Buffer) => {
-        if (metrics.length < 65536) metrics += chunk.toString()
-      })
-      const timeout = setTimeout(
-        () => {
-          if (proc.pid) process.kill(-proc.pid, 'SIGKILL')
-        },
-        15 * 60 * 1000
-      )
-      result.exitCode = await new Promise<number | null>((resolve, reject) => {
-        proc.on('error', reject)
-        proc.on('close', resolve)
-      }).finally(() => clearTimeout(timeout))
+      result.exitCode = execution.exitCode
+      const metrics =
+        process.platform === 'linux' && existsSync(metricsFile)
+          ? readFileSync(metricsFile, 'utf8')
+          : execution.stderr
+      if (execution.exitCode !== 0 || execution.timedOut)
+        writeFileSync(
+          `${stem}.stderr.txt`,
+          execution.stderr + (execution.truncated ? '\n[stderr truncated at 65536 bytes]\n' : ''),
+          { mode: 0o600 }
+        )
       result.seconds = Math.round((performance.now() - started) / 10) / 100
       const rss =
         process.platform === 'darwin'
@@ -189,6 +189,7 @@ export async function benchmark(args = process.argv.slice(2)): Promise<void> {
       result.peakMemoryBytes = rss
         ? Number(rss[1]) * (process.platform === 'darwin' ? 1 : 1024)
         : null
+      if (execution.timedOut) throw new Error('Analysis deadline exceeded')
       if (!existsSync(reportFile)) throw new Error('Engine did not produce a report')
       const bytes = readFileSync(reportFile)
       const report = JSON.parse(bytes.toString()) as Report

scripts/design-diff/process.ts

@@ -0,0 +1,65 @@
+/** Native Bun subprocess contract used by the benchmark, independent of Node stream events. */
+interface Runtime {
+  spawn(
+    args: string[],
+    options: {
+      cwd: string
+      env: NodeJS.ProcessEnv
+      stdin: 'ignore'
+      stdout: 'ignore'
+      stderr: 'pipe'
+      detached: true
+    }
+  ): { pid: number; exited: Promise<number>; stderr: ReadableStream<Uint8Array> }
+}
+
+/** Await the process exit status itself and drain bounded diagnostics separately. */
+export async function runProcess(
+  args: string[],
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+  milliseconds = 900000
+) {
+  const runtime = (globalThis as typeof globalThis & { Bun?: Runtime }).Bun
+  if (!runtime) throw new Error('Benchmark subprocesses require Bun')
+  const proc = runtime.spawn(args, {
+    cwd,
+    env,
+    stdin: 'ignore',
+    stdout: 'ignore',
+    stderr: 'pipe',
+    detached: true,
+  })
+  const reader = proc.stderr.getReader()
+  const chunks: Uint8Array[] = []
+  let bytes = 0
+  let truncated = false
+  const drain = (async () => {
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      const remaining = Math.max(0, 65536 - bytes)
+      if (value.length > remaining) truncated = true
+      if (remaining) {
+        chunks.push(value.subarray(0, remaining))
+        bytes += Math.min(remaining, value.length)
+      }
+    }
+    return Buffer.concat(chunks).toString('utf8')
+  })()
+  let timedOut = false
+  const timeout = setTimeout(() => {
+    timedOut = true
+    try {
+      process.kill(-proc.pid, 'SIGKILL')
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error
+    }
+  }, milliseconds)
+  try {
+    const [exitCode, stderr] = await Promise.all([proc.exited, drain])
+    return { exitCode, stderr, truncated, timedOut }
+  } finally {
+    clearTimeout(timeout)
+  }
+}

scripts/design-diff/resolve.ts

@@ -332,6 +332,13 @@ export class Resolver {
         }
         return initial
       }
+      if (binding?.path.isImportNamespaceSpecifier()) {
+        const declaration = binding.path.parentPath
+        if (declaration.isImportDeclaration()) {
+          const target = this.tree.resolve(file, declaration.node.source.value)
+          if (target) return this.exported(target, key, depth + 1)
+        }
+      }
       if (binding?.path.isImportSpecifier() || binding?.path.isImportDefaultSpecifier()) {
         const declaration = binding.path.parentPath
         if (declaration.isImportDeclaration()) {
@@ -348,6 +355,31 @@ export class Resolver {
         }
       }
     }
+    if (path.isAwaitExpression()) {
+      const awaited = child(path, 'argument')
+      if (awaited.isCallExpression()) {
+        const callee = child(awaited, 'callee')
+        if (
+          callee.isMemberExpression() &&
+          !callee.node.computed &&
+          t.isIdentifier(callee.node.object, { name: 'Promise' }) &&
+          !callee.scope.getBinding('Promise') &&
+          t.isIdentifier(callee.node.property, { name: 'all' })
+        ) {
+          const array = children(awaited, 'arguments')[0]
+          if (array?.isArrayExpression() && !array.node.elements.some(t.isSpreadElement)) {
+            const selected = this.selected(array, key, file, depth + 1, seen)
+            if (selected !== undefined) return { $await: selected }
+          }
+        }
+      }
+    }
+    if (path.isArrayExpression() && /^(?:0|[1-9]\d*)$/.test(key)) {
+      const elements = children(path, 'elements')
+      const index = Number(key)
+      if (index < elements.length && !elements.slice(0, index + 1).some((p) => p.isSpreadElement()))
+        return this.value(elements[index], file, depth + 1)
+    }
     if (path.isObjectExpression()) {
       for (const prop of children(path, 'properties').reverse()) {
         if (prop.isObjectMethod() && !prop.node.computed && propertyName(prop.node.key) === key)
@@ -357,7 +389,8 @@ export class Resolver {
         if (prop.isSpreadElement()) {
           const selected = this.selected(child(prop, 'argument'), key, file, depth + 1, seen)
           if (selected !== undefined) return selected
-          return undefined // An unknown later spread can override an earlier property.
+          /** An unknown later spread can override an earlier property. */
+          return undefined
         }
       }
     }
@@ -465,7 +498,10 @@ export class Resolver {
     if (!selection) return undefined
     const init = child(binding, 'init')
     const [first, ...rest] = selection.keys
-    let value = typeof first === 'string' ? this.selected(init, first, file, depth + 1) : undefined
+    let value =
+      typeof first === 'string' || typeof first === 'number'
+        ? this.selected(init, String(first), file, depth + 1)
+        : undefined
     const keys = value === undefined ? selection.keys : rest
     if (value === undefined) value = this.value(init, file, depth + 1)
     for (const key of keys) {
@@ -916,8 +952,8 @@ export class Resolver {
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
       const key = node.computed ? read('property') : propertyName(node.property)
       const selected =
-        typeof key === 'string'
-          ? this.selected(child(path, 'object'), key, file, depth + 1)
+        typeof key === 'string' || typeof key === 'number'
+          ? this.selected(child(path, 'object'), String(key), file, depth + 1)
           : undefined
       if (selected !== undefined) return selected
       const base = read('object')

scripts/design-diff/tests/precision.test.ts

@@ -344,3 +344,42 @@ it('isolates unrelated mutable object fields such as telemetry warmup state', as
   )
   expect(report.flagged).toBe(false)
 })
+
+it.each(['[live, unrelated]', 'await Promise.all([live, unrelated])'])(
+  'projects an individual array result from %s',
+  async (expression) => {
+    const source = (colour: string, telemetry: number) =>
+      `export const live='${colour}';export const unrelated=${telemetry}`
+    const files = {
+      [data]: source('red', 1),
+      [view]: `import {live,unrelated} from './data';export async function Page(){const [colour]=${expression};return <span style={{color:colour}}/>}`,
+    }
+    expect((await compareFiles(files, { [data]: source('red', 2) }, settings)).flagged).toBe(false)
+    expect((await compareFiles(files, { [data]: source('blue', 1) }, settings)).flagged).toBe(true)
+  }
+)
+
+it('keeps shadowed Promise.all conservative', async () => {
+  const source = (n: number) => `export const unrelated=${n}`
+  const report = await compareFiles(
+    {
+      [data]: source(1),
+      [view]: `import {unrelated} from './data';export async function Page({Promise}){const [colour]=await Promise.all(['red',unrelated]);return <span style={{color:colour}}/>}`,
+    },
+    { [data]: source(2) },
+    settings
+  )
+  expect(report.flagged).toBe(true)
+})
+
+it('projects namespace members even when an outer expression reaches its resolution limit', async () => {
+  const source = (colour: string, unused: number) =>
+    `export const colour='${colour}';export const unused=${unused}`
+  const files = {
+    [data]: source('red', 1),
+    [view]: `import * as palette from './data';export const Page=()=> <span style={{color:unknown(unknown(unknown(palette.colour)))}}/>`,
+  }
+  const bounded = { ...settings, limits: { ...settings.limits, resolutionDepth: 2 } }
+  expect((await compareFiles(files, { [data]: source('red', 2) }, bounded)).flagged).toBe(false)
+  expect((await compareFiles(files, { [data]: source('blue', 1) }, bounded)).flagged).toBe(true)
+})

scripts/design-diff/tests/process.test.ts

@@ -0,0 +1,22 @@
+import { execFileSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { expect, it } from 'vitest'
+
+const runner = fileURLToPath(new URL('../process.ts', import.meta.url))
+
+it.each([
+  ['exit status', 'process.stderr.write("metric");process.exit(7)', 5000, 7, false, false, 6],
+  ['bounded diagnostics', 'process.stderr.write("x".repeat(100000))', 5000, 0, false, true, 65536],
+  ['deadline', 'await new Promise(resolve=>setTimeout(resolve,30000))', 50, null, true, false, 0],
+])(
+  'measures native Bun subprocess %s',
+  (_name, source, deadline, code, timedOut, truncated, bytes) => {
+    const script = `import {runProcess} from ${JSON.stringify(runner)};const result=await runProcess([process.execPath,'--no-env-file','-e',${JSON.stringify(source)}],process.cwd(),process.env,${deadline});process.stdout.write(JSON.stringify({...result,stderr:result.stderr.length}));`
+    const result = JSON.parse(
+      execFileSync('bun', ['--no-env-file', '-e', script], { encoding: 'utf8', timeout: 10000 })
+    )
+    expect(result).toMatchObject({ timedOut, truncated, stderr: bytes })
+    if (code === null) expect(result.exitCode).not.toBe(0)
+    else expect(result.exitCode).toBe(code)
+  }
+)