peachsim 0.1.2225 → 0.1.2229

package/src/menu.ts

@@ -1,107 +1,25 @@
+import {
+  type SootSimMenuPlatform,
+  type SootSimScaleMode,
+  type SootSimAmbientGlowLevel,
+  SOOTSIM_AMBIENT_GLOW_LEVELS,
+  SOOTSIM_AMBIENT_GLOW_LABELS,
+  type SootSimStageBackground,
+  SOOTSIM_STAGE_BACKGROUNDS,
+  SOOTSIM_STAGE_BACKGROUND_LABELS,
+  type SootSimRenderResolution,
+  SOOTSIM_RENDER_RESOLUTION_LEVELS,
+  SOOTSIM_RENDER_RESOLUTION_LABELS,
+  type SootSimScreenEffect,
+  SOOTSIM_SCREEN_EFFECTS,
+  SOOTSIM_SCREEN_EFFECT_LABELS,
+} from './menuContract'
 import { rnxPublicBrand } from './public-brand'
 
 // public sootsim menu protocol. this file is deliberately pure data and pure
 // functions so hosts can import it without pulling the engine or canvaskit graph.
 
-export const SOOTSIM_ENGINE_EVENT_NAME = 'sootsim:engine-event'
-export const SOOTSIM_SHELL_COMMAND_NAME = 'sootsim:shell-command'
-
-export type SootSimMenuPlatform = 'browser' | 'electron'
-export type SootSimScaleMode = 'physical' | 'point' | 'pixel' | 'fit'
-
-// ambient glow strength. one setting with three states rather than an on/off
-// pair plus a separate strength: every host that carries the preference (the
-// menus, the persisted setting, the ?ambientGlow= boot seed, the live
-// set-ambient-glow push, electron's shared config) then carries exactly one
-// value and cannot end up half-configured.
-export type SootSimAmbientGlowLevel = 'off' | 'soft' | 'full'
-export const SOOTSIM_AMBIENT_GLOW_LEVELS = ['off', 'soft', 'full'] as const
-
-export function isSootSimAmbientGlowLevel(
-  value: unknown,
-): value is SootSimAmbientGlowLevel {
-  return value === 'off' || value === 'soft' || value === 'full'
-}
-
-export const SOOTSIM_AMBIENT_GLOW_LABELS: Record<SootSimAmbientGlowLevel, string> = {
-  off: 'Off',
-  soft: 'Soft',
-  full: 'Full',
-}
-
-// the stage behind the device: system follows the mac's appearance (white in
-// light mode, black in dark), or one pinned color. one value per host, like
-// the glow level above.
-export type SootSimStageBackground = 'system' | 'light' | 'dark' | 'gray'
-export const SOOTSIM_STAGE_BACKGROUNDS = ['system', 'light', 'dark', 'gray'] as const
-
-export function isSootSimStageBackground(
-  value: unknown,
-): value is SootSimStageBackground {
-  return value === 'system' || value === 'light' || value === 'dark' || value === 'gray'
-}
-
-export const SOOTSIM_STAGE_BACKGROUND_LABELS: Record<SootSimStageBackground, string> = {
-  system: 'System',
-  light: 'Light',
-  dark: 'Dark',
-  gray: 'Gray',
-}
-
-// render resolution: how many pixels peach renders per iphone point. one
-// setting with three states, carried by every host exactly like the ambient
-// glow level above: the menus, the persisted setting, the ?renderResolution=
-// boot seed, the live set-render-resolution push, electron's shared config.
-export type SootSimRenderResolution = 'high' | 'medium' | 'low'
-export const SOOTSIM_RENDER_RESOLUTION_LEVELS = ['high', 'medium', 'low'] as const
-
-// the installed desktop app presents the phone scaled to fit its window, so a
-// fixed 2 px/pt canvas is browser-resampled and its icons read soft. its
-// default is the level that tracks the pixels on screen; browsers and capture
-// keep medium, whose 2 px/pt is the deterministic capture contract.
-export const DESKTOP_RENDER_RESOLUTION: SootSimRenderResolution = 'low'
-
-export function isSootSimRenderResolution(
-  value: unknown,
-): value is SootSimRenderResolution {
-  return value === 'high' || value === 'medium' || value === 'low'
-}
-
-export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, string> = {
-  high: 'High',
-  medium: 'Medium',
-  low: 'Low',
-}
-
-// screen effect: the real rendering, or one of the presentation looks the
-// engine's wireframe store draws. 'wireframe' is the clean structural sketch;
-// the others are its screen-space styles that ship as named effects.
-export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
-export const SOOTSIM_SCREEN_EFFECTS = [
-  'none',
-  'wireframe',
-  'blueprint',
-  'panel',
-  'green',
-] as const
-
-export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
-  return (
-    value === 'none' ||
-    value === 'wireframe' ||
-    value === 'blueprint' ||
-    value === 'panel' ||
-    value === 'green'
-  )
-}
-
-export const SOOTSIM_SCREEN_EFFECT_LABELS: Record<SootSimScreenEffect, string> = {
-  none: 'None',
-  wireframe: 'Wireframe',
-  blueprint: 'Blueprint',
-  panel: 'Panel',
-  green: 'Green',
-}
+export * from './menuContract'
 
 export type SootSimMenuItemDef =
   | { type: 'separator' }

package/src/menuContract.ts

@@ -0,0 +1,102 @@
+// the values and event names the menu protocol carries. kept apart from the menu builder so a
+// runtime that only validates a setting or names an event does not carry the menus at boot.
+
+export const SOOTSIM_ENGINE_EVENT_NAME = 'sootsim:engine-event'
+export const SOOTSIM_SHELL_COMMAND_NAME = 'sootsim:shell-command'
+
+export type SootSimMenuPlatform = 'browser' | 'electron'
+export type SootSimScaleMode = 'physical' | 'point' | 'pixel' | 'fit'
+
+// ambient glow strength. one setting with three states rather than an on/off
+// pair plus a separate strength: every host that carries the preference (the
+// menus, the persisted setting, the ?ambientGlow= boot seed, the live
+// set-ambient-glow push, electron's shared config) then carries exactly one
+// value and cannot end up half-configured.
+export type SootSimAmbientGlowLevel = 'off' | 'soft' | 'full'
+export const SOOTSIM_AMBIENT_GLOW_LEVELS = ['off', 'soft', 'full'] as const
+
+export function isSootSimAmbientGlowLevel(
+  value: unknown,
+): value is SootSimAmbientGlowLevel {
+  return value === 'off' || value === 'soft' || value === 'full'
+}
+
+export const SOOTSIM_AMBIENT_GLOW_LABELS: Record<SootSimAmbientGlowLevel, string> = {
+  off: 'Off',
+  soft: 'Soft',
+  full: 'Full',
+}
+
+// the stage behind the device: system follows the mac's appearance (white in
+// light mode, black in dark), or one pinned color. one value per host, like
+// the glow level above.
+export type SootSimStageBackground = 'system' | 'light' | 'dark' | 'gray'
+export const SOOTSIM_STAGE_BACKGROUNDS = ['system', 'light', 'dark', 'gray'] as const
+
+export function isSootSimStageBackground(
+  value: unknown,
+): value is SootSimStageBackground {
+  return value === 'system' || value === 'light' || value === 'dark' || value === 'gray'
+}
+
+export const SOOTSIM_STAGE_BACKGROUND_LABELS: Record<SootSimStageBackground, string> = {
+  system: 'System',
+  light: 'Light',
+  dark: 'Dark',
+  gray: 'Gray',
+}
+
+// render resolution: how many pixels peach renders per iphone point. one
+// setting with three states, carried by every host exactly like the ambient
+// glow level above: the menus, the persisted setting, the ?renderResolution=
+// boot seed, the live set-render-resolution push, electron's shared config.
+export type SootSimRenderResolution = 'high' | 'medium' | 'low'
+export const SOOTSIM_RENDER_RESOLUTION_LEVELS = ['high', 'medium', 'low'] as const
+
+// the installed desktop app presents the phone scaled to fit its window, so a
+// fixed 2 px/pt canvas is browser-resampled and its icons read soft. its
+// default is the level that tracks the pixels on screen; browsers and capture
+// keep medium, whose 2 px/pt is the deterministic capture contract.
+export const DESKTOP_RENDER_RESOLUTION: SootSimRenderResolution = 'low'
+
+export function isSootSimRenderResolution(
+  value: unknown,
+): value is SootSimRenderResolution {
+  return value === 'high' || value === 'medium' || value === 'low'
+}
+
+export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, string> = {
+  high: 'High',
+  medium: 'Medium',
+  low: 'Low',
+}
+
+// screen effect: the real rendering, or one of the presentation looks the
+// engine's wireframe store draws. 'wireframe' is the clean structural sketch;
+// the others are its screen-space styles that ship as named effects.
+export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
+export const SOOTSIM_SCREEN_EFFECTS = [
+  'none',
+  'wireframe',
+  'blueprint',
+  'panel',
+  'green',
+] as const
+
+export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
+  return (
+    value === 'none' ||
+    value === 'wireframe' ||
+    value === 'blueprint' ||
+    value === 'panel' ||
+    value === 'green'
+  )
+}
+
+export const SOOTSIM_SCREEN_EFFECT_LABELS: Record<SootSimScreenEffect, string> = {
+  none: 'None',
+  wireframe: 'Wireframe',
+  blueprint: 'Blueprint',
+  panel: 'Panel',
+  green: 'Green',
+}

package/src/metro-production-bundle.ts

@@ -394,7 +394,14 @@ export async function validateRNXMetroModulePaths(
   source: string,
   modulePaths: RNXMetroModulePathMap,
 ): Promise<void> {
-  const layout = await readRNXMetroBundleLayout(source)
+  checkRNXMetroModulePaths(await readRNXMetroBundleLayout(source), modulePaths)
+}
+
+/** the identity contract against a layout the caller already read. */
+export function checkRNXMetroModulePaths(
+  layout: RNXMetroBundleLayout,
+  modulePaths: RNXMetroModulePathMap,
+): void {
   if (layout.moduleIdFailures > 0) {
     throw new Error(
       `Metro module identity could not read ${layout.moduleIdFailures} module IDs`,
@@ -431,8 +438,14 @@ export async function validateRNXMetroModulePaths(
 
 export async function validateRNXMetroModuleIdentity(
   identity: RNXMetroModuleIdentity,
+  // the layout of the bundle this identity was read from. its footers follow
+  // the graph and register nothing, so its defines are the identity source's.
+  layout?: RNXMetroBundleLayout,
 ): Promise<void> {
-  await validateRNXMetroModulePaths(identity.source, identity.modulePaths)
+  checkRNXMetroModulePaths(
+    layout ?? (await readRNXMetroBundleLayout(identity.source)),
+    identity.modulePaths,
+  )
   for (const moduleId of Object.keys(identity.logicalSpecifiers)) {
     if (!Object.prototype.hasOwnProperty.call(identity.modulePaths, moduleId)) {
       throw new Error(

package/src/settingsContract.ts

@@ -2,14 +2,6 @@ import {
   DEFAULT_PROFILER_CATEGORIES,
   formatProfilerCategories,
 } from '@peach/globals/profiler'
-import {
-  SOOTSIM_AMBIENT_GLOW_LEVELS,
-  SOOTSIM_RENDER_RESOLUTION_LEVELS,
-  SOOTSIM_STAGE_BACKGROUNDS,
-  type SootSimAmbientGlowLevel,
-  type SootSimRenderResolution,
-  type SootSimStageBackground,
-} from 'peachsim/menu'
 import {
   type DeviceModel,
   type DevicePosture,
@@ -19,6 +11,14 @@ import {
   DYNAMIC_WINDOW_LIMITS,
   devices,
 } from './device-catalog.ts'
+import {
+  SOOTSIM_AMBIENT_GLOW_LEVELS,
+  SOOTSIM_RENDER_RESOLUTION_LEVELS,
+  SOOTSIM_STAGE_BACKGROUNDS,
+  type SootSimAmbientGlowLevel,
+  type SootSimRenderResolution,
+  type SootSimStageBackground,
+} from './menuContract'
 import { DEFAULT_REACT_NATIVE_CONFIGURATION } from './reactNativeConfigurationContract.ts'
 import {
   BACKGROUND_PRESET_NAMES,

package/src/swift-compile.ts

@@ -437,6 +437,26 @@ const clangInterfaceHeader = (header: string): string =>
     .replace(/\b_TtC10Foundation\d+(NS\w+)\b/g, '$1')
     .replace(/\b__attribute__\(\(objc_subclassing_restricted\)\)\s*/g, '')
 
+export function swiftHeaderWithSuperclassImports(
+  header: string,
+  interfaceFor: (name: string) => { file: string; header: string } | null,
+): string {
+  const superclasses = new Set(
+    [...header.matchAll(/@interface\s+\w+\s*:\s*(\w+)/g)].map((match) => match[1]!),
+  )
+  return header.replace(/^@import (\w+);$/gm, (statement, name: string) => {
+    const dependency = interfaceFor(name)
+    if (
+      !dependency ||
+      ![...swiftInterfaceDeclarations(dependency.header)].some((name) =>
+        superclasses.has(name),
+      )
+    )
+      return statement
+    return `${statement}\n#import ${JSON.stringify(dependency.file)}`
+  })
+}
+
 /** the Objective-C protocols and classes a generated interface header defines. */
 export const swiftInterfaceDeclarations = (header: string): Set<string> =>
   new Set([
@@ -908,7 +928,7 @@ export function swiftOptionalFramework(name: string): boolean {
 // an import may carry attributes (`@_exported`, `@preconcurrency`) and a
 // declaration kind (`import struct Nuke.ImageRequest`).
 const SWIFT_IMPORT =
-  /^\s*(?:@\w+(?:\([^)]*\))?\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/
+  /^\s*(?:@\w+(?:\([^)]*\))?\s+|(?:public|package|internal|fileprivate|private)\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/
 
 // three-valued (kleene) logic shared by the swift and c condition
 // evaluators: an undecided operand only decides when the other forces the
@@ -7437,6 +7457,58 @@ function compileSwiftProjectOnce(
             if (existsSync(linked) && statSync(linked).size <= 8)
               rmSync(linked, { force: true })
             report('compiling and linking Swift modules')
+            const frameworkInterfaces = new Map<
+              string,
+              { file: string; header: string } | null
+            >()
+            const frameworkInterface = (
+              name: string,
+            ): { file: string; header: string } | null => {
+              if (frameworkInterfaces.has(name)) return frameworkInterfaces.get(name)!
+              const source = distribution
+                ? path.join(frameworkRoot, 'modules', `${name}-Swift.h`)
+                : path.join(
+                    prebuilt!.modules,
+                    '..',
+                    `${name}.build/include/${name}-Swift.h`,
+                  )
+              if (!existsSync(source)) {
+                frameworkInterfaces.set(name, null)
+                return null
+              }
+              const headers = path.join(
+                swiftSdkPaths(frameworkRoot, options.toolchainBin).darwin,
+                `System/Library/Frameworks/${name}.framework/Headers`,
+              )
+              const declared = new Set<string>()
+              if (existsSync(headers))
+                for (const file of readdirSync(headers, {
+                  recursive: true,
+                  encoding: 'utf8',
+                }))
+                  if (file.endsWith('.h'))
+                    for (const name of swiftInterfaceDeclarations(
+                      readFileSync(path.join(headers, file), 'utf8'),
+                    ))
+                      declared.add(name)
+              const header = withoutSwiftDeclarations(
+                clangInterfaceHeader(readFileSync(source, 'utf8')),
+                declared,
+                `#import <${name}/${name}.h>`,
+              )
+              const value = {
+                file: path.join(root, '.build/peach-framework-objc', `${name}-Swift.h`),
+                header,
+              }
+              frameworkInterfaces.set(name, value)
+              writeBuildFile(
+                value.file,
+                (existsSync(path.join(headers, `${name}.h`))
+                  ? `#import <${name}/${name}.h>\n`
+                  : '') + swiftHeaderWithSuperclassImports(header, frameworkInterface),
+              )
+              return value
+            }
             try {
               // clang consumes the real emitted headers after swift finishes.
               // swiftpm's transitive swift module maps are not C declarations:
@@ -7475,7 +7547,10 @@ function compileSwiftProjectOnce(
                     writeBuildFile(
                       emitted,
                       withoutSwiftDeclarations(
-                        clangInterfaceHeader(readFileSync(original, 'utf8')),
+                        swiftHeaderWithSuperclassImports(
+                          clangInterfaceHeader(readFileSync(original, 'utf8')),
+                          frameworkInterface,
+                        ),
                         new Set(preparation.nativeHeaderDeclarations[producer]),
                         `#import <${producer}/${producer}.h>`,
                       ),

package/src/swift-host.ts

@@ -132,8 +132,10 @@ import {
 } from './swiftContract'
 import {
   enclosingXcodeWorkspace,
+  expandXcodeBuildSetting,
   readXcodeAppTarget,
   resolveXcodeSwiftPackages,
+  xcodeFileListEntries,
   type XcodeAppTarget,
   type XcodeModuleTarget,
 } from './xcode-project'
@@ -2312,11 +2314,34 @@ export function buildSwiftBundleFiles(
           CONTENTS_FOLDER_PATH: wrapper,
           UNLOCALIZED_RESOURCES_FOLDER_PATH: wrapper,
           INFOPLIST_PATH: `${wrapper}/Info.plist`,
-          SCRIPT_INPUT_FILE_COUNT: '0',
-          SCRIPT_INPUT_FILE_LIST_COUNT: '0',
+          SCRIPT_INPUT_FILE_COUNT: String(phase.inputPaths.length),
+          SCRIPT_INPUT_FILE_LIST_COUNT: String(phase.inputFileListPaths.length),
           SCRIPT_OUTPUT_FILE_COUNT: '0',
           SCRIPT_OUTPUT_FILE_LIST_COUNT: '0',
         }
+        const inputPath = (raw: string) => {
+          const file = path.resolve(
+            phase.directory,
+            expandXcodeBuildSetting(raw, (key) => env[key] ?? ''),
+          )
+          if (!fs.existsSync(file))
+            throw new Error(
+              `${xcode.app.name}: Run Script "${phase.name}" missing input ${file}`,
+            )
+          if (!file.startsWith(`${dir}${path.sep}`))
+            watched.push(path.relative(packagePath, file).split(path.sep).join('/'))
+          return file
+        }
+        phase.inputPaths.forEach((raw, index) => {
+          env[`SCRIPT_INPUT_FILE_${index}`] = inputPath(raw)
+        })
+        phase.inputFileListPaths.forEach((raw, index) => {
+          const source = inputPath(raw)
+          const entries = xcodeFileListEntries(source, inputPath)
+          const expanded = path.join(dir, `Input-${index}.xcfilelist`)
+          fs.writeFileSync(expanded, `${entries.join('\n')}\n`)
+          env[`SCRIPT_INPUT_FILE_LIST_${index}`] = expanded
+        })
         try {
           const [shell, ...args] = phase.command
           execFileSync(shell, args, {

package/src/swift-standin-emit.ts

@@ -1529,6 +1529,7 @@ export function emitSwiftStandin(
                   ].includes(name)
                 ) &&
                 !(name === nsObjectProtocol && externalRoot(id) === nsObject) &&
+                !options.unconformed?.get(path)?.has(name.split(/::|\./).pop()!) &&
                 !options.unconformed?.get(path)?.has(name),
             ),
           ].filter((name, at, all) => all.indexOf(name) === at)

package/src/swift-standins.ts

@@ -1703,6 +1703,14 @@ function graphStandin(
         unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), conformance]))
         continue
       }
+      // a superclass another module declares already brings this conformance
+      const redundant = /^redundant conformance of '\w+' to protocol '(\w+)'$/.exec(
+        match[3]!,
+      )?.[1]
+      if (owner && redundant) {
+        unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), redundant]))
+        continue
+      }
       if (owner && swiftPaths.has(owner))
         throw new Error(
           `Swift declaration ${module}.${owner} does not typecheck: ${match[3]}`,

package/src/xcode-project.ts

@@ -180,6 +180,8 @@ export interface XcodeAppTarget extends XcodeModuleTarget {
     command: [string, ...string[]]
     directory: string
     environment: Record<string, string>
+    inputPaths: string[]
+    inputFileListPaths: string[]
   }[]
   appIconName: string
   /** the app project PBXProject developmentRegion, xcode's "en" when it declares none. */
@@ -890,6 +892,8 @@ function compilationConditions(settings: (key: string) => string): string[] {
   ]
 }
 
+export { expand as expandXcodeBuildSetting }
+
 function expand(value: string, lookup: (name: string) => string): string {
   return value.replace(
     /\$(?:\(([A-Za-z_][A-Za-z0-9_]*)((?::[^)]*)?)\)|\{([A-Za-z_][A-Za-z0-9_]*)((?::[^}]*)?)\}|([A-Za-z_][A-Za-z0-9_]*))/g,
@@ -1013,6 +1017,8 @@ function shellCopies(
 }
 
 // an xcfilelist names one path per line; blank lines and comments are skipped.
+export { fileListEntries as xcodeFileListEntries }
+
 function fileListEntries(file: string, absolute: (raw: string) => string): string[] {
   return fs
     .readFileSync(file, 'utf8')
@@ -2851,8 +2857,6 @@ export function readXcodeAppTarget(
     const phase = app.project.object(id)
     if (
       phase?.isa !== 'PBXShellScriptBuildPhase' ||
-      list(phase.inputPaths).length ||
-      list(phase.inputFileListPaths).length ||
       list(phase.outputPaths).length ||
       list(phase.outputFileListPaths).length
     )
@@ -2864,6 +2868,8 @@ export function readXcodeAppTarget(
         str(phase.shellScript) ?? '',
       ),
       directory: app.project.projectDir,
+      inputPaths: list(phase.inputPaths),
+      inputFileListPaths: list(phase.inputFileListPaths),
       environment: Object.fromEntries(
         [...settingKeys]
           .filter((key) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))