rork-xcode 0.3.0 → 0.4.0

package/README.md

@@ -25,11 +25,11 @@ const text = buildPbxproj(project); // byte-stable, Xcode-canonical layout
 
 `rork-xcode` is designed for exactly that situation:
 
-- **Zero dependencies.** The pbxproj grammar is a small OpenStep-style property list dialect: dictionaries, arrays, strings, and hex data runs. A dedicated scanner covers it completely, with no general-purpose parser stack, no native addon, and no WASM blob.
+- **Zero dependencies.** The pbxproj grammar is a small OpenStep-style property list dialect of dictionaries, arrays, strings, and hex data runs. A dedicated scanner covers it completely, with no general-purpose parser stack, no native addon, and no WASM blob.
 - **One artifact, one code path.** A single ESM file with named exports. No environment-conditional entry points, no reliance on ambient globals like `Buffer`. What you test locally is what runs in production, whatever the bundler.
 - **Xcode-canonical output.** The serializer reproduces the layout Xcode itself writes (tab indentation, per-isa object sections in sorted order, single-line build-file entries, and derived reference comments like `13B07F86… /* AppDelegate.swift in Sources */`), so diffs against Xcode-saved projects stay minimal and Xcode does not rewrite the file on next save.
 - **Round-trip faithful.** Parse → build is byte-identical for Xcode-canonical documents and a fixed point for everything else. Lexical subtleties that plain number conversion would destroy (leading-zero values like `0755`, trailing-zero versions like `5.0`, digit runs longer than the double-precision safe range) are preserved as strings by design.
-- **Loud failure modes.** Malformed documents fail with a typed error carrying line and column; unrepresentable values (`null`, booleans, non-finite numbers) fail with the exact path of the offending value. Nothing is silently dropped.
+- **Loud failure modes.** Malformed documents fail with a typed error carrying line and column, and unrepresentable values (`null`, booleans, non-finite numbers) fail with the exact path of the offending value. Nothing is silently dropped.
 
 ## Install
 
@@ -222,45 +222,48 @@ for (const [id, object] of project.objects()) {
 
 ### Semantics
 
-- **Typed vocabulary, generic fallback.** The typed views cover targets of every kind, groups and variant groups, Xcode 16 synchronized folders and their exception sets, build phases and build rules, Core Data version groups, and cross-project reference proxies. Every other kind is a generic `XcodeObject` with the same read and write access, so nothing in a document is out of reach.
+- **Typed vocabulary, generic fallback.** The typed views cover targets of every kind, groups and variant groups, Xcode 16 synchronized folders and their exception sets, build phases and build rules, build configurations, file references, container item proxies, Core Data version groups, and cross-project reference proxies. Every other kind is a generic `XcodeObject` with the same read and write access, so nothing in a document is out of reach.
+- **`is()` narrowing.** Every view class carries a static type guard for discriminating mixed objects: `if (NativeTarget.is(object))` narrows the way `instanceof` does, subclasses included. Build configurations additionally expose their settings as a live typed dictionary through `configuration.buildSettings`.
 - **Typed, open property shapes.** Known keys autocomplete (`target.properties.productType`) and the shape stays open, so keys like `INFOPLIST_KEY_*` settings remain first-class. The shapes describe well-formed documents. When reading untrusted input, use the narrowing accessors, which never trust them.
-- **Two verb families.** `add*` wires something to its owner (a dependency, a package, a framework, a synchronized folder) and is idempotent: re-adding returns the existing wiring. `ensure*` returns a structural container, creating it when missing (a build phase, a group chain, the Products group). Both families can therefore run unconditionally in scaffold and repair flows.
+- **Two verb families.** `add*` wires something to its owner (a dependency, a package, a framework, a synchronized folder) and is idempotent, so re-adding returns the existing wiring. `ensure*` returns a structural container, creating it when missing (a build phase, a group chain, the Products group). Both families can therefore run unconditionally in scaffold and repair flows.
 - **Deterministic identifiers.** New objects get ids derived from what they are (`XX` + 20 digest characters + `XX`, from an embedded hash), so programmatic edits are reproducible run to run and diffs stay minimal. Collisions within a document resolve deterministically, and identical edit sequences produce byte-identical documents.
 - **Soft reads, loud writes.** Real-world projects can be malformed, so lookups return `undefined` where a document could omit something. Operations that cannot proceed without structure (no root project object, an unknown product type, a view whose object was deleted) throw `XcodeModelError`.
 - **Identity-mapped views.** Two lookups of the same id return the same instance, so views compare with `===`.
 
 ## Schemes
 
-`.xcscheme` files describe how Xcode builds, runs, tests, and archives a target. They are not property lists but a small XML dialect of their own, and `parseXcscheme` and `buildXcscheme` cover it with the same contract as the pbxproj functions: an Xcode-written scheme rebuilds byte for byte, any other input reaches Xcode's canonical layout in one build, and malformed input fails with a typed error carrying line and column.
+`.xcscheme` files describe how Xcode builds, runs, tests, and archives a target. They are not property lists but a small XML dialect of their own, and the scheme module covers it with the same contract as the pbxproj functions. An Xcode-written scheme rebuilds byte for byte, any other input reaches Xcode's canonical layout in one build, and malformed input fails with a typed error carrying line and column.
+
+`Xcscheme` is the model. Buildable references are the elements editing flows touch, and they come back as typed views:
 
 ```ts
-import { buildXcscheme, parseXcscheme, xcschemeElements } from "rork-xcode";
+import { Xcscheme } from "rork-xcode";
 
-const scheme = parseXcscheme(xcschemeText);
+const scheme = Xcscheme.parse(xcschemeText);
 
-// The tree is plain data: elements with ordered attributes and children.
-for (const reference of xcschemeElements(scheme.root, "BuildableReference")) {
-  reference.attributes["BlueprintName"] = "RenamedApp";
-  reference.attributes["BuildableName"] = "RenamedApp.app";
-  reference.attributes["ReferencedContainer"] = "container:RenamedApp.xcodeproj";
+// Rename the app while keeping each product's own shape, so a testable
+// like DemoAppTests.xctest stays a test bundle.
+for (const reference of scheme.buildableReferences()) {
+  const { blueprintName, buildableName } = reference;
+  if (blueprintName) reference.blueprintName = blueprintName.replace("DemoApp", "RenamedApp");
+  if (buildableName) reference.buildableName = buildableName.replace("DemoApp", "RenamedApp");
+  reference.referencedContainer = "container:RenamedApp.xcodeproj";
 }
 
-const text = buildXcscheme(scheme);
+const text = scheme.build();
 ```
 
-`createXcscheme` produces the scheme Xcode's own "New Scheme" action writes for an application target, wired to the target's object id from the project document:
+`Xcscheme.create` produces the scheme Xcode's own "New Scheme" action writes for an application target, wired to the target's object id from the project document:
 
 ```ts
-import { createXcscheme } from "rork-xcode";
-
-const scheme = createXcscheme({
+const scheme = Xcscheme.create({
   appName: "DemoApp",
   blueprintIdentifier: app.id,
 });
-const text = buildXcscheme(scheme);
+const text = scheme.build();
 ```
 
-Attribute order is preserved and meaningful: the writer emits attributes in insertion order, which is how byte-identical round-trips fall out. Comments are kept, attribute values resolve the character references Xcode writes (`"`, `&`, `
` and friends), and the writer re-escapes them identically.
+Underneath, the document is a plain tree of elements with ordered attributes and children, reachable through `scheme.root` and `scheme.elements(name)`, so anything the typed surface does not cover stays one property away. `parseXcscheme` and `buildXcscheme` remain available for working with the tree directly. Attribute order is preserved and meaningful, which is how byte-identical round-trips fall out. Comments are kept, attribute values resolve the character references Xcode writes (`"`, `&`, `
` and friends), and the writer re-escapes them identically.
 
 ## Performance
 
@@ -283,8 +286,8 @@ Measured on an Apple M5 Max, Node.js 24, single thread, with `@bacons/xcode` 1.0
 
 ### Key performance features
 
-- **Single-pass scanner.** One cursor over the input string with table-driven character classification; no tokenizer stage, no intermediate token objects.
-- **Comments skip in bulk.** Reference comments are a sizable share of a canonical document's bytes; comment bodies are jumped with `indexOf` instead of being scanned per character.
+- **Single-pass scanner.** One cursor over the input string with table-driven character classification. There is no tokenizer stage and no intermediate token objects.
+- **Comments skip in bulk.** Reference comments are a sizable share of a canonical document's bytes, so comment bodies are jumped with `indexOf` instead of being scanned per character.
 - **Linear comment derivation.** Building the `/* … */` annotations uses reverse indexes over the object graph (build file → phase, configuration list → owner), so serialization stays linear on projects with thousands of objects.
 - **Memoized rendering.** Quoting decisions for the repeated key vocabulary and rendered uuid references are cached per document, halving the quote scans on reference-heavy sections.
 

package/dist/index.d.ts

@@ -307,6 +307,8 @@ interface BuildSettings extends PbxprojObject {
   SUPPORTED_PLATFORMS?: string;
   SWIFT_VERSION?: string;
   TARGETED_DEVICE_FAMILY?: number | string;
+  TEST_HOST?: string;
+  TEST_TARGET_NAME?: string;
   TVOS_DEPLOYMENT_TARGET?: string;
   WATCHOS_DEPLOYMENT_TARGET?: string;
   XROS_DEPLOYMENT_TARGET?: string;
@@ -888,6 +890,49 @@ declare class VersionGroup extends Group<VersionGroupProperties> {
    */
   setCurrentVersion(reference: XcodeObject): void;
 }
+/**
+ * An `XCBuildConfiguration` holds one named settings dictionary of a
+ * target or of the project, for example Debug or Release.
+ */
+declare class BuildConfiguration extends XcodeObject<BuildConfigurationProperties> {
+  /**
+   * The configuration's name, when present.
+   */
+  get name(): string | undefined;
+  /**
+   * The configuration's settings dictionary, typed with the keys
+   * programmatic edits touch most, or `undefined` when the configuration
+   * carries none. The dictionary is live. Writes through it land in the
+   * document.
+   */
+  get buildSettings(): BuildSettings | undefined;
+}
+/**
+ * A `PBXFileReference` names one file on disk, from source files to the
+ * built products themselves.
+ */
+declare class FileReference extends XcodeObject<FileReferenceProperties> {
+  /**
+   * The reference's path, relative to its `sourceTree`, when present.
+   */
+  get path(): string | undefined;
+  /**
+   * The reference's display name, when it carries one distinct from the
+   * path.
+   */
+  get name(): string | undefined;
+}
+/**
+ * A `PBXContainerItemProxy` is the indirection Xcode places between a
+ * target dependency and the target it points at.
+ */
+declare class ContainerItemProxy extends XcodeObject<ContainerItemProxyProperties> {
+  /**
+   * The display name of the object the proxy points at, when present.
+   * For target dependencies this is the target's name.
+   */
+  get remoteInfo(): string | undefined;
+}
 /**
  * A `PBXReferenceProxy` stands in for a product built by a target of
  * another project referenced from this one.
@@ -1213,15 +1258,32 @@ declare class XcodeObject<Properties extends PbxprojObject = PbxprojObject> {
   /** The object's 24-character identifier (its key in `objects`). */
   readonly id: string;
   /**
-   * Views are created by the project's identity map; use
+   * Views are created by the project's identity map. Use
    * {@link XcodeProject.get} or a typed query instead of constructing
    * views directly.
    */
   constructor(project: XcodeProject, id: string);
   /**
-   * 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.
+   * Whether a value is a view of this class, narrowing it when so. Views
+   * come typed out of the factory, and this is the readable way to
+   * discriminate them when iterating mixed objects.
+   *
+   * ```ts
+   * for (const [, object] of project.objects()) {
+   *   if (NativeTarget.is(object)) {
+   *     console.log(object.name);
+   *   }
+   * }
+   * ```
+   *
+   * Subclass views match their parent class too, the way `instanceof`
+   * does, so a `VersionGroup` is a `Group`.
+   */
+  static is<Constructor extends abstract new (...args: never) => unknown>(this: Constructor, value: unknown): value is InstanceType<Constructor>;
+  /**
+   * The object's raw dictionary inside the document. Mutations through
+   * the model write here, direct writes are equally valid, and 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`).
@@ -1285,19 +1347,20 @@ declare function parsePbxproj(text: string): PbxprojValue;
 /**
  * The node model of a scheme document.
  *
- * A parsed `.xcscheme` is a tree of plain objects: elements with ordered
- * attributes and child nodes, plus the occasional comment. All state lives
- * in this tree. There is no wrapper class to keep in sync, so callers
- * mutate nodes directly and serialize whatever the tree currently says.
+ * A parsed `.xcscheme` is a tree of plain objects. Elements carry ordered
+ * attributes and child nodes, and comments survive as their own nodes.
+ * All state lives in this tree. There is no wrapper to keep in sync, so
+ * callers mutate nodes directly and serialize whatever the tree currently
+ * says.
  *
  * @module
  */
 /**
  * An XML element of a scheme document.
  *
- * Attribute order is preserved and meaningful: the writer emits attributes
- * in insertion order, which is how byte-identical round-trips of
- * Xcode-written files fall out. Assigning an existing key keeps its
+ * Attribute order is preserved and meaningful. The writer emits
+ * attributes in insertion order, which is how Xcode-written files
+ * round-trip byte-identically. Assigning an existing key keeps its
  * position, and adding a new key appends it.
  */
 interface XcschemeElement {
@@ -1322,9 +1385,10 @@ interface XcschemeComment {
  */
 type XcschemeNode = XcschemeElement | XcschemeComment;
 /**
- * A parsed scheme file: its root element plus any comments sitting
- * outside it. Xcode writes only the root, so the comment lists are almost
- * always empty, but files that carry them round-trip without loss.
+ * A parsed scheme file, made of its root element plus any comments
+ * sitting outside it. Xcode writes only the root, so the comment lists
+ * are almost always empty, but files that carry them round-trip without
+ * loss.
  */
 interface XcschemeDocument {
   /** Comments before the root element. */
@@ -1354,14 +1418,99 @@ declare function buildXcscheme(document: XcschemeDocument): string;
  * Collects elements of the given name anywhere in the tree, in document
  * order, the subtree root included. Passing no name collects every
  * element.
+ */
+declare function xcschemeElements(root: XcschemeElement, name?: string): XcschemeElement[];
+/**
+ * A `BuildableReference` element with property-style attribute access.
+ *
+ * Buildable references are the elements editing flows touch most, since
+ * every action points at its target through one. The view reads and
+ * writes the element's attributes directly, so it never goes stale and
+ * needs no separate save step.
+ */
+declare class BuildableReference {
+  /** The underlying element inside the document tree. */
+  readonly element: XcschemeElement;
+  constructor(element: XcschemeElement);
+  /**
+   * The referenced target's object id in the project document, when
+   * present. Xcode repairs a missing or stale identifier on first open.
+   */
+  get blueprintIdentifier(): string | undefined;
+  set blueprintIdentifier(value: string);
+  /**
+   * The referenced target's name, when present.
+   */
+  get blueprintName(): string | undefined;
+  set blueprintName(value: string);
+  /**
+   * The built product's file name, for example `DemoApp.app`, when
+   * present.
+   */
+  get buildableName(): string | undefined;
+  set buildableName(value: string);
+  /**
+   * The container the target lives in, for example
+   * `container:DemoApp.xcodeproj`, when present.
+   */
+  get referencedContainer(): string | undefined;
+  set referencedContainer(value: string);
+}
+/**
+ * A scheme document with typed access to the elements editing flows
+ * touch.
+ *
+ * The model is a thin layer over the node tree. All state lives in the
+ * document itself, and {@link build} serializes whatever the tree
+ * currently says, so typed edits and direct tree edits compose freely.
  *
  * ```ts
- * for (const reference of xcschemeElements(scheme.root, "BuildableReference")) {
- *   reference.attributes["BlueprintName"] = "RenamedApp";
+ * const scheme = Xcscheme.parse(xcschemeText);
+ * for (const reference of scheme.buildableReferences()) {
+ *   reference.blueprintName = "RenamedApp";
+ *   reference.buildableName = "RenamedApp.app";
  * }
+ * const text = scheme.build();
  * ```
  */
-declare function xcschemeElements(root: XcschemeElement, name?: string): XcschemeElement[];
+declare class Xcscheme {
+  /** The underlying parsed document. */
+  readonly document: XcschemeDocument;
+  constructor(document: XcschemeDocument);
+  /**
+   * Parses the text of a `.xcscheme` file into a scheme model.
+   *
+   * @throws XcschemeParseError when the text is not a well-formed scheme
+   *   document, with the line and column of the failure.
+   */
+  static parse(text: string): Xcscheme;
+  /**
+   * Creates the scheme Xcode writes for an application target. See
+   * {@link createXcscheme} for the shape it produces.
+   */
+  static create(options: CreateXcschemeOptions): Xcscheme;
+  /**
+   * The document's `Scheme` element.
+   */
+  get root(): XcschemeElement;
+  /**
+   * Serializes the scheme to the text of a `.xcscheme` file in Xcode's
+   * canonical layout.
+   */
+  build(): string;
+  /**
+   * Collects elements of the given name anywhere in the document, in
+   * document order. Passing no name collects every element.
+   */
+  elements(name?: string): XcschemeElement[];
+  /**
+   * The views of every buildable reference in the document, in document
+   * order. Build entries, testables, macro expansions, runnables, and
+   * action environment buildables all point at their target through one
+   * of these, so rename flows iterate this list.
+   */
+  buildableReferences(): BuildableReference[];
+}
 /**
  * Options for {@link createXcscheme}.
  */
@@ -1381,10 +1530,11 @@ interface CreateXcschemeOptions {
   blueprintIdentifier?: string;
 }
 /**
- * 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).
+ * Creates the scheme Xcode writes for an application target. The
+ * document carries build, launch, profile, analyze, and archive actions
+ * wired to the app product, with Xcode's default configuration choices
+ * of Debug for development actions and Release for profiling and
+ * archiving.
  */
 declare function createXcscheme(options: CreateXcschemeOptions): XcschemeDocument;
 //#endregion
@@ -1424,4 +1574,4 @@ declare function parseXcscheme(text: string): XcschemeDocument;
  */
 declare function generateObjectId(seed: string, existing: ReadonlySet<string>): string;
 //#endregion
-export { type AddNativeTargetOptions, AggregateTarget, type ApplePlatform, type BuildConfigurationProperties, type BuildFileProperties, BuildPhase, type BuildPhaseProperties, BuildRule, type BuildRuleProperties, type BuildSettings, type ConfigurationListProperties, type ContainerItemProxyProperties, CopyFilesDestination, type CreateXcschemeOptions, type ExceptionSetProperties, type FileReferenceProperties, Group, type GroupProperties, Isa, LegacyTarget, type LegacyTargetProperties, NativeTarget, type NativeTargetProperties, type PbxprojArray, PbxprojBuildError, type PbxprojErrorPosition, type PbxprojObject, PbxprojParseError, type PbxprojValue, ProductType, type ProjectIssue, type ProjectIssueKind, ReferenceProxy, type ReferenceProxyProperties, RootProject, type RootProjectProperties, type SwiftPackageProductDependencyProperties, type SwiftPackageReferenceProperties, SyncRootGroup, type SyncRootGroupProperties, Target, type TargetDependencyProperties, type TargetProperties, VersionGroup, type VersionGroupProperties, XcodeModelError, XcodeObject, XcodeProject, XcschemeBuildError, type XcschemeComment, type XcschemeDocument, type XcschemeElement, type XcschemeNode, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };
+export { type AddNativeTargetOptions, AggregateTarget, type ApplePlatform, BuildConfiguration, type BuildConfigurationProperties, type BuildFileProperties, BuildPhase, type BuildPhaseProperties, BuildRule, type BuildRuleProperties, type BuildSettings, BuildableReference, type ConfigurationListProperties, ContainerItemProxy, type ContainerItemProxyProperties, CopyFilesDestination, type CreateXcschemeOptions, type ExceptionSetProperties, FileReference, type FileReferenceProperties, Group, type GroupProperties, Isa, LegacyTarget, type LegacyTargetProperties, NativeTarget, type NativeTargetProperties, type PbxprojArray, PbxprojBuildError, type PbxprojErrorPosition, type PbxprojObject, PbxprojParseError, type PbxprojValue, ProductType, type ProjectIssue, type ProjectIssueKind, ReferenceProxy, type ReferenceProxyProperties, RootProject, type RootProjectProperties, type SwiftPackageProductDependencyProperties, type SwiftPackageReferenceProperties, SyncRootGroup, type SyncRootGroupProperties, Target, type TargetDependencyProperties, type TargetProperties, VersionGroup, type VersionGroupProperties, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, type XcschemeComment, type XcschemeDocument, type XcschemeElement, type XcschemeNode, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };

package/dist/index.js

@@ -1006,9 +1006,9 @@ function stringItems(value) {
 *
 * 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.
+* itself, and 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
 */
@@ -1030,7 +1030,7 @@ var XcodeObject = class {
 	/** The object's 24-character identifier (its key in `objects`). */
 	id;
 	/**
-	* Views are created by the project's identity map; use
+	* Views are created by the project's identity map. Use
 	* {@link XcodeProject.get} or a typed query instead of constructing
 	* views directly.
 	*/
@@ -1039,9 +1039,28 @@ var XcodeObject = class {
 		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.
+	* Whether a value is a view of this class, narrowing it when so. Views
+	* come typed out of the factory, and this is the readable way to
+	* discriminate them when iterating mixed objects.
+	*
+	* ```ts
+	* for (const [, object] of project.objects()) {
+	*   if (NativeTarget.is(object)) {
+	*     console.log(object.name);
+	*   }
+	* }
+	* ```
+	*
+	* Subclass views match their parent class too, the way `instanceof`
+	* does, so a `VersionGroup` is a `Group`.
+	*/
+	static is(value) {
+		return value instanceof this;
+	}
+	/**
+	* The object's raw dictionary inside the document. Mutations through
+	* the model write here, direct writes are equally valid, and 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`).
@@ -1342,6 +1361,59 @@ var VersionGroup = class extends Group {
 	}
 };
 /**
+* An `XCBuildConfiguration` holds one named settings dictionary of a
+* target or of the project, for example Debug or Release.
+*/
+var BuildConfiguration = class extends XcodeObject {
+	/**
+	* The configuration's name, when present.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+	/**
+	* The configuration's settings dictionary, typed with the keys
+	* programmatic edits touch most, or `undefined` when the configuration
+	* carries none. The dictionary is live. Writes through it land in the
+	* document.
+	*/
+	get buildSettings() {
+		return asDictionary(this.properties["buildSettings"]);
+	}
+};
+/**
+* A `PBXFileReference` names one file on disk, from source files to the
+* built products themselves.
+*/
+var FileReference = class extends XcodeObject {
+	/**
+	* The reference's path, relative to its `sourceTree`, when present.
+	*/
+	get path() {
+		return this.getString("path");
+	}
+	/**
+	* The reference's display name, when it carries one distinct from the
+	* path.
+	*/
+	get name() {
+		return this.getString("name");
+	}
+};
+/**
+* A `PBXContainerItemProxy` is the indirection Xcode places between a
+* target dependency and the target it points at.
+*/
+var ContainerItemProxy = class extends XcodeObject {
+	/**
+	* The display name of the object the proxy points at, when present.
+	* For target dependencies this is the target's name.
+	*/
+	get remoteInfo() {
+		return this.getString("remoteInfo");
+	}
+};
+/**
 * A `PBXReferenceProxy` stands in for a product built by a target of
 * another project referenced from this one.
 */
@@ -3370,6 +3442,9 @@ var XcodeProject = class XcodeProject {
 			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.buildConfiguration: return new BuildConfiguration(this, id);
+			case Isa.fileReference: return new FileReference(this, id);
+			case Isa.containerItemProxy: return new ContainerItemProxy(this, id);
 			case Isa.referenceProxy: return new ReferenceProxy(this, id);
 			default: return isa.endsWith("BuildPhase") ? new BuildPhase(this, id) : new XcodeObject(this, id);
 		}
@@ -3454,26 +3529,28 @@ function isXcschemeElement(node) {
 /**
 * 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.
+* The output reproduces Xcode's own layout byte for byte. Xcode writes
+* the UTF-8 declaration, indents with three spaces, puts each attribute
+* on its own line with spaces around the equals sign, glues the closing
+* angle bracket to the last attribute, and closes every element with an
+* explicit close tag. Parsing an Xcode-written scheme and building it
+* back therefore yields the identical file, and any other input reaches
+* that canonical form in one build.
 *
 * @module
 */
+/** The declaration line Xcode writes at the top of every scheme file. */
 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
+* Matches valid XML names. A stray non-name, such as an empty string or
+* one carrying spaces or 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
+* 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.
 */
@@ -3493,9 +3570,10 @@ function buildXcscheme(document) {
 	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.
+* Renders one element with Xcode's layout. Attributes go each on their
+* own line indented one step past the tag, the `>` glues to the last
+* attribute, children indent one step, and the close tag is always
+* explicit.
 */
 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);
@@ -3533,10 +3611,10 @@ function renderChildren(children, depth, path) {
 	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.
+* Escapes an attribute value the way Xcode's writer does. XML syntax
+* characters become the five named entities, and tab, line feed, and
+* carriage return become character references so they survive
+* attribute-value normalization on the next parse.
 */
 function escapeAttribute(value, path, attributeName) {
 	const unencodable = UNENCODABLE_PATTERN.exec(value);
@@ -3544,152 +3622,17 @@ function escapeAttribute(value, path, attributeName) {
 	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.
+* Scheme files are XML with a narrow shape. Elements carry attributes and
+* child elements, and there is no text content, no namespace, and no
+* DOCTYPE. The parser accepts that shape from any writer, since attribute
+* order, quoting style, and whitespace vary across tools. Character and
+* entity references in attribute values resolve to their characters, and
+* comments are preserved. Anything outside the shape fails loudly with a
+* position, in line with the pbxproj parser.
 *
 * @module
 */
@@ -3746,13 +3689,24 @@ const NAMED_ENTITIES = {
 function parseXcscheme(text) {
 	return new Parser(text).parseDocument();
 }
+/**
+* Single-pass recursive-descent parser over the source text. One instance
+* parses one document and is discarded.
+*/
 var Parser = class {
+	/** The full source text of the scheme file. */
 	input;
+	/** Cursor into {@link input}, in UTF-16 code units. */
 	pos = 0;
 	constructor(input) {
 		this.input = input;
 		if (input.charCodeAt(0) === CODE_BOM) this.pos = 1;
 	}
+	/**
+	* Parses the whole document. The XML declaration is skipped, comments
+	* around the root element are collected, and anything left after the
+	* root fails.
+	*/
 	parseDocument() {
 		this.skipWhitespace();
 		this.skipDeclaration();
@@ -3778,7 +3732,8 @@ var Parser = class {
 	}
 	/**
 	* Skips the `<?xml ... ?>` declaration when present. Its attributes are
-	* not retained: the writer always emits the canonical UTF-8 declaration.
+	* not retained, since 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;
@@ -3786,6 +3741,12 @@ var Parser = class {
 		if (end === -1) this.fail("Unterminated XML declaration");
 		this.pos = end + 2;
 	}
+	/**
+	* Parses one element with the cursor on its opening `<`, including its
+	* attributes and children, through to the matching close tag. Xcode
+	* never writes self-closing tags, but other generators do, so both
+	* forms are accepted.
+	*/
 	parseElement() {
 		if (this.input.charCodeAt(this.pos) !== CODE_LESS_THAN) this.fail("Expected an element");
 		this.pos++;
@@ -3839,9 +3800,16 @@ var Parser = class {
 			else children.push(this.parseElement());
 		}
 	}
+	/**
+	* Whether the cursor sits on a `<!--` comment opener.
+	*/
 	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;
 	}
+	/**
+	* Parses one comment with the cursor on its `<!--` opener. The text
+	* between the markers is kept verbatim.
+	*/
 	parseComment() {
 		const end = this.input.indexOf("-->", this.pos + 4);
 		if (end === -1) this.fail("Unterminated comment");
@@ -3849,6 +3817,10 @@ var Parser = class {
 		this.pos = end + 3;
 		return { comment };
 	}
+	/**
+	* Parses an XML name at the cursor. The `what` label names the
+	* expectation in the error when no name starts here.
+	*/
 	parseName(what) {
 		const start = this.pos;
 		if (!isNameStart(this.input.charCodeAt(this.pos))) this.fail(`Expected ${what}`);
@@ -3856,6 +3828,12 @@ var Parser = class {
 		while (isNameChar(this.input.charCodeAt(this.pos))) this.pos++;
 		return this.input.slice(start, this.pos);
 	}
+	/**
+	* Parses a quoted attribute value with the cursor on the opening quote,
+	* resolving character and entity references along the way. Both quote
+	* styles are accepted, and a raw `<` inside the value fails as XML
+	* requires.
+	*/
 	parseAttributeValue() {
 		const quote = this.input.charCodeAt(this.pos);
 		if (quote !== CODE_QUOTE && quote !== CODE_APOSTROPHE) this.fail("Expected a quoted attribute value");
@@ -3912,12 +3890,275 @@ var Parser = class {
 		while (isWhitespace(this.input.charCodeAt(this.pos))) this.pos++;
 		return this.pos > start;
 	}
+	/**
+	* Throws a parse error at the cursor.
+	*/
 	fail(message) {
 		this.failAt(message, this.pos);
 	}
+	/**
+	* Throws a parse error at an explicit offset, which reference parsing
+	* uses to point at the start of a bad reference rather than its end.
+	*/
 	failAt(message, offset) {
 		throw new XcschemeParseError(message, this.input, offset);
 	}
 };
 //#endregion
-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 };
+//#region src/scheme/model.ts
+/**
+* The scheme object model and its helpers.
+*
+* {@link Xcscheme} wraps a parsed document with the typed access editing
+* flows want, {@link BuildableReference} gives buildable references
+* property-style attribute access, {@link xcschemeElements} is the
+* recursive query underneath it all, and {@link createXcscheme} produces
+* the scheme Xcode's own "New Scheme" action writes. The node tree stays
+* the single source of truth. Views hold only a reference into it, so
+* model calls and direct tree edits compose freely.
+*
+* @module
+*/
+/**
+* Collects elements of the given name anywhere in the tree, in document
+* order, the subtree root included. Passing no name collects every
+* element.
+*/
+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;
+}
+/**
+* A `BuildableReference` element with property-style attribute access.
+*
+* Buildable references are the elements editing flows touch most, since
+* every action points at its target through one. The view reads and
+* writes the element's attributes directly, so it never goes stale and
+* needs no separate save step.
+*/
+var BuildableReference = class {
+	/** The underlying element inside the document tree. */
+	element;
+	constructor(element) {
+		this.element = element;
+	}
+	/**
+	* The referenced target's object id in the project document, when
+	* present. Xcode repairs a missing or stale identifier on first open.
+	*/
+	get blueprintIdentifier() {
+		return this.element.attributes["BlueprintIdentifier"];
+	}
+	set blueprintIdentifier(value) {
+		this.element.attributes["BlueprintIdentifier"] = value;
+	}
+	/**
+	* The referenced target's name, when present.
+	*/
+	get blueprintName() {
+		return this.element.attributes["BlueprintName"];
+	}
+	set blueprintName(value) {
+		this.element.attributes["BlueprintName"] = value;
+	}
+	/**
+	* The built product's file name, for example `DemoApp.app`, when
+	* present.
+	*/
+	get buildableName() {
+		return this.element.attributes["BuildableName"];
+	}
+	set buildableName(value) {
+		this.element.attributes["BuildableName"] = value;
+	}
+	/**
+	* The container the target lives in, for example
+	* `container:DemoApp.xcodeproj`, when present.
+	*/
+	get referencedContainer() {
+		return this.element.attributes["ReferencedContainer"];
+	}
+	set referencedContainer(value) {
+		this.element.attributes["ReferencedContainer"] = value;
+	}
+};
+/**
+* A scheme document with typed access to the elements editing flows
+* touch.
+*
+* The model is a thin layer over the node tree. All state lives in the
+* document itself, and {@link build} serializes whatever the tree
+* currently says, so typed edits and direct tree edits compose freely.
+*
+* ```ts
+* const scheme = Xcscheme.parse(xcschemeText);
+* for (const reference of scheme.buildableReferences()) {
+*   reference.blueprintName = "RenamedApp";
+*   reference.buildableName = "RenamedApp.app";
+* }
+* const text = scheme.build();
+* ```
+*/
+var Xcscheme = class Xcscheme {
+	/** The underlying parsed document. */
+	document;
+	constructor(document) {
+		this.document = document;
+	}
+	/**
+	* Parses the text of a `.xcscheme` file into a scheme model.
+	*
+	* @throws XcschemeParseError when the text is not a well-formed scheme
+	*   document, with the line and column of the failure.
+	*/
+	static parse(text) {
+		return new Xcscheme(parseXcscheme(text));
+	}
+	/**
+	* Creates the scheme Xcode writes for an application target. See
+	* {@link createXcscheme} for the shape it produces.
+	*/
+	static create(options) {
+		return new Xcscheme(createXcscheme(options));
+	}
+	/**
+	* The document's `Scheme` element.
+	*/
+	get root() {
+		return this.document.root;
+	}
+	/**
+	* Serializes the scheme to the text of a `.xcscheme` file in Xcode's
+	* canonical layout.
+	*/
+	build() {
+		return buildXcscheme(this.document);
+	}
+	/**
+	* Collects elements of the given name anywhere in the document, in
+	* document order. Passing no name collects every element.
+	*/
+	elements(name) {
+		return xcschemeElements(this.document.root, name);
+	}
+	/**
+	* The views of every buildable reference in the document, in document
+	* order. Build entries, testables, macro expansions, runnables, and
+	* action environment buildables all point at their target through one
+	* of these, so rename flows iterate this list.
+	*/
+	buildableReferences() {
+		return this.elements("BuildableReference").map((element) => new BuildableReference(element));
+	}
+};
+/**
+* Creates the scheme Xcode writes for an application target. The
+* document carries build, launch, profile, analyze, and archive actions
+* wired to the app product, with Xcode's default configuration choices
+* of Debug for development actions and 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
+export { AggregateTarget, BuildConfiguration, BuildPhase, BuildRule, BuildableReference, ContainerItemProxy, CopyFilesDestination, FileReference, Group, Isa, LegacyTarget, NativeTarget, PbxprojBuildError, PbxprojParseError, ProductType, ReferenceProxy, RootProject, SyncRootGroup, Target, VersionGroup, XcodeModelError, XcodeObject, XcodeProject, Xcscheme, XcschemeBuildError, XcschemeParseError, buildPbxproj, buildXcscheme, createXcscheme, generateObjectId, isXcschemeElement, parsePbxproj, parseXcscheme, xcschemeElements };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rork-xcode",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Zero-dependency Xcode project (pbxproj) and scheme (xcscheme) parser, builder, and object model that runs identically in every JavaScript runtime",
   "keywords": [
     "apple",