@swiftbrowser/cli 0.6.6 → 0.7.0

package/dist/appSources.js

@@ -0,0 +1,624 @@
+// The app's sources as the shim compiles them, and what they decide about
+// the build: the rewrites `stage` applies to each file, the features that
+// choose what links, the generated file that settles names Foundation and
+// the shim share, and the app target's linker settings. No Node APIs, so the
+// browser (packages/playground) stages an app with the same code as the CLI;
+// stage.ts re-exports all of it.
+import { LINKED_FRAMEWORKS, importsOf } from './frameworks.js';
+import { extensionOverrides, keyPathStrings, objcProtocols, optionalRequirementCalls, optionalRequirementNames } from './objc.js';
+/**
+ * Adjusts one source for the shim without moving any line, so compiler
+ * diagnostics keep their line numbers:
+ * - `import SwiftUI` also imports Foundation, FoundationBridge and Observation,
+ *   as Apple's SwiftUI re-exports Foundation (and Foundation re-exports
+ *   Observation, so `@Observable` works in a file that imports either alone);
+ * - `import Foundation` also imports Observation, for the same reason, and
+ *   (`bridged`: in a module built against the bridge) FoundationBridge, whose
+ *   `URLSession`, `UserDefaults`… the alias file names: a public default
+ *   argument (`session: URLSession = .shared`) may only use a member of a
+ *   module its own file imports;
+ * - `import CoreImage.CIFilterBuiltins` → `import CoreImage`, and likewise
+ *   `import UIKit.UIImage`, `import os.log`, `import CoreGraphics.CGImage`:
+ *   on Apple platforms those are Clang submodules; the shim's frameworks are
+ *   Swift modules, which have no submodules to import;
+ * - `delegate?.urlSession?(…)` → `delegate?.urlSession(…)`: the delegate
+ *   methods are `@objc optional` on Apple platforms, plain requirements with
+ *   default implementations in FoundationBridge;
+ * - `ProcessInfo.processInfo.physicalMemory` → `_swiftBrowserPhysicalMemory` (the alias file's):
+ *   swift-foundation answers 0 on WASI, and limits sized from it refuse everything;
+ * - `import Dispatch` → `import FoundationBridge`: the SDK has no Dispatch on
+ *   WASI, and the bridge's queues run on the main actor (a package that
+ *   imports it is built from a copy, vendor.ts);
+ * - `import ObjectiveC` → `import FoundationBridge`, which has the associated
+ *   objects (CoreFoundation.swift), and `unsafeBitCast(Selector(…), to:
+ *   UnsafeRawPointer.self)` → `Selector(…)._uniquePointer`: on Apple platforms
+ *   a selector is a uniqued pointer, the usual key of an associated object;
+ *   here it is a struct, which the bit cast would trap on (`selectorPointers`;
+ *   a package that imports ObjectiveC is built from a copy, vendor.ts);
+ * - `import FoundationLite` → `import FoundationBridge`: FoundationLite was the
+ *   lean mode's formatting layer (Phase 14 folded it into Foundation); a file
+ *   that still names it gets the bridge, which holds what remains;
+ * - `configuration.delegateClass = SceneDelegate.self` records how to make
+ *   the scene delegate (`sceneDelegateClasses`);
+ * - `x as? AnyObject` → `x as? _AnyObjectValue` in a file that reads a number
+ *   off it (`.doubleValue`, `.intValue`…): Objective-C finds those members on
+ *   any object at run time, which the browser's Swift cannot (`numberCasts`);
+ * - `@objc` protocols become class-bound, with their `optional` requirements
+ *   as plain ones that have default implementations, and calls of those
+ *   requirements (`delegate?.method?(…)`, in any of the module's files:
+ *   `optionalRequirements`) plain calls; an `override` in an extension is
+ *   blanked; `#keyPath(Type.property)` becomes `"property"` (objc.ts);
+ * - `ProcessInfo()` → `ProcessInfo.processInfo`;
+ * - `#Preview { … }` blocks (and `#Preview("name", traits: …) { … }`) become
+ *   blank lines: the shim has no preview macro and previews are not part of
+ *   the app. So do the older `struct …: PreviewProvider { … }` declarations,
+ *   which packages still carry (with preview-only modifiers inside).
+ */
+/**
+ * Optional requirements of the shim's delegate protocols (Objective-C
+ * `optional` methods on Apple platforms), which the shim declares as
+ * requirements with defaults: a call `delegate?.method?(…)` is a plain call.
+ */
+const SHIM_OPTIONAL_REQUIREMENTS = [
+    'navigationController', 'navigationControllerSupportedInterfaceOrientations', 'navigationControllerPreferredInterfaceOrientationForPresentation',
+];
+export function transformSource(text, options = {}) {
+    let foundationRewrites = 0;
+    let out = text;
+    // On iOS `import SwiftUI` re-exports Foundation (UUID, JSON, Date,
+    // UserDefaults are in scope without an import) and UIKit (`UIColor`,
+    // `UIApplication.shared`); the shim's SwiftUI does not, so the same modules
+    // are imported next to it (and UIKit is linked wherever SwiftUI is, featuresOf).
+    // An access level on the import (`public import SwiftUI`, with
+    // `InternalImportsByDefault`) goes on its companions too.
+    const companions = ['Foundation', 'FoundationBridge', 'Observation', 'UIKit'];
+    // Attributes on the import (`@preconcurrency`) go on its companions too.
+    out = out.replace(/^([ \t]*)((?:@[A-Za-z_]+[ \t]+)*(?:(?:public|package|internal|fileprivate|private)[ \t]+)?)import SwiftUI[ \t]*(\r?)$/gm, (_, indent, access, cr) => `${indent}${access}import SwiftUI; ${companions.map((module) => `${access}import ${module}`).join('; ')}${cr}`);
+    const foundationCompanions = options.bridged ? ['FoundationBridge', 'Observation'] : ['Observation'];
+    out = out.replace(/^([ \t]*)((?:@[A-Za-z_]+[ \t]+)*(?:(?:public|package|internal|fileprivate|private)[ \t]+)?)import Foundation[ \t]*(\r?)$/gm, (_, indent, access, cr) => `${indent}${access}import Foundation; ${foundationCompanions.map((module) => `${access}import ${module}`).join('; ')}${cr}`);
+    out = out.replace(SUBMODULE_IMPORT, (_, lead, module, cr) => `${lead}import ${module}${cr}`);
+    // URLSession's delegate methods are `@objc optional` on Apple platforms;
+    // FoundationBridge's are requirements with defaults (URLSession.swift).
+    out = out.replace(/\.urlSession\?\(/g, '.urlSession(');
+    // swift-foundation reports no physical memory on WASI (FoundationBridge/ProcessInfo.swift).
+    out = out.replace(/\bProcessInfo\.processInfo\.physicalMemory\b/g, '_swiftBrowserPhysicalMemory');
+    // The browser runs iOS apps: `#if os(iOS)` holds, as it does on the
+    // iPhone the page stands for (the build's real OS is WASI or Linux).
+    out = out.replace(IOS_CONDITION, (line) => line.replace(/\bos\(\s*iOS\s*\)/g, '(os(iOS) || SWIFTBROWSER)'));
+    // In a package built against the shim, as on iOS, the Objective-C
+    // runtime's NSObject is there: the bridge's, with associated objects
+    // (`import ObjectiveC` imports it, below). swift-navigation's UIKit
+    // observation is NSObject's.
+    if (options.bridged) {
+        out = out.replace(OBJC_CONDITION, (line) => line.replace(/\bcanImport\(\s*ObjectiveC\s*\)/g, '(canImport(ObjectiveC) || SWIFTBROWSER)'));
+    }
+    // The SDK has no Dispatch on WASI: the bridge's queues stand in (Dispatch.swift).
+    out = out.replace(/^([ \t]*(?:@[A-Za-z_]+[ \t]+)*(?:(?:public|package|internal|fileprivate|private)[ \t]+)?)import Dispatch[ \t]*(\r?)$/gm, (_, lead, cr) => `${lead}import FoundationBridge${cr}`);
+    // Associated objects without the Objective-C runtime (FoundationBridge/CoreFoundation.swift).
+    // NSObject is Foundation's there.
+    out = out.replace(/^([ \t]*(?:@[A-Za-z_]+[ \t]+)*(?:(?:public|package|internal|fileprivate|private)[ \t]+)?)import ObjectiveC[ \t]*(\r?)$/gm, (_, lead, cr) => `${lead}import Foundation; ${lead.trimStart()}import FoundationBridge${cr}`);
+    // Apple's Foundation declares Dispatch's, RunLoop's and OperationQueue's
+    // Combine schedulers; the shim's Combine does (Combine/Schedulers.swift).
+    // A file whose imports are internal by default (`public import Foundation`
+    // beside `import Combine`) may use them in public declarations, so its
+    // Combine import is public too.
+    if (/^[ \t]*public[ \t]+import[ \t]/m.test(out)) {
+        out = out.replace(/^([ \t]*)import Combine[ \t]*(\r?)$/gm, (_, indent, cr) => `${indent}public import Combine${cr}`);
+    }
+    // Key-value observing's callback is not NSObject's without the Objective-C
+    // runtime (FoundationBridge/KeyValueObserving.swift): an override of it is
+    // a plain method, which nothing calls.
+    out = out.replace(/\boverride[ \t]+((?:(?:public|open|internal|fileprivate|private)[ \t]+)?func[ \t]+observeValue\(\s*forKeyPath\b)/g, '$1');
+    // Nor can `responds(to:)` be overridden (FoundationBridge/Selector.swift
+    // declares it in an extension): the override is renamed, and nothing
+    // asks it (no runtime sends the message).
+    out = out.replace(/\boverride[ \t]+((?:(?:public|open|internal|fileprivate|private)[ \t]+)?func[ \t]+)responds(\(\s*to\b)/g, '$1_swiftBrowserResponds$2');
+    // CoreFoundation's headers need wasi-libc's emulations (WASI_EMULATION_FLAGS),
+    // which only the module importing it is compiled with. Imported
+    // implementation-only, its clients never load it (an `internal import` of
+    // a module without library evolution, they still would).
+    out = out.replace(/^([ \t]*)import CoreFoundation[ \t]*(\r?)$/gm, (_, indent, cr) => `${indent}@_implementationOnly import CoreFoundation${cr}`);
+    out = selectorPointers(out);
+    out = out.replace(/^([ \t]*)import FoundationLite[ \t]*(\r?)$/gm, (_, indent, cr) => {
+        foundationRewrites += 1;
+        return `${indent}import FoundationBridge${cr}`;
+    });
+    // Objective-C protocols and what Swift allows only with the runtime (objc.ts).
+    out = objcProtocols(out);
+    out = optionalRequirementCalls(out, new Set([...(options.optionalRequirements ?? optionalRequirementNames([text])), ...SHIM_OPTIONAL_REQUIREMENTS]));
+    out = extensionOverrides(out);
+    out = keyPathStrings(out);
+    // `ProcessInfo()` is the process's info on Apple platforms; corelibs' initializer is internal.
+    out = out.replace(/\bProcessInfo\(\)/g, 'ProcessInfo.processInfo');
+    out = rewriteObjC(out);
+    out = sceneDelegateClasses(out);
+    out = numberCasts(out);
+    const stripped = stripPreviews(out);
+    return { text: stripped.text, previewsStripped: stripped.count, foundationRewrites };
+}
+/**
+ * `configuration.delegateClass = SceneDelegate.self` →
+ * `configuration._setDelegateClass(SceneDelegate.self) { SceneDelegate() }`:
+ * UIKit makes the scene delegate through the Objective-C runtime, and Swift
+ * without it can only make an instance from a metatype through a `required`
+ * initializer (UIKit/SceneDelegates.swift). Same line, so diagnostics keep
+ * their places.
+ */
+export function sceneDelegateClasses(text) {
+    if (!text.includes('delegateClass'))
+        return text;
+    return text.replace(/(\b[A-Za-z_][\w.]*)\.delegateClass\s*=\s*([A-Z][\w.]*)\.self\b/g, '$1._setDelegateClass($2.self) { $2() }');
+}
+/**
+ * `as? AnyObject` → `as? _AnyObjectValue` where the file reads a number from
+ * the result: `(dict[key] as? AnyObject)?.doubleValue` looks the member up on
+ * any object through Objective-C (nil where there is none); FoundationBridge's
+ * `_AnyObjectValue` (Selector.swift) has those members, optional likewise, on
+ * the numbers, booleans and strings a dictionary of `Any` holds.
+ */
+export function numberCasts(text) {
+    if (!/\bas\?\s*AnyObject\b/.test(text))
+        return text;
+    if (!/\.(?:doubleValue|floatValue|intValue|integerValue|int64Value|uint64Value|uintValue|boolValue)\b/.test(text))
+        return text;
+    return text.replace(/\bas\?(\s*)AnyObject\b/g, 'as?$1_AnyObjectValue');
+}
+/** Whether a source uses the Objective-C runtime's selectors or attributes. */
+export function usesObjC(text) {
+    return /#selector\s*\(|@objc\b|@objcMembers\b/.test(text);
+}
+/**
+ * Whether a source calls POSIX mutex functions. WASI's libc module leaves
+ * `pthread.h` out, so a package that does is built from a copy: there
+ * `#if os(iOS)` holds (Darwin's `os_unfair_lock` branch) and FoundationBridge
+ * declares the mutex functions for the page's single thread (Locks.swift).
+ */
+/**
+ * `unsafeBitCast(Selector(#function), to: UnsafeRawPointer.self)` →
+ * `Selector(#function)._uniquePointer`: the address that stands for the
+ * selector's name (FoundationBridge/Selector.swift), which on Apple
+ * platforms the bit cast gives, the selector being a uniqued pointer.
+ */
+export function selectorPointers(text) {
+    if (!text.includes('unsafeBitCast'))
+        return text;
+    return text.replace(/\bunsafeBitCast\(\s*(Selector\((?:[^()]|\([^()]*\))*\))\s*,\s*to:\s*UnsafeRawPointer\.self\s*\)/g, '$1._uniquePointer');
+}
+/** Whether a source imports ObjectiveC, which the SDK does not have on WASI (transformSource). */
+export function importsObjectiveC(text) {
+    return importsOf(text).includes('ObjectiveC');
+}
+/** Whether a source imports Dispatch, which the SDK does not have on WASI (transformSource). */
+export function importsDispatch(text) {
+    return importsOf(text).includes('Dispatch');
+}
+/** CoreFoundation's headers need wasi-libc's signal and mman emulations (`WASI_EMULATION_FLAGS`). */
+export function importsCoreFoundation(text) {
+    return importsOf(text).includes('CoreFoundation');
+}
+/** What a Swift module that imports CoreFoundation is compiled with for WASI: the emulations its headers include (the link has their libraries). */
+export const WASI_EMULATION_FLAGS = ['-Xcc', '-D_WASI_EMULATED_SIGNAL', '-Xcc', '-D_WASI_EMULATED_MMAN'];
+export function usesPosixMutex(text) {
+    return /\bpthread_mutex(?:attr)?_(?!t\b)[a-z]+\s*\(/.test(text);
+}
+/**
+ * Objective-C without its runtime (FoundationBridge/Selector.swift). The
+ * browser's Swift has no Objective-C interop, so `@objc` (and the Interface
+ * Builder attributes that imply it) is dropped, and `#selector(handle(_:))`
+ * becomes `Selector(Self.handle(_:), name: "handle(_:)")`: the method itself,
+ * which the target/selector APIs call on their target. A qualified method
+ * (`Type.method`) is used as it is; one of another object
+ * (`#selector(model.refresh)`) is called bound; `getter:`/`setter:`
+ * selectors only have a name, as does a method of three or more arguments
+ * (`navigationController(_:didShow:animated:)`), which target-action never
+ * sends (it passes the sender and the event at most) and code only compares
+ * or asks about (`responds(to:)`). A method the file declares `@MainActor` is
+ * bound to its target in a closure instead,
+ * `Selector(name: "tick", isolated: { (target: Self) in target.tick })`:
+ * Swift 6 rejects naming a main-actor method of a class that is not
+ * `Sendable` unapplied (Gifu's display link proxy).
+ */
+export function rewriteObjC(text) {
+    if (!usesObjC(text))
+        return text;
+    let out = text.replace(/@(?:objc\b(?:\([^)\n]*\))?|(?:objcMembers|IBAction|IBOutlet|IBInspectable|IBDesignable)\b)[ \t]*/g, '');
+    const mainActorMethods = new Set([...out.matchAll(/@MainActor\b(?:\s*@\w+(?:\([^)\n]*\))?)*\s*(?:(?:public|private|fileprivate|internal|open|final|override|dynamic|nonisolated)\s+)*func\s+`?([A-Za-z_][A-Za-z0-9_]*)/g)].map((m) => m[1]));
+    let result = '';
+    let index = 0;
+    const selectors = /#selector\s*\(/g;
+    for (;;) {
+        selectors.lastIndex = index;
+        const match = selectors.exec(out);
+        if (!match)
+            break;
+        const open = match.index + match[0].length - 1;
+        const close = matchingParen(out, open);
+        if (close < 0)
+            break;
+        const inner = out.slice(open + 1, close).trim();
+        const name = inner.replace(/\s+/g, '');
+        result += out.slice(index, match.index);
+        const accessor = /^(?:getter|setter)\s*:\s*(.+)$/s.exec(inner);
+        let method = inner.replace(/^self\s*\.\s*/, '');
+        const qualified = /^([A-Z][A-Za-z0-9_]*)\s*\.\s*(.+)$/s.exec(method);
+        const unqualified = method.replace(/^`?([A-Za-z_][A-Za-z0-9_]*)`?/, '$1');
+        const base = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(qualified ? qualified[2] : unqualified)?.[1];
+        if (accessor) {
+            result += `Selector(${JSON.stringify(accessor[1].replace(/\s+/g, ''))})`;
+        }
+        else if ((name.match(/:/g) ?? []).length >= 3) {
+            result += `Selector(${JSON.stringify(name.replace(/^(?:self|Self|[A-Z][A-Za-z0-9_]*)\./, ''))})`;
+        }
+        else if (base && mainActorMethods.has(base) && (qualified || !/^[A-Za-z_][A-Za-z0-9_]*\s*\./.test(method))) {
+            const type = qualified ? qualified[1] : 'Self';
+            const member = (qualified ? qualified[2] : unqualified).replace(/\s+/g, '');
+            result += `Selector(name: ${JSON.stringify(name)}, isolated: { (target: ${type}) in target.${member} })`;
+        }
+        else if (/^[A-Z][A-Za-z0-9_]*\s*\./.test(method)) {
+            result += `Selector(${method}, name: ${JSON.stringify(name)})`;
+        }
+        else if (/^[A-Za-z_][A-Za-z0-9_]*\s*\./.test(method)) {
+            result += `Selector(bound: ${method}, name: ${JSON.stringify(name)})`;
+        }
+        else {
+            method = method.replace(/^`?([A-Za-z_][A-Za-z0-9_]*)`?/, '$1');
+            result += `Selector(Self.${method}, name: ${JSON.stringify(name)})`;
+        }
+        index = close + 1;
+    }
+    result += out.slice(index);
+    return result;
+}
+/** Index of the `)` closing the `(` at `open`; -1 when unbalanced. */
+function matchingParen(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        if (text[i] === '(')
+            depth += 1;
+        else if (text[i] === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** A `#if` or `#elseif` line that tests `os(iOS)`. */
+const IOS_CONDITION = /^[ \t]*#(?:if|elseif)\b[^\n]*\bos\(\s*iOS\s*\)[^\n]*$/gm;
+const OBJC_CONDITION = /^[ \t]*#(?:if|elseif)\b[^\n]*\bcanImport\(\s*ObjectiveC\s*\)[^\n]*$/gm;
+/** `import UIKit.UIImage`-style imports of the frameworks the shim provides as Swift modules. */
+const SUBMODULE_IMPORT = /^([ \t]*(?:@[A-Za-z_]+[ \t]+)*)import[ \t]+(CoreImage|UIKit|CoreGraphics|ImageIO|os)\.[A-Za-z_][A-Za-z0-9_.]*[ \t]*(\r?)$/gm;
+/** Replaces every `#Preview …{ … }` block and `PreviewProvider` struct with blank lines of the same count. */
+export function stripPreviews(text) {
+    let count = 0;
+    let result = '';
+    let index = 0;
+    const pattern = /^[ \t]*(?:#Preview\b|(?:(?:@\w+(?:\([^)\n]*\))?|public|internal|fileprivate|private)\s+)*struct[ \t]+\w+[ \t]*:[^{\n]*\bPreviewProvider\b)/gm;
+    for (;;) {
+        pattern.lastIndex = index;
+        const match = pattern.exec(text);
+        if (!match)
+            break;
+        let start = match.index;
+        const open = text.indexOf('{', start);
+        if (open < 0)
+            break;
+        const close = matchingBrace(text, open);
+        if (close < 0)
+            break;
+        // Consume the rest of the line after the closing brace (usually nothing).
+        let end = close + 1;
+        while (end < text.length && (text[end] === ' ' || text[end] === '\t'))
+            end += 1;
+        // Attribute lines just above it (`@available(iOS 17, *)`) go with it.
+        for (;;) {
+            const lineEnd = start - 1;
+            if (lineEnd < index || text[lineEnd] !== '\n')
+                break;
+            const lineStart = text.lastIndexOf('\n', lineEnd - 1) + 1;
+            if (lineStart < index || !/^[ \t]*@\w+(?:\([^)\n]*\))?[ \t]*\r?$/.test(text.slice(lineStart, lineEnd)))
+                break;
+            start = lineStart;
+        }
+        result += text.slice(index, start);
+        const removed = text.slice(start, end);
+        result += removed.replace(/[^\n]/g, '');
+        count += 1;
+        index = end;
+    }
+    result += text.slice(index);
+    return { text: result, count };
+}
+/** Index of the `}` closing the `{` at `open`, skipping strings and comments; -1 when unbalanced. */
+export function matchingBrace(text, open) {
+    let depth = 0;
+    let i = open;
+    while (i < text.length) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (ch === '/' && next === '/') {
+            i = text.indexOf('\n', i);
+            if (i < 0)
+                return -1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            const end = text.indexOf('*/', i + 2);
+            if (end < 0)
+                return -1;
+            i = end + 2;
+            continue;
+        }
+        if (ch === '"') {
+            i = skipString(text, i);
+            if (i < 0)
+                return -1;
+            continue;
+        }
+        if (ch === '{')
+            depth += 1;
+        if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+        i += 1;
+    }
+    return -1;
+}
+/** Index just past a string literal starting at `start` (`"…"`, `"""…"""`, raw `#"…"#`), interpolations included; -1 when unterminated. */
+function skipString(text, start) {
+    const triple = text.startsWith('"""', start);
+    const quote = triple ? '"""' : '"';
+    let i = start + quote.length;
+    while (i < text.length) {
+        if (text[i] === '\\') {
+            if (text[i + 1] === '(') {
+                // Interpolation: skip to its matching parenthesis.
+                let depth = 0;
+                let j = i + 1;
+                while (j < text.length) {
+                    const c = text[j];
+                    if (c === '"') {
+                        j = skipString(text, j);
+                        if (j < 0)
+                            return -1;
+                        continue;
+                    }
+                    if (c === '(')
+                        depth += 1;
+                    if (c === ')') {
+                        depth -= 1;
+                        if (depth === 0)
+                            break;
+                    }
+                    j += 1;
+                }
+                i = j + 1;
+                continue;
+            }
+            i += 2;
+            continue;
+        }
+        if (text.startsWith(quote, i))
+            return i + quote.length;
+        i += 1;
+    }
+    return -1;
+}
+/** C-ABI entry points the browser renderer calls; the linker must keep them. */
+export const WASM_EXPORTS = ['sb_event', 'sb_ops_ptr', 'sb_ops_len', 'sb_ops_clear',
+    'sb_alloc', 'sb_event_json', 'sb_state_ptr', 'sb_state_len', 'sb_run_jobs',
+    'sb_bytes', 'sb_bytes_count', 'sb_bytes_ptr', 'sb_bytes_len'];
+/** The reconciler recurses once per view; 8 MB of stack like a native thread. */
+export const APP_STACK_SIZE = 8 * 1024 * 1024;
+/**
+ * Locale.current follows the host's choice (SB_LOCALE): the two functions
+ * that hard-code en_001 in swift-foundation are redirected to FoundationBridge.
+ */
+export const LOCALE_WRAPS = [
+    '$s20FoundationEssentials11LocaleCacheV11preferencesAA0C11PreferencesV_SbtyF',
+    '$s20FoundationEssentials6LocaleV18preferredLanguagesSaySSGvgZ',
+];
+/** The linker flags of the app's target (the manifest's `wasmExports`, without `-Xlinker`). */
+export function appLinkerFlags() {
+    return [
+        ...WASM_EXPORTS.map((name) => `--export=${name}`),
+        '-z', `stack-size=${APP_STACK_SIZE}`,
+        ...LOCALE_WRAPS.map((symbol) => `--wrap=${symbol}`),
+    ];
+}
+/** The shim's products the app links: the defaults, SwiftData and the frameworks it imports. */
+export function linkedProducts(features) {
+    return [...new Set(['SwiftUI', 'Charts', 'FoundationBridge', 'os', ...(features.swiftData ? ['SwiftData'] : []), ...features.frameworks])];
+}
+/** The features `sources` (their text) call for. */
+export function featuresOf(sources) {
+    const imported = new Set(sources.flatMap((text) => importsOf(text)));
+    // `import SwiftUI` brings UIKit along, as on iOS (transformSource).
+    if (imported.has('SwiftUI'))
+        imported.add('UIKit');
+    return {
+        swiftData: imported.has('SwiftData'),
+        frameworks: LINKED_FRAMEWORKS.filter((framework) => imported.has(framework)),
+    };
+}
+/** The staged file that settles names declared by both the shim and Foundation. */
+export const FULL_FOUNDATION_FILE = '_SwiftBrowserFoundation.swift';
+/**
+ * The app imports both the shim and Foundation, and both declare a few names
+ * (a module does not shadow another's declarations, only the current module's
+ * do). A typealias in the app module does: these point the shared names at
+ * the shim's types (what its `frame(width:)` and friends take) and at
+ * FoundationBridge's `Timer` and `RunLoop`, which Foundation lacks on WASI
+ * (`RunLoop` is marked unavailable, its `Timer` needs CFRunLoop and does not
+ * link).
+ */
+export function fullFoundationSource(features = { swiftData: false, frameworks: [] }, declared = new Set()) {
+    // A name the module declares itself (an app's own `Operation` or `Timer`)
+    // is the module's: an alias of it would be a redeclaration.
+    const text = fullFoundationTemplate(features);
+    if (declared.size === 0)
+        return text;
+    return text
+        .split('\n')
+        .filter((line) => {
+        const alias = /^public typealias ([A-Za-z_][A-Za-z0-9_]*) = /.exec(line);
+        return !alias || !declared.has(alias[1]);
+    })
+        .join('\n');
+}
+/** The type names a module's sources declare at the top level (lines that start with the declaration). */
+export function declaredTypeNames(sources) {
+    const names = new Set();
+    const pattern = /^\s*(?:@[A-Za-z_]+(?:\([^)\n]*\))?\s+)*(?:(?:public|package|internal|private|fileprivate|open|final|indirect)\s+)*(?:class|struct|enum|protocol|actor|typealias)\s+([A-Za-z_][A-Za-z0-9_]*)/;
+    for (const text of sources) {
+        // Top-level declarations only (outside any braces), indented or not:
+        // code inside `#if` is often indented (swift-composable-architecture's packages).
+        let depth = 0;
+        for (const line of text.split('\n')) {
+            if (depth === 0) {
+                const match = pattern.exec(line);
+                if (match)
+                    names.add(match[1]);
+            }
+            const code = line.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/\/\/.*$/, '');
+            for (const char of code) {
+                if (char === '{')
+                    depth++;
+                else if (char === '}')
+                    depth = Math.max(0, depth - 1);
+            }
+        }
+    }
+    return names;
+}
+function fullFoundationTemplate(features) {
+    return `// Generated by @swiftbrowser/cli; rewritten on every build.
+// The shim and Foundation both declare these names. A typealias in the app
+// module settles each in the shim's favor (SwiftUI's geometry) or on the
+// bridge (Timer and RunLoop, which the SDK's Foundation does not have on WASI).
+// The imports are public: a package may make imports internal by default
+// (\`InternalImportsByDefault\`), and public aliases need public imports.
+public import SwiftUI
+public import Foundation
+public import FoundationBridge
+public import os
+
+// Public, so the app's own public API may use the names (a public method of
+// a Layout returning CGSize, for one).
+public typealias CGFloat = SwiftUI.CGFloat
+public typealias CGPoint = SwiftUI.CGPoint
+public typealias CGSize = SwiftUI.CGSize
+public typealias CGRect = SwiftUI.CGRect
+public typealias Timer = FoundationBridge.Timer
+public typealias RunLoop = FoundationBridge.RunLoop
+// UserDefaults persists through the browser; Bundle reads the app's resources.
+// Foundation's own cannot persist on WASI, and its Bundle.main traps.
+public typealias UserDefaults = FoundationBridge.UserDefaults
+public typealias Bundle = FoundationBridge.Bundle
+// Networking runs over the browser's fetch; Foundation's own is unavailable on
+// WASI (it moved to FoundationNetworking, which the SDK does not ship).
+public typealias URLSession = FoundationBridge.URLSession
+public typealias URLSessionConfiguration = FoundationBridge.URLSessionConfiguration
+public typealias URLSessionTask = FoundationBridge.URLSessionTask
+public typealias URLSessionDataTask = FoundationBridge.URLSessionDataTask
+public typealias URLSessionUploadTask = FoundationBridge.URLSessionUploadTask
+public typealias URLSessionDelegate = FoundationBridge.URLSessionDelegate
+public typealias URLSessionTaskDelegate = FoundationBridge.URLSessionTaskDelegate
+public typealias URLSessionDataDelegate = FoundationBridge.URLSessionDataDelegate
+public typealias URLRequest = FoundationBridge.URLRequest
+public typealias URLResponse = FoundationBridge.URLResponse
+public typealias HTTPURLResponse = FoundationBridge.HTTPURLResponse
+public typealias URLError = FoundationBridge.URLError
+// The SDK has no Dispatch on WASI; the bridge's queues run on the main actor.
+public typealias DispatchQueue = FoundationBridge.DispatchQueue
+public typealias DispatchTime = FoundationBridge.DispatchTime
+public typealias DispatchTimeInterval = FoundationBridge.DispatchTimeInterval
+public typealias DispatchQoS = FoundationBridge.DispatchQoS
+public typealias DispatchSpecificKey = FoundationBridge.DispatchSpecificKey
+// Dispatch declares DispatchTime's arithmetic globally (so that .now() + 0.5
+// finds it); declared here, it reaches files that import only Foundation.
+@usableFromInline func + (time: DispatchTime, seconds: Double) -> DispatchTime { time._adding(nanoseconds: seconds * 1_000_000_000) }
+@usableFromInline func - (time: DispatchTime, seconds: Double) -> DispatchTime { time._adding(nanoseconds: -seconds * 1_000_000_000) }
+@usableFromInline func + (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { FoundationBridge.DispatchTime._plus(time, interval) }
+@usableFromInline func - (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { FoundationBridge.DispatchTime._minus(time, interval) }
+public typealias DispatchSource = FoundationBridge.DispatchSource
+public typealias DispatchWorkItem = FoundationBridge.DispatchWorkItem
+public typealias DispatchWorkItemFlags = FoundationBridge.DispatchWorkItemFlags
+public typealias DispatchGroup = FoundationBridge.DispatchGroup
+public typealias DispatchSourceProtocol = FoundationBridge.DispatchSourceProtocol
+public typealias DispatchSourceMemoryPressure = FoundationBridge.DispatchSourceMemoryPressure
+public typealias DispatchSourceTimer = FoundationBridge.DispatchSourceTimer
+// Nor Operation and OperationQueue (the bridge's run on the main actor), nor
+// the rest of URL loading's types.
+public typealias Operation = FoundationBridge.Operation
+public typealias BlockOperation = FoundationBridge.BlockOperation
+public typealias OperationQueue = FoundationBridge.OperationQueue
+public typealias URLCache = FoundationBridge.URLCache
+public typealias CachedURLResponse = FoundationBridge.CachedURLResponse
+public typealias URLSessionTaskMetrics = FoundationBridge.URLSessionTaskMetrics
+public typealias URLAuthenticationChallenge = FoundationBridge.URLAuthenticationChallenge
+public typealias URLCredential = FoundationBridge.URLCredential
+public typealias URLProtectionSpace = FoundationBridge.URLProtectionSpace
+public typealias URLSessionWebSocketTask = FoundationBridge.URLSessionWebSocketTask
+// Objective-C's selectors without its runtime (FoundationBridge/Selector.swift).
+public typealias Selector = FoundationBridge.Selector
+// WASI's Foundation keeps only the message-based center; the bridge has the classic one.
+public typealias NotificationCenter = FoundationBridge.NotificationCenter
+@usableFromInline func NSSelectorFromString(_ name: String) -> FoundationBridge.Selector { FoundationBridge.NSSelectorFromString(name) }
+@usableFromInline func NSStringFromSelector(_ selector: FoundationBridge.Selector) -> String { FoundationBridge.NSStringFromSelector(selector) }
+public typealias URLSessionWebSocketDelegate = FoundationBridge.URLSessionWebSocketDelegate
+// Nor RelativeDateTimeFormatter ("2 hr. ago").
+public typealias RelativeDateTimeFormatter = FoundationBridge.RelativeDateTimeFormatter
+// What Darwin's Foundation brings along: the Core Foundation clock, the
+// Objective-C runtime's autorelease pools and associated objects, and os's lock.
+public typealias CFAbsoluteTime = FoundationBridge.CFAbsoluteTime
+public typealias CFTimeInterval = FoundationBridge.CFTimeInterval
+@usableFromInline func CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime { FoundationBridge.CFAbsoluteTimeGetCurrent() }
+@usableFromInline func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result { try FoundationBridge.autoreleasepool(invoking: body) }
+public typealias objc_AssociationPolicy = FoundationBridge.objc_AssociationPolicy
+@usableFromInline func objc_setAssociatedObject(_ object: Any, _ key: UnsafeRawPointer, _ value: Any?, _ policy: objc_AssociationPolicy) { FoundationBridge.objc_setAssociatedObject(object, key, value, policy) }
+@usableFromInline func objc_getAssociatedObject(_ object: Any, _ key: UnsafeRawPointer) -> Any? { FoundationBridge.objc_getAssociatedObject(object, key) }
+@usableFromInline func class_getInstanceSize(_ cls: AnyClass?) -> Int { FoundationBridge.class_getInstanceSize(cls) }
+@usableFromInline func sysctlbyname(_ name: UnsafePointer<CChar>?, _ oldp: UnsafeMutableRawPointer?, _ oldlenp: UnsafeMutablePointer<Int>?, _ newp: UnsafeMutableRawPointer?, _ newlen: Int) -> Int32 { FoundationBridge.sysctlbyname(name, oldp, oldlenp, newp, newlen) }
+// ProcessInfo.processInfo.physicalMemory, which reads 0 on WASI (the staging rewrites it to this).
+@usableFromInline var _swiftBrowserPhysicalMemory: UInt64 { FoundationBridge._physicalMemory }
+public typealias os_unfair_lock = os.os_unfair_lock
+public typealias os_unfair_lock_t = os.os_unfair_lock_t
+public typealias os_unfair_lock_s = os.os_unfair_lock_s
+@usableFromInline func os_unfair_lock_lock(_ lock: os_unfair_lock_t) { os.os_unfair_lock_lock(lock) }
+@usableFromInline func os_unfair_lock_unlock(_ lock: os_unfair_lock_t) { os.os_unfair_lock_unlock(lock) }
+@usableFromInline func os_unfair_lock_trylock(_ lock: os_unfair_lock_t) -> Bool { os.os_unfair_lock_trylock(lock) }
+// FoundationBridge's POSIX mutex functions (Locks.swift; WebAssembly only),
+// settled here over libc's: a module that imports CoreFoundation sees
+// pthread.h's too.
+#if os(WASI)
+@discardableResult @usableFromInline func pthread_mutex_init(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?, _ attributes: UnsafePointer<pthread_mutexattr_t>?) -> Int32 { FoundationBridge.pthread_mutex_init(mutex, attributes) }
+@discardableResult @usableFromInline func pthread_mutex_destroy(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { FoundationBridge.pthread_mutex_destroy(mutex) }
+@discardableResult @usableFromInline func pthread_mutex_lock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { FoundationBridge.pthread_mutex_lock(mutex) }
+@discardableResult @usableFromInline func pthread_mutex_trylock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { FoundationBridge.pthread_mutex_trylock(mutex) }
+@discardableResult @usableFromInline func pthread_mutex_unlock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { FoundationBridge.pthread_mutex_unlock(mutex) }
+@discardableResult @usableFromInline func pthread_mutexattr_init(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?) -> Int32 { FoundationBridge.pthread_mutexattr_init(attributes) }
+@discardableResult @usableFromInline func pthread_mutexattr_destroy(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?) -> Int32 { FoundationBridge.pthread_mutexattr_destroy(attributes) }
+@discardableResult @usableFromInline func pthread_mutexattr_settype(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?, _ type: Int32) -> Int32 { FoundationBridge.pthread_mutexattr_settype(attributes, type) }
+@usableFromInline var PTHREAD_MUTEX_NORMAL: Int32 { FoundationBridge.PTHREAD_MUTEX_NORMAL }
+@usableFromInline var PTHREAD_MUTEX_RECURSIVE: Int32 { FoundationBridge.PTHREAD_MUTEX_RECURSIVE }
+@usableFromInline var PTHREAD_MUTEX_ERRORCHECK: Int32 { FoundationBridge.PTHREAD_MUTEX_ERRORCHECK }
+@usableFromInline var PTHREAD_MUTEX_DEFAULT: Int32 { FoundationBridge.PTHREAD_MUTEX_DEFAULT }
+#endif
+${features.swiftData ? SWIFTDATA_PREDICATE : ''}`;
+}
+/**
+ * For an app that imports SwiftData: `#Predicate` expands with SwiftData's
+ * copy of Foundation's macro, which accepts `localizedStandardContains`,
+ * `localizedCompare` and `caseInsensitiveCompare` as Apple's does (the
+ * open-source macro rejects them). A macro declared in the app module shadows
+ * Foundation's; the type `Predicate` stays Foundation's.
+ */
+const SWIFTDATA_PREDICATE = `
+// SwiftData: #Predicate as on Apple platforms (Sources/SwiftDataMacros/PredicateMacro.swift).
+@freestanding(expression)
+macro Predicate<each Input>(_ body: (repeat each Input) -> Bool) -> Foundation.Predicate<repeat each Input> = #externalMacro(module: "SwiftDataMacros", type: "PredicateMacro")
+`;
+//# sourceMappingURL=appSources.js.map