peachsim 0.1.2208 → 0.1.2210

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-shared-sdk.ts

@@ -260,7 +260,7 @@ export function swiftSharedSdkViewOptions(
     .map((entry) => path.join(entry.parentPath, entry.name))
     .sort()
   const key = JSON.stringify([
-    'v22',
+    'v23',
     toolchainBin,
     sdk,
     frameworks,
@@ -333,6 +333,7 @@ export function swiftSharedSdkViewOptions(
       ...[
         'MacTypes.h',
         'objc/NSObject.h',
+        'ObjectiveC.apinotes',
         'net/if.h',
         'notify.h',
         'notify.modulemap',

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'
+
+// 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-builtin-behavior.ts

@@ -0,0 +1,248 @@
+import type { SwiftStandinBehaviors } from './swift-standin-emit'
+
+// behavior the stand-in generator gives a closed binary framework in every
+// app. an app's own configured behavior for the same declaration replaces it.
+//
+// GoogleCast: Peach has no local network to browse, so a Cast context
+// initializes, discovery runs and finds no receiver, and no session can
+// start. the values below are what the iOS framework reports in that state;
+// the receiver-facing and UI members stay trapping stand-ins.
+const BUILTIN_STANDIN_BEHAVIOR: SwiftStandinBehaviors = {
+  GoogleCast: {
+    kGCKCastDeviceCategory: { body: 'return "com.google.cast.CastDevice"' },
+    kGCKDefaultMediaReceiverApplicationID: { body: 'return "CC1AD845"' },
+    kGCKErrorDomain: { body: 'return "com.google.cast.GCKError"' },
+    'GCKError.init(code:)': {
+      body: 'super.init(domain: kGCKErrorDomain, code: code.rawValue, userInfo: nil)',
+    },
+
+    'GCKDiscoveryCriteria.applicationIDs': { stored: '' },
+    'GCKDiscoveryCriteria.namespaces': { stored: '' },
+    'GCKDiscoveryCriteria.hasApplicationIDs': { body: 'return applicationIDs != nil' },
+    'GCKDiscoveryCriteria.hasNamespaces': { body: 'return namespaces != nil' },
+    'GCKDiscoveryCriteria.init(applicationID:)': {
+      body: 'super.init(); applicationIDs = NSOrderedSet(object: applicationID)',
+    },
+    'GCKDiscoveryCriteria.init(namespaces:)': {
+      body: 'super.init(); self.namespaces = namespaces',
+    },
+
+    GCKLaunchOptions: {
+      members: `
+        private static var peachDeviceLanguageCode: String? { Locale.preferredLanguages.first }
+      `,
+    },
+    'GCKLaunchOptions.languageCode': { stored: '' },
+    'GCKLaunchOptions.relaunchIfRunning': { stored: 'false' },
+    'GCKLaunchOptions.androidReceiverCompatible': { stored: 'false' },
+    'GCKLaunchOptions.init()': {
+      body: 'super.init(); languageCode = GCKLaunchOptions.peachDeviceLanguageCode',
+    },
+    'GCKLaunchOptions.init(relaunchIfRunning:)': {
+      body: `
+        super.init()
+        languageCode = GCKLaunchOptions.peachDeviceLanguageCode
+        self.relaunchIfRunning = relaunchIfRunning
+      `,
+    },
+    'GCKLaunchOptions.init(languageCode:relaunchIfRunning:)': {
+      body: `
+        super.init()
+        self.languageCode = languageCode
+        self.relaunchIfRunning = relaunchIfRunning
+      `,
+    },
+    'GCKLaunchOptions.init(relaunchIfRunning:androidReceiverCompatible:)': {
+      body: `
+        super.init()
+        languageCode = GCKLaunchOptions.peachDeviceLanguageCode
+        self.relaunchIfRunning = relaunchIfRunning
+        self.androidReceiverCompatible = androidReceiverCompatible
+      `,
+    },
+    'GCKLaunchOptions.init(relaunchIfRunning:languageCode:androidReceiverCompatible:)': {
+      body: `
+        super.init()
+        self.languageCode = languageCode
+        self.relaunchIfRunning = relaunchIfRunning
+        self.androidReceiverCompatible = androidReceiverCompatible
+      `,
+    },
+
+    GCKCastOptions: {
+      members: 'fileprivate var peachDiscoveryCriteria: GCKDiscoveryCriteria?',
+    },
+    'GCKCastOptions.init(discoveryCriteria:)': {
+      body: 'super.init(); peachDiscoveryCriteria = discoveryCriteria',
+    },
+    'GCKCastOptions.init(receiverApplicationID:)': {
+      body: 'super.init(); peachDiscoveryCriteria = GCKDiscoveryCriteria(applicationID: applicationID)',
+    },
+    'GCKCastOptions.init(supportedNamespaces:)': {
+      body: 'super.init(); peachDiscoveryCriteria = GCKDiscoveryCriteria(namespaces: Set(namespaces))',
+    },
+    'GCKCastOptions.physicalVolumeButtonsWillControlDeviceVolume': { stored: 'false' },
+    'GCKCastOptions.disableDiscoveryAutostart': { stored: 'false' },
+    'GCKCastOptions.disableAnalyticsLogging': { stored: 'false' },
+    'GCKCastOptions.launchOptions': { stored: '' },
+    'GCKCastOptions.sharedContainerIdentifier': { stored: '' },
+    'GCKCastOptions.suspendSessionsWhenBackgrounded': { stored: 'true' },
+    'GCKCastOptions.stopReceiverApplicationWhenEndingSession': { stored: 'false' },
+    'GCKCastOptions.startDiscoveryAfterFirstTapOnCastButton': { stored: 'true' },
+
+    GCKCastContext: {
+      members: `
+        nonisolated(unsafe) fileprivate static var peachShared: GCKCastContext?
+        fileprivate let peachDiscoveryManager = GCKDiscoveryManager()
+        fileprivate let peachSessionManager = GCKSessionManager()
+        fileprivate var peachCredentialsData: GCKCredentialsData?
+        fileprivate static func peachInitialize(_ options: GCKCastOptions) {
+          let context = GCKCastContext()
+          peachShared = context
+          if !options.disableDiscoveryAutostart && !options.startDiscoveryAfterFirstTapOnCastButton {
+            context.peachDiscoveryManager.startDiscovery()
+          }
+        }
+      `,
+    },
+    'GCKCastContext.imageCache': { stored: '' },
+    'GCKCastContext.imagePicker': { stored: '' },
+    'GCKCastContext.useDefaultExpandedMediaControls': { stored: 'false' },
+    'GCKCastContext.castState': { body: 'return .noDevicesAvailable' },
+    'GCKCastContext.discoveryManager': { body: 'return peachDiscoveryManager' },
+    'GCKCastContext.sessionManager': { body: 'return peachSessionManager' },
+    'GCKCastContext.setLaunch(_:)': { body: 'peachCredentialsData = credentialsData' },
+    'GCKCastContext.isSharedInstanceInitialized()': {
+      body: 'return peachShared != nil',
+    },
+    'GCKCastContext.sharedInstance()': {
+      body: `
+        guard let shared = peachShared else {
+          fatalError("GCKCastContext.sharedInstance() was called before the shared instance was initialized")
+        }
+        return unsafeDowncast(shared, to: Self.self)
+      `,
+    },
+    'GCKCastContext.setSharedInstanceWith(_:)': {
+      body: `
+        if peachShared != nil {
+          fatalError("GCKCastContext.setSharedInstanceWith(_:) was called when the shared instance was already initialized")
+        }
+        peachInitialize(options)
+      `,
+    },
+    'GCKCastContext.setSharedInstanceWith(_:error:)': {
+      body: `
+        if peachShared != nil {
+          error?.pointee = GCKError(code: .alreadyInitialized)
+          return false
+        }
+        peachInitialize(options)
+        return true
+      `,
+    },
+
+    GCKDiscoveryManager: {
+      members: `
+        private final class PeachListener {
+          weak var listener: (any GCKDiscoveryManagerListener)?
+          init(_ listener: any GCKDiscoveryManagerListener) { self.listener = listener }
+        }
+        private var peachListeners: [PeachListener] = []
+        private var peachState: GCKDiscoveryState = .stopped
+      `,
+    },
+    'GCKDiscoveryManager.discoveryState': { body: 'return peachState' },
+    'GCKDiscoveryManager.hasDiscoveredDevices': { body: 'return false' },
+    'GCKDiscoveryManager.passiveScan': { stored: 'false' },
+    'GCKDiscoveryManager.discoveryActive': { body: 'return peachState == .running' },
+    'GCKDiscoveryManager.deviceCount': { body: 'return 0' },
+    'GCKDiscoveryManager.add(_:)': {
+      body: `
+        peachListeners.removeAll { $0.listener == nil }
+        if !peachListeners.contains(where: { $0.listener === listener }) {
+          peachListeners.append(PeachListener(listener))
+        }
+      `,
+    },
+    'GCKDiscoveryManager.remove(_:)': {
+      body: 'peachListeners.removeAll { $0.listener == nil || $0.listener === listener }',
+    },
+    'GCKDiscoveryManager.startDiscovery()': {
+      body: `
+        if peachState == .running { return }
+        peachState = .running
+        for entry in peachListeners {
+          entry.listener?.didStartDiscovery(forDeviceCategory: kGCKCastDeviceCategory)
+        }
+      `,
+    },
+    'GCKDiscoveryManager.stopDiscovery()': { body: 'peachState = .stopped' },
+    'GCKDiscoveryManager.isDiscoveryActive(forDeviceCategory:)': {
+      body: 'return peachState == .running && deviceCategory == kGCKCastDeviceCategory',
+    },
+    'GCKDiscoveryManager.device(at:)': {
+      body: 'fatalError("GCKDiscoveryManager.device(at:) index \\(index) is out of range: no Cast device is discovered")',
+    },
+    'GCKDiscoveryManager.device(withUniqueID:)': { body: 'return nil' },
+    'GCKDiscoveryManager.cancelFindOperation()': { body: '' },
+
+    GCKSessionManager: {
+      members: `
+        private var peachListeners: [any GCKSessionManagerListener] = []
+        private var peachDefaultSessionOptions: [String: [String: any NSCoding & NSObjectProtocol]] = [:]
+      `,
+    },
+    'GCKSessionManager.currentSession': { body: 'return nil' },
+    'GCKSessionManager.currentCastSession': { body: 'return nil' },
+    'GCKSessionManager.connectionState': { body: 'return .disconnected' },
+    'GCKSessionManager.hasConnectedSession()': { body: 'return false' },
+    'GCKSessionManager.hasConnectedCastSession()': { body: 'return false' },
+    'GCKSessionManager.startSession(with:)': { body: 'return false' },
+    'GCKSessionManager.startSession(with:sessionOptions:)': { body: 'return false' },
+    'GCKSessionManager.suspendSession(with:)': { body: 'return false' },
+    'GCKSessionManager.endSession()': { body: 'return false' },
+    'GCKSessionManager.endSessionAndStopCasting(_:)': { body: 'return false' },
+    'GCKSessionManager.setDefaultSessionOptions(_:forDeviceCategory:)': {
+      body: 'peachDefaultSessionOptions[category] = sessionOptions',
+    },
+    'GCKSessionManager.defaultSessionOptions(forDeviceCategory:)': {
+      body: 'return peachDefaultSessionOptions[category]',
+    },
+    'GCKSessionManager.add(_:)': {
+      body: `
+        if !peachListeners.contains(where: { $0 === listener }) { peachListeners.append(listener) }
+      `,
+    },
+    'GCKSessionManager.remove(_:)': {
+      body: 'peachListeners.removeAll { $0 === listener }',
+    },
+
+    GCKLogger: {
+      members: 'nonisolated(unsafe) fileprivate static let peachShared = GCKLogger()',
+    },
+    'GCKLogger.sharedInstance()': { body: 'return peachShared' },
+    'GCKLogger.delegate': { stored: '' },
+    'GCKLogger.filter': { stored: '' },
+    'GCKLogger.loggingEnabled': { stored: 'true' },
+    'GCKLogger.fileLoggingEnabled': { stored: 'false' },
+    'GCKLogger.consoleLoggingEnabled': { stored: 'false' },
+  },
+}
+
+export function withBuiltinStandinBehavior(
+  behavior: SwiftStandinBehaviors,
+): SwiftStandinBehaviors {
+  const merged: SwiftStandinBehaviors = { ...behavior }
+  for (const [module, members] of Object.entries(BUILTIN_STANDIN_BEHAVIOR))
+    merged[module] = {
+      ...Object.fromEntries(
+        Object.entries(members).map(([path, entry]) => [
+          path,
+          { ...entry, builtin: true },
+        ]),
+      ),
+      ...behavior[module],
+    }
+  return merged
+}

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 */
@@ -207,6 +209,8 @@ export type StandinBehavior = {
   set?: string
   /** a stored property instead of a computed one, with this initial value */
   stored?: string
+  /** generator-owned behavior, skipped where a framework version lacks the declaration */
+  builtin?: true
 }
 
 export type SwiftStandinBehaviors = Record<string, Record<string, StandinBehavior>>
@@ -1642,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
@@ -1888,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' ||
@@ -1897,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} }`,
       )
   }