peachsim 0.1.2209 → 0.1.2213

package/src/swift-objc-compile.ts

@@ -432,7 +432,7 @@ function* xcodeObjCInputSteps(
     if (
       !binary.reached ||
       binary.publicHeaders === undefined ||
-      binary.assemblySources !== undefined
+      binary.unloweredSources !== undefined
     )
       continue
     const manifest = swiftPackageManifest(binary.dir)

package/src/swift-objc-import.ts

@@ -24,12 +24,42 @@ export function swiftClangImporterFlags(flags: readonly string[]): string[] {
   )
 }
 
+// swift names a header's submodule as `import Module.Header`, which xcode
+// infers for every header of a framework. a header an app source imports that
+// way becomes its own submodule, visible with the module; the rest stay in it.
+const SWIFT_SUBMODULE_IMPORT =
+  /^[ \t]*(?:@\w+(?:\([^)]*\))?[ \t]+)*import[ \t]+([A-Za-z_]\w*)\.([A-Za-z_]\w*)[ \t]*(?:\/\/.*)?$/gm
+
+export function swiftSubmoduleImports(
+  sources: Iterable<string>,
+): Map<string, Set<string>> {
+  const imports = new Map<string, Set<string>>()
+  for (const source of sources)
+    for (const [, module, submodule] of source.matchAll(SWIFT_SUBMODULE_IMPORT)) {
+      const names = imports.get(module!) ?? new Set<string>()
+      names.add(submodule!)
+      imports.set(module!, names)
+    }
+  return imports
+}
+
 // swiftpm synthesizes a module map for public headers when the package provides
 // none. original xcode and package module maps retain their own contents.
-export function swiftObjCModuleMap(module: string, headers: readonly string[]): string {
+export function swiftObjCModuleMap(
+  module: string,
+  headers: readonly string[],
+  submodules: ReadonlySet<string> = new Set(),
+): string {
+  const header = (file: string) => `header ${JSON.stringify(file)}`
+  const stem = (file: string) =>
+    file.slice(file.lastIndexOf('/') + 1).replace(/\.[^.]*$/, '')
   return [
     `module ${module} {`,
-    ...headers.map((header) => `  header ${JSON.stringify(header)}`),
+    ...headers.map((file) =>
+      submodules.has(stem(file))
+        ? `  module ${stem(file)} { ${header(file)} export * }`
+        : `  ${header(file)}`,
+    ),
     '  export *',
     '}',
     '',

package/src/swift-objc-standin.ts

@@ -348,7 +348,7 @@ export function iosDeploymentMinimum(version: string | null): number | undefined
 const headerFiles = (dir: string): string[] =>
   fs
     .readdirSync(dir, { recursive: true, encoding: 'utf8' })
-    .filter((file) => file.endsWith('.h'))
+    .filter((file) => file.endsWith('.h') || file.endsWith('.hh'))
     .sort()
 
 /**

package/src/swift-packages.ts

@@ -19,6 +19,7 @@ import { cacheDir } from './home-paths'
 import { requireNativeGit } from './native-git'
 import { tryAcquireNumberedLock } from './numbered-lock'
 import { preparedSwiftCheckouts, preparedSwiftPin } from './prepared-xcode-phases'
+import { swiftCTakesReturnAddress } from './swift-compile'
 import {
   isSwiftNativeTranslationUnit,
   swiftImplicitResourcePaths,
@@ -36,6 +37,7 @@ import {
   type SwiftManifestTarget,
   type SwiftPackageManifest,
 } from './swift-package-manifest'
+import { shippedBinaryDiffers } from './swift-shipped-binaries'
 import type { SwiftSourceLinkGraph } from './swiftContract'
 
 // which machine a package target is built for
@@ -114,9 +116,9 @@ export interface SwiftPackageBinary {
   reached: boolean
   /** a source Objective-C target: public headers relative to dir. */
   publicHeaders?: string
-  /** assembly sources, relative to the package, that keep a source target from
-   *  compiling; its public headers stand in for it. */
-  assemblySources?: string[]
+  /** sources, relative to the package, with no wasm32 lowering that keep a
+   *  source target from compiling; its public headers stand in for it. */
+  unloweredSources?: string[]
   /** dependency module public headers, relative to dir. */
   headerDependencies?: { module: string; path: string }[]
   /** xcode modules whose linked package products reach this clang target. */
@@ -159,29 +161,42 @@ export function remoteSwiftCheckouts(root: string): string {
 // assembly requires its own target lowering; objective-c keeps its original bodies.
 const UNSUPPORTED_NATIVE = /\.(s|S)$/
 
-// a clang source target whose sources include assembly cannot lower to wasm,
-// unless upstream declares wasi-conditioned c settings for it: that is the
-// package's own supported portable path (boringssl's guarded assembly with
-// OPENSSL_NO_ASM), which compiles with those flags exactly as swiftpm builds
-// it. without that signal the target keeps the refusal below. when a refused
-// target also ships public headers, those headers stand in for it and every
-// declaration they spell traps by name. this is the assembly rule above,
-// widened only where the target has a header surface to stand in from.
-function assemblySources(
+// a clang source target whose sources include assembly, or take their own
+// return address, cannot lower to wasm, unless upstream declares
+// wasi-conditioned c settings for it: that is the package's own supported
+// portable path (boringssl's guarded assembly with OPENSSL_NO_ASM), which
+// compiles with those flags exactly as swiftpm builds it. without that signal
+// the target keeps the refusal below. when a refused target also ships public
+// headers, those headers stand in for it and every declaration they spell
+// traps by name. this is the assembly rule above, widened only where the
+// target has a header surface to stand in from.
+function unlowerableSources(
+  files: readonly string[],
+  target: SwiftManifestTarget,
+): string[] {
+  if (target.declaresWasiNativeSettings) return []
+  return [
+    ...files.filter((file) => UNSUPPORTED_NATIVE.test(file)),
+    ...files
+      .filter(isSwiftNativeTranslationUnit)
+      .filter((file) => swiftCTakesReturnAddress(fs.readFileSync(file, 'utf8'))),
+  ]
+}
+
+function unloweredSources(
   files: readonly string[],
   target: SwiftManifestTarget,
 ): string[] | null {
   if (target.type !== 'regular') return null
-  if (target.declaresWasiNativeSettings) return null
-  const assembly = files.filter((file) => UNSUPPORTED_NATIVE.test(file))
-  if (assembly.length === 0) return null
   if (!files.some(isSwiftNativeTranslationUnit)) return null
+  const unlowered = unlowerableSources(files, target)
+  if (unlowered.length === 0) return null
   const headers = path.resolve(target.dir, target.publicHeadersPath)
   if (
     !files.some((file) => file.startsWith(`${headers}${path.sep}`) && file.endsWith('.h'))
   )
     return null
-  return assembly
+  return unlowered
 }
 
 const BINARY = 'is a binary framework'
@@ -514,6 +529,8 @@ export function resolveSwiftPackages(options: {
   /** local package directories the workspace or a project references. */
   localDirs: readonly string[]
   provided: ReadonlySet<string> | null
+  /** binary targets whose stand-in is built; one pinning another archive than peach's shipped module compiles through it. */
+  standinTargets?: ReadonlySet<string>
   /** why a binary target has no stand-in, added to its reason. */
   binaryGaps?: ReadonlyMap<string, string>
   /**
@@ -657,9 +674,7 @@ export function resolveSwiftPackages(options: {
           ? swiftTargetFiles(pkg.manifest, target)
           : []
       const gap = options.binaryGaps?.get(name)
-      const assembly = target.declaresWasiNativeSettings
-        ? []
-        : files.filter((file) => UNSUPPORTED_NATIVE.test(file))
+      const unlowerable = unlowerableSources(files, target)
       const placeholder = placeholderPackage(pkg)
       const ownReason =
         target.type === 'binary'
@@ -668,8 +683,8 @@ export function resolveSwiftPackages(options: {
             ? `${name} stands in as a placeholder (${placeholder}), and ${gap}`
             : target.type !== 'regular' && target.type !== 'system'
               ? `${name} is a ${target.type} target`
-              : assembly.length > 0
-                ? `${name} is an assembly target with no wasm32 lowering: ${assembly.map((file) => path.relative(pkg.manifest.dir, file)).join(', ')}${gap ? `; ${gap}` : ''}`
+              : unlowerable.length > 0
+                ? `${name} has native sources with no wasm32 lowering: ${unlowerable.map((file) => path.relative(pkg.manifest.dir, file)).join(', ')}${gap ? `; ${gap}` : ''}`
                 : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report
@@ -778,9 +793,8 @@ export function resolveSwiftPackages(options: {
       )
     )
       return false
-    // an assembly target stands in from its public headers, so a stand-in
-    // peach built for it stays provided instead of compiling its sources
-    if (providedTargets.has(name) && assemblySources(files, target)) return false
+    // a target whose headers stand in for its unlowered sources stays with the stand-in
+    if (unloweredSources(files, target)) return false
     claimed.add(key)
     providedTargets.delete(name)
     for (const dependency of target.dependencies) {
@@ -794,6 +808,17 @@ export function resolveSwiftPackages(options: {
   }
   const claimProduct = (pkg: LoadedPackage, product: string): void => {
     const roots = pkg.manifest.products.get(product)?.targets ?? []
+    for (const root of roots) {
+      const target = pkg.manifest.targets.get(root)
+      if (
+        target?.type === 'binary' &&
+        !options.standinTargets?.has(root) &&
+        shippedBinaryDiffers(root, target.checksum)
+      ) {
+        providedTargets.delete(root)
+        providedProducts.delete(product)
+      }
+    }
     if (roots.map((name) => claimTarget(pkg, name)).some(Boolean))
       providedProducts.delete(product)
   }
@@ -840,7 +865,7 @@ export function resolveSwiftPackages(options: {
           : []
       const objc =
         target.type === 'regular' && files.some((file) => /\.(m|mm)$/.test(file))
-      const assembly = assemblySources(files, target)
+      const unlowered = unloweredSources(files, target)
       const gap = placeholderPackage(pkg)
       const sources = files.filter((file) => file.endsWith('.swift'))
       // swiftpm's release settings, as xcode builds a package for any
@@ -873,7 +898,7 @@ export function resolveSwiftPackages(options: {
             ],
           },
         })
-      else if (target.type === 'binary' || objc || assembly)
+      else if (target.type === 'binary' || objc || unlowered)
         result.binaries.push({
           target: name,
           source: pkg.source,
@@ -889,9 +914,9 @@ export function resolveSwiftPackages(options: {
                   path.join(target.dir, target.publicHeadersPath),
                 ),
               }),
-          ...(assembly
+          ...(unlowered
             ? {
-                assemblySources: assembly.map((file) =>
+                unloweredSources: unlowered.map((file) =>
                   path.relative(pkg.manifest.dir, file),
                 ),
               }

package/src/swift-pdf-raster.ts

@@ -46,9 +46,9 @@ CGImageDestinationAddImage(dest, image, nil)
 guard CGImageDestinationFinalize(dest) else { exit(7) }
 `
 
-function rasterBinary(): string {
-  const tag = createHash('sha256').update(RASTER_SWIFT).digest('hex').slice(0, 16)
-  const binary = path.join(cacheDir(), `swift-pdf-raster-${tag}`)
+function rasterBinary(swift = RASTER_SWIFT, name = 'swift-pdf-raster'): string {
+  const tag = createHash('sha256').update(swift).digest('hex').slice(0, 16)
+  const binary = path.join(cacheDir(), `${name}-${tag}`)
   try {
     fs.accessSync(binary, fs.constants.X_OK)
     return binary
@@ -61,7 +61,7 @@ function rasterBinary(): string {
       fs.mkdtempSync(path.join(os.tmpdir(), 'swift-pdf-raster-')),
       'raster.swift',
     )
-    fs.writeFileSync(source, RASTER_SWIFT)
+    fs.writeFileSync(source, swift)
     try {
       // runner-toolchain-platform: darwin
       execFileSync('xcrun', ['swiftc', '-o', binary, source], { stdio: 'pipe' })
@@ -135,3 +135,59 @@ export function rasterizePdfFile(diskPath: string, pdfSha256: string): { bytes:
     fs.rmSync(path.dirname(out), { recursive: true, force: true })
   }
 }
+
+// actool compiles an svg imageset to a vector rendition. the engine decodes
+// rasters only, so an svg imageset travels as its 3x png like a pdf one.
+// AppKit draws svg on macOS; other hosts have no svg renderer here and keep
+// serving the file as it is.
+const RASTER_SVG_SWIFT = `import AppKit
+guard CommandLine.arguments.count == 4 else { exit(1) }
+let input = URL(fileURLWithPath: CommandLine.arguments[1])
+let scale = CGFloat(Double(CommandLine.arguments[2]) ?? 3.0)
+let output = URL(fileURLWithPath: CommandLine.arguments[3])
+guard let image = NSImage(contentsOf: input), image.size.width > 0, image.size.height > 0 else { exit(2) }
+let width = Int(ceil(image.size.width * scale))
+let height = Int(ceil(image.size.height * scale))
+if width > 12000 || height > 12000 { exit(3) }
+guard let rep = NSBitmapImageRep(bitmapDataPlanes: nil, pixelsWide: width, pixelsHigh: height, bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false, colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0) else { exit(4) }
+guard let context = NSGraphicsContext(bitmapImageRep: rep) else { exit(5) }
+NSGraphicsContext.saveGraphicsState()
+NSGraphicsContext.current = context
+context.imageInterpolation = .high
+image.draw(in: NSRect(x: 0, y: 0, width: width, height: height), from: .zero, operation: .copy, fraction: 1)
+NSGraphicsContext.restoreGraphicsState()
+guard let data = rep.representation(using: .png, properties: [:]) else { exit(6) }
+do { try data.write(to: output) } catch { exit(7) }
+`
+
+/**
+ * the svg file as 3x png bytes, cached by the svg's sha256, or null off macOS.
+ * throws when the svg cannot rasterize, like actool failing the build.
+ */
+export function rasterizeSvgFile(
+  diskPath: string,
+  svgSha256: string,
+): { bytes: Buffer } | null {
+  if (process.platform !== 'darwin') return null
+  const binary = rasterBinary(RASTER_SVG_SWIFT, 'swift-svg-raster')
+  const tag = createHash('sha256').update(RASTER_SVG_SWIFT).digest('hex').slice(0, 16)
+  const cached = path.join(cacheDir(), `swift-svg-png-${tag}-${svgSha256}.png`)
+  if (fs.existsSync(cached)) return { bytes: fs.readFileSync(cached) }
+  const out = path.join(
+    fs.mkdtempSync(path.join(os.tmpdir(), 'swift-svg-png-')),
+    'out.png',
+  )
+  try {
+    execFileSync(binary, [diskPath, '3', out], { stdio: 'pipe' })
+    const bytes = fs.readFileSync(out)
+    fs.mkdirSync(cacheDir(), { recursive: true })
+    fs.copyFileSync(out, cached)
+    return { bytes: Buffer.from(bytes) }
+  } catch (error) {
+    throw new Error(
+      `swift svg asset ${diskPath} did not rasterize: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  } finally {
+    fs.rmSync(path.dirname(out), { recursive: true, force: true })
+  }
+}

package/src/swift-shipped-archives.json

@@ -0,0 +1,44 @@
+{
+  "AppCheckCore": "a18d4e5aff27ff4b9bce8d6e73e55ccf1d11515311e219aa4473319cdff3187b",
+  "AppLovinSDK": "c00f052c4b15766a6a2734e2b3685234e6bd28dbc47fbe7cbc3edbf56f701d5c",
+  "AppsFlyerLib": "13bae495e63e22579dd9525a1c9e88d8eedc78b4586979b7e2d492cfd3efbe1f",
+  "FBAEMKit": "ceaf685683c6a23ae4893150d0d770aeeaec34811ac8c146b3aa351beade5fa0",
+  "FBAudienceNetwork": "4d84bf1e404a83852a93af2ae73e22e45bb2b11e0a9a445c3b461173a5d6aec3",
+  "FBLPromises": "3544fb457e7f60c69740cdd26617a75bdd613943e948becca643022c7edd76c0",
+  "FBSDKCoreKit": "1577edd62ec0c172928befed3b309dc59ae8915d2aaad091460d9d1be5ddc13d",
+  "FBSDKCoreKit_Basics": "c780833f204f9ec6eab70a3758a45c5c78bfb6f4e590289ccf395497f204cac1",
+  "FirebaseAnalytics": "e3253a494375c5174d20cb81925e20afa1ff6b1419125cb608d39b092b53ff2a",
+  "FirebaseAppCheck": "af82d72727d55d14f65eee96845d4d9495e4e603b4673709d6f3448b9595cc63",
+  "FirebaseAppCheckInterop": "7ffd54e6fe187bf8cd714e3d863e0095f7cbbb0fb802adb87a40c552de7cffcc",
+  "FirebaseAuth": "fcde09db8d45ffba67802e81c17b8046db6b56568226ace3fca898983b08c968",
+  "FirebaseAuthInterop": "e8e6f4fb42b3fa76c2bade7a522ab0f224558d27d2321175c791d307541787a8",
+  "FirebaseCore": "30e3505c715e17682c1dc20bb26ba475e99e6981a9a0dba3cf9352eea632fc1d",
+  "FirebaseCoreExtension": "e37ce2abcd4c218ab5426da78cbe7ab41f79ee7eba1d02dd4b0cde952ed2c4a0",
+  "FirebaseCoreInternal": "72a15c0c63585faf93e9ffa91e8a8c1c50b24749405804ffae19a29ec05b07ab",
+  "FirebaseCrashlytics": "e03c71913efd97678b895abb1e968c83e58b3fbd7955a81ec6e6581b95db16e3",
+  "FirebaseFirestore": "f7a1bb7fc4a2fb09298b514114d6aaca9a4f00fd8868667524a05bc4563bf1fd",
+  "FirebaseFirestoreInternal": "d9595a1784beaf5cd4a8e0dda0f4364ddfa6b536ad60f82746d81d14dce037a3",
+  "FirebaseInstallations": "141e313325bab001f2dbb79dc8a433f884f4c4a12a5feb665e6958098d637f7b",
+  "FirebaseRemoteConfig": "e0ae6d626a423d535bc67216f9f0cd66f98f1c0fb4b5bf88074d4496733e2db1",
+  "FirebaseRemoteConfigInterop": "794f599eb4232058715b606fa671639c8cc5d821655a0f739651d17c5ef65c37",
+  "FirebaseSessions": "1781d72e47dac0fc7a532412641021730bd5b659135633cd9ef7b97ccd31b0ce",
+  "FirebaseSharedSwift": "8d63b09a517733ef3a58390bf1e8cf054f058bdd618bb4f19a1f4b5a0b4f09e5",
+  "FirebaseStorage": "636b33180dd5ad60b4878357691fe6472cf3bd57ec691e9d661c5444f523df66",
+  "GTMSessionFetcher": "f58dc2bd9db39defd73f0f67e7a11893a0c6e6f0ba45cd83cf420b2b3c15f1bd",
+  "GoogleAdsOnDeviceConversion": "31a5a1f5204f4844a480d3889b6ebe2e69473ef32b868935c51812c0483cb08b",
+  "GoogleAppMeasurement": "5741e6334392e0345f1b5896111ffef4d5a78859970f5e197fa0b7d881165305",
+  "GoogleAppMeasurementIdentitySupport": "b70cb033eeb002ed1c5a8140953ccb3be0221ca754c05fe450ed9c9c6547f274",
+  "GoogleDataTransport": "7d08050419e0906f13039cc4d2dd69be075234c0bf5bbb34df9dd4891e48831d",
+  "GoogleMobileAds": "f2c09c60ee331ce029f563304ad73a481d57ace0d4bc11ce33a2bf59497c59bf",
+  "GoogleUtilities": "37a9d3d3810dad763a8a79bd4c7cc4c37b386240725aca07f45dba1826676c8c",
+  "Intercom": "fc8251f24b305b91f83304d4dffaf1a90c424a7bc37be8b595dd1fc5cff566ea",
+  "Promises": "6d8f1a4b3d561d67adfc2026834779b05685d1cdacea6e83c70d0641c39f24de",
+  "RecaptchaInterop": "cf5cc62ebc237b34d5267c1190d18f33b424dbc7f81713f127108d0ad8a592cf",
+  "RiveRuntime": "72b6ff5c5a1d153c9cdbea9a917c09be557cfcb1fafa02853fa06b0268551710",
+  "absl": "fff0388cf074c69a2da4bc197a005da0b8e5c23ebdcfa383600c540a342f9df1",
+  "grpc": "918737c9f8f93e14127b3894e31c7a0522475f2247b74f87d8166dff3a6bafb0",
+  "grpcpp": "b83f85e0256cf06df00cf0ed728b5c0d68373ca401742877935771447450b90a",
+  "leveldb": "5521a6e6e4cd01b2e31b099d4341f1bccae7e8ba43de648b028928573daf8bb4",
+  "nanopb": "a7fafe2e4e16d99de4c58f72e22dcc53221885aa6d678d1270123e4b01badfa3",
+  "openssl_grpc": "b2aaede82457cdd15915762a4f57b38e28ba0f47b9b48556a7e0c46881973096"
+}

package/src/swift-shipped-binaries.ts

@@ -0,0 +1,12 @@
+import archives from './swift-shipped-archives.json' with { type: 'json' }
+
+// the archive checksum of each vendor binary whose surface peach ships as a module
+// (scripts/debug/swift-binary-standin-generate.ts writes the table). a package pinning a
+// different archive gets its own stand-in, since the shipped module declares another version's API.
+const SHIPPED_ARCHIVES = new Map<string, string>(Object.entries(archives))
+
+/** true when `target` is a binary peach ships and the app's pinned archive is another one. */
+export function shippedBinaryDiffers(target: string, checksum: string | null): boolean {
+  const shipped = SHIPPED_ARCHIVES.get(target)
+  return shipped !== undefined && checksum !== null && checksum !== shipped
+}

package/src/swift-standin-config.ts

@@ -48,8 +48,10 @@ export function isSwiftStandinBehavior(value: unknown): value is StandinBehavior
   const fields = ['members', 'body', 'asyncBody', 'resultBody', 'set', 'stored']
   return (
     isRecord(value) &&
-    Object.entries(value).every(
-      ([key, entry]) => fields.includes(key) && typeof entry === 'string',
+    Object.entries(value).every(([key, entry]) =>
+      key === 'builtin'
+        ? entry === true
+        : fields.includes(key) && typeof entry === 'string',
     )
   )
 }

package/src/swift-standin-emit.ts

@@ -178,6 +178,8 @@ export type StandinOptions = {
   plain?: ReadonlySet<string>
   /** paths whose type the guest cannot represent in objective-c: emitted without @objc */
   unobjc?: ReadonlySet<string>
+  /** classes whose superclass declares init(coder:) non-failable: the compiler rejected the failable one */
+  coderNonfailable?: ReadonlySet<string>
   /** class path → objective-c protocols the compiler found its witnesses mismatch (nullability a swift protocol checks); the class drops the conformance */
   unconformed?: ReadonlyMap<string, ReadonlySet<string>>
   /** paths the compiler says must be marked override */
@@ -1644,7 +1646,7 @@ export function emitSwiftStandin(
             externalRoot(id) !== null
           )
             emit(
-              `${inner}public required init?(coder: NSCoder) { ${options.inert ? 'return nil' : trap(`${path}.init(coder:)`)} }`,
+              `${inner}public required init${options.coderNonfailable?.has(path) ? '' : '?'}(coder: NSCoder) { ${options.inert && !options.coderNonfailable?.has(path) ? 'return nil' : trap(`${path}.init(coder:)`)} }`,
             )
           // a designated init drops the inherited required init(), so a
           // subclass restates it
@@ -1890,6 +1892,8 @@ export function emitSwiftStandin(
       .replace(/^(?:weak |unowned )/, '')
       .replace(/^((?:static )?)let /, '$1var ')
     const witness = `${owner}.${leaf(member)}`
+    // a superclass the graph cannot see already declares what the compiler says must override
+    if (options.forcedOverride?.has(witness)) return
     const body = options.inert ? inertBody(member) : trap(witness)
     if (
       member.kind.identifier === 'swift.property' ||
@@ -1899,11 +1903,13 @@ export function emitSwiftStandin(
       const setter = parsed.settable
         ? ` ${parsed.nonmutating ? 'nonmutating ' : ''}set { ${body} }`
         : ''
-      emit(
+      emitAt(
+        witness,
         `${indent}${visibility} ${parsed.decl} { get${parsed.effects} { ${body} }${setter} }`,
       )
     } else
-      emit(
+      emitAt(
+        witness,
         `${indent}${member.kind.identifier === 'swift.init' ? 'public required ' : visibility + ' '}${stripDefaults(decl)} { ${body} }`,
       )
   }

package/src/swift-standins.ts

@@ -1240,7 +1240,7 @@ function interfaceEnumValues(
       const declarations = [
         ...interfaceText.matchAll(
           new RegExp(
-            `^([ \\t]*)(?:@[\\w.]+(?:\\([^)]*\\))?\\s+)*(?:nonisolated\\s+)?(?:public|open)\\s+enum\\s+${name}\\s*:\\s*(?:Swift\\.)?U?Int(?:8|16|32|64)?\\b[^{]*\\{[ \\t]*$`,
+            `^([ \\t]*)(?:@[\\w.]+(?:\\([^)]*\\))?\\s+)*(?:nonisolated\\s+)?(?:public|open)\\s+enum\\s+${name}\\s*:\\s*(?:Swift\\.)?(?:U?Int(?:8|16|32|64)?|IntegerLiteralType)\\b[^{]*\\{[ \\t]*$`,
             'gm',
           ),
         ),
@@ -1364,9 +1364,34 @@ function mixedStandin(
     null,
     view.inheritedConformances,
     interfaceProjections(view.graphs, interfaceText),
+    [],
+    externalConformances(surface.module, interfaceText),
   )
 }
 
+// an outside type's conformance to the module's own protocol (`extension Swift.String : Module.P {}`):
+// the symbol graph keeps an extension's members and drops the conformance it declares, so the
+// interface is the only record. a constrained extension stays out. a type of another module is
+// spelled by its own name, as the emitted members are.
+function externalConformances(module: string, interfaceText: string): string {
+  const lines = new Set<string>()
+  for (const match of interfaceText.matchAll(
+    /^(?:@\w+\s+)*extension\s+([\w.]+)\s*:\s*([^{\n]+?)\s*\{/gm,
+  )) {
+    const [, extended, conformances] = match
+    if (extended!.startsWith(`${module}.`) || /\bwhere\b/.test(conformances!)) continue
+    const own = conformances!
+      .split(',')
+      .map((name) => name.trim())
+      .filter((name) => name.startsWith(`${module}.`))
+    const type = extended!.startsWith('Swift.')
+      ? extended!
+      : extended!.split('.').slice(1).join('.')
+    if (own.length > 0 && type) lines.add(`extension ${type} : ${own.join(', ')} {}\n`)
+  }
+  return lines.size > 0 ? `\n${[...lines].join('')}` : ''
+}
+
 // the sdk toolset passes this to every swiftc compile; raw swiftc does not read the toolset,
 // and emitting a module aborts without it when the source reaches the wasm exception model.
 // swift-symbolgraph-extract has no -Xllvm.
@@ -1506,6 +1531,8 @@ function graphStandin(
   inheritedConformances: ReadonlyMap<string, ReadonlySet<string>> = new Map(),
   projections: ReadonlyMap<string, string> = new Map(),
   dependencyGraphs: SymbolGraph[] = [],
+  // declarations the symbol graphs cannot carry, appended after the emitted ones
+  trailer = '',
 ): SwiftStandin {
   const paths = new Set(
     graphs.flatMap((graph) =>
@@ -1556,6 +1583,8 @@ function graphStandin(
   const plain = new Set<string>()
   const unobjc = new Set<string>()
   const trapped = new Set<string>()
+  const forced = new Set<string>()
+  const nonfailable = new Set<string>()
   const unconformed = new Map<string, Set<string>>()
   const objcProtocols = new Set(
     graphs.flatMap((graph) =>
@@ -1575,7 +1604,7 @@ function graphStandin(
   // like a binary framework's.
   const inert =
     binary.placeholder !== undefined ||
-    (binary.publicHeaders !== undefined && binary.assemblySources === undefined)
+    (binary.publicHeaders !== undefined && binary.unloweredSources === undefined)
   for (;;) {
     const { source, owners, skipped } = emitSwiftStandin(graphs, {
       module,
@@ -1588,6 +1617,8 @@ function graphStandin(
       unobjc,
       unconformed,
       trapped,
+      forcedOverride: forced,
+      coderNonfailable: nonfailable,
       inert,
       imports: [...(placeholder?.peachImports ?? []), ...imports],
       family: [...imports, ...(placeholder?.peachImports ?? [])],
@@ -1609,7 +1640,7 @@ function graphStandin(
           `Configured Swift behavior ${module}.${entry.path} was not emitted: ${entry.reason}`,
         )
     }
-    fs.writeFileSync(file, source)
+    fs.writeFileSync(file, source + trailer)
     const check = spawnSync(
       path.join(toolchain.toolchainBin, 'swiftc'),
       // emitting the module runs the diagnostics a typecheck skips, such as
@@ -1633,10 +1664,17 @@ function graphStandin(
       return {
         module,
         target: binary.target,
-        files: { [`${module}.swift`]: source },
+        files: { [`${module}.swift`]: source + trailer },
         ...(imports.length ? { dependencies: imports } : {}),
       }
-    const before = omit.size + plain.size + unobjc.size + trapped.size + unconformed.size
+    const before =
+      omit.size +
+      plain.size +
+      unobjc.size +
+      trapped.size +
+      unconformed.size +
+      forced.size +
+      nonfailable.size
     const elsewhere: string[] = []
     for (const match of check.stderr.matchAll(/^(\S+?):(\d+):\d+: error: (.*)$/gm)) {
       const owner = match[1] === file ? owners[Number(match[2]) - 1] : undefined
@@ -1663,15 +1701,44 @@ function graphStandin(
         throw new Error(
           `Configured Swift behavior ${module}.${owner} does not typecheck: ${match[3]}`,
         )
-      if (owner && /does not override any|overrides nothing/.test(match[3]!))
+      if (
+        owner &&
+        /does not override any|overrides nothing|does not override a designated initializer/.test(
+          match[3]!,
+        )
+      )
         plain.add(owner)
+      else if (
+        owner &&
+        /failable initializer 'init\(coder:\)' cannot override a non-failable/.test(
+          match[3]!,
+        ) &&
+        !nonfailable.has(owner)
+      )
+        nonfailable.add(owner)
+      // the guest's superclass declares the member the vendor's graph names only as new
+      else if (
+        owner &&
+        /requires an 'override' keyword/.test(match[3]!) &&
+        !forced.has(owner)
+      )
+        forced.add(owner)
       // an inert value the declaration's type cannot build: its body traps
       else if (owner && inert && INERT_VALUE.test(match[3]!) && !trapped.has(owner))
         trapped.add(owner)
       else if (owner) omit.set(owner, `rejected by swiftc: ${match[3]}`)
       else elsewhere.push(match[3]!)
     }
-    if (omit.size + plain.size + unobjc.size + trapped.size + unconformed.size === before)
+    if (
+      omit.size +
+        plain.size +
+        unobjc.size +
+        trapped.size +
+        unconformed.size +
+        forced.size +
+        nonfailable.size ===
+      before
+    )
       throw new Error(
         `its generated source does not typecheck: ${elsewhere.slice(0, 3).join('; ') || check.stderr.trim().slice(0, 400)}`,
       )
@@ -2695,7 +2762,7 @@ export function standinGenerationInputs(
                 (dependency) =>
                   `${swiftTargetModuleName(dependency.module)}\0${treeDigest(path.join(binary.dir, dependency.path))}`,
               ),
-              ...(binary.assemblySources ?? []),
+              ...(binary.unloweredSources ?? []),
             ].join('\0')
           : swiftBinaryFramework(binary).digest,
       )

package/src/vite-plugin-one.ts

@@ -44,6 +44,7 @@ import {
   serveRuntimeFile,
   SOOTSIM_RUNTIME_MISSING_MESSAGE,
 } from './runtime-assets'
+import { ensureRuntimePackFor } from './runtime-packs'
 import { SWIFT_HMR_PATH, SWIFT_PACKAGE_PATH } from './swift-submit'
 import { swiftViteLifetime } from './swift-vite-lifetime'
 import type { OneWidgetPackage } from './oneWidgetContract'
@@ -595,7 +596,7 @@ export function peachPlugin(options: PeachPluginOptions = {}): Plugin {
         })
       })
 
-      server.middlewares.use((req, res, next) => {
+      server.middlewares.use(async (req, res, next) => {
         if (serveBrowserProxyRoute(req, res)) return
         const url = req.url || ''
         const pathname = url.split('?')[0]
@@ -615,6 +616,8 @@ export function peachPlugin(options: PeachPluginOptions = {}): Plugin {
           return
         }
 
+        await ensureRuntimePackFor(runtimeRoot, pathname)
+
         // root-relative runtime assets emitted by the shell and engine vite
         // builds. only intercept when the asset exists in the active runtime.
         if (isRootRuntimeAssetPath(pathname)) {