@swiftbrowser/xcodeproj 0.0.0-stage → 0.2.0

package/dist/project.js

@@ -0,0 +1,578 @@
+/**
+ * Interprets a parsed `project.pbxproj` (pbxproj.ts) as targets with resolved
+ * file paths and build settings, so a CLI can find an iOS app's Swift sources,
+ * asset catalogs and settings without Xcode.
+ *
+ * Object graph in brief: the `rootObject` is a `PBXProject` with `targets`
+ * (`PBXNativeTarget`), a `mainGroup` (the tree of `PBXGroup`s and
+ * `PBXFileReference`s) and a `buildConfigurationList`. Each target has
+ * `buildPhases` (`PBXSourcesBuildPhase`, `PBXResourcesBuildPhase`, ...) whose
+ * `files` are `PBXBuildFile`s pointing at a `fileRef`, plus its own
+ * `buildConfigurationList` (`XCConfigurationList` -> `XCBuildConfiguration`
+ * with `buildSettings`). Xcode 16 projects can instead point a target at
+ * `PBXFileSystemSynchronizedRootGroup`s: folders whose contents are members of
+ * the target implicitly, minus per-target exception sets.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { isDict, parsePbxproj } from './pbxproj.js';
+import { parseXmlPlist } from './plist.js';
+export const APPLICATION_PRODUCT_TYPE = 'com.apple.product-type.application';
+/** SwiftPM's identity of a package at a URL or path: its last component, without `.git`, lower-cased. */
+export function packageIdentity(location) {
+    const last = location.replace(/[/\\]+$/, '').split(/[/\\:]/).pop() ?? location;
+    return last.replace(/\.git$/i, '').toLowerCase();
+}
+/** Reads `<xcodeprojPath>/project.pbxproj` and interprets it. */
+export function readXcodeProject(xcodeprojPath) {
+    const absolute = path.resolve(xcodeprojPath);
+    const text = fs.readFileSync(path.join(absolute, 'project.pbxproj'), 'utf8');
+    return xcodeProjectFromDocument(parsePbxproj(text), absolute);
+}
+/**
+ * Interprets an already parsed document as the project at `xcodeprojPath`
+ * (which need not exist; its parent directory is the source root).
+ */
+export function xcodeProjectFromDocument(doc, xcodeprojPath) {
+    return new ProjectReader(doc, path.resolve(xcodeprojPath)).read();
+}
+// ----- Field access helpers -------------------------------------------------
+function str(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/** The string items of an array value (anything else yields no items). */
+function strings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+/** A build setting as one string: arrays (`GCC_PREPROCESSOR_DEFINITIONS`) are space-joined. */
+function settingString(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return strings(value).join(' ');
+    return undefined;
+}
+const SYNCHRONIZED_GROUP_ISAS = new Set(['PBXFileSystemSynchronizedRootGroup']);
+const GROUP_ISAS = new Set(['PBXGroup', 'PBXVariantGroup', 'XCVersionGroup', ...SYNCHRONIZED_GROUP_ISAS]);
+// ----- Reader -----------------------------------------------------------------
+class ProjectReader {
+    doc;
+    xcodeprojPath;
+    objects;
+    project;
+    /** Source root: the directory containing the `.xcodeproj`. */
+    root;
+    /** Directory the main group resolves to: `root` plus the project's `projectDirPath` (normally empty). */
+    mainGroupDir;
+    /** Group id of every group's and file reference's parent, for `<group>`-relative paths. */
+    parentOf = new Map();
+    /**
+     * Position of every group and file reference in a depth-first walk of the main
+     * group: the order the Xcode navigator shows. Build phases list their files
+     * in creation order, which is meaningless, so we sort them by this instead.
+     */
+    navigatorIndex = new Map();
+    resolvedPaths = new Map();
+    constructor(doc, xcodeprojPath) {
+        this.doc = doc;
+        this.xcodeprojPath = xcodeprojPath;
+        this.objects = doc.objects;
+        const project = this.objects[doc.rootObject];
+        if (!project || project.isa !== 'PBXProject') {
+            throw new Error(`project.pbxproj: rootObject ${doc.rootObject} is not a PBXProject`);
+        }
+        this.project = project;
+        this.root = path.dirname(this.xcodeprojPath);
+        this.mainGroupDir = path.resolve(this.root, str(project['projectDirPath']) ?? '');
+        for (const [id, object] of Object.entries(this.objects)) {
+            if (!GROUP_ISAS.has(object.isa))
+                continue;
+            for (const child of strings(object['children']))
+                this.parentOf.set(child, id);
+        }
+        const mainGroup = str(project['mainGroup']);
+        if (mainGroup)
+            this.indexGroup(mainGroup);
+    }
+    indexGroup(id) {
+        if (this.navigatorIndex.has(id))
+            return; // cyclic or shared child
+        this.navigatorIndex.set(id, this.navigatorIndex.size);
+        const object = this.objects[id];
+        if (object && GROUP_ISAS.has(object.isa)) {
+            for (const child of strings(object['children']))
+                this.indexGroup(child);
+        }
+    }
+    read() {
+        const targets = [];
+        for (const id of strings(this.project['targets'])) {
+            const target = this.objects[id];
+            if (target?.isa === 'PBXNativeTarget')
+                targets.push(this.readTarget(id, target));
+        }
+        const packages = strings(this.project['packageReferences'])
+            .map((id) => this.packageReference(id))
+            .filter((reference) => reference !== undefined);
+        return {
+            path: this.xcodeprojPath,
+            root: this.root,
+            objectVersion: this.doc.objectVersion,
+            packages,
+            targets,
+            appTargets: () => targets.filter((target) => target.productType === APPLICATION_PRODUCT_TYPE),
+        };
+    }
+    // --- Paths ---
+    /**
+     * Absolute path of a file reference or group, following `sourceTree`:
+     * `<group>` is relative to the parent group's directory, `SOURCE_ROOT` to the
+     * source root, `<absolute>` is absolute; anything else (`BUILT_PRODUCTS_DIR`,
+     * `SDKROOT`, `DEVELOPER_DIR`) falls back to the source root. Groups without a
+     * `path` resolve to their parent's directory.
+     */
+    resolvePath(id) {
+        if (this.resolvedPaths.has(id))
+            return this.resolvedPaths.get(id);
+        this.resolvedPaths.set(id, undefined); // guards against cyclic groups
+        const object = this.objects[id];
+        if (!object)
+            return undefined;
+        const relative = str(object['path']);
+        let base;
+        switch (str(object['sourceTree']) ?? '<group>') {
+            case '<group>': {
+                const parent = this.parentOf.get(id);
+                base = (parent ? this.resolvePath(parent) : undefined) ?? this.mainGroupDir;
+                break;
+            }
+            case '<absolute>':
+                base = '/';
+                break;
+            case 'SOURCE_ROOT':
+            default:
+                base = this.root;
+                break;
+        }
+        const resolved = relative ? path.resolve(base, relative) : base;
+        this.resolvedPaths.set(id, resolved);
+        return resolved;
+    }
+    /**
+     * Absolute paths of the files a build phase's entry refers to. A
+     * `PBXVariantGroup` (localized resources) contributes each of its variants.
+     */
+    buildFilePaths(buildFileId) {
+        const buildFile = this.objects[buildFileId];
+        const fileRef = str(buildFile?.['fileRef']);
+        if (!fileRef)
+            return [];
+        const ref = this.objects[fileRef];
+        if (!ref)
+            return [];
+        if (ref.isa === 'PBXVariantGroup') {
+            return strings(ref['children'])
+                .map((child) => this.resolvePath(child))
+                .filter((p) => p !== undefined);
+        }
+        const resolved = this.resolvePath(fileRef);
+        return resolved ? [resolved] : [];
+    }
+    /** The files of the target's build phases with the given `isa`, in navigator order. */
+    buildPhaseFiles(target, isa) {
+        const buildFileIds = [];
+        for (const phaseId of strings(target['buildPhases'])) {
+            const phase = this.objects[phaseId];
+            if (phase?.isa === isa)
+                buildFileIds.push(...strings(phase['files']));
+        }
+        const position = (buildFileId) => {
+            const fileRef = str(this.objects[buildFileId]?.['fileRef']);
+            return (fileRef ? this.navigatorIndex.get(fileRef) : undefined) ?? Number.MAX_SAFE_INTEGER;
+        };
+        return buildFileIds
+            .map((id, order) => ({ id, order, position: position(id) }))
+            .sort((a, b) => a.position - b.position || a.order - b.order)
+            .flatMap((entry) => this.buildFilePaths(entry.id));
+    }
+    // --- Synchronized folders (Xcode 16) ---
+    /**
+     * The `.swift` files, Core ML models and `.xcassets` folders under the
+     * target's synchronized folders, read from disk (sorted, recursive), minus
+     * the target's membership exceptions. A folder missing on disk contributes
+     * nothing.
+     */
+    synchronizedMembers(targetId, target) {
+        const sources = [];
+        const models = [];
+        const assetCatalogs = [];
+        const localizations = [];
+        for (const groupId of strings(target['fileSystemSynchronizedGroups'])) {
+            const group = this.objects[groupId];
+            if (!group || !SYNCHRONIZED_GROUP_ISAS.has(group.isa))
+                continue;
+            const dir = this.resolvePath(groupId);
+            if (!dir)
+                continue;
+            const excluded = new Set();
+            for (const exceptionId of strings(group['exceptions'])) {
+                const exceptions = this.objects[exceptionId];
+                if (exceptions?.isa !== 'PBXFileSystemSynchronizedBuildFileExceptionSet')
+                    continue;
+                if (str(exceptions['target']) !== targetId)
+                    continue;
+                for (const relative of strings(exceptions['membershipExceptions']))
+                    excluded.add(path.resolve(dir, relative));
+            }
+            walkSynchronizedFolder(dir, (entry) => {
+                if (excluded.has(entry))
+                    return false;
+                if (entry.endsWith('.swift'))
+                    sources.push(entry);
+                else if (isCoreMLModel(entry))
+                    models.push(entry);
+                else if (entry.endsWith('.xcassets'))
+                    assetCatalogs.push(entry);
+                else if (isLocalization(entry))
+                    localizations.push(entry);
+                return true;
+            });
+        }
+        return { sources, models, assetCatalogs, localizations };
+    }
+    // --- Build settings ---
+    configurations(listId) {
+        const list = listId ? this.objects[listId] : undefined;
+        if (list?.isa !== 'XCConfigurationList')
+            return [];
+        return strings(list['buildConfigurations'])
+            .map((id) => this.objects[id])
+            .filter((config) => config?.isa === 'XCBuildConfiguration');
+    }
+    defaultConfigurationName(target) {
+        const listId = str(target['buildConfigurationList']);
+        const names = this.configurations(listId).map((config) => str(config['name']));
+        if (names.includes('Debug'))
+            return 'Debug';
+        const list = listId ? this.objects[listId] : undefined;
+        return str(list?.['defaultConfigurationName']) ?? names[0];
+    }
+    /** The `buildSettings` of the configuration named `name` in a configuration list. */
+    buildSettings(listId, name) {
+        const config = this.configurations(listId).find((candidate) => str(candidate['name']) === name);
+        const settings = config?.['buildSettings'];
+        return isDict(settings) ? settings : {};
+    }
+    /** Project-level then target-level settings for a configuration, as raw strings. */
+    rawSettings(target, configuration) {
+        const merged = {};
+        const layers = [
+            this.buildSettings(str(this.project['buildConfigurationList']), configuration),
+            this.buildSettings(str(target['buildConfigurationList']), configuration),
+        ];
+        for (const layer of layers) {
+            for (const [key, value] of Object.entries(layer)) {
+                const text = settingString(value);
+                if (text !== undefined)
+                    merged[key] = text;
+            }
+        }
+        return merged;
+    }
+    /**
+     * Expands the variables this package knows about in every value. `PRODUCT_NAME`
+     * is expanded first (with `$(TARGET_NAME)` only) because the other values may
+     * refer to it.
+     */
+    expandSettings(targetName, raw) {
+        const base = {
+            TARGET_NAME: targetName,
+            SRCROOT: this.root,
+            PROJECT_DIR: this.root,
+        };
+        const productName = expandVariables(raw['PRODUCT_NAME'] ?? '$(TARGET_NAME)', base) || targetName;
+        const variables = { ...base, PRODUCT_NAME: productName };
+        const settings = {};
+        for (const [key, value] of Object.entries(raw))
+            settings[key] = expandVariables(value, variables);
+        return settings;
+    }
+    // --- Targets ---
+    readTarget(targetId, target) {
+        const name = str(target['name']) ?? str(target['productName']) ?? targetId;
+        const defaultConfiguration = this.defaultConfigurationName(target);
+        const settingsCache = new Map();
+        const settings = (configuration = defaultConfiguration ?? '') => {
+            let result = settingsCache.get(configuration);
+            if (!result) {
+                result = this.expandSettings(name, this.rawSettings(target, configuration));
+                settingsCache.set(configuration, result);
+            }
+            return result;
+        };
+        const defaults = settings();
+        const phaseFiles = this.buildPhaseFiles(target, 'PBXSourcesBuildPhase');
+        const phaseSources = phaseFiles.filter((p) => p.endsWith('.swift'));
+        const resources = this.buildPhaseFiles(target, 'PBXResourcesBuildPhase');
+        const synchronized = this.synchronizedMembers(targetId, target);
+        const productName = defaults['PRODUCT_NAME'] || str(target['productName']) || name;
+        const result = {
+            name,
+            productType: str(target['productType']) ?? '',
+            productName,
+            sources: [...phaseSources, ...synchronized.sources],
+            models: [...phaseFiles.filter(isCoreMLModel), ...synchronized.models],
+            resources,
+            assetCatalogs: [...resources.filter((p) => p.endsWith('.xcassets')), ...synchronized.assetCatalogs],
+            localizations: [...localizationFiles(resources), ...synchronized.localizations],
+            dependencies: this.dependencyNames(target),
+            packageProducts: this.packageProductNames(target),
+            packageDependencies: this.packageProductDependencies(target),
+            settings,
+        };
+        const bundleIdentifier = defaults['PRODUCT_BUNDLE_IDENTIFIER'];
+        if (bundleIdentifier)
+            result.bundleIdentifier = bundleIdentifier;
+        const displayName = defaults['INFOPLIST_KEY_CFBundleDisplayName'] ?? this.infoPlistDisplayName(defaults['INFOPLIST_FILE']);
+        if (displayName)
+            result.displayName = displayName;
+        if (defaults['ASSETCATALOG_COMPILER_APPICON_NAME'])
+            result.appIconName = defaults['ASSETCATALOG_COMPILER_APPICON_NAME'];
+        if (defaults['SWIFT_VERSION'])
+            result.swiftVersion = defaults['SWIFT_VERSION'];
+        if (defaults['IPHONEOS_DEPLOYMENT_TARGET'])
+            result.deploymentTarget = defaults['IPHONEOS_DEPLOYMENT_TARGET'];
+        return result;
+    }
+    /** `CFBundleDisplayName` from an `INFOPLIST_FILE` (relative to the source root) when it is a readable XML plist. */
+    infoPlistDisplayName(infoPlistFile) {
+        if (!infoPlistFile)
+            return undefined;
+        let text;
+        try {
+            text = fs.readFileSync(path.resolve(this.root, infoPlistFile), 'utf8');
+        }
+        catch {
+            return undefined;
+        }
+        const plist = parseXmlPlist(text);
+        if (typeof plist !== 'object' || plist === null || Array.isArray(plist))
+            return undefined;
+        const displayName = plist['CFBundleDisplayName'];
+        return typeof displayName === 'string' && displayName !== '' ? displayName : undefined;
+    }
+    /** Names of the target dependencies: the referenced target's name, else the dependency's own `name`. */
+    dependencyNames(target) {
+        const names = [];
+        for (const dependencyId of strings(target['dependencies'])) {
+            const dependency = this.objects[dependencyId];
+            if (dependency?.isa !== 'PBXTargetDependency')
+                continue;
+            const dependedId = str(dependency['target']);
+            const depended = dependedId ? this.objects[dependedId] : undefined;
+            const name = str(depended?.['name']) ?? str(dependency['name']) ?? this.packageProductName(str(dependency['productRef']));
+            if (name)
+                names.push(name);
+        }
+        return names;
+    }
+    packageProductName(productRefId) {
+        const product = productRefId ? this.objects[productRefId] : undefined;
+        return product?.isa === 'XCSwiftPackageProductDependency' ? str(product['productName']) : undefined;
+    }
+    /**
+     * Swift package products the target links: its `packageProductDependencies`,
+     * plus any `productRef` of a build file in its Frameworks phase (older projects).
+     */
+    packageProductNames(target) {
+        const names = new Set();
+        for (const id of strings(target['packageProductDependencies'])) {
+            const name = this.packageProductName(id);
+            if (name)
+                names.add(name);
+        }
+        for (const phaseId of strings(target['buildPhases'])) {
+            const phase = this.objects[phaseId];
+            if (phase?.isa !== 'PBXFrameworksBuildPhase')
+                continue;
+            for (const buildFileId of strings(phase['files'])) {
+                const name = this.packageProductName(str(this.objects[buildFileId]?.['productRef']));
+                if (name)
+                    names.add(name);
+            }
+        }
+        return [...names];
+    }
+    /** `packageProductNames` with the package of each product, when recorded. */
+    packageProductDependencies(target) {
+        const seen = new Set();
+        const out = [];
+        const add = (productRefId) => {
+            const product = productRefId ? this.objects[productRefId] : undefined;
+            if (product?.isa !== 'XCSwiftPackageProductDependency')
+                return;
+            const name = str(product['productName']);
+            if (!name || seen.has(name))
+                return;
+            seen.add(name);
+            const reference = this.packageReference(str(product['package'])) ?? this.folderPackage(name);
+            out.push(reference ? { product: name, package: reference } : { product: name });
+        };
+        for (const id of strings(target['packageProductDependencies']))
+            add(id);
+        for (const phaseId of strings(target['buildPhases'])) {
+            const phase = this.objects[phaseId];
+            if (phase?.isa !== 'PBXFrameworksBuildPhase')
+                continue;
+            for (const buildFileId of strings(phase['files']))
+                add(str(this.objects[buildFileId]?.['productRef']));
+        }
+        return out;
+    }
+    /**
+     * Local packages added to the project as folders (how Xcode added a local
+     * package before `XCLocalSwiftPackageReference`, and still does when one is
+     * dragged in): a file reference to a folder holding a `Package.swift`. The
+     * product dependency then names no package, so the package is the folder
+     * whose manifest declares a library of that name (read from the manifest's
+     * text: `.library(name: "…"`), or, failing that, the folder of that name.
+     */
+    folderPackagesByProduct;
+    folderPackage(product) {
+        if (!this.folderPackagesByProduct) {
+            const byProduct = new Map();
+            const byFolder = new Map();
+            for (const [id, object] of Object.entries(this.objects)) {
+                if (object.isa !== 'PBXFileReference')
+                    continue;
+                const type = str(object['lastKnownFileType']) ?? str(object['explicitFileType']);
+                if (type !== undefined && type !== 'wrapper' && type !== 'folder')
+                    continue;
+                const dir = this.resolvePath(id);
+                if (!dir)
+                    continue;
+                let manifest;
+                try {
+                    manifest = fs.readFileSync(path.join(dir, 'Package.swift'), 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                const reference = { kind: 'local', path: dir, identity: packageIdentity(dir) };
+                byFolder.set(path.basename(dir), reference);
+                for (const match of manifest.matchAll(/\.library\(\s*name:\s*"([^"]+)"/g)) {
+                    if (!byProduct.has(match[1]))
+                        byProduct.set(match[1], reference);
+                }
+            }
+            for (const [name, reference] of byFolder)
+                if (!byProduct.has(name))
+                    byProduct.set(name, reference);
+            this.folderPackagesByProduct = byProduct;
+        }
+        return this.folderPackagesByProduct.get(product);
+    }
+    /** An `XCRemoteSwiftPackageReference` or `XCLocalSwiftPackageReference`. */
+    packageReference(id) {
+        const object = id ? this.objects[id] : undefined;
+        if (object?.isa === 'XCRemoteSwiftPackageReference') {
+            const url = str(object['repositoryURL']);
+            if (!url)
+                return undefined;
+            const requirement = packageRequirement(object['requirement']);
+            return requirement ? { kind: 'remote', url, identity: packageIdentity(url), requirement } : { kind: 'remote', url, identity: packageIdentity(url) };
+        }
+        if (object?.isa === 'XCLocalSwiftPackageReference') {
+            const relative = str(object['relativePath']);
+            if (!relative)
+                return undefined;
+            const absolute = path.resolve(this.root, relative);
+            return { kind: 'local', path: absolute, identity: packageIdentity(absolute) };
+        }
+        return undefined;
+    }
+}
+/** Xcode's dependency rule; undefined for a kind it does not spell out here. */
+function packageRequirement(value) {
+    if (!isDict(value))
+        return undefined;
+    const minimumVersion = str(value['minimumVersion']);
+    switch (str(value['kind'])) {
+        case 'upToNextMajorVersion':
+            return minimumVersion ? { kind: 'upToNextMajorVersion', minimumVersion } : undefined;
+        case 'upToNextMinorVersion':
+            return minimumVersion ? { kind: 'upToNextMinorVersion', minimumVersion } : undefined;
+        case 'exactVersion': {
+            const version = str(value['version']);
+            return version ? { kind: 'exactVersion', version } : undefined;
+        }
+        case 'versionRange': {
+            const maximumVersion = str(value['maximumVersion']);
+            return minimumVersion && maximumVersion ? { kind: 'versionRange', minimumVersion, maximumVersion } : undefined;
+        }
+        case 'branch': {
+            const branch = str(value['branch']);
+            return branch ? { kind: 'branch', branch } : undefined;
+        }
+        case 'revision': {
+            const revision = str(value['revision']);
+            return revision ? { kind: 'revision', revision } : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+// ----- Helpers ----------------------------------------------------------------
+/**
+ * Replaces `$(NAME)` and `${NAME}` for the names in `variables`; other
+ * references (`$(inherited)`, `$(SDKROOT)`, ...) are kept verbatim.
+ */
+export function expandVariables(value, variables) {
+    return value.replace(/\$[({]([A-Za-z_][A-Za-z0-9_]*)[)}]/g, (whole, name) => variables[name] ?? whole);
+}
+/**
+ * Visits every entry under `dir` in sorted order, depth first. `visit` returns
+ * whether to descend into a directory; `.xcassets` bundles and dot-entries are
+ * never descended into. Unreadable directories are skipped.
+ */
+/** A string catalog, or a `.strings` / `.stringsdict` table. */
+function isLocalization(file) {
+    return /\.(xcstrings|strings|stringsdict)$/.test(file);
+}
+/** The localization files among resources: catalogs and tables, and the tables in `.lproj` folders. */
+function localizationFiles(resources) {
+    const out = [];
+    for (const resource of resources) {
+        if (isLocalization(resource)) {
+            out.push(resource);
+        }
+        else if (resource.endsWith('.lproj') && fs.existsSync(resource) && fs.statSync(resource).isDirectory()) {
+            for (const name of fs.readdirSync(resource).sort())
+                if (isLocalization(name))
+                    out.push(path.join(resource, name));
+        }
+    }
+    return out;
+}
+function walkSynchronizedFolder(dir, visit) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const full = path.join(dir, entry.name);
+        const descend = visit(full);
+        if (descend && entry.isDirectory() && !entry.name.endsWith('.xcassets') && !entry.name.endsWith('.mlpackage'))
+            walkSynchronizedFolder(full, visit);
+    }
+}
+/** A Core ML model Xcode compiles into a class: an `.mlmodel` file or an `.mlpackage` bundle. */
+function isCoreMLModel(file) {
+    return file.endsWith('.mlmodel') || file.endsWith('.mlpackage');
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@swiftbrowser/xcodeproj",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Reads Xcode projects (project.pbxproj): app targets, their Swift sources, asset catalogs and build settings. Pure TypeScript, no Xcode needed.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noya-app/SwiftBrowser.git",
+    "directory": "packages/xcodeproj"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test:unit": "vitest run",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.4",
+    "typescript": "^5.9.2",
+    "vitest": "^5.0.3"
+  }
+}