peachsim 0.1.1620 → 0.1.1625

package/src/swift-distribution.lock.json

@@ -1,11 +1,34 @@
 {
-  "id": "64fd4ea71bc39e4f",
+  "id": "1fda1fb984f25758",
   "release": "swift-6.4.0-RELEASE",
-  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-dc9c8c67",
-  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-dc9c8c67.artifactbundle.tar.gz",
-  "wasmSdkChecksum": "5d38f795f516ccfef3d7ac869b447cdedcd82a35af9761a65b9f88924eb6a89a",
-  "source": "77fbca997182e53ceb1944e27d8689f469f632c5",
+  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-34b989c2",
+  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-34b989c2.artifactbundle.tar.gz",
+  "wasmSdkChecksum": "1598ac9d063e07b20aa6232acb03c7147c9a94abf989d51f1e55688eb4aba854",
+  "source": "078b4f63d3734871dc1fbea898005e2ef95a73cb",
   "targets": [
+    "System",
+    "_LocationEssentials",
+    "GeoToolbox",
+    "DataDetection",
+    "Accessibility",
+    "Contacts",
+    "CoreML",
+    "EventKit",
+    "CloudKit",
+    "IOSurface",
+    "OpenGLES",
+    "ContactsUI",
+    "CoreLocationUI",
+    "MediaPlayer",
+    "MusicKit",
+    "RealityKit",
+    "SecureElementCredential",
+    "Social",
+    "Speech",
+    "Vision",
+    "VisionKit",
+    "WorkoutKit",
+    "_PassKit_SwiftUI",
     "ExpoModulesCore",
     "_MapKit_SwiftUI",
     "PeachJSON",
@@ -21,6 +44,7 @@
     "PeachObjC",
     "UIKitCore",
     "PeachICU",
+    "PeachCMark",
     "CoreImage",
     "QuartzCore",
     "CoreGraphics",
@@ -51,6 +75,7 @@
     "ActivityKit",
     "SwiftData",
     "UIKit",
+    "React",
     "Combine",
     "PeachFoundationCombine",
     "AppIntents",
@@ -132,6 +157,7 @@
     "systemVersion": ["string"],
     "colorScheme": ["string:light", "string:dark"],
     "semanticColors": ["object"],
+    "imageAssets": ["object"],
     "locale": ["string"],
     "dynamicTypeSize": [
       "string:xSmall",
@@ -153,16 +179,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "6b60bae2bc91957af3baee5e9cad44200f15ff3840d8e70afa5ddc63413d880f",
-      "size": 58565898
+      "sha256": "6a3b956b13bcc76dbf0b55533088251e2ae29badcd5c8d66394a2459e0942a32",
+      "size": 63180761
     },
     "linux-x64": {
-      "sha256": "d97e287ca5d7ea0d00dfc9db60be746aec35a9b7412299461ce0d5e77f38b7a8",
-      "size": 58569694
+      "sha256": "37f26adff0a90c0647065b3c2e70bfdae05c84832b27add00915d441f2f79359",
+      "size": 63183751
     },
     "linux-arm64": {
-      "sha256": "495fe6adc7cf1c8ec9fc8de3410c976e65a7ff051ca50ee3f6d0d3fee8aa2c5d",
-      "size": 58567328
+      "sha256": "e329424d19ede87f4c9257de40f88220cdaff42bd82f1ab47616394ec7f32f35",
+      "size": 63181548
     }
   }
 }

package/src/swift-distribution.ts

@@ -27,13 +27,23 @@ export interface SwiftModule {
   toolchainBin: string
 }
 
-const installs = new Map<string, Promise<string>>()
+const installs = new Map<
+  string,
+  {
+    promise: Promise<string>
+    controller: AbortController
+    clients: number
+  }
+>()
 
 /** the installed distribution's root, downloading it on first use, or null
  *  when PEACH_SWIFT_ENDPOINT is unset. */
-export function swiftDistributionRoot(): Promise<string | null> {
+export async function swiftDistributionRoot(
+  signal?: AbortSignal,
+): Promise<string | null> {
+  signal?.throwIfAborted()
   const endpoint = process.env[SWIFT_ENDPOINT_ENV]?.trim().replace(/\/+$/, '')
-  if (!endpoint) return Promise.resolve(null)
+  if (!endpoint) return null
   const lock = parseSwiftDistributionLock(lockJson)
   const host = swiftDistributionHost(process.platform, process.arch)
   if (!host) {
@@ -46,13 +56,16 @@ export function swiftDistributionRoot(): Promise<string | null> {
   swiftToolchain(lock.release, lock)
   const dir = path.join(rnxHomeDir(), 'swift', `${lock.id}-${host}`)
   let pending = installs.get(dir)
+  if (pending?.controller.signal.aborted) pending = undefined
   if (!pending) {
-    pending = (async () => {
+    const controller = new AbortController()
+    const promise = (async () => {
       if (!fs.existsSync(path.join(dir, SWIFT_DISTRIBUTION_MANIFEST))) {
         process.stderr.write(
           `peach: downloading Swift distribution ${lock.id} (${host})…\n`,
         )
         await installVerifiedTarball({
+          signal: controller.signal,
           url: `${endpoint}/${swiftDistributionKey(lock.id, host)}`,
           digest: {
             algorithm: 'sha256',
@@ -69,11 +82,48 @@ export function swiftDistributionRoot(): Promise<string | null> {
         throw new Error(`${dir} does not hold Swift distribution ${lock.id} (${host})`)
       }
       return dir
-    })()
-    pending.catch(() => installs.delete(dir))
+    })().finally(() => {
+      if (installs.get(dir)?.controller === controller) installs.delete(dir)
+    })
+    pending = { promise, controller, clients: 0 }
     installs.set(dir, pending)
   }
-  return pending
+  const current = pending
+  current.clients++
+  let released = false
+  const release = () => {
+    if (released) return
+    released = true
+    if (--current.clients === 0) current.controller.abort(signal?.reason)
+  }
+  let abort: (() => void) | undefined
+  try {
+    const root = await new Promise<string>((resolve, reject) => {
+      abort = () => {
+        release()
+        const reason: unknown = signal?.reason
+        const error =
+          reason instanceof Error
+            ? reason
+            : new Error('Swift distribution installation canceled', { cause: reason })
+        // other callers retain ownership; the last caller waits for cleanup.
+        if (current.clients > 0) reject(error)
+        else
+          current.promise.then(
+            () => reject(error),
+            () => reject(error),
+          )
+      }
+      signal?.addEventListener('abort', abort, { once: true })
+      current.promise.then(resolve, reject)
+      if (signal?.aborted) abort()
+    })
+    signal?.throwIfAborted()
+    return root
+  } finally {
+    if (abort) signal?.removeEventListener('abort', abort)
+    release()
+  }
 }
 
 /** the module this process compiles app Swift against: the checkout beside a
@@ -81,7 +131,9 @@ export function swiftDistributionRoot(): Promise<string | null> {
  *  nothing without it, so a checkout's toolchain error surfaces to them. */
 export async function resolveSwiftModule({
   required = false,
-}: { required?: boolean } = {}): Promise<SwiftModule | null> {
+  signal,
+}: { required?: boolean; signal?: AbortSignal } = {}): Promise<SwiftModule | null> {
+  signal?.throwIfAborted()
   const checkout = path.resolve(import.meta.dirname, '../../sootsim-swift')
   if (fs.existsSync(path.join(checkout, 'toolchain.json'))) {
     // a checkout is implicit: without its toolchain, apps run without their
@@ -93,7 +145,7 @@ export async function resolveSwiftModule({
       return null
     }
   }
-  const root = await swiftDistributionRoot()
+  const root = await swiftDistributionRoot(signal)
   return root ? { root, ...swiftModuleToolchain(root) } : null
 }
 

package/src/swift-host.ts

@@ -51,6 +51,7 @@ import {
   standinGenerationInputs,
   standinLibrary,
   swiftStandins,
+  SWIFT_STANDINS_DIR,
   type SwiftStandin,
 } from './swift-standins'
 import {
@@ -172,13 +173,18 @@ export interface SwiftProject {
   packagePath: string
   artifact: SwiftArtifact | null
   // the build in flight and the sources it was started from
-  building: { stamp: string; promise: Promise<SwiftArtifact> } | null
+  building: {
+    stamp: string
+    promise: Promise<SwiftArtifact>
+    signal?: AbortSignal
+  } | null
   // two bounded generations of immutable bytes cover in-flight asset reads.
   resourceFiles: Map<string, { bytes: Buffer; contentType: string }>
   resourcesPrevious: Map<string, { bytes: Buffer; contentType: string }>
   artifacts: SwiftArtifact[]
   hosted?: SwiftHostedCompileOptions
   signal?: AbortSignal
+  libraries?: Record<string, string>
 }
 
 // a project is its swiftpm package: the build, the artifact, and the dev
@@ -402,9 +408,6 @@ const XCODE_FRAMEWORKS_DIR = '__frameworks__'
 // remote package checkouts compile here: swiftpm owns `.build` in the
 // compile's package root as its scratch directory.
 const XCODE_PACKAGES_DIR = '__packages__'
-// each binary target's stand-in compiles as a target under its module's
-// directory here, from sources generated on this host.
-const XCODE_STANDINS_DIR = '__standins__'
 const CHECKOUTS_PREFIX = `${REMOTE_CHECKOUTS.split(path.sep).join(path.posix.sep)}/`
 
 // the compile input key of a root-relative path in an xcode layout.
@@ -485,7 +488,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
   for (const standin of standins)
     targets.push({
       name: standin.module,
-      path: path.posix.join(XCODE_STANDINS_DIR, standin.module),
+      path: path.posix.join(SWIFT_STANDINS_DIR, standin.module),
       executable: false,
       resources: false,
       exclude: [],
@@ -1033,6 +1036,8 @@ export function sourceStamp(
   const hash = createHash('sha256')
   hash.update(packagePath)
   hash.update(JSON.stringify(xcodeProjects.get(packagePath)?.behavior ?? {}))
+  const libraries = projects.get(packagePath)?.libraries
+  if (libraries) hash.update(JSON.stringify(libraries))
   const projectInputs = new Set(packageFiles(packagePath))
   for (const file of [...projectInputs].sort()) {
     hash.update(path.relative(packagePath, file))
@@ -1092,15 +1097,19 @@ export function icuUrl(origin: string, artifact: SwiftArtifact): string {
 // keyed by the stand-in target it links into; its own source then defines
 // nothing, so the library's functions run instead of the traps. one library
 // links once, through the first module its framework ships.
-function standinLibraries(layout: XcodeLayout): Map<string, SwiftStandin[]> {
+export function standinLibraries(
+  binaries: readonly SwiftPackageBinary[],
+  standins: readonly SwiftStandin[],
+  rootDir: string,
+): Map<string, SwiftStandin[]> {
   const linked = new Map<string, SwiftStandin[]>()
-  for (const binary of layout.binaries) {
-    const modules = layout.standins.filter(
+  for (const binary of binaries) {
+    const modules = standins.filter(
       (standin) =>
         standin.target === binary.target && `${standin.module}.c` in standin.files,
     )
     if (modules.length === 0) continue
-    const library = standinLibrary(binary, layout.app.rootDir)
+    const library = standinLibrary(binary, rootDir)
     if (!library) continue
     linked.set(library, modules)
   }
@@ -1131,7 +1140,7 @@ function packageSources(
     files['Package.swift'] = xcodeManifest(xcode)
     for (const standin of xcode.standins)
       for (const [file, text] of Object.entries(standin.files))
-        files[path.posix.join(XCODE_STANDINS_DIR, standin.module, file)] =
+        files[path.posix.join(SWIFT_STANDINS_DIR, standin.module, file)] =
           linked.has(standin) && file === `${standin.module}.c`
             ? `// ${standin.target}'s WebAssembly library defines ${standin.module}'s functions.\n`
             : text
@@ -1152,7 +1161,9 @@ interface SwiftPackageSnapshot {
 
 function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnapshot {
   const layout = xcodeLayout(project.packagePath)
-  const linked = layout ? standinLibraries(layout) : new Map<string, SwiftStandin[]>()
+  const linked = layout
+    ? standinLibraries(layout.binaries, layout.standins, layout.app.rootDir)
+    : new Map<string, SwiftStandin[]>()
   const files = packageSources(project.packagePath, new Set([...linked.values()].flat()))
   const native = nativeSourceDescriptor(project.packagePath)
   return {
@@ -1178,14 +1189,17 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
       files,
     ),
     native,
-    ...(linked.size > 0
+    ...(linked.size > 0 || project.libraries
       ? {
-          libraries: Object.fromEntries(
-            [...linked].map(([library, [first]]) => [
-              first!.module,
-              fs.readFileSync(library).toString('base64'),
-            ]),
-          ),
+          libraries: {
+            ...project.libraries,
+            ...Object.fromEntries(
+              [...linked].map(([library, [first]]) => [
+                first!.module,
+                fs.readFileSync(library).toString('base64'),
+              ]),
+            ),
+          },
         }
       : {}),
     ...(native
@@ -1252,7 +1266,7 @@ async function compile(
     linkedModuleRoots(packagePath).find((root) =>
       fs.existsSync(path.join(root, 'toolchain.json')),
     ) ??
-    (await swiftDistributionRoot())
+    (await swiftDistributionRoot(signal))
   if (!moduleRoot)
     return {
       ...(await compileRemote(packagePath, snapshot, undefined, signal)),
@@ -1559,8 +1573,11 @@ export function artifactFor(
   project: SwiftProject,
   entry: string,
   moduleRoot?: string,
+  signal: AbortSignal | undefined = project.signal,
 ): Promise<SwiftArtifact> {
-  project.signal?.throwIfAborted()
+  if (project.signal && signal !== project.signal)
+    signal = signal ? AbortSignal.any([project.signal, signal]) : project.signal
+  signal?.throwIfAborted()
   const stamp = sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted))
   if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact)
   if (project.building) {
@@ -1569,13 +1586,27 @@ export function artifactFor(
     // and ask again, which starts the build these sources need; joining it
     // would emit the older artifact and nothing would trigger another load.
     const running = project.building
-    if (running.stamp === stamp) return running.promise
-    const again = () => artifactFor(project, entry, moduleRoot)
-    return running.promise.then(again, again)
+    if (running.stamp === stamp && running.signal === signal) return running.promise
+    const again = () => artifactFor(project, entry, moduleRoot, signal)
+    const queued = running.promise.then(again, again)
+    if (!signal) return queued
+    return new Promise<SwiftArtifact>((resolve, reject) => {
+      const stop = () =>
+        reject(
+          signal.reason instanceof Error
+            ? signal.reason
+            : new Error('Swift compilation canceled', { cause: signal.reason }),
+        )
+      signal.addEventListener('abort', stop, { once: true })
+      if (signal.aborted) stop()
+      queued
+        .then(resolve, reject)
+        .finally(() => signal.removeEventListener('abort', stop))
+    })
   }
   const snapshot = packageSnapshot(project, entry)
   if (sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) !== stamp) {
-    return artifactFor(project, entry, moduleRoot)
+    return artifactFor(project, entry, moduleRoot, signal)
   }
   // a save that changed only view builder literals keeps the running bytes
   const compiled = project.artifact?.compiled
@@ -1600,7 +1631,7 @@ export function artifactFor(
     moduleRoot,
     project.hosted,
     snapshot,
-    project.signal,
+    signal,
   ).then(
     (artifact) => {
       project.artifact = artifact
@@ -1620,9 +1651,9 @@ export function artifactFor(
     sourceStamp(project.packagePath, moduleRoot, Boolean(project.hosted)) ===
     artifact.stamp
       ? artifact
-      : artifactFor(project, entry, moduleRoot),
+      : artifactFor(project, entry, moduleRoot, signal),
   )
-  project.building = { stamp, promise: fresh }
+  project.building = { stamp, promise: fresh, signal }
   return fresh
 }
 

package/src/swift-objc-standin.ts

@@ -174,6 +174,19 @@ export function objcView(
     const slash = include.indexOf('/')
     if (slash > 0 && /^[A-Z]/.test(include)) {
       const name = include.slice(0, slash)
+      const umbrella = `${name}/${name}.h`
+      if (
+        Object.hasOwn(
+          IOS_SDK_HEADERS,
+          `System/Library/Frameworks/${name}.framework/Headers/${name}.h`,
+        )
+      ) {
+        // retain the sdk module's owner when a vendor imports a leaf header.
+        const header = path.join(stubIncludes, include)
+        fs.mkdirSync(path.dirname(header), { recursive: true })
+        fs.writeFileSync(header, `#import <${umbrella}>\n`)
+        return true
+      }
       const root = path.join(stubs, `${name}.framework`)
       const header = path.join(root, 'Headers', include.slice(slash + 1))
       fs.mkdirSync(path.dirname(header), { recursive: true })

package/src/swift-standin-emit.ts

@@ -87,7 +87,7 @@ export type StandinResult = {
 }
 
 /** bump when emitted source changes: the stand-in cache keys on it. */
-export const STANDIN_EMIT_VERSION = '6'
+export const STANDIN_EMIT_VERSION = '7'
 
 /** the modules every stand-in source imports. */
 export const STANDIN_IMPORTS = ['Foundation', 'UIKit']

package/src/swift-standins.ts

@@ -38,6 +38,8 @@ import type { SwiftPackageBinary } from './swift-packages'
 const TRIPLE = 'wasm32-unknown-wasip1'
 // builder workspaces share this persistent cache; temporary directories hold only work.
 const cacheDir = path.join(os.homedir(), 'builders/cache/peach-swift-standins')
+// each binary stand-in is a target under its module's directory here.
+export const SWIFT_STANDINS_DIR = '__standins__'
 
 export interface SwiftStandin {
   /** the module it stands in for, which names its compile target. */
@@ -993,7 +995,7 @@ function sourceBinaryStandins(
         release: toolchain.release,
       }),
     )
-    execFileSync(
+    const build = spawnSync(
       'bun',
       [
         path.join(repo, 'scripts/build/swift-standins-submit.ts'),
@@ -1004,11 +1006,20 @@ function sourceBinaryStandins(
         '--delivery-dir',
         delivery,
       ],
-      { cwd: repo, stdio: 'inherit' },
-    )
-    const receipt: unknown = JSON.parse(
-      fs.readFileSync(path.join(delivery, 'standins.json'), 'utf8'),
+      { cwd: repo, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 },
     )
+    if (build.stdout) process.stdout.write(build.stdout)
+    if (build.stderr) process.stderr.write(build.stderr)
+    if (build.error || build.status !== 0)
+      throw new Error(
+        `source stand-in build for ${binary.target} failed (${build.error?.message ?? build.signal ?? `exit ${build.status}`}): ${build.stderr?.trim().slice(-4000) || build.stdout?.trim().slice(-4000) || 'builder returned no diagnostic'}`,
+      )
+    const output = path.join(delivery, 'standins.json')
+    if (!fs.existsSync(output))
+      throw new Error(
+        `source stand-in builder returned no standins.json for ${binary.target}`,
+      )
+    const receipt: unknown = JSON.parse(fs.readFileSync(output, 'utf8'))
     if (
       !receipt ||
       typeof receipt !== 'object' ||
@@ -1174,6 +1185,7 @@ function binaryStandins(
   try {
     result =
       process.platform === 'darwin' &&
+      process.env.TM_EXEC_BUILD_PLATFORM !== 'mac' &&
       process.env.TM_SESSION &&
       process.env.CI !== 'true' &&
       toolchain.moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&

package/src/vite-plugin.ts

@@ -17,6 +17,7 @@ import { fileURLToPath, pathToFileURL } from 'url'
 import { parseSync } from 'oxc-parser'
 import { minifySync, transformSync } from 'rolldown/utils'
 import { type Plugin, transformWithOxc } from 'vite'
+import { resolveOneNativeBackend } from '../../contrast-bundler/src/oneFramework.ts'
 import { transformFlowSource } from '../../peach-compat/src/flow-strip.ts'
 import { renderWorkerSystemChunk } from './worker-system-chunks.ts'
 
@@ -34,7 +35,7 @@ import {
 import { resolveExportsHiddenSubpath } from '../../peach-compat/src/resolve-hidden-subpath.ts'
 import {
   SOOTSIM_COMPAT_PUBLISHED_BROWSER_ENTRIES,
-  SOOTSIM_COMPAT_WRAPPER_REAL_PACKAGES,
+  PEACH_UPSTREAM_MODULES,
   SOOTSIM_HAPTIC_FEEDBACK_TOUCHABLE_SOURCE,
   SOOTSIM_HAPTIC_FEEDBACK_TOUCHABLE_SPECIFIER,
   compatStubsForBuildResolver,
@@ -291,9 +292,7 @@ const compatWrapperRealPackageAliases: Array<{
   find: string
   replacement: string
 }> = []
-for (const { specifier, packageName } of Object.values(
-  SOOTSIM_COMPAT_WRAPPER_REAL_PACKAGES,
-)) {
+for (const { specifier, packageName } of Object.values(PEACH_UPSTREAM_MODULES)) {
   let replacement = resolveExportsHiddenSubpath(packageName, (specifier) =>
     sootsimPluginRequire.resolve(specifier),
   )
@@ -366,7 +365,6 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
   }
 
   return [
-    wsBridgePlugin(),
     reactBridgePlugin(),
     {
       name: 'sootsim-published-browser-internals',
@@ -1319,9 +1317,9 @@ declare global {
 // across the overlap so every connected sim stays on the same websocket.
 const viteBridgeProcesses = (globalThis.__sootsimViteBridgeProcesses ??= new Map())
 
-// start WS bridge server for debug CLI connectivity. exported so shell
-// vite can install it standalone (engine builds via `vite build --watch`,
-// which doesn't fire configureServer — the bridge has to run on shell).
+// start WS bridge server for debug CLI connectivity. the shell vite server
+// installs it explicitly and owns the one shared bridge; sootsim() never
+// does, so an isolated dev server cannot bind the shared default port.
 export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plugin {
   if (
     options.ownedBridgePort !== undefined &&
@@ -1726,17 +1724,6 @@ function sootsimConfigPlugin(
                 'react-native/src/private/featureflags/ReactNativeFeatureFlags.js',
               ),
             },
-            ...[
-              'BatchedBridge/BatchedBridge',
-              'Components/View/ReactNativeStyleAttributes',
-              'StyleSheet/processColor',
-            ].map((module) => ({
-              find: `@peach-internal/react-native/${module}`,
-              replacement: path.resolve(
-                workspaceNodeModules,
-                `react-native/Libraries/${module}.js`,
-              ),
-            })),
             ...Object.entries(rnLibraryStubs).map(([find, replacement]) => ({
               find: new RegExp(
                 `^${find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.[cm]?[jt]sx?)?$`,
@@ -2227,6 +2214,8 @@ function metroNativeResolve(isAppSource: (p: string) => boolean): Plugin {
       filter: { id: /^\./ },
       handler(source, importer) {
         if (!importer) return null
+        const oneBackend = resolveOneNativeBackend(source, importer)
+        if (oneBackend) return oneBackend
         if (!importer.includes('node_modules') && !isAppSource(importer)) return null
         if (platformExts.some((ext) => source.endsWith(ext))) return null
 

package/src/worklet-executable.ts

@@ -92,7 +92,7 @@ interface Scope {
 
 type Binding =
   | { kind: 'value'; init: SyntaxNode; scope: Scope }
-  // `key` is set when the parameter is a destructured property of that argument.
+  // `key` is set when the parameter is a destructured member of that argument.
   | { kind: 'param'; fn: SyntaxNode; index: number; key?: string }
   | { kind: 'opaque' }
 
@@ -147,7 +147,7 @@ function lookup(scope: Scope, name: string): Binding | undefined {
   return undefined
 }
 
-// a destructured parameter binds each plain property to that key of its argument.
+// a destructured parameter binds each plain member to that key of its argument.
 // rest elements, defaults and nested patterns stay opaque.
 function declareParam(inner: Scope, fn: SyntaxNode, index: number, param: unknown): void {
   const name = identifierName(param)
@@ -155,6 +155,17 @@ function declareParam(inner: Scope, fn: SyntaxNode, index: number, param: unknow
     declare(inner, name, { kind: 'param', fn, index })
     return
   }
+  if (isNode(param) && param.type === 'ArrayPattern') {
+    const elements: unknown = Reflect.get(param, 'elements')
+    if (!Array.isArray(elements)) return
+    elements.forEach((element: unknown, position) => {
+      const name = identifierName(element)
+      if (name !== undefined)
+        declare(inner, name, { kind: 'param', fn, index, key: String(position) })
+      else declareOpaque(inner, patternNames(element))
+    })
+    return
+  }
   if (!isNode(param) || param.type !== 'ObjectPattern') {
     declareOpaque(inner, patternNames(param))
     return
@@ -334,6 +345,21 @@ function immediateArgument(
 // the value a literal holds under a static name. the last duplicate wins, as it
 // does at run time. a spread makes the literal's keys unknown.
 function propertyValue(object: SyntaxNode, name: string): SyntaxNode | undefined {
+  if (object.type === 'ArrayExpression') {
+    const index = Number(name)
+    const elements: unknown = Reflect.get(object, 'elements')
+    if (!Number.isSafeInteger(index) || index < 0 || String(index) !== name)
+      return undefined
+    if (!Array.isArray(elements)) return undefined
+    if (
+      elements
+        .slice(0, index + 1)
+        .some((element: unknown) => isNode(element) && element.type === 'SpreadElement')
+    )
+      return undefined
+    const value: unknown = elements[index]
+    return isNode(value) ? value : undefined
+  }
   let value: SyntaxNode | undefined
   for (const property of childNodes(Reflect.get(object, 'properties'))) {
     if (property.type === 'SpreadElement') return undefined
@@ -373,7 +399,8 @@ function resolveObject(
   depth: number,
 ): ResolvedObject | undefined {
   if (depth > MAX_RESOLUTION_DEPTH) return undefined
-  if (expression.type === 'ObjectExpression') return { object: expression, scope }
+  if (expression.type === 'ObjectExpression' || expression.type === 'ArrayExpression')
+    return { object: expression, scope }
   if (expression.type === 'SequenceExpression') {
     const last = childNodes(Reflect.get(expression, 'expressions')).at(-1)
     return last && resolveObject(last, scope, collection, depth + 1)