rork-xcode 0.1.0 → 0.3.0

package/dist/index.js

@@ -14,7 +14,7 @@ function isDictionary(value) {
 * Field access on parsed documents goes through this because any field of
 * an untrusted document can hold any value type.
 */
-function asString(value) {
+function asString$1(value) {
 	return typeof value === "string" ? value : void 0;
 }
 /**
@@ -70,33 +70,33 @@ function createReferenceComments(root) {
 	for (const ownerId of Object.keys(objects)) {
 		const owner = objects[ownerId];
 		if (!isDictionary(owner)) continue;
-		const isa = asString(owner["isa"]) ?? "";
+		const isa = asString$1(owner["isa"]) ?? "";
 		if (isa.endsWith("BuildPhase")) indexFirst(fileToPhase, owner["files"], {
 			isa,
-			name: asString(owner["name"])
+			name: asString$1(owner["name"])
 		});
 		else if (isa === "PBXContainerItemProxy") {
-			const portal = asString(owner["containerPortal"]);
-			const remoteInfo = asString(owner["remoteInfo"]);
+			const portal = asString$1(owner["containerPortal"]);
+			const remoteInfo = asString$1(owner["remoteInfo"]);
 			if (portal != null && remoteInfo != null && !proxyRemoteInfoByPortal.has(portal)) proxyRemoteInfoByPortal.set(portal, remoteInfo);
 		}
 		indexFirst(syncGroupByExceptionSet, owner["exceptions"], owner);
 		indexFirst(targetByBuildPhase, owner["buildPhases"], owner);
-		const listId = asString(owner["buildConfigurationList"]);
+		const listId = asString$1(owner["buildConfigurationList"]);
 		if (listId != null && !configurationListOwners.has(listId)) configurationListOwners.set(listId, [ownerId, owner]);
 	}
 	/**
 	* The name an object displays as when nothing more specific applies:
 	* `name`, then `productName`, then `path`, then its isa.
 	*/
-	const defaultName = (object, isa) => asString(object["name"]) ?? asString(object["productName"]) ?? asString(object["path"]) ?? isa;
+	const defaultName = (object, isa) => asString$1(object["name"]) ?? asString$1(object["productName"]) ?? asString$1(object["path"]) ?? isa;
 	/**
 	* The display name of the synchronized folder an exception set belongs
 	* to, found through the sync group whose `exceptions` array lists it.
 	*/
 	const exceptionSetFolderName = (id) => {
 		const group = syncGroupByExceptionSet.get(id);
-		return group == null ? void 0 : asString(group["name"]) ?? asString(group["path"]);
+		return group == null ? void 0 : asString$1(group["name"]) ?? asString$1(group["path"]);
 	};
 	/**
 	* Comment for a `PBXFileSystemSynchronizedBuildFileExceptionSet`,
@@ -106,10 +106,10 @@ function createReferenceComments(root) {
 	*/
 	const buildFileExceptionSetComment = (id, set) => {
 		const folder = exceptionSetFolderName(id);
-		const targetId = asString(set["target"]);
+		const targetId = asString$1(set["target"]);
 		const target = targetId == null ? void 0 : objects[targetId];
 		if (folder == null || !isDictionary(target)) return;
-		const targetName = asString(target["name"]) ?? asString(target["productName"]) ?? asString(target["path"]);
+		const targetName = asString$1(target["name"]) ?? asString$1(target["productName"]) ?? asString$1(target["path"]);
 		return targetName == null ? void 0 : `Exceptions for "${folder}" folder in "${targetName}" target`;
 	};
 	/**
@@ -120,12 +120,12 @@ function createReferenceComments(root) {
 	*/
 	const membershipExceptionSetComment = (id, set) => {
 		const folder = exceptionSetFolderName(id);
-		const phaseId = asString(set["buildPhase"]);
+		const phaseId = asString$1(set["buildPhase"]);
 		const phase = phaseId == null ? void 0 : objects[phaseId];
 		if (folder == null || phaseId == null || !isDictionary(phase)) return;
-		const phaseName = asString(phase["name"]) ?? defaultBuildPhaseName(asString(phase["isa"]) ?? "");
+		const phaseName = asString$1(phase["name"]) ?? defaultBuildPhaseName(asString$1(phase["isa"]) ?? "");
 		const target = targetByBuildPhase.get(phaseId);
-		const targetName = target == null ? void 0 : asString(target["name"]) ?? asString(target["productName"]) ?? asString(target["path"]);
+		const targetName = target == null ? void 0 : asString$1(target["name"]) ?? asString$1(target["productName"]) ?? asString$1(target["path"]);
 		if (phaseName == null || targetName == null) return;
 		return `Exceptions for "${folder}" folder in "${phaseName}" phase from "${targetName}" target`;
 	};
@@ -136,7 +136,7 @@ function createReferenceComments(root) {
 	const buildFileComment = (id, buildFile) => {
 		const phase = fileToPhase.get(id);
 		const phaseName = phase == null ? "[missing build phase]" : phase.name ?? defaultBuildPhaseName(phase.isa) ?? "";
-		const refId = asString(buildFile["fileRef"]) ?? asString(buildFile["productRef"]);
+		const refId = asString$1(buildFile["fileRef"]) ?? asString$1(buildFile["productRef"]);
 		const referenced = refId == null ? void 0 : objects[refId];
 		return `${(refId != null && isDictionary(referenced) ? commentFor(refId, referenced) : void 0) ?? "(null)"} in ${phaseName}`;
 	};
@@ -148,15 +148,15 @@ function createReferenceComments(root) {
 		const ownerEntry = configurationListOwners.get(id);
 		if (ownerEntry == null) return "Build configuration list for [unknown]";
 		const [ownerId, owner] = ownerEntry;
-		const isa = asString(owner["isa"]) ?? "";
-		const ownName = asString(owner["name"]) ?? asString(owner["path"]) ?? asString(owner["productName"]);
+		const isa = asString$1(owner["isa"]) ?? "";
+		const ownName = asString$1(owner["name"]) ?? asString$1(owner["path"]) ?? asString$1(owner["productName"]);
 		if (ownName != null) return `Build configuration list for ${isa} "${ownName}"`;
 		const targets = owner["targets"];
 		if (Array.isArray(targets)) {
 			const firstTargetId = targets.find((target) => typeof target === "string");
 			const firstTarget = firstTargetId == null ? void 0 : objects[firstTargetId];
 			if (isDictionary(firstTarget)) {
-				const targetName = asString(firstTarget["productName"]) ?? asString(firstTarget["name"]);
+				const targetName = asString$1(firstTarget["productName"]) ?? asString$1(firstTarget["name"]);
 				if (targetName != null) return `Build configuration list for ${isa} "${targetName}"`;
 			}
 		}
@@ -172,7 +172,7 @@ function createReferenceComments(root) {
 	const commentFor = (id, object) => {
 		const cached = cache.get(id);
 		if (cached != null) return cached;
-		const isa = asString(object["isa"]);
+		const isa = asString$1(object["isa"]);
 		if (isa == null) return;
 		if (inProgress.has(id)) return;
 		inProgress.add(id);
@@ -180,17 +180,17 @@ function createReferenceComments(root) {
 		if (isa === "PBXBuildFile") comment = buildFileComment(id, object);
 		else if (isa === "XCConfigurationList") comment = configurationListComment(id);
 		else if (isa === "XCRemoteSwiftPackageReference") {
-			const repoUrl = asString(object["repositoryURL"]);
+			const repoUrl = asString$1(object["repositoryURL"]);
 			comment = repoUrl == null ? isa : `${isa} "${repoNameFromUrl(repoUrl)}"`;
 		} else if (isa === "XCLocalSwiftPackageReference") {
-			const relativePath = asString(object["relativePath"]);
+			const relativePath = asString$1(object["relativePath"]);
 			comment = relativePath == null ? isa : `${isa} "${relativePath}"`;
 		} else if (isa === "PBXProject") comment = "Project object";
 		else if (isa === "PBXFileSystemSynchronizedBuildFileExceptionSet") comment = buildFileExceptionSetComment(id, object) ?? isa;
 		else if (isa === "PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet") comment = membershipExceptionSetComment(id, object) ?? isa;
 		else if (isa === "PBXTargetDependency") comment = isa;
-		else if (isa.endsWith("BuildPhase")) comment = asString(object["name"]) ?? defaultBuildPhaseName(isa) ?? "";
-		else if (isa === "PBXGroup" && asString(object["name"]) == null && asString(object["path"]) == null) comment = "";
+		else if (isa.endsWith("BuildPhase")) comment = asString$1(object["name"]) ?? defaultBuildPhaseName(isa) ?? "";
+		else if (isa === "PBXGroup" && asString$1(object["name"]) == null && asString$1(object["path"]) == null) comment = "";
 		else comment = defaultName(object, isa);
 		inProgress.delete(id);
 		cache.set(id, comment);
@@ -259,6 +259,70 @@ var PbxprojParseError = class extends Error {
 	}
 };
 /**
+* Thrown when the source text is not a well-formed scheme document (the
+* XML dialect of `.xcscheme` files).
+*
+* The message always embeds the line and column of the failure, and the
+* same information is available in structured form on {@link position}
+* for programmatic use.
+*/
+var XcschemeParseError = class extends Error {
+	/** Where in the source text parsing failed. */
+	position;
+	/**
+	* @param message Failure description without location; the location is
+	*   appended automatically.
+	* @param source Full source text, used to compute the position.
+	* @param offset Character offset of the failure inside `source`.
+	*/
+	constructor(message, source, offset) {
+		const position = positionAt(source, offset);
+		super(`${message} (line ${position.line}, column ${position.column})`);
+		this.name = "XcschemeParseError";
+		this.position = position;
+	}
+};
+/**
+* Thrown when a scheme element cannot be written as XML.
+*
+* Raised for element and attribute names that are not valid XML names and
+* for attribute values carrying control characters XML 1.0 cannot encode.
+* The {@link path} pinpoints the offending element inside the tree.
+*/
+var XcschemeBuildError = class extends Error {
+	/** Path to the offending element from the root, e.g. `Scheme.BuildAction[0]`. */
+	path;
+	/**
+	* @param message Failure description without location; the element path
+	*   is appended automatically.
+	* @param path Path to the offending element from the root.
+	*/
+	constructor(message, path) {
+		super(`${message} (at ${path})`);
+		this.name = "XcschemeBuildError";
+		this.path = path;
+	}
+};
+/**
+* Thrown by the object model when an operation cannot proceed: the
+* document lacks the structure the operation needs (no objects dictionary,
+* no root project object), a view's object was removed from the document,
+* or a creation request names a product type the model cannot scaffold.
+*
+* Read paths in the model return `undefined` for merely malformed data;
+* this error marks the cases where continuing would corrupt the document
+* or hide a programming mistake.
+*/
+var XcodeModelError = class extends Error {
+	/**
+	* @param message Description of the failed operation.
+	*/
+	constructor(message) {
+		super(message);
+		this.name = "XcodeModelError";
+	}
+};
+/**
 * Thrown when a value cannot be represented in a `project.pbxproj` document.
 *
 * Raised for `null`, `undefined`, booleans, bigints, functions, symbols,
@@ -727,6 +791,578 @@ function buildPbxproj(root) {
 	return new Writer(root).toString();
 }
 //#endregion
+//#region src/model/isa.ts
+/**
+* Names and well-known values of the pbxproj object vocabulary.
+*
+* Everything here mirrors strings Xcode itself writes; nothing is invented.
+* Centralizing them keeps the object model free of string literals and
+* gives call sites one place to import from.
+*
+* @module
+*/
+/**
+* The `isa` names the object model works with. The parser and serializer
+* accept any isa; this list only covers the kinds the model creates or
+* gives typed access to.
+*/
+const Isa = {
+	aggregateTarget: "PBXAggregateTarget",
+	buildFile: "PBXBuildFile",
+	buildRule: "PBXBuildRule",
+	containerItemProxy: "PBXContainerItemProxy",
+	copyFilesBuildPhase: "PBXCopyFilesBuildPhase",
+	fileReference: "PBXFileReference",
+	fileSystemSynchronizedBuildFileExceptionSet: "PBXFileSystemSynchronizedBuildFileExceptionSet",
+	fileSystemSynchronizedRootGroup: "PBXFileSystemSynchronizedRootGroup",
+	frameworksBuildPhase: "PBXFrameworksBuildPhase",
+	group: "PBXGroup",
+	legacyTarget: "PBXLegacyTarget",
+	nativeTarget: "PBXNativeTarget",
+	project: "PBXProject",
+	referenceProxy: "PBXReferenceProxy",
+	resourcesBuildPhase: "PBXResourcesBuildPhase",
+	sourcesBuildPhase: "PBXSourcesBuildPhase",
+	targetDependency: "PBXTargetDependency",
+	variantGroup: "PBXVariantGroup",
+	buildConfiguration: "XCBuildConfiguration",
+	configurationList: "XCConfigurationList",
+	localSwiftPackageReference: "XCLocalSwiftPackageReference",
+	remoteSwiftPackageReference: "XCRemoteSwiftPackageReference",
+	swiftPackageProductDependency: "XCSwiftPackageProductDependency",
+	versionGroup: "XCVersionGroup"
+};
+/**
+* Product type identifiers of the targets the model creates or reasons
+* about. Other product types pass through untouched.
+*/
+const ProductType = {
+	application: "com.apple.product-type.application",
+	messagesApplication: "com.apple.product-type.application.messages",
+	appExtension: "com.apple.product-type.app-extension",
+	messagesExtension: "com.apple.product-type.app-extension.messages",
+	extensionKitExtension: "com.apple.product-type.extensionkit-extension",
+	onDemandInstallCapableApplication: "com.apple.product-type.application.on-demand-install-capable",
+	watchApp: "com.apple.product-type.application.watchapp2"
+};
+/**
+* How a product type's build product appears on disk. Each entry carries
+* the wrapper file extension and the `explicitFileType` of the product
+* file reference.
+*/
+const PRODUCT_FILE_INFO = {
+	[ProductType.application]: {
+		extension: ".app",
+		fileType: "wrapper.application"
+	},
+	[ProductType.messagesApplication]: {
+		extension: ".app",
+		fileType: "wrapper.application"
+	},
+	[ProductType.onDemandInstallCapableApplication]: {
+		extension: ".app",
+		fileType: "wrapper.application"
+	},
+	[ProductType.watchApp]: {
+		extension: ".app",
+		fileType: "wrapper.application"
+	},
+	[ProductType.appExtension]: {
+		extension: ".appex",
+		fileType: "wrapper.app-extension"
+	},
+	[ProductType.messagesExtension]: {
+		extension: ".appex",
+		fileType: "wrapper.app-extension"
+	},
+	[ProductType.extensionKitExtension]: {
+		extension: ".appex",
+		fileType: "wrapper.app-extension"
+	}
+};
+/**
+* The build-setting key that carries each platform's deployment target.
+* A target (or its project) sets exactly one of these per platform it
+* builds for, which is what makes them usable as a platform signal.
+*/
+const DEPLOYMENT_TARGET_KEY = {
+	ios: "IPHONEOS_DEPLOYMENT_TARGET",
+	macos: "MACOSX_DEPLOYMENT_TARGET",
+	tvos: "TVOS_DEPLOYMENT_TARGET",
+	watchos: "WATCHOS_DEPLOYMENT_TARGET",
+	visionos: "XROS_DEPLOYMENT_TARGET"
+};
+/**
+* `dstSubfolderSpec` values for copy-files build phases, named after the
+* destination each selects.
+*/
+const CopyFilesDestination = {
+	plugins: 13,
+	productsDirectory: 16
+};
+/**
+* Resolves the embed phase destination for an extension-like product type.
+* Watch applications are embedded by product type here; callers that only
+* know build settings should check the deployment-target key instead.
+*/
+function embedDestinationFor(productType) {
+	switch (productType) {
+		case ProductType.onDemandInstallCapableApplication: return {
+			phaseName: "Embed App Clips",
+			dstSubfolderSpec: CopyFilesDestination.productsDirectory,
+			dstPath: "$(CONTENTS_FOLDER_PATH)/AppClips"
+		};
+		case ProductType.watchApp:
+		case ProductType.application: return {
+			phaseName: "Embed Watch Content",
+			dstSubfolderSpec: CopyFilesDestination.productsDirectory,
+			dstPath: "$(CONTENTS_FOLDER_PATH)/Watch"
+		};
+		case ProductType.extensionKitExtension: return {
+			phaseName: "Embed ExtensionKit Extensions",
+			dstSubfolderSpec: CopyFilesDestination.productsDirectory,
+			dstPath: "$(EXTENSIONS_FOLDER_PATH)"
+		};
+		default: return {
+			phaseName: "Embed Foundation Extensions",
+			dstSubfolderSpec: CopyFilesDestination.plugins,
+			dstPath: ""
+		};
+	}
+}
+/**
+* `lastKnownFileType` values for file references created by path, keyed by
+* file extension. Extensions outside the map create references without a
+* type, which Xcode tolerates and re-derives.
+*/
+const FILE_TYPE_BY_EXTENSION = {
+	".swift": "sourcecode.swift",
+	".m": "sourcecode.c.objc",
+	".mm": "sourcecode.cpp.objcpp",
+	".h": "sourcecode.c.h",
+	".c": "sourcecode.c.c",
+	".cpp": "sourcecode.cpp.cpp",
+	".plist": "text.plist.xml",
+	".entitlements": "text.plist.entitlements",
+	".xcconfig": "text.xcconfig",
+	".storyboard": "file.storyboard",
+	".xib": "file.xib",
+	".xcassets": "folder.assetcatalog",
+	".framework": "wrapper.framework",
+	".xcdatamodeld": "wrapper.xcdatamodeld",
+	".metal": "sourcecode.metal",
+	".md": "net.daringfireball.markdown",
+	".json": "text.json"
+};
+//#endregion
+//#region src/model/values.ts
+/**
+* Returns the value when it is a string, and `undefined` otherwise.
+*/
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Returns the value when it is a dictionary, and `undefined` otherwise.
+*
+* Arrays and `Uint8Array` data are objects at runtime too, so a bare
+* `typeof` check is not enough.
+*/
+function asDictionary(value) {
+	if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Uint8Array)) return value;
+}
+/**
+* Returns the array under `key`, creating an empty one when the key is
+* absent or holds a non-array value.
+*
+* Mutating methods use this to append into list fields (`children`,
+* `dependencies`, `exceptions`) without separate existence checks at every
+* call site.
+*/
+function ensureArray(object, key) {
+	const existing = object[key];
+	if (Array.isArray(existing)) return existing;
+	const created = [];
+	object[key] = created;
+	return created;
+}
+/**
+* Collects the string items of a possibly absent, possibly mixed array.
+*
+* Reference lists in well-formed documents contain only id strings, but a
+* malformed document can mix in anything; non-strings are skipped rather
+* than thrown on, matching the library's soft-failure stance on reads.
+*/
+function stringItems(value) {
+	if (!Array.isArray(value)) return [];
+	const items = [];
+	for (const item of value) if (typeof item === "string") items.push(item);
+	return items;
+}
+//#endregion
+//#region src/model/object.ts
+/**
+* The base view class of the object model.
+*
+* Views are lightweight, identity-mapped facades over entries of the
+* document's `objects` dictionary. All state lives in the parsed document
+* itself; a view holds only its id and a reference back to the project, so
+* document text produced from the model reflects every mutation with no
+* separate serialization step.
+*
+* @module
+*/
+/**
+* A typed handle on one object of the document.
+*
+* Two lookups of the same id return the same view instance (the project
+* keeps an identity map), so views compare with `===`.
+*
+* The type parameter describes the properties of a well-formed object of
+* this kind. Subclasses fix it to their kind's interface, which gives
+* `properties` autocompletion. Treat the shape as a description rather
+* than a guarantee. A malformed document can hold anything, so the model
+* itself always reads through the narrowing accessors.
+*/
+var XcodeObject = class {
+	/** The project this object belongs to. */
+	project;
+	/** The object's 24-character identifier (its key in `objects`). */
+	id;
+	/**
+	* Views are created by the project's identity map; use
+	* {@link XcodeProject.get} or a typed query instead of constructing
+	* views directly.
+	*/
+	constructor(project, id) {
+		this.project = project;
+		this.id = id;
+	}
+	/**
+	* The object's raw dictionary inside the document. Mutations through the
+	* model write here, and direct writes are equally valid; the model adds
+	* no caching over these properties.
+	*
+	* The typed shape is asserted, not checked. It describes what a
+	* well-formed object of this kind carries (see `properties.ts`).
+	*/
+	get properties() {
+		return this.project.propertiesOf(this.id);
+	}
+	/**
+	* The object's `isa` kind name, or the empty string when the field is
+	* missing or malformed.
+	*/
+	get isa() {
+		return asString(this.properties["isa"]) ?? "";
+	}
+	/**
+	* Reads a property expected to be a string. Returns `undefined` when the
+	* property is absent or holds another type.
+	*/
+	getString(key) {
+		return asString(this.properties[key]);
+	}
+	/**
+	* Writes one property of the object.
+	*
+	* The write goes through the untyped document dictionary. TypeScript
+	* does not allow writes through a generic index, and the typed shape on
+	* `properties` is descriptive anyway.
+	*/
+	set(key, value) {
+		this.project.propertiesOf(this.id)[key] = value;
+	}
+	/**
+	* The views of the objects referenced by an id-list property, resolved in
+	* list order. Dangling ids and non-string entries of malformed documents
+	* are skipped.
+	*/
+	referencedViews(key) {
+		const items = this.properties[key];
+		if (!Array.isArray(items)) return [];
+		const views = [];
+		for (const item of items) {
+			const view = typeof item === "string" ? this.project.get(item) : void 0;
+			if (view != null) views.push(view);
+		}
+		return views;
+	}
+	/**
+	* Removes the object from the document and strips every reference to it:
+	* string properties naming the id are deleted, id lists drop it, and
+	* nested dictionaries keyed by object id (such as the root project's
+	* `TargetAttributes`) drop its entry.
+	*
+	* This is the low-level removal; it does not cascade to objects that only
+	* made sense alongside this one. Higher-level operations like
+	* {@link XcodeProject.removeTarget} compose it into full teardowns.
+	*/
+	removeFromProject() {
+		this.project.removeObject(this.id);
+	}
+};
+//#endregion
+//#region src/model/objects.ts
+/**
+* Typed views over the document object kinds that are not targets, from
+* groups and build phases to version groups and reference proxies.
+*
+* Each class adds the accessors and mutations its kind supports; everything
+* ultimately reads and writes the raw dictionaries through the base class,
+* so mixing model calls with direct property access stays safe.
+*
+* @module
+*/
+/**
+* A `PBXGroup` is a folder in Xcode's navigator, holding references to
+* files and other groups. Variant groups (`PBXVariantGroup`) share this
+* view. The type parameter lets subclasses carry a more specific property
+* shape.
+*/
+var Group = class Group extends XcodeObject {
+	/**
+	* Ids of the group's children, in navigator order. Non-string entries of
+	* a malformed document are skipped.
+	*/
+	get childIds() {
+		return stringItems(this.properties["children"]);
+	}
+	/**
+	* The views of the group's children, in navigator order.
+	*/
+	children() {
+		return this.referencedViews("children");
+	}
+	/**
+	* Adds an existing object (a file reference or another group) to the end
+	* of the group's children. Adding a child the group already lists is a
+	* no-op.
+	*/
+	addChild(child) {
+		const children = ensureArray(this.properties, "children");
+		if (!children.includes(child.id)) children.push(child.id);
+	}
+	/**
+	* Returns the descendant group for a `/`-separated path, creating any
+	* missing groups along the way. Each component matches a child group by
+	* its `path`, falling back to its `name`; created groups carry the
+	* component as their `path` so they mirror folders on disk.
+	*
+	* ```ts
+	* const generated = mainGroup.ensureGroup("Sources/Generated");
+	* generated.createFile("Config.swift");
+	* ```
+	*/
+	ensureGroup(path) {
+		return path.split("/").filter((component) => component !== "").reduce((parent, component) => {
+			const existing = parent.children().find((child) => child instanceof Group && (child.getString("path") ?? child.getString("name")) === component);
+			if (existing != null) return existing;
+			const created = this.project.add(Isa.group, {
+				children: [],
+				path: component,
+				sourceTree: "<group>"
+			}, `${Isa.group} ${parent.id} ${component}`);
+			parent.addChild(created);
+			return created;
+		}, this);
+	}
+	/**
+	* Creates a `PBXFileReference` for a path relative to this group and adds
+	* it to the group's children.
+	*
+	* The reference's `lastKnownFileType` derives from the file extension
+	* when it is a known kind; otherwise the reference carries no type and
+	* Xcode re-derives one on open.
+	*
+	* @param path File path relative to the group, for example
+	*   `Demo/Config.swift`.
+	* @returns The view of the created file reference.
+	*/
+	createFile(path) {
+		const extensionStart = path.lastIndexOf(".");
+		const fileType = extensionStart === -1 ? void 0 : FILE_TYPE_BY_EXTENSION[path.slice(extensionStart)];
+		const reference = this.project.add(Isa.fileReference, {
+			...fileType == null ? {} : { lastKnownFileType: fileType },
+			path,
+			sourceTree: "<group>"
+		}, `${Isa.fileReference} ${path}`);
+		this.addChild(reference);
+		return reference;
+	}
+};
+/**
+* A build phase is an ordered list of build files processed by one step
+* of a target's build. Every `PBX*BuildPhase` kind shares this view.
+*/
+var BuildPhase = class extends XcodeObject {
+	/**
+	* The phase's display name, when it carries an explicit one. Xcode names
+	* copy-files and shell-script phases; the standard phases derive their
+	* names from their isa.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+	/**
+	* Ids of the phase's `PBXBuildFile` entries, in build order.
+	*/
+	get buildFileIds() {
+		return stringItems(this.properties["files"]);
+	}
+	/**
+	* Whether the phase already lists the build file.
+	*/
+	containsBuildFile(buildFileId) {
+		return this.buildFileIds.includes(buildFileId);
+	}
+	/**
+	* Appends an existing build file to the phase unless it is already
+	* listed.
+	*/
+	appendBuildFile(buildFileId) {
+		const files = ensureArray(this.properties, "files");
+		if (!files.includes(buildFileId)) files.push(buildFileId);
+	}
+	/**
+	* Removes a build file from the phase. Removing an id the phase does not
+	* list is a no-op.
+	*/
+	removeBuildFile(buildFileId) {
+		const files = this.properties["files"];
+		if (Array.isArray(files)) this.properties["files"] = files.filter((file) => file !== buildFileId);
+	}
+	/**
+	* Ensures the phase carries a `PBXBuildFile` for the referenced object,
+	* creating one when no existing build file in this phase points at it.
+	*
+	* @param reference The file reference or package product the build file
+	*   should point at.
+	* @param options.referenceKey Which build-file field carries the
+	*   reference: `fileRef` for file references (the default) or
+	*   `productRef` for Swift package products.
+	* @param options.settings Optional per-file settings, for example
+	*   `{ ATTRIBUTES: ["RemoveHeadersOnCopy"] }`.
+	* @returns The view of the phase's build file for the reference.
+	*/
+	ensureBuildFile(reference, options = {}) {
+		const referenceKey = options.referenceKey ?? "fileRef";
+		for (const buildFileId of this.buildFileIds) {
+			const existing = this.project.get(buildFileId);
+			if (existing?.getString(referenceKey) === reference.id) return existing;
+		}
+		const buildFile = this.project.add(Isa.buildFile, {
+			[referenceKey]: reference.id,
+			...options.settings == null ? {} : { settings: options.settings }
+		}, `${Isa.buildFile} ${this.id} ${reference.id}`);
+		this.appendBuildFile(buildFile.id);
+		return buildFile;
+	}
+};
+/**
+* A `PBXFileSystemSynchronizedRootGroup` is an Xcode 16 folder whose
+* members are synchronized from disk instead of listed individually.
+*/
+var SyncRootGroup = class extends XcodeObject {
+	/**
+	* The group's on-disk folder path, when present.
+	*/
+	get path() {
+		return this.getString("path");
+	}
+	/**
+	* Excludes files from a target's membership in this synchronized folder
+	* through a `PBXFileSystemSynchronizedBuildFileExceptionSet` linked into
+	* the group's exceptions.
+	*
+	* Xcode keeps one exception set per target and folder, so when this
+	* group already carries a set for the target, the file names merge into
+	* it instead of creating a second set; names already excluded are not
+	* duplicated.
+	*
+	* The standard use is keeping a scaffolded `Info.plist` from being
+	* double-copied: the build already processes it through the target's
+	* `INFOPLIST_FILE` setting.
+	*
+	* @param target The target whose membership the exceptions restrict.
+	* @param membershipExceptions File names inside the folder to exclude.
+	* @returns The view of the target's exception set for this folder.
+	*/
+	addMembershipExceptions(target, membershipExceptions) {
+		for (const id of stringItems(this.properties["exceptions"])) {
+			const existing = this.project.get(id);
+			if (existing?.isa === Isa.fileSystemSynchronizedBuildFileExceptionSet && existing.getString("target") === target.id) {
+				const names = ensureArray(existing.properties, "membershipExceptions");
+				for (const name of membershipExceptions) if (!names.includes(name)) names.push(name);
+				return existing;
+			}
+		}
+		const exceptionSet = this.project.add(Isa.fileSystemSynchronizedBuildFileExceptionSet, {
+			membershipExceptions,
+			target: target.id
+		}, `${Isa.fileSystemSynchronizedBuildFileExceptionSet} ${this.id} ${target.id}`);
+		ensureArray(this.properties, "exceptions").push(exceptionSet.id);
+		return exceptionSet;
+	}
+};
+/**
+* A `PBXBuildRule` tells a target which compiler or script processes a
+* kind of file.
+*/
+var BuildRule = class extends XcodeObject {
+	/**
+	* The rule's script, when it is a script rule rather than a reference
+	* to a compiler specification.
+	*/
+	get script() {
+		return this.getString("script");
+	}
+};
+/**
+* An `XCVersionGroup` contains a versioned Core Data model
+* (`.xcdatamodeld`). Its children are the model versions and
+* `currentVersion` names the active one.
+*/
+var VersionGroup = class extends Group {
+	/**
+	* The view of the active model version's file reference, when the group
+	* names one.
+	*/
+	currentVersion() {
+		const id = this.getString("currentVersion");
+		return id == null ? void 0 : this.project.get(id);
+	}
+	/**
+	* Makes a model version the active one, adding it to the group's
+	* children when it is not listed yet.
+	*/
+	setCurrentVersion(reference) {
+		this.addChild(reference);
+		this.properties["currentVersion"] = reference.id;
+	}
+};
+/**
+* A `PBXReferenceProxy` stands in for a product built by a target of
+* another project referenced from this one.
+*/
+var ReferenceProxy = class extends XcodeObject {
+	/**
+	* The proxy's product path inside the other project's build directory,
+	* when present.
+	*/
+	get path() {
+		return this.getString("path");
+	}
+	/**
+	* The view of the container item proxy that names the remote target,
+	* when the reference resolves.
+	*/
+	remoteReference() {
+		const id = this.getString("remoteRef");
+		return id == null ? void 0 : this.project.get(id);
+	}
+};
+//#endregion
 //#region src/escape.ts
 /**
 * Escape handling for quoted strings.
@@ -1004,11 +1640,11 @@ const IS_LITERAL_CHAR = (() => {
 	for (const ch of "_$/:.-") table[ch.charCodeAt(0)] = 1;
 	return table;
 })();
-const CODE_TAB = 9;
-const CODE_LINE_FEED = 10;
-const CODE_CARRIAGE_RETURN = 13;
-const CODE_SPACE = 32;
-const CODE_QUOTE = 34;
+const CODE_TAB$1 = 9;
+const CODE_LINE_FEED$1 = 10;
+const CODE_CARRIAGE_RETURN$1 = 13;
+const CODE_SPACE$1 = 32;
+const CODE_QUOTE$1 = 34;
 const CODE_SINGLE_QUOTE = 39;
 const CODE_OPEN_PAREN = 40;
 const CODE_CLOSE_PAREN = 41;
@@ -1016,13 +1652,13 @@ const CODE_ASTERISK = 42;
 const CODE_COMMA = 44;
 const CODE_MINUS = 45;
 const CODE_DOT = 46;
-const CODE_SLASH = 47;
+const CODE_SLASH$1 = 47;
 const CODE_ZERO = 48;
 const CODE_NINE = 57;
 const CODE_SEMICOLON = 59;
-const CODE_LESS_THAN = 60;
-const CODE_EQUALS = 61;
-const CODE_GREATER_THAN = 62;
+const CODE_LESS_THAN$1 = 60;
+const CODE_EQUALS$1 = 61;
+const CODE_GREATER_THAN$1 = 62;
 const CODE_BACKSLASH = 92;
 const CODE_OPEN_BRACE = 123;
 const CODE_CLOSE_BRACE = 125;
@@ -1034,10 +1670,10 @@ const CODE_CLOSE_BRACE = 125;
 */
 const IS_WHITESPACE = (() => {
 	const table = /* @__PURE__ */ new Uint8Array(256);
-	table[CODE_SPACE] = 1;
-	table[CODE_TAB] = 1;
-	table[CODE_CARRIAGE_RETURN] = 1;
-	table[CODE_LINE_FEED] = 1;
+	table[CODE_SPACE$1] = 1;
+	table[CODE_TAB$1] = 1;
+	table[CODE_CARRIAGE_RETURN$1] = 1;
+	table[CODE_LINE_FEED$1] = 1;
 	return table;
 })();
 /**
@@ -1053,7 +1689,7 @@ function isDigit(code) {
 * through the `read*` and `parse*` methods; there is no separate tokenizer
 * stage and no token objects.
 */
-var Parser = class {
+var Parser$1 = class {
 	/** Source text of the document being parsed. */
 	input;
 	/** Cursor position as a UTF-16 code unit offset into {@link input}. */
@@ -1100,7 +1736,7 @@ var Parser = class {
 		const length = input.length;
 		let pos = this.pos;
 		while (pos < length && IS_WHITESPACE[input.charCodeAt(pos)] === 1) pos++;
-		if (pos < length && input.charCodeAt(pos) === CODE_SLASH) pos = this.skipCommentedTrivia(pos);
+		if (pos < length && input.charCodeAt(pos) === CODE_SLASH$1) pos = this.skipCommentedTrivia(pos);
 		this.pos = pos;
 	}
 	/**
@@ -1120,7 +1756,7 @@ var Parser = class {
 		const length = input.length;
 		for (;;) {
 			const next = input.charCodeAt(pos + 1);
-			if (next === CODE_SLASH) {
+			if (next === CODE_SLASH$1) {
 				const lineEnd = input.indexOf("\n", pos + 2);
 				pos = lineEnd === -1 ? length : lineEnd;
 			} else if (next === CODE_ASTERISK) {
@@ -1132,7 +1768,7 @@ var Parser = class {
 				pos = commentEnd + 2;
 			} else return pos;
 			while (pos < length && IS_WHITESPACE[input.charCodeAt(pos)] === 1) pos++;
-			if (pos >= length || input.charCodeAt(pos) !== CODE_SLASH) return pos;
+			if (pos >= length || input.charCodeAt(pos) !== CODE_SLASH$1) return pos;
 		}
 	}
 	/**
@@ -1215,7 +1851,7 @@ var Parser = class {
 		const input = this.input;
 		const length = input.length;
 		const start = ++this.pos;
-		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN) this.pos++;
+		while (this.pos < length && input.charCodeAt(this.pos) !== CODE_GREATER_THAN$1) this.pos++;
 		if (this.pos >= length) this.fail("Unterminated data run", start - 1);
 		let hex = "";
 		for (let i = start; i < this.pos; i++) {
@@ -1258,10 +1894,10 @@ var Parser = class {
 				return result;
 			}
 			let key;
-			if (code === CODE_QUOTE || code === CODE_SINGLE_QUOTE) key = this.readQuotedString();
+			if (code === CODE_QUOTE$1 || code === CODE_SINGLE_QUOTE) key = this.readQuotedString();
 			else if (IS_LITERAL_CHAR[code] === 1) key = this.readLiteral();
 			else this.fail(`Expected a key but found '${input[this.pos]}'`);
-			this.expect(CODE_EQUALS, "=");
+			this.expect(CODE_EQUALS$1, "=");
 			const value = this.parseValue();
 			this.expect(CODE_SEMICOLON, ";");
 			if (key === "__proto__") Object.defineProperty(result, key, {
@@ -1314,9 +1950,9 @@ var Parser = class {
 		const code = this.input.charCodeAt(this.pos);
 		if (code === CODE_OPEN_BRACE) return this.parseObject();
 		if (code === CODE_OPEN_PAREN) return this.parseArray();
-		if (code === CODE_QUOTE || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
+		if (code === CODE_QUOTE$1 || code === CODE_SINGLE_QUOTE) return this.readQuotedString();
 		if (IS_LITERAL_CHAR[code] === 1) return interpretLiteral(this.readLiteral());
-		if (code === CODE_LESS_THAN) return this.readData();
+		if (code === CODE_LESS_THAN$1) return this.readData();
 		this.fail(`Expected a value but found '${this.input[this.pos]}'`);
 	}
 };
@@ -1370,7 +2006,1918 @@ function interpretLiteral(literal) {
 *   carries the line and column of the failure.
 */
 function parsePbxproj(text) {
-	return new Parser(text).parseDocument();
+	return new Parser$1(text).parseDocument();
+}
+//#endregion
+//#region src/md5.ts
+/**
+* Embedded MD5, implemented from RFC 1321.
+*
+* Deterministic object ids hash their seed text (see `uuid.ts`), and the
+* library runs in every JavaScript runtime without depending on a crypto
+* module, so the digest is implemented here. MD5 is used strictly as a
+* stable text-to-bits mapping for identifier generation; nothing security
+* relevant derives from it.
+*
+* @module
+*/
+/**
+* Per-round left-rotation amounts, in the order the 64 steps apply them
+* (RFC 1321 section 3.4).
+*/
+const SHIFTS = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+/**
+* Step constants for the 64 steps: the integer parts of
+* `abs(sin(i + 1)) * 2^32`, as RFC 1321 section 3.4 tabulates them. The
+* values are fixed by the specification rather than derived through
+* `Math.sin` at load, because the digest feeds deterministic identifiers
+* and floating-point transcendentals are the one spot where runtimes could
+* legally disagree.
+*/
+const SINES = new Uint32Array([
+	3614090360,
+	3905402710,
+	606105819,
+	3250441966,
+	4118548399,
+	1200080426,
+	2821735955,
+	4249261313,
+	1770035416,
+	2336552879,
+	4294925233,
+	2304563134,
+	1804603682,
+	4254626195,
+	2792965006,
+	1236535329,
+	4129170786,
+	3225465664,
+	643717713,
+	3921069994,
+	3593408605,
+	38016083,
+	3634488961,
+	3889429448,
+	568446438,
+	3275163606,
+	4107603335,
+	1163531501,
+	2850285829,
+	4243563512,
+	1735328473,
+	2368359562,
+	4294588738,
+	2272392833,
+	1839030562,
+	4259657740,
+	2763975236,
+	1272893353,
+	4139469664,
+	3200236656,
+	681279174,
+	3936430074,
+	3572445317,
+	76029189,
+	3654602809,
+	3873151461,
+	530742520,
+	3299628645,
+	4096336452,
+	1126891415,
+	2878612391,
+	4237533241,
+	1700485571,
+	2399980690,
+	4293915773,
+	2240044497,
+	1873313359,
+	4264355552,
+	2734768916,
+	1309151649,
+	4149444226,
+	3174756917,
+	718787259,
+	3951481745
+]);
+/**
+* Encodes text as UTF-8 bytes with RFC 1321 padding applied: a `0x80`
+* terminator, zero fill to 56 bytes mod 64, then the bit length as a
+* little-endian 64-bit integer.
+*/
+function paddedUtf8(text) {
+	const bytes = new TextEncoder().encode(text);
+	const paddedLength = (Math.floor((bytes.length + 8) / 64) + 1) * 64;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const bitLength = bytes.length * 8;
+	padded[paddedLength - 8] = bitLength & 255;
+	padded[paddedLength - 7] = bitLength >>> 8 & 255;
+	padded[paddedLength - 6] = bitLength >>> 16 & 255;
+	padded[paddedLength - 5] = bitLength >>> 24 & 255;
+	return padded;
+}
+/**
+* Adds two 32-bit values with wraparound, keeping intermediates inside the
+* 32-bit range JavaScript bitwise operators preserve. `Math.trunc` is not
+* a substitute here: the bitwise coercion is what performs the modular
+* wrap the algorithm requires.
+*/
+function add32(a, b) {
+	return a + b | 0;
+}
+/**
+* Computes the MD5 digest of the text (as UTF-8) and returns it as 32
+* uppercase hexadecimal characters.
+*
+* Uppercase matches the identifier alphabet Xcode uses, which is what the
+* digest feeds (see `uuid.ts`).
+*/
+function md5Hex(text) {
+	const message = paddedUtf8(text);
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	const words = /* @__PURE__ */ new Uint32Array(16);
+	for (let offset = 0; offset < message.length; offset += 64) {
+		for (let i = 0; i < 16; i++) {
+			const base = offset + i * 4;
+			words[i] = message[base] | message[base + 1] << 8 | message[base + 2] << 16 | message[base + 3] << 24;
+		}
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		for (let step = 0; step < 64; step++) {
+			let mix;
+			let wordIndex;
+			if (step < 16) {
+				mix = b & c | ~b & d;
+				wordIndex = step;
+			} else if (step < 32) {
+				mix = d & b | ~d & c;
+				wordIndex = (5 * step + 1) % 16;
+			} else if (step < 48) {
+				mix = b ^ c ^ d;
+				wordIndex = (3 * step + 5) % 16;
+			} else {
+				mix = c ^ (b | ~d);
+				wordIndex = 7 * step % 16;
+			}
+			const rotated = add32(add32(a, mix), add32(SINES[step], words[wordIndex]));
+			const shift = SHIFTS[step];
+			const next = add32(b, rotated << shift | rotated >>> 32 - shift);
+			a = d;
+			d = c;
+			c = b;
+			b = next;
+		}
+		a0 = add32(a0, a);
+		b0 = add32(b0, b);
+		c0 = add32(c0, c);
+		d0 = add32(d0, d);
+	}
+	let hex = "";
+	for (const word of [
+		a0,
+		b0,
+		c0,
+		d0
+	]) for (let shift = 0; shift < 32; shift += 8) hex += (word >>> shift & 255).toString(16).toUpperCase().padStart(2, "0");
+	return hex;
+}
+//#endregion
+//#region src/uuid.ts
+/**
+* Deterministic object identifiers for generated pbxproj objects.
+*
+* Xcode identifies every object with 24 hexadecimal characters. Generated
+* ids here are deterministic: the same seed always produces the same id, so
+* programmatic edits are reproducible and diffs stay minimal across runs.
+* The format is `XX` + the first 20 characters of `md5(seed)` + `XX`, which
+* is a valid identifier that remains recognizable as generated.
+*
+* @module
+*/
+/**
+* Formats the deterministic id for a seed without collision handling.
+*/
+function idForSeed(seed) {
+	return `XX${md5Hex(seed).slice(0, 20)}XX`;
 }
+/**
+* Generates a deterministic 24-character object id from a seed string.
+*
+* When the id already exists in `existing`, the seed is retried with a
+* space appended until it is free, so ids stay deterministic (the same
+* seeds in the same order produce the same ids) while never colliding
+* within a document.
+*
+* @param seed Any text that identifies the object being created, for
+*   example `PBXNativeTarget DemoWidget`.
+* @param existing Ids already present in the document.
+* @returns An id not contained in `existing`; the caller records it.
+*/
+function generateObjectId(seed, existing) {
+	let currentSeed = seed;
+	for (;;) {
+		const id = idForSeed(currentSeed);
+		if (!existing.has(id)) return id;
+		currentSeed += " ";
+	}
+}
+//#endregion
+//#region src/model/doctor.ts
+/**
+* Structural validation and cleanup for project documents.
+*
+* Real projects accumulate damage. References outlive the objects they
+* point at, orphans pile up, and entries lose their kind. Xcode tolerates
+* some of that silently and breaks on the rest. {@link validateProject}
+* reports the problems, and {@link pruneOrphanObjects} removes the
+* unreachable objects.
+*
+* @module
+*/
+/**
+* Object properties that hold a single reference to another object of the
+* same document. `remoteGlobalIDString` and `TestTargetID` are absent by
+* design. They reference objects of another container, so they cannot be
+* resolved here.
+*/
+const SCALAR_REFERENCE_PROPERTIES = [
+	"baseConfigurationReference",
+	"buildConfigurationList",
+	"buildPhase",
+	"containerPortal",
+	"currentVersion",
+	"fileRef",
+	"mainGroup",
+	"package",
+	"productRef",
+	"productRefGroup",
+	"productReference",
+	"remoteRef",
+	"target",
+	"targetProxy"
+];
+/**
+* Object properties that hold a list of references to other objects of the
+* same document.
+*/
+const LIST_REFERENCE_PROPERTIES = [
+	"buildConfigurations",
+	"buildPhases",
+	"buildRules",
+	"children",
+	"dependencies",
+	"exceptions",
+	"files",
+	"fileSystemSynchronizedGroups",
+	"packageProductDependencies",
+	"packageReferences",
+	"targets"
+];
+/**
+* Collects the ids of every object reachable from the document's root
+* object.
+*
+* Reachability follows every string that names an existing object,
+* anywhere in an object's properties (including nested dictionaries, their
+* keys, and arrays). This is deliberately broader than the known reference
+* schema. An unknown-but-real reference keeps its object alive, so pruning
+* stays conservative.
+*/
+function reachableObjectIds(project) {
+	const reachable = /* @__PURE__ */ new Set();
+	const rootId = project.document["rootObject"];
+	if (typeof rootId !== "string" || project.propertiesOfOptional(rootId) == null) return reachable;
+	const pending = [rootId];
+	const visitValue = (value) => {
+		if (typeof value === "string") {
+			if (!reachable.has(value) && project.propertiesOfOptional(value) != null) pending.push(value);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) visitValue(item);
+			return;
+		}
+		const nested = asDictionary(value);
+		if (nested != null) for (const key of Object.keys(nested)) {
+			visitValue(key);
+			visitValue(nested[key]);
+		}
+	};
+	while (pending.length > 0) {
+		const id = pending.pop();
+		if (reachable.has(id)) continue;
+		reachable.add(id);
+		const properties = project.propertiesOfOptional(id);
+		if (properties != null) for (const key of Object.keys(properties)) visitValue(properties[key]);
+	}
+	return reachable;
+}
+/**
+* Reports one dangling reference when the id does not resolve.
+*/
+function checkReference(project, issues, objectId, property, id) {
+	if (project.propertiesOfOptional(id) == null) issues.push({
+		kind: "dangling-reference",
+		message: `${objectId}.${property} references ${id}, which does not exist in the document`,
+		objectId
+	});
+}
+/**
+* Validates the document's object graph and returns every problem found.
+* An empty array means the graph is structurally sound. The checks cover
+* the root object, object kinds, the known reference schema, and
+* reachability. See {@link ProjectIssueKind} for the meanings.
+*/
+function validateProject(project) {
+	const issues = [];
+	const rootId = project.document["rootObject"];
+	const rootProperties = typeof rootId === "string" ? project.propertiesOfOptional(rootId) : void 0;
+	if (rootProperties == null || rootProperties["isa"] !== "PBXProject") issues.push({
+		kind: "dangling-root",
+		message: typeof rootId === "string" ? `rootObject references ${rootId}, which is not a PBXProject in the document` : "The document has no rootObject"
+	});
+	for (const [id, view] of project.objects()) {
+		const properties = view.properties;
+		if (view.isa === "") issues.push({
+			kind: "missing-isa",
+			message: `${id} has no isa, so Xcode cannot read it`,
+			objectId: id
+		});
+		for (const property of SCALAR_REFERENCE_PROPERTIES) {
+			const value = properties[property];
+			if (typeof value === "string") checkReference(project, issues, id, property, value);
+		}
+		for (const property of LIST_REFERENCE_PROPERTIES) {
+			const value = properties[property];
+			const items = Array.isArray(value) ? value : [];
+			for (const item of items) if (typeof item === "string") checkReference(project, issues, id, property, item);
+		}
+	}
+	const reachable = reachableObjectIds(project);
+	if (reachable.size > 0) {
+		for (const [id] of project.objects()) if (!reachable.has(id)) issues.push({
+			kind: "unreachable-object",
+			message: `${id} is unreachable from the root object`,
+			objectId: id
+		});
+	}
+	return issues;
+}
+/**
+* Removes every object unreachable from the document's root object and
+* returns the removed ids, in document order. A document whose root is
+* missing prunes nothing, since reachability is undefined there.
+*
+* Reachability is the conservative walk of {@link reachableObjectIds}.
+* Any real reference keeps an object alive, even when the reference
+* property is outside the known schema.
+*/
+function pruneOrphanObjects(project) {
+	const reachable = reachableObjectIds(project);
+	if (reachable.size === 0) return [];
+	const orphanIds = [];
+	for (const [id] of project.objects()) if (!reachable.has(id)) orphanIds.push(id);
+	for (const id of orphanIds) project.removeObject(id);
+	return orphanIds;
+}
+//#endregion
+//#region src/model/settings.ts
+/**
+* Build-configuration helpers shared by targets and the root project
+* object, both of which own an `XCConfigurationList`.
+*
+* @module
+*/
+/**
+* The views of a configuration list's build configurations, in list order.
+* Dangling ids and non-dictionary entries of malformed documents are
+* skipped.
+*/
+function configurationsOf(project, configurationListId) {
+	const list = asDictionary(project.propertiesOfOptional(configurationListId));
+	const configurations = [];
+	for (const id of stringItems(list?.["buildConfigurations"])) {
+		const configuration = project.get(id);
+		if (configuration != null) configurations.push(configuration);
+	}
+	return configurations;
+}
+/**
+* The settings dictionary of a configuration list's default configuration:
+* the one named by `defaultConfigurationName`, falling back to the first
+* configuration. Returns `undefined` when the list has no configurations
+* or the default carries no settings dictionary.
+*/
+function defaultConfigurationSettingsOf(project, configurationListId) {
+	const list = asDictionary(project.propertiesOfOptional(configurationListId));
+	const configurations = configurationsOf(project, configurationListId);
+	const defaultName = asString(list?.["defaultConfigurationName"]);
+	return asDictionary((configurations.find((configuration) => configuration.getString("name") === defaultName) ?? configurations[0])?.properties["buildSettings"]);
+}
+//#endregion
+//#region src/model/target.ts
+/**
+* Views of the project's targets. The behavior all target kinds share
+* lives on the {@link Target} base class, and {@link NativeTarget}
+* extends it with products, embedding, synchronized folders, Swift
+* packages, and system frameworks.
+*
+* Reads are deliberately soft: user-generated projects can be malformed,
+* so lookups return `undefined` instead of throwing wherever a document
+* could legally or illegally omit something. Mutations create any missing
+* structure they need.
+*
+* @module
+*/
+/**
+* The behavior every target kind shares. A target of any kind carries
+* build configurations and settings, build phases, and dependencies, and
+* this class holds their accessors and mutations. `PBXNativeTarget`,
+* `PBXAggregateTarget`, and `PBXLegacyTarget` all extend it, so code that
+* walks or rewires targets can accept any of them.
+*/
+var Target = class extends XcodeObject {
+	/**
+	* The target's name, when present.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+	/**
+	* The views of the target's build configurations, in list order.
+	*/
+	buildConfigurations() {
+		return configurationsOf(this.project, this.getString("buildConfigurationList"));
+	}
+	/**
+	* The settings dictionary of the target's default configuration: the one
+	* named by the list's `defaultConfigurationName`, falling back to the
+	* first configuration. Returns `undefined` when the target has no
+	* configurations or the default carries no settings dictionary.
+	*/
+	defaultConfigurationSettings() {
+		return defaultConfigurationSettingsOf(this.project, this.getString("buildConfigurationList"));
+	}
+	/**
+	* Reads a build setting from the target's default configuration,
+	* inheriting from the project-level configuration when the target omits
+	* the key. This mirrors how Xcode resolves settings hierarchically;
+	* generated app templates set values like `SDKROOT` only at the project
+	* level.
+	*
+	* Only string values are returned; a list- or number-valued setting reads
+	* as `undefined`.
+	*/
+	getBuildSetting(key) {
+		const targetSettings = this.defaultConfigurationSettings();
+		if (targetSettings != null && key in targetSettings) return asString(targetSettings[key]);
+		return asString(this.project.rootProject.defaultConfigurationSettings()?.[key]);
+	}
+	/**
+	* Writes a build setting on every configuration of the target, so Debug
+	* and Release stay consistent.
+	*/
+	setBuildSetting(key, value) {
+		for (const configuration of this.buildConfigurations()) {
+			const settings = asDictionary(configuration.properties["buildSettings"]);
+			if (settings == null) configuration.properties["buildSettings"] = { [key]: value };
+			else settings[key] = value;
+		}
+	}
+	/**
+	* Removes a build setting from every configuration of the target.
+	*/
+	removeBuildSetting(key) {
+		for (const configuration of this.buildConfigurations()) {
+			const settings = asDictionary(configuration.properties["buildSettings"]);
+			if (settings != null) delete settings[key];
+		}
+	}
+	/**
+	* The views of the target's dependency objects
+	* (`PBXTargetDependency`), in declaration order. Resolve a dependency's
+	* target through its `target` property.
+	*/
+	dependencies() {
+		return this.referencedViews("dependencies");
+	}
+	/**
+	* The views of the target's build phases, in build order.
+	*/
+	buildPhases() {
+		const phases = [];
+		for (const id of stringItems(this.properties["buildPhases"])) {
+			const phase = this.project.get(id);
+			if (phase instanceof BuildPhase) phases.push(phase);
+		}
+		return phases;
+	}
+	/**
+	* Finds the target's first build phase with the given isa, and, when
+	* `name` is provided, the given display name.
+	*/
+	findBuildPhase(isa, name) {
+		return this.buildPhases().find((phase) => phase.isa === isa && (name == null || phase.name === name));
+	}
+	/**
+	* Returns the target's build phase with the given isa and properties,
+	* creating and appending it when missing. The properties apply only on
+	* creation; an existing phase is returned as is.
+	*
+	* The match key is the isa plus the `name` property when one is given,
+	* so differently named copy-files phases coexist.
+	*/
+	ensureBuildPhase(isa, properties = {}) {
+		const name = asString(properties["name"]);
+		const existing = this.findBuildPhase(isa, name);
+		if (existing != null) return existing;
+		const phase = this.project.add(isa, {
+			isa,
+			buildActionMask: 2147483647,
+			files: [],
+			runOnlyForDeploymentPostprocessing: 0,
+			...properties
+		}, `${isa} ${this.id} ${name ?? ""}`);
+		ensureArray(this.properties, "buildPhases").push(phase.id);
+		return phase;
+	}
+	/**
+	* The target's shell-script phase with the given name, created with the
+	* usual defaults (`/bin/sh`, empty input and output lists) when missing.
+	* The script and other properties apply only on creation.
+	*
+	* @param name Display name of the phase, which is also its match key.
+	* @param properties Phase properties, most usefully `shellScript`.
+	*/
+	ensureShellScriptPhase(name, properties = {}) {
+		return this.ensureBuildPhase("PBXShellScriptBuildPhase", {
+			inputFileListPaths: [],
+			inputPaths: [],
+			name,
+			outputFileListPaths: [],
+			outputPaths: [],
+			shellPath: "/bin/sh",
+			shellScript: "",
+			...properties
+		});
+	}
+	/**
+	* Adds a dependency on another target of the same project, wiring the
+	* `PBXContainerItemProxy` and `PBXTargetDependency` pair Xcode uses to
+	* express it. Adding an existing dependency is a no-op.
+	*
+	* @returns The view of the target dependency object.
+	*/
+	addDependency(dependency) {
+		for (const id of stringItems(this.properties["dependencies"])) {
+			const existing = this.project.get(id);
+			if (existing?.getString("target") === dependency.id) return existing;
+		}
+		const proxy = this.project.add(Isa.containerItemProxy, {
+			containerPortal: this.project.rootProject.id,
+			proxyType: 1,
+			remoteGlobalIDString: dependency.id,
+			remoteInfo: dependency.name ?? dependency.id
+		}, `${Isa.containerItemProxy} ${this.id} ${dependency.id}`);
+		const targetDependency = this.project.add(Isa.targetDependency, {
+			target: dependency.id,
+			targetProxy: proxy.id
+		}, `${Isa.targetDependency} ${this.id} ${dependency.id}`);
+		ensureArray(this.properties, "dependencies").push(targetDependency.id);
+		return targetDependency;
+	}
+};
+/**
+* A `PBXNativeTarget` is a product the project compiles and packages
+* itself, such as an application or an app extension.
+*/
+var NativeTarget = class extends Target {
+	/**
+	* The target's product type identifier, for example
+	* `com.apple.product-type.application`.
+	*/
+	get productType() {
+		return this.getString("productType");
+	}
+	/**
+	* Rewrites the target's product type. Used by packaging repairs that
+	* convert foundation extensions into ExtensionKit extensions.
+	*/
+	set productType(value) {
+		this.properties["productType"] = value;
+	}
+	/**
+	* The view of the target's product file reference, when the target has
+	* one.
+	*/
+	get productReference() {
+		const id = this.getString("productReference");
+		return id == null ? void 0 : this.project.get(id);
+	}
+	/**
+	* Whether the target builds for watchOS, decided by its product type or
+	* its watchOS deployment-target setting.
+	*/
+	isWatchOS() {
+		if (this.productType === ProductType.watchApp) return true;
+		const defaultSettings = this.defaultConfigurationSettings();
+		return defaultSettings != null && "WATCHOS_DEPLOYMENT_TARGET" in defaultSettings;
+	}
+	/**
+	* The views of the target's Swift package product dependencies, in
+	* declaration order.
+	*/
+	packageProductDependencies() {
+		return this.referencedViews("packageProductDependencies");
+	}
+	/**
+	* The views of the target's file-system-synchronized folders, in
+	* declaration order.
+	*/
+	syncGroups() {
+		return this.referencedViews("fileSystemSynchronizedGroups").filter((view) => view instanceof SyncRootGroup);
+	}
+	/**
+	* The views of the target's build rules, in evaluation order. Empty for
+	* targets without custom rules, which is nearly all of them.
+	*/
+	buildRules() {
+		return this.referencedViews("buildRules").filter((view) => view instanceof BuildRule);
+	}
+	/**
+	* The target's sources phase, created when missing.
+	*/
+	ensureSourcesPhase() {
+		return this.ensureBuildPhase(Isa.sourcesBuildPhase);
+	}
+	/**
+	* The target's frameworks phase, created when missing.
+	*/
+	ensureFrameworksPhase() {
+		return this.ensureBuildPhase(Isa.frameworksBuildPhase);
+	}
+	/**
+	* The target's resources phase, created when missing.
+	*/
+	ensureResourcesPhase() {
+		return this.ensureBuildPhase(Isa.resourcesBuildPhase);
+	}
+	/**
+	* Embeds another target's product into this target through the
+	* copy-files phase its product type calls for ("Embed Foundation
+	* Extensions", "Embed App Clips", "Embed Watch Content", or "Embed
+	* ExtensionKit Extensions").
+	*
+	* An existing phase with the same name is reused, its destination is
+	* repaired to the type's canonical values, and the product's build file
+	* is deduplicated, so embedding is idempotent.
+	*
+	* @returns The view of the embed phase, or `undefined` when the embedded
+	*   target has no product reference to embed.
+	*/
+	embed(extension) {
+		const product = extension.productReference;
+		if (product == null) return;
+		const destination = embedDestinationFor(extension.isWatchOS() ? ProductType.watchApp : extension.productType);
+		const phase = this.ensureBuildPhase(Isa.copyFilesBuildPhase, { name: destination.phaseName });
+		phase.set("dstPath", destination.dstPath);
+		phase.set("dstSubfolderSpec", destination.dstSubfolderSpec);
+		phase.ensureBuildFile(product, { settings: { ATTRIBUTES: ["RemoveHeadersOnCopy"] } });
+		return phase;
+	}
+	/**
+	* The on-disk folder paths of the file-system-synchronized groups linked
+	* to this target. Empty for targets without synchronized folders
+	* (projects predating Xcode 16).
+	*/
+	syncGroupPaths() {
+		const paths = [];
+		for (const id of stringItems(this.properties["fileSystemSynchronizedGroups"])) {
+			const group = this.project.get(id);
+			const path = group instanceof SyncRootGroup ? group.path : void 0;
+			if (path != null) paths.push(path);
+		}
+		return paths;
+	}
+	/**
+	* Creates a file-system-synchronized folder for an on-disk path, links it
+	* to this target, and registers it in the project's main group so Xcode
+	* shows it in the navigator. When the target already links a folder with
+	* the same path, that folder is returned instead, so re-running a
+	* scaffold step cannot duplicate groups.
+	*
+	* @param path Folder path relative to the project root, for example the
+	*   target's name.
+	* @returns The view of the target's synchronized folder for the path.
+	*/
+	addSyncGroup(path) {
+		for (const id of stringItems(this.properties["fileSystemSynchronizedGroups"])) {
+			const existing = this.project.get(id);
+			if (existing instanceof SyncRootGroup && existing.path === path) return existing;
+		}
+		const group = this.project.add(Isa.fileSystemSynchronizedRootGroup, {
+			path,
+			sourceTree: "<group>"
+		}, `${Isa.fileSystemSynchronizedRootGroup} ${path}`);
+		ensureArray(this.properties, "fileSystemSynchronizedGroups").push(group.id);
+		this.project.rootProject.mainGroup()?.addChild(group);
+		return group;
+	}
+	/**
+	* Links a Swift package product to this target. It creates the
+	* `XCSwiftPackageProductDependency`, registers it on the target, and
+	* ensures the frameworks phase carries its build file. Linking an
+	* already linked product is a no-op.
+	*
+	* @param options.productName The product to link, as the package
+	*   manifest names it.
+	* @param options.packageReference The package reference view returned by
+	*   {@link XcodeProject.addSwiftPackage} or
+	*   {@link XcodeProject.findSwiftPackage}.
+	* @returns The view of the product dependency.
+	*/
+	addSwiftPackageProduct(options) {
+		for (const id of stringItems(this.properties["packageProductDependencies"])) {
+			const existing = this.project.get(id);
+			if (existing?.getString("productName") === options.productName && existing.getString("package") === options.packageReference.id) return existing;
+		}
+		const productDependency = this.project.add(Isa.swiftPackageProductDependency, {
+			package: options.packageReference.id,
+			productName: options.productName
+		}, `${Isa.swiftPackageProductDependency} ${this.id} ${options.productName}`);
+		ensureArray(this.properties, "packageProductDependencies").push(productDependency.id);
+		this.ensureFrameworksPhase().ensureBuildFile(productDependency, { referenceKey: "productRef" });
+		return productDependency;
+	}
+	/**
+	* Links a system framework (for example `Messages`) to this target. It
+	* reuses or creates the file reference under the SDK's frameworks
+	* directory and makes sure the frameworks phase carries its build file.
+	* Linking an already linked framework is a no-op.
+	*
+	* @param name Framework name without the `.framework` suffix.
+	* @returns The view of the framework's file reference.
+	*/
+	addSystemFramework(name) {
+		const path = `System/Library/Frameworks/${name}.framework`;
+		let reference;
+		for (const [, view] of this.project.objects()) if (view.isa === Isa.fileReference && view.getString("path") === path) {
+			reference = view;
+			break;
+		}
+		reference ??= this.project.add(Isa.fileReference, {
+			lastKnownFileType: "wrapper.framework",
+			name: `${name}.framework`,
+			path,
+			sourceTree: "SDKROOT"
+		}, `${Isa.fileReference} ${path}`);
+		this.ensureFrameworksPhase().ensureBuildFile(reference);
+		return reference;
+	}
+};
+/**
+* An aggregate target produces nothing itself. It exists to group other
+* targets through its dependencies and to run script or copy-files
+* phases, and the shared target surface covers everything it carries.
+*/
+var AggregateTarget = class extends Target {};
+/**
+* A legacy target shells out to an external build tool such as make
+* instead of using Xcode's build system.
+*/
+var LegacyTarget = class extends Target {
+	/**
+	* The build tool the target invokes, as an absolute path.
+	*/
+	get buildToolPath() {
+		return this.getString("buildToolPath");
+	}
+	/**
+	* The arguments passed to the build tool, as one shell-style string.
+	*/
+	get buildArgumentsString() {
+		return this.getString("buildArgumentsString");
+	}
+	/**
+	* The working directory the build tool runs in, when the target sets
+	* one.
+	*/
+	get buildWorkingDirectory() {
+		return this.getString("buildWorkingDirectory");
+	}
+};
+//#endregion
+//#region src/model/project.ts
+/**
+* The project document model. It gives typed, mutable access to a parsed
+* `project.pbxproj`.
+*
+* The model is a set of lightweight views over the plain parsed document.
+* All state lives in the document itself; views hold only an id and a
+* project reference, so model mutations and direct dictionary writes
+* compose freely and {@link XcodeProject.build} always serializes the
+* current state. New objects receive deterministic identifiers (see
+* `uuid.ts`), so programmatic edits are reproducible run to run.
+*
+* @module
+*/
+/**
+* The `PBXProject` object at the document root. It owns the target list,
+* the main group, and the project-level configurations.
+*/
+var RootProject = class extends XcodeObject {
+	/**
+	* Ids of the project's targets, in project order.
+	*/
+	targetIds() {
+		return stringItems(this.properties["targets"]);
+	}
+	/**
+	* The view of the project's main group, when the document has one. The
+	* main group is the root of Xcode's navigator tree.
+	*/
+	mainGroup() {
+		const group = this.project.get(this.getString("mainGroup"));
+		return group instanceof Group ? group : void 0;
+	}
+	/**
+	* The settings dictionary of the project-level default configuration.
+	* Targets inherit from these settings; see
+	* {@link NativeTarget.getBuildSetting}.
+	*/
+	defaultConfigurationSettings() {
+		return defaultConfigurationSettingsOf(this.project, this.getString("buildConfigurationList"));
+	}
+	/**
+	* The views of the project's Swift package references, remote and local,
+	* in declaration order.
+	*/
+	packageReferences() {
+		return this.referencedViews("packageReferences");
+	}
+	/**
+	* The group product references live in, creating it (and registering it
+	* as the project's `productRefGroup`) when missing.
+	*/
+	ensureProductsGroup() {
+		const existing = this.project.get(this.getString("productRefGroup"));
+		if (existing instanceof Group) return existing;
+		const group = this.project.add(Isa.group, {
+			children: [],
+			name: "Products",
+			sourceTree: "<group>"
+		}, `${Isa.group} Products`);
+		this.mainGroup()?.addChild(group);
+		this.set("productRefGroup", group.id);
+		return group;
+	}
+};
+/**
+* A parsed `project.pbxproj` with typed, mutable access to its objects.
+*
+* ```ts
+* const project = XcodeProject.parse(pbxprojText);
+* const app = project.findMainAppTarget("ios");
+* app?.setBuildSetting("MARKETING_VERSION", "1.2.0");
+* const text = project.build();
+* ```
+*/
+var XcodeProject = class XcodeProject {
+	/** The parsed document this model wraps. */
+	document;
+	/** The document's `objects` dictionary. */
+	objectsDictionary;
+	/**
+	* Identity map of object views, one view per id, created on first
+	* access, so views of the same object compare with `===`.
+	*/
+	views = /* @__PURE__ */ new Map();
+	constructor(document) {
+		const objects = asDictionary(document["objects"]);
+		if (objects == null) throw new XcodeModelError("The document has no objects dictionary");
+		this.document = document;
+		this.objectsDictionary = objects;
+	}
+	/**
+	* Parses pbxproj text and wraps it in a model.
+	*
+	* @throws PbxprojParseError when the text is malformed.
+	* @throws XcodeModelError when the document has no objects dictionary.
+	*/
+	static parse(text) {
+		const document = asDictionary(parsePbxproj(text));
+		if (document == null) throw new XcodeModelError("The document root is not a dictionary");
+		return new XcodeProject(document);
+	}
+	/**
+	* Wraps an already parsed document in a model. The document is used in
+	* place, not copied; model mutations write into it.
+	*/
+	static fromDocument(document) {
+		return new XcodeProject(document);
+	}
+	/**
+	* Serializes the current document state to pbxproj text in Xcode's
+	* canonical layout.
+	*/
+	build() {
+		return buildPbxproj(this.document);
+	}
+	/**
+	* The raw properties dictionary of an object.
+	*
+	* @throws XcodeModelError when no object with the id exists; views use
+	*   this accessor, so a view of a deleted object fails loudly instead of
+	*   resurrecting the entry.
+	*/
+	propertiesOf(id) {
+		const properties = asDictionary(this.objectsDictionary[id]);
+		if (properties == null) throw new XcodeModelError(`No object with id ${id} exists in the document`);
+		return properties;
+	}
+	/**
+	* The raw properties dictionary of an object, or `undefined` when the id
+	* is absent, dangling, or not a dictionary.
+	*/
+	propertiesOfOptional(id) {
+		return id == null ? void 0 : asDictionary(this.objectsDictionary[id]);
+	}
+	/**
+	* The view of an object by id, or `undefined` when the id is absent or
+	* its entry is not a dictionary. Repeated lookups return the same view
+	* instance.
+	*/
+	get(id) {
+		if (id == null) return;
+		const existing = this.views.get(id);
+		if (existing != null) return existing;
+		const properties = asDictionary(this.objectsDictionary[id]);
+		if (properties == null) return;
+		const view = this.createView(id, asString(properties["isa"]) ?? "");
+		this.views.set(id, view);
+		return view;
+	}
+	/**
+	* Iterates `[id, view]` over every well-formed object in the document,
+	* in document order. Entries that are not dictionaries are skipped.
+	*/
+	*objects() {
+		for (const id of Object.keys(this.objectsDictionary)) {
+			const view = this.get(id);
+			if (view != null) yield [id, view];
+		}
+	}
+	/**
+	* Generates a deterministic 24-character id from a seed, avoiding every
+	* id the document currently contains. The id is not reserved; adding an
+	* object with it (see {@link add}) is what claims it.
+	*/
+	generateId(seed) {
+		return generateObjectId(seed, new Set(Object.keys(this.objectsDictionary)));
+	}
+	/**
+	* Adds an object to the document and returns its view.
+	*
+	* @param isa The object's kind; written as the `isa` property.
+	* @param properties The object's remaining properties. The dictionary is
+	*   stored as passed (not copied), with `isa` written first so the
+	*   serialized entry leads with it.
+	* @param seed Seed for the deterministic id; defaults to the isa, which
+	*   is only sensible for singleton objects.
+	* @returns The view of the created object.
+	*/
+	add(isa, properties, seed) {
+		const id = this.generateId(seed ?? isa);
+		this.objectsDictionary[id] = {
+			isa,
+			...properties
+		};
+		const view = this.createView(id, isa);
+		this.views.set(id, view);
+		return view;
+	}
+	/**
+	* The view of the document's root `PBXProject` object.
+	*
+	* @throws XcodeModelError when `rootObject` is missing or dangling,
+	*   since without it no project-level operation is meaningful.
+	*/
+	get rootProject() {
+		const view = this.get(asString(this.document["rootObject"]));
+		if (!(view instanceof RootProject)) throw new XcodeModelError("The document's rootObject does not reference a PBXProject");
+		return view;
+	}
+	/**
+	* The views of the project's targets of every kind (native, aggregate,
+	* and legacy), in project order.
+	*/
+	targets() {
+		const targets = [];
+		for (const id of this.rootProject.targetIds()) {
+			const view = this.get(id);
+			if (view instanceof Target) targets.push(view);
+		}
+		return targets;
+	}
+	/**
+	* The views of the project's native targets, in project order. Targets
+	* of other kinds (aggregate and legacy targets) are not included.
+	*/
+	nativeTargets() {
+		return this.targets().filter((target) => target instanceof NativeTarget);
+	}
+	/**
+	* Finds a native target by name.
+	*/
+	findTarget(name) {
+		return this.nativeTargets().find((target) => target.name === name);
+	}
+	/**
+	* Finds the main application target for a platform. It prefers the
+	* application target whose own configurations carry the platform's
+	* deployment-target key, and falls back to the first application target
+	* in project order. Returns `undefined` when the project has no
+	* application target.
+	*/
+	findMainAppTarget(platform = "ios") {
+		const deploymentKey = DEPLOYMENT_TARGET_KEY[platform];
+		const applications = this.nativeTargets().filter((target) => target.productType === ProductType.application);
+		return applications.find((target) => target.buildConfigurations().some((configuration) => {
+			const settings = asDictionary(configuration.properties["buildSettings"]);
+			return settings != null && deploymentKey in settings;
+		})) ?? applications[0];
+	}
+	/**
+	* Creates a native target with its build configurations, product file
+	* reference in the Products group, and the standard Sources, Frameworks,
+	* and Resources build phases, and registers it on the project.
+	*
+	* @throws XcodeModelError for product types the model cannot create a
+	*   product reference for; see {@link AddNativeTargetOptions.productType}.
+	*/
+	addNativeTarget(options) {
+		const productInfo = PRODUCT_FILE_INFO[options.productType];
+		if (productInfo == null) throw new XcodeModelError(`Cannot create a product reference for product type ${options.productType}`);
+		const configurationIds = (options.configurationNames ?? ["Debug", "Release"]).map((configurationName) => this.add(Isa.buildConfiguration, {
+			buildSettings: { ...options.buildSettings },
+			name: configurationName
+		}, `${Isa.buildConfiguration} ${options.name} ${configurationName}`).id);
+		const configurationList = this.add(Isa.configurationList, {
+			buildConfigurations: configurationIds,
+			defaultConfigurationIsVisible: 0,
+			defaultConfigurationName: options.defaultConfigurationName ?? "Release"
+		}, `${Isa.configurationList} ${options.name}`);
+		const productReference = this.add(Isa.fileReference, {
+			explicitFileType: productInfo.fileType,
+			includeInIndex: 0,
+			path: `${options.name}${productInfo.extension}`,
+			sourceTree: "BUILT_PRODUCTS_DIR"
+		}, `${Isa.fileReference} ${options.name}${productInfo.extension}`);
+		this.rootProject.ensureProductsGroup().addChild(productReference);
+		const target = this.add(Isa.nativeTarget, {
+			buildConfigurationList: configurationList.id,
+			buildPhases: [],
+			buildRules: [],
+			dependencies: [],
+			name: options.name,
+			productName: options.name,
+			productReference: productReference.id,
+			productType: options.productType
+		}, `${Isa.nativeTarget} ${options.name}`);
+		ensureArray(this.rootProject.properties, "targets").push(target.id);
+		const nativeTarget = target;
+		nativeTarget.ensureSourcesPhase();
+		nativeTarget.ensureFrameworksPhase();
+		nativeTarget.ensureResourcesPhase();
+		return nativeTarget;
+	}
+	/**
+	* Finds the remote Swift package reference for a repository URL.
+	*/
+	findSwiftPackage(repositoryUrl) {
+		for (const id of stringItems(this.rootProject.properties["packageReferences"])) {
+			const reference = this.get(id);
+			if (reference?.getString("repositoryURL") === repositoryUrl) return reference;
+		}
+	}
+	/**
+	* Adds a remote Swift package reference and registers it on the project.
+	* When the project already references the repository, the existing
+	* reference is returned unchanged, requirement included; adjust an
+	* existing requirement through the reference's properties. Link products
+	* to targets with {@link NativeTarget.addSwiftPackageProduct}.
+	*
+	* @param options.repositoryURL The package's git URL.
+	* @param options.requirement The version requirement dictionary as Xcode
+	*   stores it, for example
+	*   `{ kind: "upToNextMajorVersion", minimumVersion: "5.0.0" }`.
+	* @returns The view of the package reference for the repository.
+	*/
+	addSwiftPackage(options) {
+		const existing = this.findSwiftPackage(options.repositoryURL);
+		if (existing != null) return existing;
+		const reference = this.add(Isa.remoteSwiftPackageReference, {
+			repositoryURL: options.repositoryURL,
+			requirement: options.requirement
+		}, `${Isa.remoteSwiftPackageReference} ${options.repositoryURL}`);
+		ensureArray(this.rootProject.properties, "packageReferences").push(reference.id);
+		return reference;
+	}
+	/**
+	* Finds the local Swift package reference for a directory path.
+	*/
+	findLocalSwiftPackage(relativePath) {
+		return this.rootProject.packageReferences().find((reference) => reference.isa === Isa.localSwiftPackageReference && reference.getString("relativePath") === relativePath);
+	}
+	/**
+	* Adds a local (path-based) Swift package reference and registers it on
+	* the project, returning the existing reference when the path is already
+	* registered. Products link to targets the same way as remote packages,
+	* through {@link NativeTarget.addSwiftPackageProduct}.
+	*
+	* @param relativePath The package directory, relative to the project.
+	* @returns The view of the package reference for the path.
+	*/
+	addLocalSwiftPackage(relativePath) {
+		const existing = this.findLocalSwiftPackage(relativePath);
+		if (existing != null) return existing;
+		const reference = this.add(Isa.localSwiftPackageReference, { relativePath }, `${Isa.localSwiftPackageReference} ${relativePath}`);
+		ensureArray(this.rootProject.properties, "packageReferences").push(reference.id);
+		return reference;
+	}
+	/**
+	* The views of every `PBXBuildFile` that points at the referenced object
+	* through `fileRef` or `productRef`. Useful for relocating a product
+	* between copy phases.
+	*/
+	buildFilesReferencing(reference) {
+		const buildFiles = [];
+		for (const [, view] of this.objects()) if (view.isa === Isa.buildFile && (view.getString("fileRef") === reference.id || view.getString("productRef") === reference.id)) buildFiles.push(view);
+		return buildFiles;
+	}
+	/**
+	* Validates the document's object graph and returns every problem
+	* found. An empty array means the graph is structurally sound. The
+	* checks cover the root object, object kinds, known references, and
+	* reachability.
+	*/
+	validate() {
+		return validateProject(this);
+	}
+	/**
+	* Removes every object unreachable from the root object and returns the
+	* removed ids. Reachability is conservative. Any real reference keeps
+	* an object alive, even through properties outside the known schema.
+	*/
+	pruneOrphans() {
+		return pruneOrphanObjects(this);
+	}
+	/**
+	* The views of every object that references the id anywhere in its
+	* properties. A reference is a string property naming the id, an id
+	* list containing it, or a nested dictionary carrying it as a key or
+	* string value.
+	*
+	* The scan is linear over the document; removal flows call it once per
+	* removed object, which keeps teardown proportional to what is actually
+	* removed.
+	*/
+	referrersOf(id) {
+		const referrers = [];
+		for (const [referrerId, view] of this.objects()) if (referrerId !== id && objectReferences(view.properties, id)) referrers.push(view);
+		return referrers;
+	}
+	/**
+	* Removes an object from the document and strips every reference to it
+	* from the remaining objects. String properties naming the id are
+	* deleted, id lists drop it, and nested dictionaries keyed by object id
+	* (such as `TargetAttributes`) drop its entry.
+	*
+	* Removing an id the document does not contain is a no-op. This is the
+	* low-level removal; {@link removeTarget} composes it into a full
+	* teardown.
+	*/
+	removeObject(id) {
+		if (!(id in this.objectsDictionary)) return;
+		delete this.objectsDictionary[id];
+		this.views.delete(id);
+		for (const [, view] of this.objects()) stripReferences(view.properties, id);
+	}
+	/**
+	* Removes a target and everything that exists only for its sake. That
+	* covers its build phases and their build files, its configuration list
+	* and configurations, its product reference and the build files
+	* embedding it, dependency objects and container proxies in both
+	* directions (other targets' dependencies on it, and its own
+	* dependencies on others), its membership exception sets, and
+	* synchronized folders no remaining target links.
+	*
+	* On-disk sources are untouched; the removal is document-only, like
+	* deleting a target in Xcode and keeping its folder.
+	*
+	* @throws XcodeModelError when the target belongs to another project,
+	*   since removing by another document's ids would tear down unrelated
+	*   objects that happen to share them.
+	*/
+	removeTarget(target) {
+		if (target.project !== this) throw new XcodeModelError("Cannot remove a target that belongs to another project");
+		const ownedIds = /* @__PURE__ */ new Set();
+		for (const phase of target.buildPhases()) {
+			for (const buildFileId of phase.buildFileIds) ownedIds.add(buildFileId);
+			ownedIds.add(phase.id);
+		}
+		const configurationListId = target.getString("buildConfigurationList");
+		if (configurationListId != null) {
+			for (const configuration of target.buildConfigurations()) ownedIds.add(configuration.id);
+			ownedIds.add(configurationListId);
+		}
+		const product = this.get(target.getString("productReference"));
+		if (product != null) {
+			for (const buildFile of this.buildFilesReferencing(product)) ownedIds.add(buildFile.id);
+			ownedIds.add(product.id);
+		}
+		for (const dependency of target.dependencies()) {
+			const proxyId = dependency.getString("targetProxy");
+			if (proxyId != null) ownedIds.add(proxyId);
+			ownedIds.add(dependency.id);
+		}
+		for (const [, view] of this.objects()) {
+			if (view.isa === Isa.targetDependency && view.getString("target") === target.id) {
+				const proxyId = view.getString("targetProxy");
+				if (proxyId != null) ownedIds.add(proxyId);
+				ownedIds.add(view.id);
+			}
+			if (view.isa === Isa.fileSystemSynchronizedBuildFileExceptionSet && view.getString("target") === target.id) ownedIds.add(view.id);
+		}
+		const syncGroupIds = stringItems(target.properties["fileSystemSynchronizedGroups"]);
+		this.removeObject(target.id);
+		for (const id of ownedIds) this.removeObject(id);
+		for (const groupId of syncGroupIds) if (!this.nativeTargets().some((remaining) => stringItems(remaining.properties["fileSystemSynchronizedGroups"]).includes(groupId))) this.removeObject(groupId);
+	}
+	/**
+	* Finds a file reference by its project-relative path, resolving each
+	* reference's location through the group tree from the main group
+	* (nested group `path` components join with `/`).
+	*
+	* Members of file-system-synchronized folders are not listed in the
+	* document and therefore cannot be found; check
+	* {@link NativeTarget.syncGroupPaths} for folder-level containment
+	* instead.
+	*/
+	findFileReference(projectRelativePath) {
+		const mainGroup = this.rootProject.mainGroup();
+		if (mainGroup == null) return;
+		const visited = /* @__PURE__ */ new Set();
+		const search = (group, prefix) => {
+			if (visited.has(group.id)) return;
+			visited.add(group.id);
+			for (const childId of group.childIds) {
+				const child = this.get(childId);
+				if (child == null) continue;
+				const childPath = child.getString("path");
+				if (child instanceof Group) {
+					const found = search(child, childPath == null ? prefix : joinPath(prefix, childPath));
+					if (found != null) return found;
+				} else if (child.isa === Isa.fileReference && childPath != null && joinPath(prefix, childPath) === projectRelativePath) return child;
+			}
+		};
+		return search(mainGroup, "");
+	}
+	/**
+	* Creates the typed view for an object, dispatching on its isa. Objects
+	* outside the typed vocabulary get the generic base view.
+	*/
+	createView(id, isa) {
+		switch (isa) {
+			case Isa.nativeTarget: return new NativeTarget(this, id);
+			case Isa.aggregateTarget: return new AggregateTarget(this, id);
+			case Isa.legacyTarget: return new LegacyTarget(this, id);
+			case Isa.project: return new RootProject(this, id);
+			case Isa.group:
+			case Isa.variantGroup: return new Group(this, id);
+			case Isa.versionGroup: return new VersionGroup(this, id);
+			case Isa.fileSystemSynchronizedRootGroup: return new SyncRootGroup(this, id);
+			case Isa.buildRule: return new BuildRule(this, id);
+			case Isa.referenceProxy: return new ReferenceProxy(this, id);
+			default: return isa.endsWith("BuildPhase") ? new BuildPhase(this, id) : new XcodeObject(this, id);
+		}
+	}
+};
+/**
+* Joins two path segments with a `/`, treating an empty prefix as the
+* project root.
+*/
+function joinPath(prefix, segment) {
+	return prefix === "" ? segment : `${prefix}/${segment}`;
+}
+/**
+* Whether a value references the id anywhere in its structure. A
+* reference is a string equal to it, an array containing it at any depth,
+* or a dictionary carrying it as a key or somewhere in its values.
+*/
+function valueReferences(value, id) {
+	if (typeof value === "string") return value === id;
+	if (Array.isArray(value)) return value.some((item) => valueReferences(item, id));
+	const nested = asDictionary(value);
+	if (nested != null) return id in nested || objectReferences(nested, id);
+	return false;
+}
+/**
+* Whether an object's properties reference the id anywhere. See
+* {@link valueReferences} for the shapes considered.
+*/
+function objectReferences(properties, id) {
+	for (const key of Object.keys(properties)) if (valueReferences(properties[key], id)) return true;
+	return false;
+}
+/**
+* Strips every reference to the id inside a value and returns the value
+* to keep. Strings equal to the id become `undefined`, arrays drop
+* matching items at any depth, and dictionaries drop entries keyed by it
+* and recurse into their values.
+*/
+function stripValue(value, id) {
+	if (typeof value === "string") return value === id ? void 0 : value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const kept = [];
+		for (const item of value) {
+			const stripped = stripValue(item, id);
+			if (stripped == null || stripped !== item) changed = true;
+			if (stripped != null) kept.push(stripped);
+		}
+		return changed ? kept : value;
+	}
+	const nested = asDictionary(value);
+	if (nested != null) {
+		if (id in nested) delete nested[id];
+		stripReferences(nested, id);
+	}
+	return value;
+}
+/**
+* Strips every reference to the id from an object's properties; see
+* {@link stripValue} for the shapes handled. String properties naming the
+* id are deleted rather than left empty.
+*/
+function stripReferences(properties, id) {
+	for (const key of Object.keys(properties)) {
+		const value = properties[key];
+		if (value == null) continue;
+		const stripped = stripValue(value, id);
+		if (stripped == null) delete properties[key];
+		else if (stripped !== value) properties[key] = stripped;
+	}
+}
+//#endregion
+//#region src/scheme/types.ts
+/**
+* Whether a node is an element rather than a comment.
+*/
+function isXcschemeElement(node) {
+	return "name" in node;
+}
+//#endregion
+//#region src/scheme/build.ts
+/**
+* Serializer for the `.xcscheme` XML dialect.
+*
+* The output reproduces Xcode's own layout byte for byte: the UTF-8
+* declaration, three-space indentation, one attribute per line with
+* spaces around the equals sign, the closing angle bracket glued to the
+* last attribute, and an explicit close tag on every element. Parsing an
+* Xcode-written scheme and building it back yields the identical file,
+* and any input reaches that canonical form in one build.
+*
+* @module
+*/
+const XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+/** One indentation step of Xcode's scheme writer. */
+const INDENT = "   ";
+/**
+* Matches the names Xcode's scheme vocabulary uses; a stray non-name
+* (an empty string, spaces, XML syntax) must fail rather than produce a
+* document no parser accepts.
+*/
+const NAME_PATTERN = /^[A-Za-z_:][A-Za-z0-9_:.-]*$/u;
+/**
+* Matches characters that cannot appear in an attribute value: XML 1.0
+* has no representation for control characters other than tab, line
+* feed, and carriage return.
+*/
+const UNENCODABLE_PATTERN = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/u;
+/**
+* Serializes a scheme document to the text of a `.xcscheme` file.
+*
+* @throws XcschemeBuildError for element or attribute names that are not
+*   XML names and for attribute values carrying unencodable control
+*   characters, with the path of the offending node.
+*/
+function buildXcscheme(document) {
+	let output = XML_DECLARATION;
+	for (const comment of document.leading) output += `<!--${comment.comment}-->\n`;
+	output += renderElement(document.root, 0, document.root.name);
+	for (const comment of document.trailing) output += `<!--${comment.comment}-->\n`;
+	return output;
+}
+/**
+* Renders one element with Xcode's layout: attributes each on their own
+* line indented one step past the tag, `>` glued to the last attribute,
+* children indented one step, and always an explicit close tag.
+*/
+function renderElement(element, depth, path) {
+	if (!NAME_PATTERN.test(element.name)) throw new XcschemeBuildError(`Element name ${JSON.stringify(element.name)} is not a valid XML name`, path);
+	const indent = INDENT.repeat(depth);
+	const names = Object.keys(element.attributes);
+	let output;
+	if (names.length === 0) output = `${indent}<${element.name}>\n`;
+	else {
+		output = `${indent}<${element.name}\n`;
+		const attributeIndent = indent + INDENT;
+		for (let i = 0; i < names.length; i++) {
+			const name = names[i];
+			if (!NAME_PATTERN.test(name)) throw new XcschemeBuildError(`Attribute name ${JSON.stringify(name)} is not a valid XML name`, path);
+			const value = escapeAttribute(element.attributes[name], path, name);
+			const terminator = i === names.length - 1 ? ">" : "";
+			output += `${attributeIndent}${name} = "${value}"${terminator}\n`;
+		}
+	}
+	output += renderChildren(element.children, depth + 1, path);
+	output += `${indent}</${element.name}>\n`;
+	return output;
+}
+/**
+* Renders an element's children in document order, numbering repeated
+* element names in the error path so a failure points at one node.
+*/
+function renderChildren(children, depth, path) {
+	let output = "";
+	const seen = /* @__PURE__ */ new Map();
+	for (const child of children) if (isXcschemeElement(child)) {
+		const index = seen.get(child.name) ?? 0;
+		seen.set(child.name, index + 1);
+		output += renderElement(child, depth, `${path}.${child.name}[${index}]`);
+	} else output += `${INDENT.repeat(depth)}<!--${child.comment}-->\n`;
+	return output;
+}
+/**
+* Escapes an attribute value the way Xcode's writer does: the five named
+* entities for XML syntax characters, and character references for tab,
+* line feed, and carriage return so they survive attribute-value
+* normalization on the next parse.
+*/
+function escapeAttribute(value, path, attributeName) {
+	const unencodable = UNENCODABLE_PATTERN.exec(value);
+	if (unencodable != null) throw new XcschemeBuildError(`Attribute ${attributeName} contains the control character U+${unencodable[0].charCodeAt(0).toString(16).padStart(4, "0").toUpperCase()}, which XML cannot encode`, path);
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;").replaceAll("	", "&#9;").replaceAll("\n", "&#10;").replaceAll("\r", "&#13;");
+}
+//#endregion
+//#region src/scheme/model.ts
+/**
+* Helpers over the scheme node tree: element queries and the default
+* scheme factory.
+*
+* The tree itself is plain data, so most edits are direct property
+* writes. What this module adds is the recursive query that editing
+* flows start from and a factory producing the scheme Xcode's own "New
+* Scheme" action writes for an application target.
+*
+* @module
+*/
+/**
+* Collects elements of the given name anywhere in the tree, in document
+* order, the subtree root included. Passing no name collects every
+* element.
+*
+* ```ts
+* for (const reference of xcschemeElements(scheme.root, "BuildableReference")) {
+*   reference.attributes["BlueprintName"] = "RenamedApp";
+* }
+* ```
+*/
+function xcschemeElements(root, name) {
+	const found = [];
+	const visit = (element) => {
+		if (name == null || element.name === name) found.push(element);
+		for (const child of element.children) if (isXcschemeElement(child)) visit(child);
+	};
+	visit(root);
+	return found;
+}
+/**
+* Creates the scheme Xcode writes for an application target: build,
+* launch, profile, analyze, and archive actions wired to the app product,
+* with Xcode's default configuration choices (Debug for development
+* actions, Release for profiling and archiving).
+*/
+function createXcscheme(options) {
+	const xcodeprojName = options.xcodeprojName ?? `${options.appName}.xcodeproj`;
+	/**
+	* Buildable references appear once per action; each site gets its own
+	* element so a mutation through one action cannot alias into another.
+	*/
+	const buildableReference = () => ({
+		name: "BuildableReference",
+		attributes: {
+			BuildableIdentifier: "primary",
+			BlueprintIdentifier: options.blueprintIdentifier ?? "",
+			BuildableName: `${options.appName}.app`,
+			BlueprintName: options.appName,
+			ReferencedContainer: `container:${xcodeprojName}`
+		},
+		children: []
+	});
+	return {
+		leading: [],
+		root: {
+			name: "Scheme",
+			attributes: { version: "1.7" },
+			children: [
+				{
+					name: "BuildAction",
+					attributes: {
+						parallelizeBuildables: "YES",
+						buildImplicitDependencies: "YES"
+					},
+					children: [{
+						name: "BuildActionEntries",
+						attributes: {},
+						children: [{
+							name: "BuildActionEntry",
+							attributes: {
+								buildForTesting: "YES",
+								buildForRunning: "YES",
+								buildForProfiling: "YES",
+								buildForArchiving: "YES",
+								buildForAnalyzing: "YES"
+							},
+							children: [buildableReference()]
+						}]
+					}]
+				},
+				{
+					name: "LaunchAction",
+					attributes: {
+						buildConfiguration: "Debug",
+						selectedDebuggerIdentifier: "Xcode.DebuggerFoundation.Debugger.LLDB",
+						selectedLauncherIdentifier: "Xcode.DebuggerFoundation.Launcher.LLDB",
+						launchStyle: "0",
+						useCustomWorkingDirectory: "NO",
+						ignoresPersistentStateOnLaunch: "NO",
+						debugDocumentVersioning: "YES",
+						debugServiceExtension: "internal",
+						allowLocationSimulation: "YES"
+					},
+					children: [{
+						name: "BuildableProductRunnable",
+						attributes: { runnableDebuggingMode: "0" },
+						children: [buildableReference()]
+					}]
+				},
+				{
+					name: "ProfileAction",
+					attributes: {
+						buildConfiguration: "Release",
+						shouldUseLaunchSchemeArgsEnv: "YES",
+						savedToolIdentifier: "",
+						useCustomWorkingDirectory: "NO",
+						debugDocumentVersioning: "YES"
+					},
+					children: [{
+						name: "BuildableProductRunnable",
+						attributes: { runnableDebuggingMode: "0" },
+						children: [buildableReference()]
+					}]
+				},
+				{
+					name: "AnalyzeAction",
+					attributes: { buildConfiguration: "Debug" },
+					children: []
+				},
+				{
+					name: "ArchiveAction",
+					attributes: {
+						buildConfiguration: "Release",
+						revealArchiveInOrganizer: "YES"
+					},
+					children: []
+				}
+			]
+		},
+		trailing: []
+	};
+}
+//#endregion
+//#region src/scheme/parse.ts
+/**
+* Parser for the `.xcscheme` XML dialect.
+*
+* Scheme files are XML with a narrow shape: elements with attributes and
+* child elements, no text content, no namespaces, no DOCTYPE. The parser
+* accepts that shape from any writer (attribute order, quoting style, and
+* whitespace vary across tools), resolves character and entity references
+* in attribute values, and preserves comments. Anything outside the shape
+* fails loudly with a position, in line with the pbxproj parser.
+*
+* @module
+*/
+const CODE_TAB = 9;
+const CODE_LINE_FEED = 10;
+const CODE_CARRIAGE_RETURN = 13;
+const CODE_SPACE = 32;
+const CODE_BANG = 33;
+const CODE_QUOTE = 34;
+const CODE_AMPERSAND = 38;
+const CODE_APOSTROPHE = 39;
+const CODE_HYPHEN = 45;
+const CODE_SLASH = 47;
+const CODE_LESS_THAN = 60;
+const CODE_EQUALS = 61;
+const CODE_GREATER_THAN = 62;
+const CODE_QUESTION = 63;
+const CODE_HASH = 35;
+const CODE_BOM = 65279;
+/**
+* Whether a code unit is XML whitespace (space, tab, line feed, or
+* carriage return).
+*/
+function isWhitespace(code) {
+	return code === CODE_SPACE || code === CODE_TAB || code === CODE_LINE_FEED || code === CODE_CARRIAGE_RETURN;
+}
+/**
+* Whether a code unit can start an XML name. The scheme vocabulary is
+* ASCII, so the accepted alphabet is letters, underscore, and colon.
+*/
+function isNameStart(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95 || code === 58;
+}
+/**
+* Whether a code unit can continue an XML name.
+*/
+function isNameChar(code) {
+	return isNameStart(code) || code >= 48 && code <= 57 || code === CODE_HYPHEN || code === 46;
+}
+/** The named character entities XML 1.0 predefines. */
+const NAMED_ENTITIES = {
+	amp: "&",
+	apos: "'",
+	gt: ">",
+	lt: "<",
+	quot: "\""
+};
+/**
+* Parses the text of a `.xcscheme` file into its node tree.
+*
+* @throws XcschemeParseError when the text is not a well-formed scheme
+*   document, with the line and column of the failure.
+*/
+function parseXcscheme(text) {
+	return new Parser(text).parseDocument();
+}
+var Parser = class {
+	input;
+	pos = 0;
+	constructor(input) {
+		this.input = input;
+		if (input.charCodeAt(0) === CODE_BOM) this.pos = 1;
+	}
+	parseDocument() {
+		this.skipWhitespace();
+		this.skipDeclaration();
+		const leading = [];
+		const trailing = [];
+		this.skipWhitespace();
+		while (this.peekIsCommentStart()) {
+			leading.push(this.parseComment());
+			this.skipWhitespace();
+		}
+		const root = this.parseElement();
+		this.skipWhitespace();
+		while (this.peekIsCommentStart()) {
+			trailing.push(this.parseComment());
+			this.skipWhitespace();
+		}
+		if (this.pos < this.input.length) this.fail("Expected end of document after the root element");
+		return {
+			leading,
+			root,
+			trailing
+		};
+	}
+	/**
+	* Skips the `<?xml ... ?>` declaration when present. Its attributes are
+	* not retained: the writer always emits the canonical UTF-8 declaration.
+	*/
+	skipDeclaration() {
+		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN || this.input.charCodeAt(this.pos + 1) !== CODE_QUESTION) return;
+		const end = this.input.indexOf("?>", this.pos + 2);
+		if (end === -1) this.fail("Unterminated XML declaration");
+		this.pos = end + 2;
+	}
+	parseElement() {
+		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN) this.fail("Expected an element");
+		this.pos++;
+		const name = this.parseName("element name");
+		const attributes = Object.create(null);
+		for (;;) {
+			const hadWhitespace = this.skipWhitespace();
+			const code = this.input.charCodeAt(this.pos);
+			if (code === CODE_GREATER_THAN) {
+				this.pos++;
+				break;
+			}
+			if (code === CODE_SLASH && this.input.charCodeAt(this.pos + 1) === CODE_GREATER_THAN) {
+				this.pos += 2;
+				return {
+					name,
+					attributes,
+					children: []
+				};
+			}
+			if (Number.isNaN(code)) this.fail(`Unterminated <${name}> tag`);
+			if (!hadWhitespace) this.fail("Expected whitespace before an attribute");
+			const attributeName = this.parseName("attribute name");
+			this.skipWhitespace();
+			if (this.input.charCodeAt(this.pos) !== CODE_EQUALS) this.fail(`Expected = after attribute ${attributeName}`);
+			this.pos++;
+			this.skipWhitespace();
+			if (attributeName in attributes) this.fail(`Duplicate attribute ${attributeName} on <${name}>`);
+			attributes[attributeName] = this.parseAttributeValue();
+		}
+		const children = [];
+		for (;;) {
+			this.skipWhitespace();
+			const code = this.input.charCodeAt(this.pos);
+			if (Number.isNaN(code)) this.fail(`Missing </${name}> close tag`);
+			if (code !== CODE_LESS_THAN) this.fail("Unexpected text content inside an element");
+			if (this.input.charCodeAt(this.pos + 1) === CODE_SLASH) {
+				this.pos += 2;
+				const closeName = this.parseName("close tag name");
+				if (closeName !== name) this.fail(`Expected </${name}> but found </${closeName}>`);
+				this.skipWhitespace();
+				if (this.input.charCodeAt(this.pos) !== CODE_GREATER_THAN) this.fail(`Malformed </${closeName}> close tag`);
+				this.pos++;
+				return {
+					name,
+					attributes,
+					children
+				};
+			}
+			if (this.peekIsCommentStart()) children.push(this.parseComment());
+			else children.push(this.parseElement());
+		}
+	}
+	peekIsCommentStart() {
+		return this.input.charCodeAt(this.pos) === CODE_LESS_THAN && this.input.charCodeAt(this.pos + 1) === CODE_BANG && this.input.charCodeAt(this.pos + 2) === CODE_HYPHEN && this.input.charCodeAt(this.pos + 3) === CODE_HYPHEN;
+	}
+	parseComment() {
+		const end = this.input.indexOf("-->", this.pos + 4);
+		if (end === -1) this.fail("Unterminated comment");
+		const comment = this.input.slice(this.pos + 4, end);
+		this.pos = end + 3;
+		return { comment };
+	}
+	parseName(what) {
+		const start = this.pos;
+		if (!isNameStart(this.input.charCodeAt(this.pos))) this.fail(`Expected ${what}`);
+		this.pos++;
+		while (isNameChar(this.input.charCodeAt(this.pos))) this.pos++;
+		return this.input.slice(start, this.pos);
+	}
+	parseAttributeValue() {
+		const quote = this.input.charCodeAt(this.pos);
+		if (quote !== CODE_QUOTE && quote !== CODE_APOSTROPHE) this.fail("Expected a quoted attribute value");
+		this.pos++;
+		let value = "";
+		let runStart = this.pos;
+		for (;;) {
+			const code = this.input.charCodeAt(this.pos);
+			if (Number.isNaN(code)) this.fail("Unterminated attribute value");
+			if (code === quote) {
+				value += this.input.slice(runStart, this.pos);
+				this.pos++;
+				return value;
+			}
+			if (code === CODE_LESS_THAN) this.fail("Attribute values cannot contain a raw <");
+			if (code === CODE_AMPERSAND) {
+				value += this.input.slice(runStart, this.pos);
+				value += this.parseReference();
+				runStart = this.pos;
+			} else this.pos++;
+		}
+	}
+	/**
+	* Resolves one `&...;` reference with the cursor on the ampersand. The
+	* accepted forms are the five XML named entities and decimal or hex
+	* character references, which covers everything observed in
+	* Xcode-written schemes (`&quot;`, `&amp;`, `&apos;`, `&lt;`, `&gt;`,
+	* and `&#10;`-style whitespace).
+	*/
+	parseReference() {
+		const start = this.pos;
+		const end = this.input.indexOf(";", start + 1);
+		if (end === -1 || end - start > 12) this.fail("Unterminated character reference");
+		const body = this.input.slice(start + 1, end);
+		this.pos = end + 1;
+		if (body.charCodeAt(0) === CODE_HASH) {
+			const isHex = body.charCodeAt(1) === 120 || body.charCodeAt(1) === 88;
+			const digits = body.slice(isHex ? 2 : 1);
+			const radix = isHex ? 16 : 10;
+			const codePoint = Number.parseInt(digits, radix);
+			if (digits.length === 0 || Number.isNaN(codePoint) || codePoint > 1114111) this.failAt(`Invalid character reference &${body};`, start);
+			return String.fromCodePoint(codePoint);
+		}
+		const named = Object.hasOwn(NAMED_ENTITIES, body) ? NAMED_ENTITIES[body] : void 0;
+		if (named == null) this.failAt(`Unknown entity &${body};`, start);
+		return named;
+	}
+	/**
+	* Skips whitespace and reports whether any was consumed, which attribute
+	* parsing uses to require separation between attributes.
+	*/
+	skipWhitespace() {
+		const start = this.pos;
+		while (isWhitespace(this.input.charCodeAt(this.pos))) this.pos++;
+		return this.pos > start;
+	}
+	fail(message) {
+		this.failAt(message, this.pos);
+	}
+	failAt(message, offset) {
+		throw new XcschemeParseError(message, this.input, offset);
+	}
+};
 //#endregion
-export { PbxprojBuildError, PbxprojParseError, buildPbxproj, parsePbxproj };
+export { AggregateTarget, BuildPhase, BuildRule, CopyFilesDestination, Group, Isa, LegacyTarget, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RootProject, SyncRootGroup, Target, VersionGroup, XcodeModelError, XcodeObject, XcodeProject, XcschemeBuildError, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };