@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/os/os.swift

@@ -0,0 +1,376 @@
+// `import os` for the browser: Apple's unified logging, signposts and
+// `os_unfair_lock`, as packages use them. The page has one thread, so the
+// lock never waits (it still checks that it is not taken twice); log
+// messages go to standard error, which the page shows in the console, and
+// signposts are dropped.
+
+/// A lock, as `os_unfair_lock_t` points to one.
+public struct os_unfair_lock: Sendable {
+    var _locked = false
+
+    public init() {}
+}
+
+public typealias os_unfair_lock_t = UnsafeMutablePointer<os_unfair_lock>
+public typealias os_unfair_lock_s = os_unfair_lock
+
+public func os_unfair_lock_lock(_ lock: os_unfair_lock_t) {
+    precondition(!lock.pointee._locked, "os_unfair_lock_lock: the lock is already held (the browser has one thread, so this would wait forever)")
+    lock.pointee._locked = true
+}
+
+public func os_unfair_lock_unlock(_ lock: os_unfair_lock_t) {
+    lock.pointee._locked = false
+}
+
+public func os_unfair_lock_trylock(_ lock: os_unfair_lock_t) -> Bool {
+    guard !lock.pointee._locked else { return false }
+    lock.pointee._locked = true
+    return true
+}
+
+public func os_unfair_lock_assert_owner(_ lock: os_unfair_lock_t) {}
+public func os_unfair_lock_assert_not_owner(_ lock: os_unfair_lock_t) {}
+
+/// A lock that owns the state it protects (`OSAllocatedUnfairLock<State>`).
+/// The page has one thread, so it never waits; taking it inside its own
+/// `withLock` traps, as `os_unfair_lock` does.
+public struct OSAllocatedUnfairLock<State>: @unchecked Sendable {
+    final class Storage {
+        var state: State
+        var locked = false
+        init(_ state: State) { self.state = state }
+    }
+
+    let storage: Storage
+
+    public init(uncheckedState initialState: State) { storage = Storage(initialState) }
+    public init(initialState: State) where State: Sendable { storage = Storage(initialState) }
+
+    public func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R: Sendable {
+        try withLockUnchecked(body)
+    }
+
+    public func withLockUnchecked<R>(_ body: (inout State) throws -> R) rethrows -> R {
+        Swift.precondition(!storage.locked, "OSAllocatedUnfairLock: the lock is already held (the browser has one thread, so this would wait forever)")
+        storage.locked = true
+        defer { storage.locked = false }
+        return try body(&storage.state)
+    }
+
+    public func withLockIfAvailable<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R? where R: Sendable {
+        guard !storage.locked else { return nil }
+        return try withLockUnchecked(body)
+    }
+
+    public func withLockIfAvailableUnchecked<R>(_ body: (inout State) throws -> R) rethrows -> R? {
+        guard !storage.locked else { return nil }
+        return try withLockUnchecked(body)
+    }
+
+    public func precondition(_ condition: Ownership) {}
+
+    public enum Ownership: Sendable { case owner, notOwner }
+}
+
+extension OSAllocatedUnfairLock where State == () {
+    public init() { storage = Storage(()) }
+
+    public func lock() {
+        Swift.precondition(!storage.locked, "OSAllocatedUnfairLock: the lock is already held")
+        storage.locked = true
+    }
+
+    public func unlock() { storage.locked = false }
+
+    public func lockIfAvailable() -> Bool {
+        guard !storage.locked else { return false }
+        storage.locked = true
+        return true
+    }
+
+    public func withLock<R>(_ body: @Sendable () throws -> R) rethrows -> R where R: Sendable {
+        try withLockUnchecked { _ in try body() }
+    }
+}
+
+// MARK: - Logging
+
+/// The type of a log message.
+public struct OSLogType: Equatable, Hashable, RawRepresentable, Sendable {
+    public let rawValue: UInt8
+    public init(rawValue: UInt8) { self.rawValue = rawValue }
+    public init(_ rawValue: UInt8) { self.rawValue = rawValue }
+
+    public static let `default` = OSLogType(rawValue: 0x00)
+    public static let info = OSLogType(rawValue: 0x01)
+    public static let debug = OSLogType(rawValue: 0x02)
+    public static let error = OSLogType(rawValue: 0x10)
+    public static let fault = OSLogType(rawValue: 0x11)
+}
+
+/// A log: a subsystem and a category its messages are tagged with.
+public final class OSLog: @unchecked Sendable {
+    public struct Category: Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let pointsOfInterest = Category(rawValue: "PointsOfInterest")
+        public static let dynamicTracing = Category(rawValue: "DynamicTracing")
+        public static let dynamicStackTracing = Category(rawValue: "DynamicStackTracing")
+    }
+
+    public let subsystem: String
+    public let category: String
+    let enabled: Bool
+
+    public init(subsystem: String, category: String) {
+        self.subsystem = subsystem
+        self.category = category
+        self.enabled = true
+    }
+
+    public convenience init(subsystem: String, category: Category) {
+        self.init(subsystem: subsystem, category: category.rawValue)
+    }
+
+    private init(disabled: Void) {
+        subsystem = ""
+        category = ""
+        enabled = false
+    }
+
+    public static let `default` = OSLog(subsystem: "", category: "")
+    public static let disabled = OSLog(disabled: ())
+
+    public var signpostsEnabled: Bool { false }
+
+    public func isEnabled(type: OSLogType) -> Bool { enabled }
+}
+
+func _write(_ log: OSLog, _ type: OSLogType, _ message: String) {
+    guard log.enabled, type != .debug else { return }
+    let tag = [log.subsystem, log.category].filter { !$0.isEmpty }.joined(separator: " ")
+    _standardError((tag.isEmpty ? "" : "[\(tag)] ") + message + "\n")
+}
+
+/// `os_log("…", log: …, type: …, args…)`: the arguments fill the `%@`, `%d`,
+/// `%s` (and `%{public}…`) placeholders in order.
+public func os_log(_ message: StaticString, dso: UnsafeRawPointer? = nil, log: OSLog = .default, type: OSLogType = .default, _ args: any CVarArg...) {
+    _write(log, type, _format("\(message)", args))
+}
+
+public func os_log(_ type: OSLogType, dso: UnsafeRawPointer? = nil, log: OSLog = .default, _ message: StaticString, _ args: any CVarArg...) {
+    _write(log, type, _format("\(message)", args))
+}
+
+/// Replaces each `%…` placeholder with the next argument.
+func _format(_ format: String, _ args: [any CVarArg]) -> String {
+    var out = ""
+    var remaining = args[...]
+    var chars = format[...]
+    while let c = chars.first {
+        chars = chars.dropFirst()
+        guard c == "%" else { out.append(c); continue }
+        if chars.first == "%" { out.append("%"); chars = chars.dropFirst(); continue }
+        // Skip `{public}`-style privacy and the conversion's flags, up to its letter.
+        if chars.first == "{", let close = chars.firstIndex(of: "}") { chars = chars[chars.index(after: close)...] }
+        // Flags, width, precision and length modifiers, then one conversion character.
+        while let f = chars.first, "0123456789.-+ #'lhqzjtL".contains(f) { chars = chars.dropFirst() }
+        chars = chars.dropFirst()
+        if let next = remaining.first {
+            out += "\(next)"
+            remaining = remaining.dropFirst()
+        }
+    }
+    return out
+}
+
+/// The modern logging API: `Logger(subsystem:category:).info("…")`. A
+/// message is an `OSLogMessage`, so interpolations take `privacy:`,
+/// `format:` and `align:` as on Apple platforms; the browser's console is the
+/// developer's own, so every value is written out whatever its privacy.
+public struct Logger: Sendable {
+    let log: OSLog
+
+    public init(subsystem: String, category: String) { log = OSLog(subsystem: subsystem, category: category) }
+    public init(_ log: OSLog) { self.log = log }
+    public init() { log = .default }
+
+    public func log(level: OSLogType = .default, _ message: OSLogMessage) { _write(log, level, message.text) }
+    public func log(_ message: OSLogMessage) { _write(log, .default, message.text) }
+    public func trace(_ message: OSLogMessage) { _write(log, .debug, message.text) }
+    public func debug(_ message: OSLogMessage) { _write(log, .debug, message.text) }
+    public func info(_ message: OSLogMessage) { _write(log, .info, message.text) }
+    public func notice(_ message: OSLogMessage) { _write(log, .default, message.text) }
+    public func warning(_ message: OSLogMessage) { _write(log, .error, message.text) }
+    public func error(_ message: OSLogMessage) { _write(log, .error, message.text) }
+    public func critical(_ message: OSLogMessage) { _write(log, .fault, message.text) }
+    public func fault(_ message: OSLogMessage) { _write(log, .fault, message.text) }
+}
+
+/// A log message: a string literal with interpolated values, each with its
+/// privacy and formatting.
+public struct OSLogMessage: ExpressibleByStringInterpolation, ExpressibleByStringLiteral, Sendable {
+    let text: String
+
+    public init(stringLiteral value: String) { text = value }
+    public init(stringInterpolation: OSLogInterpolation) { text = stringInterpolation.text }
+
+    public struct OSLogInterpolation: StringInterpolationProtocol, Sendable {
+        var text = ""
+        public init(literalCapacity: Int, interpolationCount: Int) { text.reserveCapacity(literalCapacity) }
+        public mutating func appendLiteral(_ literal: String) { text += literal }
+
+        public mutating func appendInterpolation<T>(_ value: @autoclosure () -> T, privacy: OSLogPrivacy = .auto, attributes: String = "") {
+            text += String(describing: value())
+        }
+
+        public mutating func appendInterpolation<T>(_ value: @autoclosure () -> T, align: OSLogStringAlignment, privacy: OSLogPrivacy = .auto) {
+            text += align.aligned(String(describing: value()))
+        }
+
+        public mutating func appendInterpolation<T: BinaryInteger>(_ number: @autoclosure () -> T, format: OSLogIntegerFormatting = .decimal, align: OSLogStringAlignment = .none, privacy: OSLogPrivacy = .auto) {
+            text += align.aligned(format.formatted(number()))
+        }
+
+        public mutating func appendInterpolation<T: BinaryFloatingPoint>(_ number: @autoclosure () -> T, format: OSLogFloatFormatting = .fixed, align: OSLogStringAlignment = .none, privacy: OSLogPrivacy = .auto) {
+            text += align.aligned(format.formatted(Double(number())))
+        }
+
+        public mutating func appendInterpolation(_ boolean: @autoclosure () -> Bool, format: OSLogBoolFormat = .truth, privacy: OSLogPrivacy = .auto) {
+            let value = boolean()
+            text += format == .answer ? (value ? "YES" : "NO") : (value ? "true" : "false")
+        }
+    }
+}
+
+public typealias OSLogInterpolation = OSLogMessage.OSLogInterpolation
+
+/// Who may read an interpolated value in the log. The browser's console
+/// shows them all.
+public struct OSLogPrivacy: Equatable, Sendable {
+    public enum Mask: Equatable, Sendable { case hash, none }
+    let name: String
+    public static let auto = OSLogPrivacy(name: "auto")
+    public static let `public` = OSLogPrivacy(name: "public")
+    public static let `private` = OSLogPrivacy(name: "private")
+    public static let sensitive = OSLogPrivacy(name: "sensitive")
+    public static func auto(mask: Mask) -> OSLogPrivacy { .auto }
+    public static func `private`(mask: Mask) -> OSLogPrivacy { .private }
+    public static func sensitive(mask: Mask) -> OSLogPrivacy { .sensitive }
+}
+
+public struct OSLogStringAlignment: Sendable {
+    let columns: Int
+    public static let none = OSLogStringAlignment(columns: 0)
+    public static func left(columns: @autoclosure () -> Int) -> OSLogStringAlignment { OSLogStringAlignment(columns: -columns()) }
+    public static func right(columns: @autoclosure () -> Int) -> OSLogStringAlignment { OSLogStringAlignment(columns: columns()) }
+
+    func aligned(_ text: String) -> String {
+        let pad = String(repeating: " ", count: max(0, abs(columns) - text.count))
+        return columns < 0 ? text + pad : pad + text
+    }
+}
+
+public struct OSLogIntegerFormatting: Sendable {
+    let radix: Int
+    let prefix: String
+    let uppercase: Bool
+    let minDigits: Int
+    let explicitPositiveSign: Bool
+
+    public static let decimal = OSLogIntegerFormatting(radix: 10, prefix: "", uppercase: false, minDigits: 0, explicitPositiveSign: false)
+    public static let hex = OSLogIntegerFormatting(radix: 16, prefix: "", uppercase: false, minDigits: 0, explicitPositiveSign: false)
+    public static let octal = OSLogIntegerFormatting(radix: 8, prefix: "", uppercase: false, minDigits: 0, explicitPositiveSign: false)
+
+    public static func decimal(explicitPositiveSign: Bool = false, minDigits: @autoclosure () -> Int = 0) -> OSLogIntegerFormatting {
+        OSLogIntegerFormatting(radix: 10, prefix: "", uppercase: false, minDigits: minDigits(), explicitPositiveSign: explicitPositiveSign)
+    }
+
+    public static func hex(explicitPositiveSign: Bool = false, includePrefix: Bool = false, uppercase: Bool = false, minDigits: @autoclosure () -> Int = 0) -> OSLogIntegerFormatting {
+        OSLogIntegerFormatting(radix: 16, prefix: includePrefix ? "0x" : "", uppercase: uppercase, minDigits: minDigits(), explicitPositiveSign: explicitPositiveSign)
+    }
+
+    public static func octal(explicitPositiveSign: Bool = false, includePrefix: Bool = false, uppercase: Bool = false, minDigits: @autoclosure () -> Int = 0) -> OSLogIntegerFormatting {
+        OSLogIntegerFormatting(radix: 8, prefix: includePrefix ? "0o" : "", uppercase: uppercase, minDigits: minDigits(), explicitPositiveSign: explicitPositiveSign)
+    }
+
+    func formatted<T: BinaryInteger>(_ value: T) -> String {
+        var digits = String(value.magnitude, radix: radix, uppercase: uppercase)
+        if digits.count < minDigits { digits = String(repeating: "0", count: minDigits - digits.count) + digits }
+        let sign = value < 0 ? "-" : explicitPositiveSign ? "+" : ""
+        return sign + prefix + digits
+    }
+}
+
+public struct OSLogFloatFormatting: Sendable {
+    let precision: Int?
+    public static let fixed = OSLogFloatFormatting(precision: nil)
+    public static let hybrid = OSLogFloatFormatting(precision: nil)
+    public static let exponential = OSLogFloatFormatting(precision: nil)
+    public static func fixed(precision: @autoclosure () -> Int, explicitPositiveSign: Bool = false, uppercase: Bool = false) -> OSLogFloatFormatting {
+        OSLogFloatFormatting(precision: precision())
+    }
+    public static func fixed(explicitPositiveSign: Bool = false, uppercase: Bool = false) -> OSLogFloatFormatting { .fixed }
+    public static func hybrid(precision: @autoclosure () -> Int, explicitPositiveSign: Bool = false, uppercase: Bool = false) -> OSLogFloatFormatting {
+        OSLogFloatFormatting(precision: precision())
+    }
+    public static func exponential(precision: @autoclosure () -> Int, explicitPositiveSign: Bool = false, uppercase: Bool = false) -> OSLogFloatFormatting {
+        OSLogFloatFormatting(precision: precision())
+    }
+
+    func formatted(_ value: Double) -> String {
+        guard let precision, value.isFinite else { return "\(value)" }
+        // Round half away from zero to `precision` digits after the point.
+        var scale = 1.0
+        for _ in 0..<precision { scale *= 10 }
+        let scaled = (abs(value) * scale).rounded()
+        let whole = Int(scaled / scale)
+        var fraction = String(Int(scaled) - whole * Int(scale))
+        fraction = String(repeating: "0", count: max(0, precision - fraction.count)) + fraction
+        return (value < 0 ? "-" : "") + String(whole) + (precision > 0 ? "." + fraction : "")
+    }
+}
+
+public enum OSLogBoolFormat: Sendable { case truth, answer }
+
+// MARK: - Signposts
+
+public enum OSSignpostType: Sendable {
+    case event, begin, end
+}
+
+public struct OSSignpostID: Equatable, Hashable, Comparable, Sendable {
+    public let rawValue: UInt64
+    public init(_ rawValue: UInt64) { self.rawValue = rawValue }
+    public init(log: OSLog) { rawValue = 1 }
+    public init(log: OSLog, object: AnyObject) { rawValue = UInt64(UInt(bitPattern: ObjectIdentifier(object).hashValue)) }
+
+    public static let exclusive = OSSignpostID(0xEEEE_B0B5_B2B2_EEEE)
+    public static let invalid = OSSignpostID(0)
+    public static let null = OSSignpostID(0)
+
+    public static func < (lhs: OSSignpostID, rhs: OSSignpostID) -> Bool { lhs.rawValue < rhs.rawValue }
+}
+
+/// Dropped: the browser has no Instruments to show them.
+public func os_signpost(_ type: OSSignpostType, dso: UnsafeRawPointer? = nil, log: OSLog, name: StaticString, signpostID: OSSignpostID = .exclusive) {}
+
+public func os_signpost(_ type: OSSignpostType, dso: UnsafeRawPointer? = nil, log: OSLog, name: StaticString, signpostID: OSSignpostID = .exclusive, _ format: StaticString, _ arguments: any CVarArg...) {}
+
+// MARK: - Output
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+func _standardError(_ text: String) {
+    var bytes = Array(text.utf8)
+    _ = bytes.withUnsafeMutableBytes { write(2, $0.baseAddress, $0.count) }
+}

package/Sources/zlib/zlib.swift

@@ -0,0 +1,6 @@
+// `import zlib` for the browser: zlib's decompression API (`inflateInit2_`,
+// `inflate`, `inflateEnd` over a `z_stream`) lives in the Compression module
+// (Sources/Compression/Zlib.swift) next to the DEFLATE decoder it runs on,
+// and this module re-exports it. RevenueCat gunzips its container elements
+// this way.
+@_exported import Compression

package/index.d.ts

@@ -1,2 +1,2 @@
-/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts and FoundationLite products. */
+/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts and FoundationBridge products. */
 export function swiftPackagePath(): string;

package/index.mjs

@@ -1,13 +1,13 @@
 // Where the Swift package lives: next to this file once `Sources/` was synced
 // (a published tarball), else the repository root (a checkout, whose
-// Package.swift carries the same library products plus the examples).
+// Package.swift carries the same library products).
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 
-/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts, FoundationLite and FoundationBridge products. */
+/** Absolute path of a directory holding a Package.swift with the SwiftUI, Charts, SwiftData and FoundationBridge products. */
 export function swiftPackagePath() {
   if (existsSync(path.join(here, 'Sources', 'SwiftUI'))) return here;
   const repoRoot = path.resolve(here, '../..');

package/manifest.d.mts

@@ -0,0 +1,2 @@
+export function publishedManifest(rootManifest: string): string;
+export function sourceDirectories(manifest: string): string[];

package/manifest.mjs

@@ -0,0 +1,41 @@
+// The published package's manifest, made from the repository's Package.swift
+// so the two cannot drift: the same library products and targets, without the
+// test targets and the HelloWasm executable (whose sources are not shipped),
+// and without the lines marked `// repository only`, under this package's own
+// header comment.
+
+const HEADER = `// The SwiftBrowser Swift package as @swiftbrowser/cli ships it: every library
+// of the repository's Package.swift (the SwiftUI shim, Charts, SwiftData,
+// FoundationBridge and the framework and package stand-ins), library products
+// only. Generated from that manifest by sync-sources.mjs (manifest.mjs), which
+// also copies the targets' Sources/ in at \`npm pack\` time; in a repository
+// checkout the CLI uses the repository's own Package.swift.
+`;
+
+/** `rootManifest` (the repository's Package.swift) as this package's manifest. */
+export function publishedManifest(rootManifest) {
+  const lines = rootManifest.split('\n');
+  const start = lines.findIndex((line) => line.startsWith('let package = Package('));
+  if (start < 0) throw new Error('manifest.mjs: no `let package = Package(` in the root manifest');
+  const imports = lines
+    .slice(0, start)
+    .filter((line) => (line.startsWith('// swift-tools-version') || line.startsWith('import ')) && !line.trim().endsWith('// repository only'));
+  const body = [];
+  for (const line of lines.slice(start)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('.executable(') || trimmed.startsWith('.executableTarget(') || trimmed.startsWith('.testTarget(')) continue;
+    if (trimmed.endsWith('// repository only')) continue;
+    if (trimmed === '// Smallest possible Swift-on-Wasm program; CI runs it under wasmtime.') continue;
+    // Collapse the blank lines the removed declarations leave behind.
+    if (trimmed === '' && body.length > 0 && body[body.length - 1].trim() === '') continue;
+    body.push(line);
+  }
+  // A trailing blank line before the closing bracket of `targets:`.
+  const text = body.join('\n').replace(/\n\s*\n(\s*\]\n\))/, '\n$1');
+  return `${imports[0]}\n${HEADER}${imports.slice(1).join('\n')}\n\n${text}`;
+}
+
+/** The `Sources/<name>` folders a manifest's targets build from. */
+export function sourceDirectories(manifest) {
+  return [...manifest.matchAll(/path: "Sources\/([^"/]+)"/g)].map((match) => match[1]);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@swiftbrowser/swift",
-  "version": "0.1.0",
-  "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, FoundationLite and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
+  "version": "0.3.0",
+  "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, SwiftData and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/dabbott/SwiftBrowser.git",
+    "url": "git+https://github.com/noya-app/SwiftBrowser.git",
     "directory": "packages/swift"
   },
   "files": [
@@ -12,6 +12,8 @@
     "Sources",
     "index.mjs",
     "index.d.ts",
+    "manifest.mjs",
+    "manifest.d.mts",
     "sync-sources.mjs",
     "README.md"
   ],

package/sync-sources.mjs

@@ -1,19 +1,33 @@
-// `npm pack` / `npm publish` hook: copy the repository's Sources/ (the SwiftUI
-// shim, Charts, FoundationLite, FoundationBridge) into this package so the published tarball is a
-// complete Swift package. The copy is gitignored.
-import { cpSync, existsSync, rmSync } from 'node:fs';
+// `npm pack` / `npm publish` hook (and CI, before building apps against the
+// published layout): write this package's Package.swift from the
+// repository's (manifest.mjs) and copy in the Sources/ folder of every target
+// it declares, so the published tarball is a complete Swift package. The
+// Sources copy is gitignored; the manifest is committed, and a CLI test checks
+// it matches the repository's. `--manifest-only` writes the manifest and copies
+// nothing (in a checkout, a synced Sources/ would make the CLI build against
+// the copy instead of the repository's sources).
+import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { publishedManifest, sourceDirectories } from './manifest.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-const repoSources = path.resolve(here, '../../Sources');
+const repoRoot = path.resolve(here, '../..');
+const repoSources = path.join(repoRoot, 'Sources');
 const dest = path.join(here, 'Sources');
 if (!existsSync(repoSources)) {
   console.error(`sync-sources: ${repoSources} not found; run from a repository checkout`);
   process.exit(1);
 }
+const manifest = publishedManifest(readFileSync(path.join(repoRoot, 'Package.swift'), 'utf8'));
+writeFileSync(path.join(here, 'Package.swift'), manifest);
+if (process.argv.includes('--manifest-only')) {
+  console.log(`sync-sources: wrote ${path.join(here, 'Package.swift')}`);
+  process.exit(0);
+}
 rmSync(dest, { recursive: true, force: true });
-for (const target of ['SwiftUI', 'Charts', '_FoundationCommon', 'FoundationLite', 'FoundationBridge']) {
+const targets = sourceDirectories(manifest);
+for (const target of targets) {
   cpSync(path.join(repoSources, target), path.join(dest, target), { recursive: true });
 }
-console.log(`sync-sources: copied Sources/{SwiftUI,Charts,_FoundationCommon,FoundationLite,FoundationBridge} into ${dest}`);
+console.log(`sync-sources: wrote Package.swift and copied Sources/{${targets.join(',')}} into ${here}`);

package/Sources/FoundationLite/Common.swift

@@ -1,3 +0,0 @@
-// `UserDefaults` and `Bundle` for the browser are shared with FoundationBridge
-// (Sources/_FoundationCommon); they are part of this module's API.
-@_exported import _FoundationCommon