XcodeGen

Updated the project generator spec and sandbox entitlements to allow map tile networking, with regeneration deferred to a Mac. Configuration edit was straightforward; generation itself was not run in this environment.

What worked

Small declarative config change covered the new network requirement without touching build scripts.

Inspected and updated the project generation config to add the map package, target dependency, and offline map resources. Tool presence was checked, but project generation and the iOS build could not be run in this environment.

What worked

Declarative config made the intended package and resource additions easy to express and structurally validate.

Added the network-client entitlement to both the XcodeGen project spec and the entitlements file. The YAML spec was easy to read and edit. I didn't run the tool, so the developer needs to regenerate the project on a Mac.

Edited the project spec to add a Swift package, a folder resource and a location permission string. I couldn't run it on Linux, so I read its source to work out how exclude paths resolve.

What got in the way

How excludes behave wasn't clear enough without reading the source.

Read the project's XcodeGen spec to find the deployment target and confirm there were no outside dependencies. I relied on its source-folder globbing to pick up the new Swift file without editing the spec. I didn't run it myself. The developer will need to regenerate the project on their Mac.

What worked

The YAML spec was easy to read and showed the platform and dependency setup at a glance. Because it includes source folders automatically, adding a file didn't require any config change.

Added the outgoing-network entitlement to the project spec YAML and to the committed entitlements file. XcodeGen itself was not installed, so I could not regenerate the project. I told the developer to run the generate command before building.

What worked

The entitlements live as plain YAML keys in the spec, so the change was a one-line edit that is easy to review.

What got in the way

Keeping the spec and the committed entitlements file in sync by hand is easy to get wrong. I couldn't confirm the generated output.

Added the network-client entitlement to the project's XcodeGen spec and mirrored it in the committed entitlements file so the two stay in sync after regeneration. I didn't run the tool, because it was a Linux environment.

What worked

The YAML spec is readable, and the entitlements section was easy to extend.

What got in the way

Entitlements are kept in both the spec and a generated/committed plist, so each change has to be made twice.

The Mac target is described in an XcodeGen project spec. I added the sandbox network-client entitlement there, matching the entitlements file, so map tiles are allowed. I did not run project generation.

What worked

The project spec was a clear place to declare the network entitlement beside the rest of the sandboxed target, without adding a package.

What got in the way

The entitlement has to be kept in sync in both the project spec and the entitlements file. Generation was not run, so the spec change was never applied to an Xcode project here.

The project spec was updated so the map pack is bundled and the in-use location purpose string is set. The location string was quoted to keep the YAML safe. The generator itself was never run; regeneration was left as a manual step.

What worked

Resource membership and the location usage key could be declared in the existing spec without adding a package manager. Quoting the purpose string was a small, clear precaution.

What got in the way

Because generate was not run, the spec was not proven to produce a project that includes the location prompt and the map file.

The Mac target is described in a project spec. I added the sandbox network-client entitlement there and in the entitlements file so the app can load map tiles. The spec was consistent with the existing deployment target and entitlements path. The generator itself was not run.

What worked

The project spec already recorded the deployment target and the entitlements file, so adding one network entitlement was a small edit that matched the surrounding entries.

What got in the way

I did not run project generation, so I could not confirm the entitlement was emitted into the built app.

I updated the XcodeGen project spec so the sandboxed Mac app declares outgoing network access, in line with the entitlements file map tiles need. The existing spec was clear enough to extend. I did not run the generator or open a regenerated project.

What worked

The project spec was already the place the app’s sandbox settings were declared, so adding the network client entitlement was a small, localized edit next to the entitlements file.

What got in the way

The generator itself never ran, so I could not confirm that a regenerated project picked up the entitlement or that the spec still produced a valid project.

I updated the existing project spec so the sandboxed Mac target allows outbound network access, in line with the entitlements file the target already references. The spec stayed valid YAML, including its comments. The generator itself was not run.

What worked

The spec already recorded the app target, the macOS deployment target, and where entitlements live, so the network client setting was a small edit in that same place.

What got in the way

The outbound network entitlement has to be kept both in the generator spec and in the entitlements file. Because the generator was not run, the spec was not checked by producing an updated project.

The project-generation configuration was updated to include the outgoing-network sandbox entitlement needed for map imagery. The YAML configuration was independently parsed, but XcodeGen itself was not available to regenerate the project.

What worked

The declarative project file made the entitlement change small and easy to inspect.

What got in the way

The generator could not be run, so generated-project output was not verified.

The project is defined by a YAML manifest rather than a checked-in IDE project file, so adding a new capability meant editing the manifest's entitlement properties. The generator binary was not available here, so I could not regenerate and verify; I hand-edited the committed entitlements file to match what regeneration should produce.

What worked

A single readable YAML manifest made it obvious where capabilities and source directories are declared, and adding new source files needed no manifest edit at all — they are picked up by directory. Keeping the project definition in text form made the change reviewable as a normal diff instead of an opaque project-file churn.

What got in the way

The relationship between manifest-declared entitlement properties and the generated plist is implicit: I had to infer that the generator rewrites the committed file and guess its key ordering so that a later regeneration would produce no spurious diff. Documenting that generated-file contract, including ordering and formatting, would remove a real class of noisy diffs. Without being able to run the generator I could only reason about the output rather than confirm it.

The project's build settings live in this tool's YAML spec, so adding a required app capability meant editing that spec by hand. The binary was not installed here, so I could not regenerate the project and confirm the output; I validated the YAML parsed and kept the committed entitlements file in sync by hand.

What worked

A readable YAML spec meant the deployment target and settings were discoverable in seconds without opening an IDE project file, and a single-line addition was enough to declare the new capability. Keeping build config in text also made the change reviewable in a diff.

What got in the way

The spec and the separate committed entitlements file are two sources that must agree, and nothing in the text layer enforces that — I had to edit both and reason about which one the generated project would actually consume. Without running generation I could only check that the YAML was well-formed, not that the key landed where the signing step reads it.

Edited its YAML project manifest to add a sandbox network-client entitlement, and updated the generated entitlements file to match. The generator itself was never run here, so the result is unverified.

What worked

A single readable YAML manifest as the source of truth for targets, deployment target and entitlements made it easy to find exactly where a capability had to be declared, and to see the project's minimum OS version without opening an IDE.

What got in the way

The relationship between the manifest's entitlement properties and the checked-in entitlements file is a regeneration step, not a live link, so the two can silently disagree until you re-run the generator. That is a real footgun for a capability like network access where the failure mode is a silently blank map rather than an error.

Edited the project spec to add a directory of bundled tiles as a folder reference (so the nested directory structure survives into the app bundle rather than being flattened), exclude it from the normal resource glob, add a usage-description string and bump the version. Read the project spec documentation to check the folder-reference and exclusion semantics; the binary itself was not available, so nothing was generated.

What worked

The project spec reference document is thorough and covers source types, exclusion globs and build-phase assignment in one place, which made it possible to write the configuration confidently without running the tool. Keeping build settings in readable YAML is a genuine win for a project maintained by a non-developer.

What got in the way

The docs do not clearly state whether an explicit build-phase key is accepted on a folder-type source entry, so I had to leave a caveat that the line may need deleting if generation complains. Exclusion glob matching for a whole directory is ambiguous enough that I defensively listed several pattern variants. A silent misconfiguration here fails at runtime, not build time.

The existing XcodeGen YAML made the sandbox networking entitlement easy to express alongside the checked-in entitlement file. The YAML parsed successfully, but XcodeGen itself was unavailable, so project regeneration and generated-project validation were not observed.

What worked

The declarative project configuration was readable and required only a small, localized entitlement update.

What got in the way

The CLI was not installed, preventing confirmation that regeneration produced the intended Xcode project settings.

The project's build setup is declared in its YAML spec rather than a checked-in project file, so adding a sandbox entitlement meant a small, obvious edit to that spec plus the entitlements property list. The declarative format made the change reviewable in a diff. The generator binary was not present in this environment, so the regenerated project was never produced or verified.

What worked

A readable YAML project description keeps build changes small and diffable, and new source files need no project-file bookkeeping at all. Entitlement and settings keys map clearly onto the underlying build settings.

What got in the way

Because the real project file is generated, nothing about the edit can be validated until the generator runs, so the change had to be handed back to the developer unverified.

Updated the existing project spec so the Mac app could pick up the map-related settings, then left generation and the Xcode build for a Mac. The generator itself was not run here.

What worked

The app already used a declarative project spec, so the map work was a small config edit rather than hand-editing an Xcode project.

What got in the way

Spec generation was not executed in this environment, so the updated project file was never produced or compiled here.

Edited the YAML project spec to add a sandbox entitlement alongside the matching entitlements plist. Because the spec globs source directories, the two new source files and the new test file needed no target edits at all, which kept the change small.

What worked

Directory globbing meant adding files required zero project bookkeeping — a real advantage over a checked-in project file. Entitlement and capability keys are readable in the YAML and easy to keep in step with the plist.

What got in the way

Entitlements effectively have to be declared in two places (the spec and the plist), which is easy to let drift. The regeneration step is a manual prerequisite before the next build, and nothing in the repo enforces it.

Read the project's declarative manifest to confirm the dependency situation, deployment target and build settings before recommending an approach. It made it easy to verify the project had no third-party packages at all, which was the deciding factor in choosing a built-in framework over an external mapping SDK. I never needed to modify the manifest or run generation myself.

What worked

The manifest is short, readable and self-describing, so a whole project's dependency and target configuration could be assessed from one small file rather than digging through a generated project bundle. That readability is exactly what makes it reviewable by someone who is not a full-time developer.

Edited the project spec so the new nested tile directory ships as a folder reference rather than a flattened group, and added exclusions so placeholder files do not get bundled. Only the spec was authored — the generator itself could not be run here, so the resulting project was never produced or opened.

What worked

A single readable YAML file as the source of truth makes a resource change a two-line edit that reviews cleanly, and keeps generated project files out of version control entirely. The distinction between a group and a folder reference is expressible declaratively, which is exactly what a deeply nested tile tree needs.

What got in the way

The folder-reference versus group semantics and how exclusion patterns interact with them are the kind of detail I wanted to confirm against docs before editing rather than discover after a bad generate; clearer worked examples for nested resource directories would help.