@invarn/cibuild 2.9.2 → 2.9.4

package/dist/src/yaml/steps/cocoapods-deployment-floor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * After `pod install`: raise every pod target whose deployment target is below
+ * the app's own to the app's.
+ *
+ * A pod target below iOS 9 links ARC Lite, and Xcode 14.3 removed
+ * `libarclite`: `clang: error: SDK does not contain 'libarclite' at …
+ * libarclite_iphonesimulator.a; try increasing the minimum deployment
+ * target`. CocoaPods gives each pod target the deployment target its podspec
+ * declares, so an old pod (SwiftLinkPreview 3.1.0, `ios: '8.0'`) stops an app
+ * that itself targets iOS 12 (YuigaWada/MissCat, nightly-baseline issue 53).
+ * The usual fix lives in the app's own Podfile, a `post_install` that raises
+ * the pods; a repository whose Podfile has none cannot build under any
+ * current Xcode.
+ *
+ * RULED 2026-10-01 (Alex): raise every pod target below the app target's own
+ * deployment target to it, in the step, always. Never the app target, never
+ * past what the app promises: the floor is the lowest deployment target among
+ * the user targets CocoaPods integrated (each found by its `Pods-*.xcconfig`
+ * base configuration), so an extension that targets lower than the app keeps
+ * its pods buildable for it. A pod cannot run below the app that embeds it, so
+ * the raise changes nothing a user of the app could observe. Only the
+ * generated `Pods/*.xcodeproj` is edited; it is the checkout's, never
+ * committed back.
+ *
+ * Measured on a clone, Xcode 26.4, 2026-10-01: MissCat @ 574355469ebb, app
+ * targets MissCat and MissCatShare at 12.0, 74 pod build configurations raised
+ * from 8.0–9.3; SwiftLinkPreview then compiled at ios12.0-simulator and the
+ * build log never mentioned libarclite.
+ *
+ * Never a reason the step fails: a Ruby that cannot load `xcodeproj`, a Pods
+ * project it cannot read, a workspace it cannot find — each is a line in the
+ * log and the pods as CocoaPods left them.
+ */
+/** Ruby; argv[0] is the Pods directory. Prints what it read and what it raised. */
+export declare const POD_DEPLOYMENT_FLOOR_SOURCE: string;
+/**
+ * Bash lines that run the raise in the step's directory, after `pod install`.
+ * They expect `$USE_BUNDLE_EXEC` and `$BUNDLE_CMD` from the step, and never
+ * fail it.
+ */
+export declare function podDeploymentFloorLines(): string[];
+//# sourceMappingURL=cocoapods-deployment-floor.d.ts.map

package/dist/src/yaml/steps/cocoapods-deployment-floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cocoapods-deployment-floor.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/cocoapods-deployment-floor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,EAAE,MAgEzC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,EAAE,CAkClD"}

package/dist/src/yaml/steps/cocoapods-deployment-floor.js

@@ -0,0 +1,140 @@
+/**
+ * After `pod install`: raise every pod target whose deployment target is below
+ * the app's own to the app's.
+ *
+ * A pod target below iOS 9 links ARC Lite, and Xcode 14.3 removed
+ * `libarclite`: `clang: error: SDK does not contain 'libarclite' at …
+ * libarclite_iphonesimulator.a; try increasing the minimum deployment
+ * target`. CocoaPods gives each pod target the deployment target its podspec
+ * declares, so an old pod (SwiftLinkPreview 3.1.0, `ios: '8.0'`) stops an app
+ * that itself targets iOS 12 (YuigaWada/MissCat, nightly-baseline issue 53).
+ * The usual fix lives in the app's own Podfile, a `post_install` that raises
+ * the pods; a repository whose Podfile has none cannot build under any
+ * current Xcode.
+ *
+ * RULED 2026-10-01 (Alex): raise every pod target below the app target's own
+ * deployment target to it, in the step, always. Never the app target, never
+ * past what the app promises: the floor is the lowest deployment target among
+ * the user targets CocoaPods integrated (each found by its `Pods-*.xcconfig`
+ * base configuration), so an extension that targets lower than the app keeps
+ * its pods buildable for it. A pod cannot run below the app that embeds it, so
+ * the raise changes nothing a user of the app could observe. Only the
+ * generated `Pods/*.xcodeproj` is edited; it is the checkout's, never
+ * committed back.
+ *
+ * Measured on a clone, Xcode 26.4, 2026-10-01: MissCat @ 574355469ebb, app
+ * targets MissCat and MissCatShare at 12.0, 74 pod build configurations raised
+ * from 8.0–9.3; SwiftLinkPreview then compiled at ios12.0-simulator and the
+ * build log never mentioned libarclite.
+ *
+ * Never a reason the step fails: a Ruby that cannot load `xcodeproj`, a Pods
+ * project it cannot read, a workspace it cannot find — each is a line in the
+ * log and the pods as CocoaPods left them.
+ */
+/** Ruby; argv[0] is the Pods directory. Prints what it read and what it raised. */
+export const POD_DEPLOYMENT_FLOOR_SOURCE = String.raw `
+require 'xcodeproj'
+pods_dir = File.expand_path(ARGV[0] || 'Pods')
+pod_projects = Dir.glob(File.join(pods_dir, '*.xcodeproj'))
+if pod_projects.empty?
+  puts "No Pods project under #{pods_dir}; pods' deployment targets left as they are"
+  exit 0
+end
+root = File.expand_path('..', pods_dir)
+KEYS = %w[IPHONEOS_DEPLOYMENT_TARGET MACOSX_DEPLOYMENT_TARGET TVOS_DEPLOYMENT_TARGET WATCHOS_DEPLOYMENT_TARGET XROS_DEPLOYMENT_TARGET]
+def version_of(value)
+  value.to_s.strip =~ /\A\d+(\.\d+){0,2}\z/ ? Gem::Version.new(value.to_s.strip) : nil
+end
+
+floors = {}
+Dir.glob(File.join(root, '*.xcworkspace')).each do |ws|
+  Xcodeproj::Workspace.new_from_xcworkspace(ws).file_references.each do |ref|
+    path = File.expand_path(ref.absolute_path(File.expand_path('..', ws)))
+    next if path.start_with?(pods_dir + File::SEPARATOR) || !File.directory?(path)
+    project = Xcodeproj::Project.open(path)
+    project.native_targets.each do |target|
+      target.build_configurations.each do |config|
+        base = config.base_configuration_reference
+        next unless base && File.basename(base.path.to_s) =~ /\APods-.*\.xcconfig\z/
+        project_settings = project.build_configuration_list.build_settings(config.name) || {}
+        KEYS.each do |key|
+          v = version_of(config.build_settings[key]) || version_of(project_settings[key])
+          next unless v
+          floors[key] = v if floors[key].nil? || v < floors[key]
+        end
+      end
+    end
+  end
+end
+if floors.empty?
+  puts "No app target CocoaPods integrated declares a deployment target; pods' deployment targets left as they are"
+  exit 0
+end
+puts "The app's own deployment target: #{floors.map { |k, v| "#{k} #{v}" }.join(', ')}"
+
+raised = []
+pod_projects.each do |path|
+  project = Xcodeproj::Project.open(path)
+  changed = false
+  project.targets.each do |target|
+    next if target.name.start_with?('Pods-')
+    target.build_configurations.each do |config|
+      floors.each do |key, floor|
+        v = version_of(config.build_settings[key])
+        next unless v && v < floor
+        config.build_settings[key] = floor.to_s
+        raised << "#{target.name} #{v}"
+        changed = true
+      end
+    end
+  end
+  project.save if changed
+end
+if raised.empty?
+  puts "No pod target is below it"
+else
+  names = raised.uniq
+  puts "Raised #{names.size} pod target(s) below the app's deployment target to it: #{names.join(', ')}"
+end
+`;
+/**
+ * Bash lines that run the raise in the step's directory, after `pod install`.
+ * They expect `$USE_BUNDLE_EXEC` and `$BUNDLE_CMD` from the step, and never
+ * fail it.
+ */
+export function podDeploymentFloorLines() {
+    return [
+        "# Raise pods below the app's own deployment target to it — see",
+        '# cocoapods-deployment-floor.ts. Never fails the step.',
+        'if [ -d Pods ]; then',
+        '  POD_FLOOR_SCRIPT="$(mktemp -t cibuild-pod-floor).rb"',
+        `  cat > "$POD_FLOOR_SCRIPT" << 'CIBUILD_POD_FLOOR_EOF'`,
+        POD_DEPLOYMENT_FLOOR_SOURCE.trim(),
+        'CIBUILD_POD_FLOOR_EOF',
+        '  # A Ruby that can load xcodeproj: the bundle CocoaPods ran from, the',
+        "  # ruby on PATH, or a Homebrew pod wrapper's own interpreter and gems.",
+        '  POD_FLOOR_RUN=""',
+        '  if [ "$USE_BUNDLE_EXEC" = "true" ] && $BUNDLE_CMD exec ruby -e "require %q(xcodeproj)" >/dev/null 2>&1; then',
+        '    POD_FLOOR_RUN="$BUNDLE_CMD exec ruby"',
+        '  elif ruby -e "require %q(xcodeproj)" >/dev/null 2>&1; then',
+        '    POD_FLOOR_RUN="ruby"',
+        '  else',
+        '    POD_WRAPPER="$(command -v pod 2>/dev/null || true)"',
+        '    POD_GEM_HOME="$( [ -n "$POD_WRAPPER" ] && sed -n \'s/^GEM_HOME="\\([^"]*\\)".*/\\1/p\' "$POD_WRAPPER" | head -n 1)"',
+        '    POD_REAL="$( [ -n "$POD_WRAPPER" ] && sed -n \'s/.*exec "\\([^"]*\\)".*/\\1/p\' "$POD_WRAPPER" | head -n 1)"',
+        '    POD_RUBY="$( [ -n "$POD_REAL" ] && [ -f "$POD_REAL" ] && head -n 1 "$POD_REAL" | sed -n \'s/^#!//p\')"',
+        '    if [ -n "$POD_GEM_HOME" ] && [ -n "$POD_RUBY" ] && GEM_HOME="$POD_GEM_HOME" $POD_RUBY -e "require %q(xcodeproj)" >/dev/null 2>&1; then',
+        '      POD_FLOOR_RUN="env GEM_HOME=$POD_GEM_HOME $POD_RUBY"',
+        '    fi',
+        '  fi',
+        '  if [ -n "$POD_FLOOR_RUN" ]; then',
+        '    $POD_FLOOR_RUN "$POD_FLOOR_SCRIPT" Pods || echo "⚠️  Could not raise pods to the app\'s deployment target; left as CocoaPods wrote them"',
+        '  else',
+        '    echo "⚠️  No Ruby here loads xcodeproj; pods\' deployment targets left as CocoaPods wrote them"',
+        '  fi',
+        '  rm -f "$POD_FLOOR_SCRIPT"',
+        'fi',
+        '',
+    ];
+}
+//# sourceMappingURL=cocoapods-deployment-floor.js.map

package/dist/src/yaml/steps/cocoapods-deployment-floor.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pods below the app's own deployment target are raised to it, after pod
+ * install, and nothing else moves. Witness: YuigaWada/MissCat (nightly-baseline
+ * issue 53) — SwiftLinkPreview 3.1.0 at iOS 8.0 linked libarclite, which
+ * Xcode 14.3 removed, in an app that targets iOS 12.0.
+ *
+ * The Ruby runs for real against projects the xcodeproj gem writes, when this
+ * machine's ruby can load it; otherwise those tests are skipped and say so.
+ */
+export {};
+//# sourceMappingURL=cocoapods-deployment-floor.test.d.ts.map

package/dist/src/yaml/steps/cocoapods-deployment-floor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cocoapods-deployment-floor.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/cocoapods-deployment-floor.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/src/yaml/steps/cocoapods-deployment-floor.test.js

@@ -0,0 +1,176 @@
+/**
+ * Pods below the app's own deployment target are raised to it, after pod
+ * install, and nothing else moves. Witness: YuigaWada/MissCat (nightly-baseline
+ * issue 53) — SwiftLinkPreview 3.1.0 at iOS 8.0 linked libarclite, which
+ * Xcode 14.3 removed, in an app that targets iOS 12.0.
+ *
+ * The Ruby runs for real against projects the xcodeproj gem writes, when this
+ * machine's ruby can load it; otherwise those tests are skipped and say so.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { POD_DEPLOYMENT_FLOOR_SOURCE, podDeploymentFloorLines } from './cocoapods-deployment-floor.js';
+import { CocoapodsInstallStepExecutor } from './ios-deps.js';
+import { testConfig } from './test-config.js';
+const hasXcodeproj = (() => {
+    try {
+        execFileSync('ruby', ['-e', 'require %q(xcodeproj)'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+/**
+ * MissCat's shape: an app at 12.0 and a share extension at 11.0, both
+ * integrated by CocoaPods; pods at 8.0 (SwiftLinkPreview), 11.0 and 13.0; a
+ * library target in the app's project that CocoaPods does not integrate, at 8.0.
+ */
+const FIXTURE = String.raw `
+require 'xcodeproj'
+require 'fileutils'
+dir = ARGV[0]
+FileUtils.mkdir_p(File.join(dir, 'Pods', 'Target Support Files', 'Pods-App'))
+app = Xcodeproj::Project.new(File.join(dir, 'App.xcodeproj'))
+xc = app.new_file('Pods/Target Support Files/Pods-App/Pods-App.debug.xcconfig')
+[['App', :application, '12.0', true], ['Share', :app_extension, '11.0', true], ['Unpodded', :framework, '8.0', false]].each do |name, type, dt, podded|
+  t = app.new_target(type, name, :ios, dt)
+  t.build_configurations.each { |c| c.base_configuration_reference = xc if podded }
+end
+app.save
+pods = Xcodeproj::Project.new(File.join(dir, 'Pods', 'Pods.xcodeproj'))
+pods.new_target(:framework, 'Pods-App', :ios, '12.0')
+[['SwiftLinkPreview', '8.0'], ['MidPod', '11.0'], ['NewPod', '13.0']].each { |n, dt| pods.new_target(:framework, n, :ios, dt) }
+pods.save
+ws = Xcodeproj::Workspace.new(nil)
+ws << 'App.xcodeproj'
+ws << 'Pods/Pods.xcodeproj'
+ws.save_as(File.join(dir, 'App.xcworkspace'))
+`;
+const DUMP = String.raw `
+require 'xcodeproj'
+p = Xcodeproj::Project.open(ARGV[0])
+p.targets.each { |t| t.build_configurations.each { |c| puts "#{t.name} #{c.name} #{c.build_settings['IPHONEOS_DEPLOYMENT_TARGET']}" } }
+`;
+const ruby = (source, args, cwd) => {
+    const dir = mkdtempSync(join(tmpdir(), 'pod-floor-rb-'));
+    try {
+        const f = join(dir, 's.rb');
+        writeFileSync(f, source);
+        return execFileSync('ruby', [f, ...args], { encoding: 'utf8', cwd });
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+};
+(hasXcodeproj ? describe : describe.skip)('the raise, on projects the xcodeproj gem wrote', () => {
+    const withFixture = (fn) => {
+        const dir = mkdtempSync(join(tmpdir(), 'pod-floor-'));
+        try {
+            ruby(FIXTURE, [dir]);
+            fn(dir);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    };
+    const settings = (projectPath) => Object.fromEntries(ruby(DUMP, [projectPath])
+        .trim()
+        .split('\n')
+        .map((l) => {
+        const [t, c, v] = l.split(' ');
+        return [`${t} ${c}`, v];
+    }));
+    test('raises pods below the lowest integrated user target to it, and only those', () => {
+        withFixture((dir) => {
+            const out = ruby(POD_DEPLOYMENT_FLOOR_SOURCE, ['Pods'], dir);
+            const pods = settings(join(dir, 'Pods', 'Pods.xcodeproj'));
+            // The floor is the share extension's 11.0, the lowest the app promises.
+            expect(pods['SwiftLinkPreview Debug']).toBe('11.0');
+            expect(pods['SwiftLinkPreview Release']).toBe('11.0');
+            expect(pods['MidPod Debug']).toBe('11.0');
+            expect(pods['NewPod Debug']).toBe('13.0');
+            expect(pods['Pods-App Debug']).toBe('12.0');
+            expect(out).toContain('IPHONEOS_DEPLOYMENT_TARGET 11.0');
+            expect(out).toContain('Raised 1 pod target(s)');
+            expect(out).toContain('SwiftLinkPreview 8.0');
+        });
+    });
+    test("never touches the app's own project, not even a target CocoaPods does not integrate", () => {
+        withFixture((dir) => {
+            const before = readFileSync(join(dir, 'App.xcodeproj', 'project.pbxproj'), 'utf8');
+            ruby(POD_DEPLOYMENT_FLOOR_SOURCE, ['Pods'], dir);
+            expect(readFileSync(join(dir, 'App.xcodeproj', 'project.pbxproj'), 'utf8')).toBe(before);
+            // ...and the unintegrated 8.0 library is not the floor: the pod was raised.
+            expect(settings(join(dir, 'Pods', 'Pods.xcodeproj'))['SwiftLinkPreview Debug']).toBe('11.0');
+        });
+    });
+    test('a second run changes nothing', () => {
+        withFixture((dir) => {
+            ruby(POD_DEPLOYMENT_FLOOR_SOURCE, ['Pods'], dir);
+            const once = readFileSync(join(dir, 'Pods', 'Pods.xcodeproj', 'project.pbxproj'), 'utf8');
+            expect(ruby(POD_DEPLOYMENT_FLOOR_SOURCE, ['Pods'], dir)).toContain('No pod target is below it');
+            expect(readFileSync(join(dir, 'Pods', 'Pods.xcodeproj', 'project.pbxproj'), 'utf8')).toBe(once);
+        });
+    });
+    test('no workspace to read the app from: says so, raises nothing, exits 0', () => {
+        withFixture((dir) => {
+            rmSync(join(dir, 'App.xcworkspace'), { recursive: true, force: true });
+            const before = readFileSync(join(dir, 'Pods', 'Pods.xcodeproj', 'project.pbxproj'), 'utf8');
+            expect(ruby(POD_DEPLOYMENT_FLOOR_SOURCE, ['Pods'], dir)).toContain('left as they are');
+            expect(readFileSync(join(dir, 'Pods', 'Pods.xcodeproj', 'project.pbxproj'), 'utf8')).toBe(before);
+        });
+    });
+});
+if (!hasXcodeproj) {
+    test.skip('the raise on real projects — this ruby cannot load xcodeproj', () => { });
+}
+describe('cocoapods-install runs the raise after pod install', () => {
+    const script = async (inputs = {}) => (await new CocoapodsInstallStepExecutor().execute(inputs, {}, testConfig)).script;
+    test('after the pod command, before the step reports done', async () => {
+        const s = await script();
+        const raise = s.indexOf('cibuild-pod-floor');
+        expect(raise).toBeGreaterThan(s.indexOf('$POD_INVOCATION $POD_CMD'));
+        expect(raise).toBeLessThan(s.indexOf('✅ CocoaPods'));
+    });
+    test('carries the Ruby verbatim, in a quoted heredoc', async () => {
+        const s = await script();
+        expect(s).toContain(`<< 'CIBUILD_POD_FLOOR_EOF'`);
+        expect(s).toContain(POD_DEPLOYMENT_FLOOR_SOURCE.trim());
+    });
+    test('never fails the step', () => {
+        const lines = podDeploymentFloorLines().join('\n');
+        expect(lines).toContain('|| echo "⚠️  Could not raise pods');
+        expect(lines).not.toMatch(/\bexit 1\b/);
+    });
+    test('the emitted script is valid bash', async () => {
+        const dir = mkdtempSync(join(tmpdir(), 'pod-floor-sh-'));
+        try {
+            const f = join(dir, 's.sh');
+            writeFileSync(f, await script({ skip_if_absent: true }));
+            expect(() => execFileSync('bash', ['-n', f])).not.toThrow();
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test('the emitted lines run end to end: the raise happens through the bash', () => {
+        if (!hasXcodeproj)
+            return;
+        const dir = mkdtempSync(join(tmpdir(), 'pod-floor-e2e-'));
+        try {
+            ruby(FIXTURE, [dir]);
+            const f = join(dir, 'raise.sh');
+            writeFileSync(f, ['USE_BUNDLE_EXEC=false', 'BUNDLE_CMD=bundle', ...podDeploymentFloorLines()].join('\n'));
+            const out = execFileSync('bash', [f], { cwd: dir, encoding: 'utf8' });
+            expect(out).toContain('Raised 1 pod target(s)');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=cocoapods-deployment-floor.test.js.map

package/dist/src/yaml/steps/ios-deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ios-deps.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ios-deps.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAc,MAAM,wBAAwB,CAAC;AAMhF,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,yBAAyB,CACvB,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CA+MpB;AAMD,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,yBAAyB,CACvB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAyDpB"}
+{"version":3,"file":"ios-deps.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/ios-deps.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAc,MAAM,wBAAwB,CAAC;AAMhF,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,yBAAyB,CACvB,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAgNpB;AAMD,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,yBAAyB,CACvB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAUpB,OAAO,CACX,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,OAAO,CAAC;CAyDpB"}

package/dist/src/yaml/steps/ios-deps.js

@@ -3,6 +3,7 @@
  */
 import { BaseStepExecutor } from './base.js';
 import { refusedFetchHelpers, retryOnRefusedFetch } from './git-fetch-retry.js';
+import { podDeploymentFloorLines } from './cocoapods-deployment-floor.js';
 /**
  * Runs `pod install` or `pod update`.
  * Auto-detects Gemfile and uses `bundle exec pod` when appropriate.
@@ -210,6 +211,7 @@ export class CocoapodsInstallStepExecutor extends BaseStepExecutor {
             command: '$POD_INVOCATION $POD_CMD',
         }));
         commands.push('');
+        commands.push(...podDeploymentFloorLines());
         commands.push('echo "✅ CocoaPods ${POD_CMD%% *} completed"');
         const script = this.createBashScriptFromCommands(commands, stepName);
         return this.createScriptStep(script, stepName);

package/dist/src/yaml/steps/xcode-derived-data.test.js

@@ -28,7 +28,7 @@
  */
 import { describe, test, expect } from '@jest/globals';
 import { execFileSync } from 'child_process';
-import { mkdtempSync, realpathSync } from 'fs';
+import { mkdtempSync, realpathSync, symlinkSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { XcodeBuildStepExecutor, XcodeBuildForTestStepExecutor, XcodeBuildForSimulatorStepExecutor, } from './xcode.js';
@@ -226,6 +226,23 @@ describe('derived data is outside the source tree', () => {
         const b = resolve(script, { CIBUILD_SCRATCH: '/scratch', OUTPUT_DIR: '/work/repo/build' });
         expect(a).not.toBe(b);
     });
+    // analogcode/Swift-Radio-Pro: LNPopupController's Package.swift lists its
+    // header directories with FileManager (real paths, /private/tmp/...) and
+    // strips packageBase.path (/tmp/...) by text replacement, so every header
+    // search path came out eight characters short and '_LNPopupGlassUtils.h'
+    // was not found. On macOS /tmp and TMPDIR's /var are symlinks into
+    // /private; derived data has to be named by its real path.
+    test('derived data is named by its real path, not through a symlink', async () => {
+        const real = realpathSync(mkdtempSync(join(tmpdir(), 'real-')));
+        const link = join(realpathSync(mkdtempSync(join(tmpdir(), 'link-'))), 'tmp');
+        symlinkSync(real, link);
+        const script = await scriptFor(new XcodeBuildStepExecutor(), {});
+        const lines = script.split('\n');
+        const from = lines.findIndex((l) => l.startsWith('DERIVED_DATA_PATH='));
+        const to = lines.findIndex((l) => l.startsWith('echo "Derived data:'));
+        const path = execFileSync('bash', ['-c', `set -e\n${lines.slice(from, to).join('\n')}\nprintf '%s' "$DERIVED_DATA_PATH"`], { env: { PATH: process.env.PATH ?? '', TMPDIR: link, OUTPUT_DIR: '/work/repo/build' } }).toString();
+        expect(path.startsWith(real + '/')).toBe(true);
+    });
     test('the product listing and the xctestrun search follow it', async () => {
         const build = await scriptFor(new XcodeBuildStepExecutor(), {});
         expect(build).toContain('ls -lhR "$DERIVED_DATA_PATH/Build/Products"');

package/dist/src/yaml/steps/xcode-simulator-archs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The simulator architecture, chosen at run time.
+ *
+ * A pipeline pins `ARCHS=arm64` on its simulator builds: a *generic* simulator
+ * destination otherwise exports `ARCHS='arm64 x86_64'`, and anything that maps
+ * ARCHS onto a second toolchain meets an architecture nothing on the runner
+ * builds. But a project can exclude arm64 from the simulator
+ * (`EXCLUDED_ARCHS[sdk=iphonesimulator*] = arm64`, an Intel-era workaround),
+ * and then the pin leaves nothing to build: "None of the architectures in
+ * ARCHS (arm64) are valid", and CocoaPods' `[CP] Embed Pods Frameworks` dies
+ * on `ARCHS[@]: unbound variable`.
+ *
+ * Invarn switches to x86_64 at pipeline creation when the exclusion is in the
+ * repository (the pbxproj or the Podfile). A pod can also carry it, in its
+ * podspec's `user_target_xcconfig`, which CocoaPods writes into the app's
+ * `Pods-…debug.xcconfig` — and that exists only after `pod install`
+ * (ExistOrLive/GithubClient: WoodPeckeriOS 1.4.3, nightly-baseline issue 54).
+ * So the step asks Xcode, right before it builds, for the effective settings:
+ * `-showBuildSettings` reads the pbxproj, every xcconfig and the pods at once.
+ *
+ * Only an `ARCHS=arm64` pin is checked. An `ARCHS=x86_64` chosen at creation
+ * is left as it is, and options without a pin have nothing to decide.
+ */
+/** The variable the build line reads its simulator architecture from. */
+export declare const SIMULATOR_ARCHS_VAR = "CIBUILD_SIMULATOR_ARCHS";
+/** Whether `xcodebuild_options` pins the simulator build to arm64. */
+export declare function pinsSimulatorArm64(xcodebuildOptions: string): boolean;
+/** The options with the arm64 pin replaced by the run-time choice. */
+export declare function withRuntimeSimulatorArchs(xcodebuildOptions: string): string;
+/**
+ * Reads `xcodebuild -showBuildSettings -json` on stdin and prints one line
+ * naming the target that excludes arm64, or nothing. The application target
+ * decides when the scheme lists one; a framework the scheme also lists is not
+ * what is being built for the simulator. Output it cannot read is no
+ * evidence: it prints nothing and exits 0, and the build keeps arm64.
+ */
+export declare const ARM64_EXCLUSION_READER_SOURCE: string;
+/**
+ * The lines that set `$CIBUILD_SIMULATOR_ARCHS`: arm64, or x86_64 when the
+ * project's effective simulator settings exclude arm64, saying so in the log.
+ * They expect `$PROJECT_TYPE` and `$DERIVED_DATA_PATH` to be set, and go after
+ * package resolution, so the settings are read from the graph the build uses.
+ */
+export declare function simulatorArchsLines(opts: {
+    /** Already escaped for a single-quoted bash string. */
+    projectPath: string;
+    scheme: string;
+    configuration: string;
+    destination: string;
+    /** Pass `-xcconfig "$XCCONFIG_FILE"` too, as the build does. */
+    xcconfig: boolean;
+}): string[];
+//# sourceMappingURL=xcode-simulator-archs.d.ts.map

package/dist/src/yaml/steps/xcode-simulator-archs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-simulator-archs.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/xcode-simulator-archs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,sEAAsE;AACtE,wBAAgB,yBAAyB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,EAAE,MAqB3C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,MAAM,EAAE,CAyBX"}

package/dist/src/yaml/steps/xcode-simulator-archs.js

@@ -0,0 +1,98 @@
+/**
+ * The simulator architecture, chosen at run time.
+ *
+ * A pipeline pins `ARCHS=arm64` on its simulator builds: a *generic* simulator
+ * destination otherwise exports `ARCHS='arm64 x86_64'`, and anything that maps
+ * ARCHS onto a second toolchain meets an architecture nothing on the runner
+ * builds. But a project can exclude arm64 from the simulator
+ * (`EXCLUDED_ARCHS[sdk=iphonesimulator*] = arm64`, an Intel-era workaround),
+ * and then the pin leaves nothing to build: "None of the architectures in
+ * ARCHS (arm64) are valid", and CocoaPods' `[CP] Embed Pods Frameworks` dies
+ * on `ARCHS[@]: unbound variable`.
+ *
+ * Invarn switches to x86_64 at pipeline creation when the exclusion is in the
+ * repository (the pbxproj or the Podfile). A pod can also carry it, in its
+ * podspec's `user_target_xcconfig`, which CocoaPods writes into the app's
+ * `Pods-…debug.xcconfig` — and that exists only after `pod install`
+ * (ExistOrLive/GithubClient: WoodPeckeriOS 1.4.3, nightly-baseline issue 54).
+ * So the step asks Xcode, right before it builds, for the effective settings:
+ * `-showBuildSettings` reads the pbxproj, every xcconfig and the pods at once.
+ *
+ * Only an `ARCHS=arm64` pin is checked. An `ARCHS=x86_64` chosen at creation
+ * is left as it is, and options without a pin have nothing to decide.
+ */
+const ARM64_PIN = /(^|\s)ARCHS=arm64(?=\s|$)/;
+/** The variable the build line reads its simulator architecture from. */
+export const SIMULATOR_ARCHS_VAR = 'CIBUILD_SIMULATOR_ARCHS';
+/** Whether `xcodebuild_options` pins the simulator build to arm64. */
+export function pinsSimulatorArm64(xcodebuildOptions) {
+    return ARM64_PIN.test(xcodebuildOptions);
+}
+/** The options with the arm64 pin replaced by the run-time choice. */
+export function withRuntimeSimulatorArchs(xcodebuildOptions) {
+    return xcodebuildOptions.replace(ARM64_PIN, (_m, lead) => `${lead}ARCHS="$${SIMULATOR_ARCHS_VAR}"`);
+}
+/**
+ * Reads `xcodebuild -showBuildSettings -json` on stdin and prints one line
+ * naming the target that excludes arm64, or nothing. The application target
+ * decides when the scheme lists one; a framework the scheme also lists is not
+ * what is being built for the simulator. Output it cannot read is no
+ * evidence: it prints nothing and exits 0, and the build keeps arm64.
+ */
+export const ARM64_EXCLUSION_READER_SOURCE = String.raw `
+var input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', function (d) { input += d; });
+process.stdin.on('end', function () {
+  var entries;
+  try { entries = JSON.parse(input); } catch (err) { return; }
+  if (!Array.isArray(entries)) return;
+  var apps = entries.filter(function (e) {
+    return e && e.buildSettings && e.buildSettings.PRODUCT_TYPE === 'com.apple.product-type.application';
+  });
+  var judged = apps.length > 0 ? apps : entries;
+  for (var i = 0; i < judged.length; i++) {
+    var e = judged[i];
+    var excluded = String((e && e.buildSettings && e.buildSettings.EXCLUDED_ARCHS) || '').trim();
+    if (excluded.split(/\s+/).indexOf('arm64') >= 0) {
+      process.stdout.write('target ' + e.target + ' sets EXCLUDED_ARCHS = ' + excluded + '\n');
+      return;
+    }
+  }
+});
+`;
+/**
+ * The lines that set `$CIBUILD_SIMULATOR_ARCHS`: arm64, or x86_64 when the
+ * project's effective simulator settings exclude arm64, saying so in the log.
+ * They expect `$PROJECT_TYPE` and `$DERIVED_DATA_PATH` to be set, and go after
+ * package resolution, so the settings are read from the graph the build uses.
+ */
+export function simulatorArchsLines(opts) {
+    let ask = 'xcodebuild -showBuildSettings -json';
+    ask += ` "$PROJECT_TYPE" '${opts.projectPath}'`;
+    ask += ` -scheme '${opts.scheme}'`;
+    if (opts.configuration)
+        ask += ` -configuration '${opts.configuration}'`;
+    ask += ` -destination '${opts.destination}'`;
+    ask += ' -derivedDataPath "$DERIVED_DATA_PATH"';
+    if (opts.xcconfig)
+        ask += ' -xcconfig "$XCCONFIG_FILE"';
+    return [
+        '# The simulator architecture, read after pod install: a pod can exclude',
+        '# arm64 through its user_target_xcconfig, which no file in the repository',
+        '# says until CocoaPods has run. See xcode-simulator-archs.ts.',
+        `${SIMULATOR_ARCHS_VAR}=arm64`,
+        'ARCHS_READER="$(mktemp -t cibuild-sim-archs).cjs"',
+        `cat > "$ARCHS_READER" << 'CIBUILD_SIM_ARCHS_EOF'`,
+        ARM64_EXCLUSION_READER_SOURCE.trim(),
+        'CIBUILD_SIM_ARCHS_EOF',
+        `ARM64_EXCLUDED_BY=$(${ask} 2>/dev/null | node "$ARCHS_READER" 2>/dev/null || true)`,
+        'rm -f "$ARCHS_READER"',
+        'if [ -n "$ARM64_EXCLUDED_BY" ]; then',
+        `  ${SIMULATOR_ARCHS_VAR}=x86_64`,
+        '  echo "Building the simulator app as x86_64, not arm64: $ARM64_EXCLUDED_BY in the project\'s effective simulator settings (after pod install)"',
+        'fi',
+        '',
+    ];
+}
+//# sourceMappingURL=xcode-simulator-archs.js.map

package/dist/src/yaml/steps/xcode-simulator-archs.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A simulator build pinned to arm64, on a project whose effective settings
+ * exclude arm64 from the simulator, builds x86_64 instead — decided at run
+ * time, after `pod install`, from what Xcode itself reports.
+ *
+ * The witness (nightly-baseline issue 54): ExistOrLive/GithubClient @ 7969212a.
+ * Its pod WoodPeckeriOS 1.4.3 ships `user_target_xcconfig:
+ * { "EXCLUDED_ARCHS[sdk=iphonesimulator*]": "arm64" }`, which CocoaPods writes
+ * into the app's `Pods-…debug.xcconfig`. The pipeline pinned `ARCHS=arm64`, so
+ * nothing was left to build and `[CP] Embed Pods Frameworks` died on
+ * `ARCHS[@]: unbound variable` (bld_b91e230368d6505e97ec9b75). Nothing in the
+ * repository says so before `pod install` has run.
+ *
+ * Measured on a clone, Xcode 26.4, 2026-10-01: after `pod install`,
+ * `xcodebuild -showBuildSettings -json … -destination 'generic/platform=iOS
+ * Simulator'` reported, for target ZLGitHubClient
+ * (com.apple.product-type.application), `EXCLUDED_ARCHS = "arm64"`, in 3 s;
+ * and `ARCHS=x86_64` compiled the app's sources.
+ */
+export {};
+//# sourceMappingURL=xcode-simulator-archs.test.d.ts.map

package/dist/src/yaml/steps/xcode-simulator-archs.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xcode-simulator-archs.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/xcode-simulator-archs.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}