peachsim 0.1.2210 → 0.1.2213

package/cli/command-registry.ts

@@ -23,6 +23,7 @@ const NODE_COMMAND_NAMES = [
   'storage',
   'permissions',
   'perf',
+  'map',
   'screenshot',
   'state',
   'reset',

package/cli/commands/inspect/settling.ts

@@ -541,7 +541,7 @@ export async function waitForSootsimIdle({
               const bounds = element.getBoundingClientRect()
               return element.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true }) &&
                 bounds.width > 0 && bounds.height > 0 && bounds.right > 0 && bounds.bottom > 0 &&
-                bounds.left < window.innerWidth && bounds.top < window.innerHeight
+                bounds.left < globalThis.innerWidth && bounds.top < globalThis.innerHeight
             })
             if (busyEl) {
               webViewStarting = true

package/cli/commands/map.ts

@@ -0,0 +1,576 @@
+// peach map: build a branch screen map screen by screen, or crawl routes
+// by deep link, then publish it to peach cloud (/api/maps). the local
+// working file is peach-map.json with pngs under peach-map-assets/.
+// capture reuses `peach screenshot` so readiness and fidelity match.
+
+import { execSync } from 'node:child_process'
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { isRecord } from '../../src/is-record'
+import { sleep } from '../../src/sleep'
+import { authHeaderValue, resolveCliAuth } from '../auth'
+import { createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
+import { inspectDescribe, type InspectBridge } from './inspect/core'
+import { runScreenshot } from './screenshot'
+import { resolveDefaultUploadOrigin } from './upload'
+
+type LocalScreen = {
+  id: string
+  route: string | null
+  title: string
+  state: string | null
+  png: string
+  source: string
+}
+
+type LocalEdge = {
+  from: string
+  to: string
+  label: string | null
+  testID: string | null
+  source: string
+}
+
+type LocalMap = {
+  version: 1
+  screens: LocalScreen[]
+  edges: LocalEdge[]
+  gaps: Array<{ screen: string; reason: string }>
+}
+
+const HELP = `
+peach map — capture screens tied to routes and publish the branch map
+
+usage:
+  peach map add --route /settings --title Settings [--from / --label Settings]
+  peach map crawl --scheme myapp:// --routes /,/settings,/profile
+  peach map crawl --app ~/my-app [--scheme myapp://] [--routes /,/settings]
+  peach map list
+  peach map publish --owner acme --repo my-app [--branch main]
+
+add options:
+  --route <path>     route this screen answers to (the screen id)
+  --id <id>          screen id when it is not the route
+  --title <text>     display title (default: the route)
+  --state <name>     a second state of the same screen (e.g. signed-in)
+  --from <screen>    screen the tap started from (adds an edge)
+  --label <text>     tapped control label for the edge
+  --testid <id>      tapped control testID for the edge
+  --png <file>       use an existing png instead of capturing the sim
+  --file <path>      working file (default: peach-map.json)
+
+crawl options:
+  --app <dir>        discover routes from the app router dir, scheme from app.json
+  --scheme <url>     deep link scheme, e.g. myapp:// (required unless --app finds one)
+  --routes <list>    comma separated routes to open and capture (required unless --app)
+  --settle-ms <n>    wait per route for the tree to change, 0 to skip (default: 15000)
+
+publish options:
+  --owner <org>      github owner the cloud repo is linked under (required)
+  --repo <name>      repo name (required)
+  --branch <name>    branch the map belongs to (default: current git branch)
+  --commit <sha>     commit the map was captured at (default: git HEAD)
+  --device <name>    device label (default: default)
+  --appearance <a>   light | dark (default: light)
+  --origin <url>     cloud origin (default: your session origin)
+
+examples:
+  peach open 8081
+  peach map add --route / --title Home
+  peach do tap-text Settings
+  peach map add --route /settings --title Settings --from / --label Settings
+  peach map publish --owner acme --repo my-app
+`
+
+function flag(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name)
+  if (index < 0) return undefined
+  const value = args[index + 1]
+  if (!value || value.startsWith('--')) throw new Error(`${name} requires a value`)
+  return value
+}
+
+function screenKey(id: string, state: string | null): string {
+  return state ? `${id}#${state}` : id
+}
+
+function assetName(key: string): string {
+  return `${key.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'root'}.png`
+}
+
+function readLocalMap(file: string): LocalMap {
+  if (!existsSync(file)) return { version: 1, screens: [], edges: [], gaps: [] }
+  const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'))
+  if (!isRecord(parsed) || !Array.isArray(parsed.screens)) {
+    throw new Error(`${file} is not a peach map file`)
+  }
+  const screens: LocalScreen[] = []
+  for (const raw of parsed.screens) {
+    if (!isRecord(raw)) continue
+    if (typeof raw.id !== 'string' || typeof raw.title !== 'string') continue
+    if (typeof raw.png !== 'string') continue
+    screens.push({
+      id: raw.id,
+      route: typeof raw.route === 'string' ? raw.route : null,
+      title: raw.title,
+      state: typeof raw.state === 'string' ? raw.state : null,
+      png: raw.png,
+      source: typeof raw.source === 'string' ? raw.source : 'manual',
+    })
+  }
+  const edges: LocalEdge[] = []
+  if (Array.isArray(parsed.edges)) {
+    for (const raw of parsed.edges) {
+      if (!isRecord(raw)) continue
+      if (typeof raw.from !== 'string' || typeof raw.to !== 'string') continue
+      edges.push({
+        from: raw.from,
+        to: raw.to,
+        label: typeof raw.label === 'string' ? raw.label : null,
+        testID: typeof raw.testID === 'string' ? raw.testID : null,
+        source: typeof raw.source === 'string' ? raw.source : 'manual',
+      })
+    }
+  }
+  const gaps: LocalMap['gaps'] = []
+  if (Array.isArray(parsed.gaps)) {
+    for (const raw of parsed.gaps) {
+      if (!isRecord(raw)) continue
+      if (typeof raw.screen !== 'string' || typeof raw.reason !== 'string') continue
+      gaps.push({ screen: raw.screen, reason: raw.reason })
+    }
+  }
+  return { version: 1, screens, edges, gaps }
+}
+
+function writeLocalMap(file: string, map: LocalMap): void {
+  writeFileSync(file, `${JSON.stringify(map, null, 2)}\n`)
+}
+
+function upsertScreen(map: LocalMap, screen: LocalScreen, edge: LocalEdge | null): void {
+  const key = screenKey(screen.id, screen.state)
+  const index = map.screens.findIndex((entry) => screenKey(entry.id, entry.state) === key)
+  if (index >= 0) map.screens[index] = screen
+  else map.screens.push(screen)
+  map.gaps = map.gaps.filter((gap) => gap.screen !== key)
+  if (edge && !map.edges.some((e) => e.from === edge.from && e.to === edge.to)) {
+    map.edges.push(edge)
+  }
+}
+
+// a crawl is rerun as the app grows: one gap per screen, the newest reason.
+function recordGaps(file: string, gaps: LocalMap['gaps']): void {
+  const map = readLocalMap(file)
+  const named = new Set(gaps.map((gap) => gap.screen))
+  map.gaps = [...map.gaps.filter((gap) => !named.has(gap.screen)), ...gaps]
+  writeLocalMap(file, map)
+}
+
+async function captureTo(
+  pngPath: string,
+  opts: { port?: number; verbose?: boolean },
+): Promise<void> {
+  mkdirSync(dirname(pngPath), { recursive: true })
+  await runScreenshot(['--output', pngPath], opts)
+  if (!existsSync(pngPath)) throw new Error(`screenshot did not write ${pngPath}`)
+}
+
+export async function runMap(
+  args: string[],
+  opts: { port?: number; verbose?: boolean },
+): Promise<number> {
+  try {
+    return await dispatch(args, opts)
+  } catch (error) {
+    console.error(
+      `  map failed: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return 1
+  }
+}
+
+async function dispatch(
+  args: string[],
+  opts: { port?: number; verbose?: boolean },
+): Promise<number> {
+  const [verb, ...rest] = args
+  if (!verb || verb === '--help' || verb === '-h' || verb === 'help') {
+    console.log(HELP)
+    return 0
+  }
+  const file = resolve(flag(rest, '--file') ?? 'peach-map.json')
+  if (verb === 'add') return addScreen(file, rest, opts, 'manual')
+  if (verb === 'crawl') return crawl(file, rest, opts)
+  if (verb === 'list') {
+    const map = readLocalMap(file)
+    for (const screen of map.screens) {
+      console.log(
+        `  ${screenKey(screen.id, screen.state)}  ${screen.title}${screen.route ? `  (${screen.route})` : ''}`,
+      )
+    }
+    for (const edge of map.edges) {
+      console.log(
+        `  ${edge.from} -> ${edge.to}${edge.label ? `  tap "${edge.label}"` : ''}${edge.testID ? `  #${edge.testID}` : ''}`,
+      )
+    }
+    for (const gap of map.gaps) console.log(`  gap: ${gap.screen} — ${gap.reason}`)
+    console.log(`  ${map.screens.length} screens, ${map.edges.length} edges`)
+    return 0
+  }
+  if (verb === 'publish') return publish(file, rest)
+  console.error(`  unknown map verb: ${verb}\n${HELP}`)
+  return 1
+}
+
+async function addScreen(
+  file: string,
+  args: string[],
+  opts: { port?: number; verbose?: boolean },
+  source: string,
+  prebuilt?: { id: string; route: string; title: string },
+): Promise<number> {
+  const route = prebuilt?.route ?? flag(args, '--route')
+  const id = prebuilt?.id ?? flag(args, '--id') ?? route
+  if (!id) throw new Error('peach map add needs --route or --id')
+  const title = prebuilt?.title ?? flag(args, '--title') ?? route ?? id
+  const state = flag(args, '--state') ?? null
+  const key = screenKey(id, state)
+  const assetDir = join(dirname(file), 'peach-map-assets')
+  const assetPath = join(assetDir, assetName(key))
+  const givenPng = flag(args, '--png')
+  if (givenPng) {
+    mkdirSync(assetDir, { recursive: true })
+    writeFileSync(assetPath, readFileSync(resolve(givenPng)))
+  } else {
+    await captureTo(assetPath, opts)
+  }
+  const from = flag(args, '--from')
+  const map = readLocalMap(file)
+  upsertScreen(
+    map,
+    {
+      id,
+      route: route ?? null,
+      title,
+      state,
+      png: `peach-map-assets/${assetName(key)}`,
+      source,
+    },
+    from
+      ? {
+          from,
+          to: key,
+          label: flag(args, '--label') ?? null,
+          testID: flag(args, '--testid') ?? null,
+          source,
+        }
+      : null,
+  )
+  writeLocalMap(file, map)
+  console.log(`  mapped ${key} (${title}) -> ${file}`)
+  return 0
+}
+
+const ROUTE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js']
+const PLATFORM_SUFFIX_RE = /\.(native|ios|android|web)(?=\.[^.]+$)/
+const RENDER_MODE_SUFFIX_RE = /\+(ssg|ssr|spa)$/
+
+export type DiscoveredAppRoutes = {
+  routes: string[]
+  gaps: Array<{ screen: string; reason: string }>
+  scheme: string | null
+  routerRoot: string | null
+}
+
+function readAppJsonScheme(appRoot: string): string | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(appRoot, 'app.json'), 'utf8'))
+    if (!isRecord(parsed)) return null
+    const expo = parsed.expo
+    if (!isRecord(expo)) return null
+    const scheme = expo.scheme
+    if (typeof scheme === 'string' && scheme.trim()) return scheme.trim()
+    if (Array.isArray(scheme)) {
+      const first = scheme.find(
+        (entry): entry is string => typeof entry === 'string' && entry.trim().length > 0,
+      )
+      return first?.trim() ?? null
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+function walkRouteFiles(root: string): string[] {
+  const found: string[] = []
+  const visit = (dir: string) => {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry)
+      let stat: ReturnType<typeof statSync>
+      try {
+        stat = statSync(full)
+      } catch {
+        continue
+      }
+      if (stat.isDirectory()) visit(full)
+      else if (stat.isFile()) found.push(full)
+    }
+  }
+  visit(root)
+  return found.sort()
+}
+
+// file routes follow the one/expo-router conventions in
+// src/bundler/routeDiscovery.ts: groups vanish from the url, index names the
+// directory, layouts/api/middleware/not-found are not screens. dynamic
+// segments become gaps: a deep link cannot invent their values.
+export function discoverDeepLinkRoutes(appRoot: string): DiscoveredAppRoutes {
+  const root = resolve(appRoot)
+  const scheme = readAppJsonScheme(root)
+  const routerRoot = ['app', 'src/app']
+    .map((leaf) => join(root, leaf))
+    .find((candidate) => {
+      try {
+        return statSync(candidate).isDirectory()
+      } catch {
+        return false
+      }
+    })
+  if (!routerRoot) return { routes: [], gaps: [], scheme, routerRoot: null }
+  const byRoute = new Map<string, { priority: number; file: string }>()
+  const gaps: DiscoveredAppRoutes['gaps'] = []
+  for (const file of walkRouteFiles(routerRoot)) {
+    if (!ROUTE_EXTENSIONS.some((ext) => file.endsWith(ext))) continue
+    const relative = file.slice(routerRoot.length + 1)
+    const segments = relative.split('/')
+    const name = segments.pop() ?? ''
+    const platform = PLATFORM_SUFFIX_RE.exec(name)?.[1]
+    if (platform === 'web') continue
+    const base = name
+      .replace(PLATFORM_SUFFIX_RE, '')
+      .replace(/\.[^.]+$/, '')
+      .replace(RENDER_MODE_SUFFIX_RE, '')
+    if (base === '_layout' || base === '+middleware' || base === '+not-found') continue
+    if (base === '+html' || base === '+native-intent') continue
+    if (base.endsWith('+api')) continue
+    const publicSegments = segments.filter(
+      (segment) => !(segment.startsWith('(') && segment.endsWith(')')),
+    )
+    const parts = base === 'index' ? publicSegments : [...publicSegments, base]
+    const dynamic = parts.find((part) => part.startsWith('[') && part.endsWith(']'))
+    if (dynamic) {
+      gaps.push({
+        screen: `/${parts.join('/')}`,
+        reason: `dynamic segment ${dynamic} needs a value; pass --routes to capture one`,
+      })
+      continue
+    }
+    const routePath = `/${parts.join('/')}`.replace(/\/+$/, '') || '/'
+    const priority = !platform ? 0 : platform === 'native' ? 1 : 2
+    const existing = byRoute.get(routePath)
+    if (!existing || priority < existing.priority) {
+      byRoute.set(routePath, { priority, file })
+    }
+  }
+  const routes = [...byRoute.keys()].sort((a, b) => {
+    if (a === '/') return -1
+    if (b === '/') return 1
+    const depthA = a.split('/').length
+    const depthB = b.split('/').length
+    return depthA === depthB ? a.localeCompare(b) : depthA - depthB
+  })
+  return { routes, gaps, scheme, routerRoot }
+}
+
+const DEFAULT_CRAWL_SETTLE_MS = 15000
+const SETTLE_POLL_MS = 500
+
+function treeDigest(tree: string): string {
+  let hash = 5381
+  for (let index = 0; index < tree.length; index++) {
+    hash = ((hash << 5) + hash + tree.charCodeAt(index)) | 0
+  }
+  return `${tree.length}:${hash}`
+}
+
+// a deep link lands after openUrl returns: metro may still be
+// transforming the route while the old screen looks settled, so the
+// screenshot gate alone captures one navigation late. wait for the
+// tree to actually change, bounded; identical screens never change
+// it, so they fall through to the screenshot gate.
+export async function settleRoute(
+  bridge: InspectBridge,
+  settleMs: number,
+): Promise<void> {
+  const dump = { describe: true, verbose: false, filter: '', compact: true, hideXy: true }
+  let before: string | null = null
+  try {
+    const snapshot = await inspectDescribe(bridge, dump)
+    if (!snapshot.tree) return
+    before = treeDigest(snapshot.tree)
+  } catch {
+    return
+  }
+  const deadline = Date.now() + Math.max(0, settleMs)
+  while (Date.now() < deadline) {
+    await sleep(SETTLE_POLL_MS)
+    try {
+      const snapshot = await inspectDescribe(bridge, dump)
+      if (snapshot.tree && treeDigest(snapshot.tree) !== before) return
+    } catch {
+      return
+    }
+  }
+}
+
+async function crawl(
+  file: string,
+  args: string[],
+  opts: { port?: number; verbose?: boolean },
+): Promise<number> {
+  const appRoot = flag(args, '--app')
+  let scheme = flag(args, '--scheme')
+  const routesRaw = flag(args, '--routes')
+  let routes: string[]
+  if (appRoot) {
+    const discovered = discoverDeepLinkRoutes(appRoot)
+    if (!scheme) scheme = discovered.scheme ?? undefined
+    if (!scheme) {
+      throw new Error(
+        `peach map crawl found no scheme in ${resolve(appRoot)}/app.json; pass --scheme myapp://`,
+      )
+    }
+    if (routesRaw) {
+      routes = routesRaw
+        .split(',')
+        .map((route) => route.trim())
+        .filter(Boolean)
+    } else {
+      if (!discovered.routerRoot) {
+        throw new Error(
+          `peach map crawl found no app/ router dir under ${resolve(appRoot)}; pass --routes /,...`,
+        )
+      }
+      if (discovered.routes.length === 0) {
+        throw new Error(
+          `peach map crawl found no static routes under ${discovered.routerRoot}; pass --routes /,...`,
+        )
+      }
+      routes = discovered.routes
+      if (discovered.gaps.length > 0) recordGaps(file, discovered.gaps)
+      console.log(`  discovered ${routes.length} routes under ${discovered.routerRoot}`)
+    }
+  } else {
+    if (!scheme || !routesRaw) {
+      throw new Error('peach map crawl needs --scheme and --routes, or --app <dir>')
+    }
+    routes = routesRaw
+      .split(',')
+      .map((route) => route.trim())
+      .filter(Boolean)
+  }
+  const base = scheme.endsWith('://') ? scheme : `${scheme}://`
+  const bridge = createBridgeFromParsed(
+    parseBridgeCliArgs([], { port: opts.port, commandTimeoutMs: 30000 }),
+  )
+  const settleRaw = Number(flag(args, '--settle-ms'))
+  const settleMs =
+    Number.isFinite(settleRaw) && settleRaw >= 0 ? settleRaw : DEFAULT_CRAWL_SETTLE_MS
+  let captured = 0
+  let previous: string | null = null
+  try {
+    for (const route of routes) {
+      const url = `${base}${route.replace(/^\//, '')}`
+      try {
+        await bridge.send({ type: 'openUrl', url })
+        await settleRoute(bridge, settleMs)
+        const code = await addScreen(
+          file,
+          previous ? ['--from', previous] : [],
+          opts,
+          'crawl',
+          { id: route, route, title: route },
+        )
+        if (code === 0) {
+          captured++
+          previous = route
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error)
+        recordGaps(file, [{ screen: route, reason: `crawl failed: ${reason}` }])
+        console.error(`  gap ${route}: ${reason}`)
+      }
+    }
+  } finally {
+    bridge.close()
+  }
+  console.log(`  crawled ${captured}/${routes.length} routes`)
+  return captured > 0 ? 0 : 1
+}
+
+function gitValue(command: string): string | undefined {
+  try {
+    return (
+      execSync(command, { stdio: ['ignore', 'pipe', 'ignore'] })
+        .toString()
+        .trim() || undefined
+    )
+  } catch {
+    return undefined
+  }
+}
+
+async function publish(file: string, args: string[]): Promise<number> {
+  const owner = flag(args, '--owner')
+  const repo = flag(args, '--repo')
+  if (!owner || !repo) throw new Error('peach map publish needs --owner and --repo')
+  const auth = resolveCliAuth()
+  if (!auth) throw new Error('peach map publish needs `peach login` or PEACH_API_KEY')
+  const origin = await resolveDefaultUploadOrigin(flag(args, '--origin'))
+  const map = readLocalMap(file)
+  if (map.screens.length === 0) throw new Error(`${file} has no screens to publish`)
+  const dir = dirname(file)
+  const body = {
+    version: 1,
+    owner,
+    repo,
+    branch:
+      flag(args, '--branch') ?? gitValue('git rev-parse --abbrev-ref HEAD') ?? 'main',
+    commitSha: flag(args, '--commit') ?? gitValue('git rev-parse HEAD') ?? null,
+    device: flag(args, '--device') ?? 'default',
+    appearance: flag(args, '--appearance') === 'dark' ? 'dark' : 'light',
+    mode: map.screens.some((screen) => screen.source === 'crawl') ? 'crawl' : 'manual',
+    screens: map.screens.map((screen) => ({
+      id: screen.id,
+      route: screen.route,
+      title: screen.title,
+      state: screen.state,
+      source: screen.source,
+      screenshotPngBase64: readFileSync(join(dir, screen.png)).toString('base64'),
+    })),
+    edges: map.edges,
+    gaps: map.gaps,
+  }
+  const res = await fetch(`${origin.replace(/\/$/, '')}/api/maps`, {
+    method: 'POST',
+    headers: {
+      authorization: authHeaderValue(auth),
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) {
+    throw new Error(`publish failed (${res.status}): ${(await res.text()).slice(0, 300)}`)
+  }
+  const url = `${origin.replace(/\/$/, '')}/org/${owner}/${repo}/map?branch=${encodeURIComponent(body.branch)}&appearance=${body.appearance}`
+  console.log(`  published ${map.screens.length} screens: ${url}`)
+  return 0
+}

package/cli/commands/runtime.ts

@@ -4,7 +4,7 @@ import fs from 'fs'
 // runtimes are versioned tarballs hosted behind the configured CDN origin
 // (default https://contrast.dev/runtimes/). each install:
 //   1. fetches manifest.json to resolve a version (or confirm the literal)
-//   2. downloads sootsim-runtime-<version>.tar.gz to an operation temp directory
+//   2. downloads sootsim-runtime-<version>.tar.zst to an operation temp directory
 //   3. verifies sha256
 //   4. extracts to ~/.peach/runtimes/<version>/
 //   5. (optionally) sets it active + tells the daemon to hot-swap

package/cli/main.ts

@@ -512,6 +512,12 @@ try {
         await exitWithFlush(typeof code === 'number' ? code : 0)
       }
 
+      case 'map': {
+        const { runMap } = await import('./commands/map')
+        const code = await runMap(commandArgsWithSim, { port, verbose })
+        await exitWithFlush(code)
+      }
+
       case 'screenshot': {
         const { runScreenshotCommand } = await import('./commands/screenshot-command')
         const code = await runScreenshotCommand(commandArgsWithSim, { port, verbose })

package/cli/outbound-endpoints.ts

@@ -421,6 +421,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
   },
   'packages/peachsim/cli/commands/preview.ts :: fetch :: `${endpoint}?id=${encodeURIComponent()}`':
     { category: 'contrast_user_action', count: 2 },
+  "packages/peachsim/cli/commands/map.ts :: fetch :: `${origin.replace(/\\/$/, '')}/api/maps`":
+    { category: 'contrast_user_action', count: 1 },
   // the live-dev-stack publisher fetches a cloudflared binary only when none
   // is installed; the token proxy below it forwards to the user's own
   // loopback dev server and sidecars, never anywhere remote.
@@ -750,6 +752,10 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'guest_app_network',
     count: 1,
   },
+  'packages/peach-engine/src/guest/host-fetch.ts :: fetch :: input': {
+    category: 'guest_app_network',
+    count: 1,
+  },
   'packages/peach-engine/src/render-worker/rive-animation-clock.ts :: fetch :: wasmUrl': {
     category: 'same_origin_runtime',
     count: 1,
@@ -1034,6 +1040,11 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'kotlin_app_library_sources',
     count: 1,
   },
+  // the idle warm of the android emoji face, fetched from the engine's own font directory.
+  'packages/peach-engine/src/engine/android-emoji-font.ts :: fetch-alias :: url': {
+    category: 'same_origin_runtime',
+    count: 1,
+  },
   'packages/peach-engine/src/engine/app-font-loader.ts :: fetch-alias :: url': {
     category: 'local_development',
     count: 1,

package/dist-lib/agent-daemon-client.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2210 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/agent-events.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2210 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/attached-projects.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2210 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/auth/shared-session.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2210 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/backend-origin.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2210 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2213 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;