peachsim 0.1.637 → 0.1.638

package/src/host/bridge-host.ts

@@ -229,6 +229,8 @@ interface BridgeForwardedCommand {
 export interface BridgeHostOptions {
   /** use 0 for an OS-assigned port; startAsync returns the bound address. */
   port?: number
+  /** listener address; defaults to 127.0.0.1. */
+  host?: string
   openUrl?: (url: string, options?: OpenUrlOptions) => Promise<void> | void
   /** Contrast-specific excludes for the agent host's dev-server scan. passed
    *  through to AgentHost; see packages/peach-engine/src/dev-scan-excludes.ts
@@ -404,6 +406,7 @@ export class SootSimBridgeHost {
   // of reconnecting the zombie straight back in.
   private static SIM_IDLE_REAP_TTL_MS = 30 * 60_000
 
+  private bindHost: string
   private preferredPort: number
   private portFallbackCount: number
   private shouldWriteLockfile: boolean
@@ -438,6 +441,7 @@ export class SootSimBridgeHost {
   private static SCAN_FRESH_MS = 2000
 
   constructor(opts: BridgeHostOptions = {}) {
+    this.bindHost = opts.host ?? '127.0.0.1'
     this.preferredPort = opts.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT
     this.port = this.preferredPort
     // default off — callers that want the lockfile (peach serve) opt in.
@@ -533,11 +537,7 @@ export class SootSimBridgeHost {
       }
       server.once('error', onError)
 
-      // loopback-only bind. we listen on 127.0.0.1 explicitly because the
-      // daemon serves the active runtime's dist as plain static files —
-      // never expose that to LAN peers. tests + the electron renderer use
-      // 127.0.0.1 explicitly to avoid the localhost-vs-::1 DNS coinflip.
-      server.listen(port, '127.0.0.1', () => {
+      server.listen(port, this.bindHost, () => {
         if (settled) return
         const address = server.address()
         if (!address || typeof address === 'string') {

package/src/native-seam-manifest.ts

@@ -153,15 +153,13 @@ export const NATIVE_SEAM_MANIFEST: NativeSeamEntry[] = [
   },
   {
     pkg: '@bam.tech/react-native-image-resizer',
-    // upstream is not shipped to most guest bundles via node_modules — it
-    // arrives through the bundle-loader stub-registry which routes the
-    // package entry to `stubs/bam-react-native-image-resizer.ts`. listed here
-    // for documentation parity; vite-path redirect would key on
-    // `NativeImageResizer`.
+    // a Metro bundle reaches the same seam through the ImageResizer
+    // TurboModule that `stubs/bam-react-native-image-resizer-register.ts`
+    // registers.
     seamBasenames: ['NativeImageResizer'],
     target: seamPath('bam-react-native-image-resizer'),
     notes:
-      'ImageResizer TurboModule — browser-side canvas resize implementing the iOS contain/cover/stretch + onlyScaleDown semantics from ios/ImageResizer.mm',
+      'ImageResizer TurboModule following ios/ImageResizer.mm: loader decode, rotation, scaling, and the file written to the app container',
   },
   {
     pkg: 'react-native-adjust',

package/src/swift-compile.ts

@@ -224,8 +224,8 @@ export function swiftArtifactHash(
   moduleRoot: string,
 ): string {
   const hash = createHash('sha256')
-  // v2: sources compile with os(iOS) true (swiftSourceAsIOS)
-  hash.update(`swift-compile/v2\n${release}\n`)
+  // v3: sources compile with os(iOS) true on code lines (swiftSourceAsIOS)
+  hash.update(`swift-compile/v3\n${release}\n`)
   if (input.oneModule) hash.update('one-module\n')
   hash.update(linkedModuleDigest(moduleRoot))
   for (const file of Object.keys(input.files).sort()) {
@@ -347,15 +347,111 @@ function syncSwiftTree(base: string, files: Map<string, string>): void {
 // every iOS branch of the app would compile out. a condition line names iOS
 // as `true` padded to the same length, so diagnostics keep their columns;
 // os(WASI) still holds for code written for wasm. only `#if` and `#elseif`
-// lines change, and the artifact hash stays over the original text.
-const CONDITION_LINE = /^([ \t]*#(?:if|elseif)\b)(.*)$/gm
+// lines that begin in code change: a line inside a string literal or a block
+// comment is content. the artifact hash stays over the original text.
+const DIRECTIVE = /^[ \t]*#(?:if|elseif)\b/
 const OS_IOS = /\bos\(\s*iOS\s*\)/g
 export function swiftSourceAsIOS(source: string): string {
-  return source.replace(
-    CONDITION_LINE,
-    (_, directive: string, condition: string) =>
-      directive + condition.replace(OS_IOS, (match) => 'true'.padEnd(match.length)),
-  )
+  const code = swiftCodeLineStarts(source)
+  let offset = 0
+  return source
+    .split('\n')
+    .map((line) => {
+      const start = offset
+      offset += line.length + 1
+      if (!code.has(start) || !DIRECTIVE.test(line)) return line
+      return line.replace(OS_IOS, (match) => 'true'.padEnd(match.length))
+    })
+    .join('\n')
+}
+
+// the offsets of the lines that begin in code, from a scan of Swift's lexical
+// contexts: nested block comments, line comments, string literals (single and
+// multiline, raw with any number of #, interpolations holding code and
+// strings of their own) and #/ /# regex literals. a bare /regex/ literal
+// reads as code.
+type Lexical =
+  | { kind: 'code'; parens: number }
+  | { kind: 'block'; depth: number }
+  | { kind: 'string'; hashes: number; multiline: boolean }
+  | { kind: 'regex'; hashes: number }
+function swiftCodeLineStarts(source: string): Set<number> {
+  const starts = new Set<number>()
+  const stack: Lexical[] = [{ kind: 'code', parens: 0 }]
+  const hashesAt = (at: number) => {
+    let end = at
+    while (source[end] === '#') end++
+    return end - at
+  }
+  const closes = (at: number, hashes: number) => source.startsWith('#'.repeat(hashes), at)
+  let i = 0
+  while (i < source.length) {
+    const top = stack[stack.length - 1]
+    if ((i === 0 || source[i - 1] === '\n') && top.kind === 'code' && stack.length === 1)
+      starts.add(i)
+    const char = source[i]
+    if (top.kind === 'block') {
+      if (source.startsWith('/*', i)) {
+        top.depth++
+        i += 2
+      } else if (source.startsWith('*/', i)) {
+        if (--top.depth === 0) stack.pop()
+        i += 2
+      } else i++
+      continue
+    }
+    if (top.kind === 'string') {
+      if (char === '\\' && closes(i + 1, top.hashes)) {
+        const after = i + 1 + top.hashes
+        if (source[after] === '(') {
+          stack.push({ kind: 'code', parens: 0 })
+          i = after + 1
+        } else i = after + 1
+        continue
+      }
+      const quote = top.multiline ? '"""' : '"'
+      if (source.startsWith(quote, i) && closes(i + quote.length, top.hashes)) {
+        stack.pop()
+        i += quote.length + top.hashes
+      } else i++
+      continue
+    }
+    if (top.kind === 'regex') {
+      if (char === '/' && closes(i + 1, top.hashes)) {
+        stack.pop()
+        i += 1 + top.hashes
+      } else i++
+      continue
+    }
+    if (source.startsWith('//', i)) {
+      const end = source.indexOf('\n', i)
+      i = end === -1 ? source.length : end
+    } else if (source.startsWith('/*', i)) {
+      stack.push({ kind: 'block', depth: 1 })
+      i += 2
+    } else if (char === '"' || char === '#') {
+      const hashes = hashesAt(i)
+      const at = i + hashes
+      if (source.startsWith('"""', at)) {
+        stack.push({ kind: 'string', hashes, multiline: true })
+        i = at + 3
+      } else if (source[at] === '"') {
+        stack.push({ kind: 'string', hashes, multiline: false })
+        i = at + 1
+      } else if (hashes > 0 && source[at] === '/') {
+        stack.push({ kind: 'regex', hashes })
+        i = at + 1
+      } else i = Math.max(at, i + 1)
+    } else if (char === '(') {
+      top.parens++
+      i++
+    } else if (char === ')') {
+      if (top.parens === 0 && stack.length > 1) stack.pop()
+      else top.parens--
+      i++
+    } else i++
+  }
+  return starts
 }
 
 const compiledSource = (file: string, contents: string) =>