unity-devkit 0.1.14__tar.gz → 0.1.15__tar.gz

unity_devkit-0.1.15/.csharpierrc.json

@@ -0,0 +1,6 @@
+{
+  "printWidth": 120,
+  "useTabs": false,
+  "indentSize": 4,
+  "endOfLine": "auto"
+}

unity_devkit-0.1.15/.github/actions/unity-container-prep/action.yml

@@ -0,0 +1,37 @@
+name: Unity container prep
+description: Wipe, checkout, uv setup, and license restore — the front-matter of every per-project Unity container job
+
+inputs:
+  cache-tag:
+    description: License cache tag to restore the activated license from
+    required: true
+  github-token:
+    required: true
+  unity-email:
+    required: true
+  unity-password:
+    required: true
+  unity-serial:
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: astral-sh/setup-uv@v7
+      with:
+        enable-cache: true
+        save-cache: "false"
+
+    - name: Sync dependencies
+      shell: bash
+      run: uv sync
+
+    - name: Activate Unity license
+      shell: bash
+      run: uv run --no-sync activate-unity-license --oras-push
+      env:
+        GITHUB_TOKEN: ${{ inputs.github-token }}
+        LICENSE_CACHE_TAG: ${{ inputs.cache-tag }}
+        UNITY_EMAIL: ${{ inputs.unity-email }}
+        UNITY_PASSWORD: ${{ inputs.unity-password }}
+        UNITY_SERIAL: ${{ inputs.unity-serial }}

unity_devkit-0.1.15/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Preflight
+        run: uvx --from python-devkit==0.1.5 preflight-python
+
+  manifest:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Publish plan dry run
+        run: uvx --from release-devkit==0.1.14 publish-stable --config release-devkit.json --dry-run
+
+  compile-check:
+    permissions:
+      contents: read
+      packages: write
+    uses: ./.github/workflows/unity-check.yml
+    with:
+      runner-labels: '["self-hosted","unity"]'
+    secrets: inherit

{unity_devkit-0.1.14 → unity_devkit-0.1.15}/.github/workflows/release.yml

@@ -28,4 +28,8 @@ jobs:
       - uses: astral-sh/setup-uv@v7
 
       - name: Publish
-        run: uvx --from release-devkit==0.1.13 publish-stable --config publish-config.json
+        env:
+          # npm decides in silence whether to attempt the OIDC exchange; without verbose a trusted-publisher
+          # mismatch surfaces as a bare ENEEDAUTH indistinguishable from a missing token
+          NPM_CONFIG_LOGLEVEL: verbose
+        run: uvx --from release-devkit==0.1.14 publish-stable --config release-devkit.json

{unity_devkit-0.1.14 → unity_devkit-0.1.15}/.github/workflows/unity-build.yml

@@ -23,64 +23,15 @@ env:
   CACHE_REGISTRY: ghcr.io/${{ github.repository }}/cache
 
 jobs:
-  matrix:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    outputs:
-      build-matrix: ${{ steps.generate.outputs.matrix }}
-      license-image: ${{ steps.generate.outputs.license-image }}
-    steps:
-      - uses: actions/checkout@v5
-
-      - uses: astral-sh/setup-uv@v7
-        with:
-          enable-cache: true
-          save-cache: "false"
-
-      - name: Sync dependencies
-        run: uv sync
-
-      - name: Generate build matrix
-        id: generate
-        run: uv run --no-sync unity-matrix >> "$GITHUB_OUTPUT"
-
-  activate-license:
-    needs: [matrix]
-    runs-on: ${{ fromJSON(inputs.runner-labels) }}
-    permissions:
-      contents: read
-      packages: write
-    outputs:
-      cache-tag: ${{ steps.tag.outputs.value }}
-    container:
-      image: ${{ needs.matrix.outputs.license-image }}
-    steps:
-      - uses: actions/checkout@v5
-
-      - uses: astral-sh/setup-uv@v7
-        with:
-          enable-cache: true
-          save-cache: "false"
-
-      - name: Sync dependencies
-        run: uv sync
-
-      - name: Compute license cache tag
-        id: tag
-        run: echo "value=$(uv run --no-sync unity-license-tag)" >> "$GITHUB_OUTPUT"
-
-      - name: Activate Unity license
-        run: uv run --no-sync activate-unity-license --oras-push
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-          LICENSE_CACHE_TAG: ${{ steps.tag.outputs.value }}
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}
+  prepare:
+    uses: ./.github/workflows/unity-prepare.yml
+    with:
+      runner-labels: ${{ inputs.runner-labels }}
+      matrix-command: uv run --no-sync unity-matrix
+    secrets: inherit
 
   build-unity:
-    needs: [matrix, activate-license]
+    needs: [prepare]
     name: ${{ matrix.project-name }} (${{ matrix.platform }})
     runs-on: ${{ fromJSON(inputs.runner-labels) }}
     permissions:
@@ -90,7 +41,7 @@ jobs:
       image: ${{ matrix.editor-image }}
     strategy:
       fail-fast: false
-      matrix: ${{ fromJson(needs.matrix.outputs.build-matrix) }}
+      matrix: ${{ fromJson(needs.prepare.outputs.matrix) }}
     steps:
       - name: Wipe workspace
         run: |
@@ -99,13 +50,13 @@ jobs:
 
       - uses: actions/checkout@v5
 
-      - uses: astral-sh/setup-uv@v7
+      - uses: ./.github/actions/unity-container-prep
         with:
-          enable-cache: true
-          save-cache: "false"
-
-      - name: Sync dependencies
-        run: uv sync
+          cache-tag: ${{ needs.prepare.outputs.cache-tag }}
+          github-token: ${{ github.token }}
+          unity-email: ${{ secrets.UNITY_EMAIL }}
+          unity-password: ${{ secrets.UNITY_PASSWORD }}
+          unity-serial: ${{ secrets.UNITY_SERIAL }}
 
       - name: Cache UPM packages
         uses: actions/cache@v5
@@ -116,7 +67,7 @@ jobs:
       - name: Build
         env:
           GITHUB_TOKEN: ${{ github.token }}
-          LICENSE_CACHE_TAG: ${{ needs.activate-license.outputs.cache-tag }}
+          LICENSE_CACHE_TAG: ${{ needs.prepare.outputs.cache-tag }}
           BUILD_ENV: ${{ inputs.build-env }}
         run: |
           uv run --no-sync build-unity \

unity_devkit-0.1.15/.github/workflows/unity-check.yml

@@ -0,0 +1,58 @@
+name: Unity Check
+
+on:
+  workflow_call:
+    inputs:
+      runner-labels:
+        description: JSON-encoded runs-on value (string or array) for the license/check jobs
+        type: string
+        default: '"ubuntu-latest"'
+    secrets:
+      UNITY_EMAIL:
+        required: true
+      UNITY_PASSWORD:
+        required: true
+      UNITY_SERIAL:
+        required: true
+
+env:
+  CACHE_REGISTRY: ghcr.io/${{ github.repository }}/cache
+
+jobs:
+  prepare:
+    uses: ./.github/workflows/unity-prepare.yml
+    with:
+      runner-labels: ${{ inputs.runner-labels }}
+      matrix-command: uv run --no-sync unity-check-matrix
+    secrets: inherit
+
+  check-unity:
+    needs: [prepare]
+    name: ${{ matrix.project-name }} (check)
+    runs-on: ${{ fromJSON(inputs.runner-labels) }}
+    permissions:
+      contents: read
+      packages: write
+    container:
+      image: ${{ matrix.editor-image }}
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.prepare.outputs.matrix) }}
+    steps:
+      - name: Wipe workspace
+        run: |
+          find "$GITHUB_WORKSPACE" -mindepth 1 -delete
+          rm -rf ~/.cache/Unity
+
+      - uses: actions/checkout@v5
+
+      - uses: ./.github/actions/unity-container-prep
+        with:
+          cache-tag: ${{ needs.prepare.outputs.cache-tag }}
+          github-token: ${{ github.token }}
+          unity-email: ${{ secrets.UNITY_EMAIL }}
+          unity-password: ${{ secrets.UNITY_PASSWORD }}
+          unity-serial: ${{ secrets.UNITY_SERIAL }}
+
+      - name: Compile check
+        run: uv run --no-sync check-unity --project ${{ matrix.project-name }}

unity_devkit-0.1.15/.github/workflows/unity-prepare.yml

@@ -0,0 +1,90 @@
+name: Unity Prepare
+
+on:
+  workflow_call:
+    inputs:
+      runner-labels:
+        description: JSON-encoded runs-on value (string or array) for the license/matrix jobs
+        type: string
+        default: '"ubuntu-latest"'
+      matrix-command:
+        description: uv run command whose stdout carries matrix=<json> and license-image=<tag> lines
+        type: string
+        required: true
+    outputs:
+      matrix:
+        description: The include matrix emitted by matrix-command
+        value: ${{ jobs.matrix.outputs.matrix }}
+      license-image:
+        description: The editor image for license activation
+        value: ${{ jobs.matrix.outputs.license-image }}
+      cache-tag:
+        description: The license cache tag pushed by activation
+        value: ${{ jobs.activate-license.outputs.cache-tag }}
+    secrets:
+      UNITY_EMAIL:
+        required: true
+      UNITY_PASSWORD:
+        required: true
+      UNITY_SERIAL:
+        required: true
+
+env:
+  CACHE_REGISTRY: ghcr.io/${{ github.repository }}/cache
+
+jobs:
+  matrix:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      matrix: ${{ steps.generate.outputs.matrix }}
+      license-image: ${{ steps.generate.outputs.license-image }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "false"
+
+      - name: Sync dependencies
+        run: uv sync
+
+      - name: Generate matrix
+        id: generate
+        run: ${{ inputs.matrix-command }} >> "$GITHUB_OUTPUT"
+
+  activate-license:
+    needs: [matrix]
+    runs-on: ${{ fromJSON(inputs.runner-labels) }}
+    permissions:
+      contents: read
+      packages: write
+    outputs:
+      cache-tag: ${{ steps.tag.outputs.value }}
+    container:
+      image: ${{ needs.matrix.outputs.license-image }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "false"
+
+      - name: Sync dependencies
+        run: uv sync
+
+      - name: Compute license cache tag
+        id: tag
+        run: echo "value=$(uv run --no-sync unity-license-tag)" >> "$GITHUB_OUTPUT"
+
+      - name: Activate Unity license
+        run: uv run --no-sync activate-unity-license --oras-push
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          LICENSE_CACHE_TAG: ${{ steps.tag.outputs.value }}
+          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
+          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
+          UNITY_SERIAL: ${{ secrets.UNITY_SERIAL }}

unity_devkit-0.1.15/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+.venv/
+.ruff_cache/
+.pytest_cache/
+bookmark.md
+
+# PlayerBuild Unity harness
+PlayerBuild/*.csproj
+PlayerBuild/*.sln
+PlayerBuild/Assets/Packages/
+PlayerBuild/Assets/_LocalWorkspace
+PlayerBuild/Assets/_LocalWorkspace.meta
+PlayerBuild/Build/
+PlayerBuild/Build.meta
+PlayerBuild/Builds/
+PlayerBuild/Library/
+PlayerBuild/Logs/
+PlayerBuild/Temp/
+PlayerBuild/UserSettings/
+PlayerBuild/obj/
+PlayerBuild/.utmp/

unity_devkit-0.1.15/AGENTS.md

@@ -0,0 +1,57 @@
+# unity-devkit
+
+## What this is
+
+`unity-devkit` is the Unity build toolkit: the root project catalog, local builds, CI builds, license activation, the `install` command (download-or-build then install onto a device), and the ORAS cache/setup helpers those need. Consumer repositories install this package from PyPI and get the same Unity CI and install flow — paired with two reusable GitHub Actions workflows hosted in this repo's `.github/workflows/`, both invoking only this package's entry points inside the caller's checkout and both consumed cross-repo pinned to a pushed SHA with `secrets: inherit`: `unity-build.yml` (player builds) and `unity-check.yml` (the same machinery reduced to a compile gate — `check-unity` per cataloged project, path-only entries included). Their shared scaffold lives in `unity-prepare.yml` — a matrix job parameterized by the matrix verb, plus the ORAS-backed license activation — and the wipe/checkout/uv/license-restore front-matter of every per-project container job lives in the `.github/actions/unity-container-prep` composite action; consumers never call those two directly. Both doors need `UNITY_EMAIL`/`UNITY_PASSWORD`/`UNITY_SERIAL` available to the calling repo, and every Unity invocation runs in a `unityci/editor` container image composed from the project's `ProjectVersion.txt` (the runners supply Docker, not an installed editor).
+
+This repo also develops and publishes the **`org.outernet.playerbuild`** UPM editor package (npm) — the inside-of-Unity half of app builds: platform-fact application from a C# table, the batchmode build entry, the editor configure window, and build-time environment materialization. Its source lives in `PlayerBuild/Assets/Package/`, developed inside the `PlayerBuild/` Unity harness project (catalog entry of the same name); CI's `compile-check` job is its compile gate. Both folded in from the retired `unitybuild` repo (2026-09-27); that repo's docs and history remain the record of the package's design.
+
+The repo and package renamed from `unity-buildkit` to `unity-devkit` (2026-09-21, member of the `-devkit` family; before that `placeframe-unity` → `unity-buildkit` on extraction). The PyPI identity is fresh: `unity-devkit` starts its own tag ledger at `0.1.0`; the terminal `unity-buildkit` distributions (≤0.1.1) are deprecation signposts pointing here, not this package's history.
+
+## Release flow
+
+Publishing rides `release.yml`, triggered by a successful CI run on a `main` push: the machinery — release-devkit's `publish-stable` (an inlined, version-pinned `uvx` step in the publish job, keeping OIDC identity local), never a project dependency (unity-devkit sits inside its own dependency graph; a project-level release-devkit edge is a resolver cycle) — computes the plan from the tag ledger and path-diff, patches the version ephemerally, and publishes to PyPI under OIDC trusted publishing (publisher bound to `release.yml`, no environment). The same publish also covers the npm package: `release-devkit.json` declares two packages — `unity-devkit` (PyPI, path `.`, `unity-devkit-v*` ledger) and `playerbuild` (npm `org.outernet.playerbuild`, path `PlayerBuild/Assets/Package`, `playerbuild-v*` ledger), each gated by its own path-diff. The npm trusted publisher is bound to this repo's `release.yml` (one publisher per package, single workflow filename — never rename it), and the publish step sets `NPM_CONFIG_LOGLEVEL: verbose` because npm decides in silence whether to attempt the OIDC exchange. The committed `pyproject.toml` version is permanently the `0.0.0.dev0` sentinel; the tags are the version ledger (declared `major_minor` line in `release-devkit.json`, patch-auto within the line). While pre-1.0, breaking changes ride the current `0.1` patch line; a `major_minor` bump is reserved for the eventual 1.0.0 stabilization release.
+
+## Shape
+
+One flat module per concern under `src/unity_devkit/`:
+
+| `uv run` command | Module | Notes |
+|---|---|---|
+| `compile-unity` | `compile_unity.py` | Local Unity build (APK or platform binary, suitable for `adb install`). Required flags: `--project <name>` and `--build <target>`, where the project's `unity-devkit.json` catalog entry declares `builds` and `execute_methods`. Streams the editor log, prints output paths under `<project>/Build/`. `--stamp-version` stamps the tag-ledger version into `ProjectSettings.asset` before the run. |
+| `check-unity` | `check_unity.py` | Compile gate: batchmode open+quit (`-nographics`, no executeMethod) failing on non-zero exit or any `error CS` in the log — Unity exits 0 on a plain open+quit despite script compile errors, so the log scan is the authoritative signal. Path-only (needs no `builds`); the gate for package/harness repos that own editor code but build no players. Two optional flags turn it into a build-free method driver: `--execute-method Class.Method` runs a static method after load (one editor session per invocation — the vehicle for committed-generated-asset regeneration, where each pass needs a fresh session) and `--build-target <target>` forces the startup build target for sessions that must open on a non-default platform. Player builds must not ride this verb (`-nographics` + `-quit` cannot build players); use `compile-unity`. |
+| `install` | `install.py` | Install a Unity build onto an `adb`-connected device or launch a linux executable. Default: download the latest GitHub Actions artifact for `(project, target)` on the current branch (overridable with `--branch` / `--run`), cache it under `~/.unity-devkit/builds/{run_id}/`, `adb install` the APK (or `bash_handoff` the linux64 executable). With `--build` / `-B`, skips the artifact fetch and calls `compile-unity` locally instead, funneling the produced APK / executable through the same install path. Honours the catalog entry's `package` (for pre-install uninstall) and `grant_permissions` (post-install `adb shell pm grant`). |
+| `lock-unity` | `lock_unity.py` | Lock Unity package versions for reproducible builds. |
+| `test-unity` | `test_unity.py` | Run Unity editmode / playmode tests. |
+| `activate-unity-license` | `license.py` | Activate the Unity Editor license (locally or with `--oras-push` for the CI cache). |
+| `unity-license-tag` | `license_restore.py` | Print the license cache tag (CI pins it via `LICENSE_CACHE_TAG`). |
+| `unity-matrix` | `matrix.py` | Emit the CI build matrix (CI-only). |
+| `unity-check-matrix` | `matrix.py` | Emit the CI compile-check matrix (CI-only): one entry per cataloged project — path-only entries included, no `builds` needed — each carrying a `linux-il2cpp` editor image composed from that project's `ProjectVersion.txt`, plus the `license-image` line. Consumed by the hosted `unity-check.yml`. |
+| `build-unity` | `build_unity.py` | CI build with library cache restore/save and ProjectSettings version stamping (CI-only; assumes `GITHUB_WORKSPACE`, OCI registry, runner environment). |
+
+Supporting modules: `projects.py` (catalog schema + loader, and the pruned tree walk that is cross-repo API), `unity.py` (editor lookup, platform configs, batchmode command, shared Unity runner), `versioning.py` (tag-ledger version computation and the `ProjectSettings.asset` stamping both build verbs share). The CI-floor modules (step wrapper, runner provisioning, ORAS artifact cache) live in [`ci-devkit`](https://github.com/outernet-foundation/ci-devkit) (a runtime dependency); unity-devkit owns only Unity concerns.
+
+The `PlayerBuild/` harness is this repo's one cataloged Unity project: a minimal Unity `6000.0.66f1` host (no scenes, no XR settings asset, no `build-config.json` — package entry paths fail loudly there by design) whose only job is compiling and developing `Assets/Package/`. C# style is the owner's ruleset recorded in the unitybuild record; CSharpier (`.csharpierrc.json` at the repo root, 120 cols) formats `PlayerBuild/Assets/Package/**/*.cs` — run `csharpier format` before committing C# changes. The package's architecture and semantics doc lives in its own shipped files plus the unitybuild record; the package convention summary: namespace `Outernet` flat, no unit tests ever (the compile gate is the test surface), `.meta` files committed alongside.
+
+## Constraints
+
+**Every Unity invocation goes through `unity.run_unity_batchmode`, which does not trust the editor's exit code.** Unity exits 0 while reporting fatal package-manager errors (unresolvable dependencies, invalid package.json versions) only in the editor log — a resolver failure therefore surfaces as a stale `packages-lock.json` and nothing else. The runner streams the log live through `tee` into a captured file and afterwards scans it for `QUIET_FAILURE_SIGNATURES`; a match fails the invocation with the matched log block regardless of exit code. New Unity verbs must call the runner rather than invoking the editor directly, and newly discovered silent-failure log lines get added to the signature tuple. Verb-local signatures ride the same scan via `extra_failure_signatures`: `check-unity` passes `("error CS",)` because a plain open+quit exits 0 despite script compile errors — the signature stays verb-local because `lock-unity` intentionally tolerates them. Exit-code strictness is per-verb: build/test verbs fail on non-zero (`strict_exit=True`, the default), while `lock-unity` passes `strict_exit=False` — it judges resolution, not compilation, so a project whose scripts fail to compile (resolution already done, lock written) produces a warning, not a failure. `-runTests` invocations pass `auto_quit=False` (the test runner owns exit timing).
+
+**Every runtime dependency must be PyPI-resolvable.** This package publishes to and is consumed from PyPI, and a registry consumer resolves the whole graph transitively by name — any dependency that is not on PyPI breaks every consumer's install. [`bashrun`](https://github.com/outernet-foundation/bashrun) is on PyPI like the rest; git-source pins are a scratch-branch-only vehicle for testing unreleased changes.
+
+**Unity projects are declared in a root catalog.** `unity-devkit.json` at the repo root maps stable project names to entries (`path`, `builds`, `execute_methods`, `package`, `grant_permissions`, `tag_prefix` — schema in `projects.py`). Every verb resolves `--project` through the catalog, the path-only ones (`lock-unity`, `test-unity`, `check-unity`) included — absence from the catalog is the exclusion mechanism: a project not listed is never touched, so vendored or nested projects need no prune list. Names are catalog keys, decoupled from directory names; they are the workflow contract (`matrix.project-name`, artifact names, `--project` everywhere). `ProjectSettings/ProjectVersion.txt` inside each entry's project remains the editor-version truth, read per entry; an entry whose path lacks the marker fails at load, as does a missing or empty catalog. Run commands from the repo root — catalog paths are repo-relative. The per-project build manifests and the structural marker walk are gone from the verbs; the pruned walk (`projects.directories_containing`) remains as cross-repo API.
+
+**`unity-matrix` prints `$GITHUB_OUTPUT`-format lines, not bare JSON.** Its stdout is two `key=value` lines — `matrix=<JSON with an include array>` and `license-image=<unityci/editor tag>` — so the workflow step is exactly `uv run --no-sync unity-matrix >> "$GITHUB_OUTPUT"` with no shell logic. Each matrix entry carries an `editor-image` tag composed from the project's `ProjectSettings/ProjectVersion.txt` editor version, the platform's unityci module, and the `UNITYCI_IMAGE_REVISION` constant in `unity.py`; `license-image` uses the highest cataloged editor version with the `linux-il2cpp` module. Nothing else pins an editor version: upgrading a project's editor in `ProjectVersion.txt` automatically switches its CI container, and the hosted `unity-build.yml` stays free of repo-specific values.
+
+**Entry-point names are the workflow contract.** The hosted `unity-build.yml` invokes `unity-matrix`, `unity-license-tag`, `activate-unity-license`, and `build-unity` by name via `uv run` in the caller's checkout (the caller's venv supplies this package). Consumers pin the workflow by pushed SHA and the package by PyPI version independently; the two pins stay compatible as long as the entry-point names and flags hold, so treat those as a public API.
+
+**The environment-lookup helpers are cross-repo Python API.** `unity.find_editor_for_version` (editor ladder: `unity-editor` on PATH → `/opt/unity/<version>` → `~/Unity/Hub/Editor/<version>`; raises `ValueError` listing every searched path on a miss), `unity.editor_version` (`ProjectVersion.txt` parse; `None` for a missing file or unparseable content), and `projects.directories_containing` (+ `PRUNE_DIRECTORIES`) are imported by registry consumers — prepo's `sync` verb. Their signatures and miss behavior are contract, not internals. The `SystemExit`-raising wrapper `read_editor_version` exists for unity-devkit's own CLI paths and delegates to the core helper; `unity_batchmode_command` consumes the `ValueError`-raising `find_editor_for_version` and `read_editor_version` directly, so a missing editor surfaces as the raw `ValueError`.
+
+**Version stamping is opt-in via `tag_prefix` and writes `ProjectSettings.asset` directly.** When the project's catalog entry declares `tag_prefix`, `build-unity` stamps `bundleVersion` and `AndroidBundleVersionCode` (two scalar line edits in `ProjectSettings/ProjectSettings.asset` — no Unity API, no executeMethod contract) before batchmode; `compile-unity` does the same when passed `--stamp-version`. The version is the latest `<tag_prefix>-v*` git tag (a local bashrun query — the version-ledger primitives live in release-devkit and are not imported here) plus a run-number suffix; the Android `bundleVersionCode` is the run number. Projects without the field build unversioned. Precondition: Unity not running on the project. The catalog's `tag_prefix` and the same package's `tag_prefix` in the repo's `release-devkit.json` are two spellings of one fact — they must agree for projects that release.
+
+**The ORAS cache media type identifies the wrapper package, not the consuming repo.** `cache.save()` pushes with `application/vnd.unity-devkit.cache.v1+zstd`. Restore doesn't filter on media type, so older manifests carrying a different vendor prefix still pull, but new pushes always carry this one — the identifier tracks the tool that wrote the cache, not the project whose bytes are inside it.
+
+## See also
+
+- [`bashrun`](https://github.com/outernet-foundation/bashrun) — the shell-exec helpers this package uses everywhere (`bash`, `bash_output`, `bash_check`, `bash_handoff`).
+- `README.md` — human-facing setup, command catalog, and consumer install snippet.

{unity_devkit-0.1.14 → unity_devkit-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unity-devkit
-Version: 0.1.14
+Version: 0.1.15
 Summary: Unity build, license, and CI tooling
 License-File: LICENSE
 License-File: NOTICE

unity_devkit-0.1.15/PlayerBuild/Assets/Package/Editor/BuildConfig.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using UnityEditor.Build;
+
+namespace Outernet
+{
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum EnvironmentFieldType
+    {
+        [EnumMember(Value = "string")]
+        String,
+
+        [EnumMember(Value = "boolean")]
+        Boolean,
+
+        [EnumMember(Value = "integer")]
+        Integer,
+
+        [EnumMember(Value = "enum")]
+        Enum,
+    }
+
+    public sealed class EnvironmentConfig
+    {
+        [JsonProperty("target", Required = Required.Always)]
+        public string Target { get; set; } = "";
+
+        [JsonProperty("default_preset")]
+        public string DefaultPreset { get; set; } = "";
+
+        [JsonProperty("presets", Required = Required.DisallowNull)]
+        public Dictionary<string, string> Presets { get; set; } = new();
+
+        [JsonProperty("fields")]
+        public Dictionary<string, EnvironmentField> Fields { get; set; } = new();
+    }
+
+    public sealed class EnvironmentField
+    {
+        [JsonProperty("name")]
+        public string Name { get; set; } = "";
+
+        [JsonProperty("path", Required = Required.Always)]
+        public string Path { get; set; } = "";
+
+        [JsonProperty("type", Required = Required.Always)]
+        public EnvironmentFieldType Type { get; set; }
+
+        [JsonProperty("values")]
+        public List<string> Values { get; set; }
+    }
+
+    public sealed class PlatformOverrides
+    {
+        [JsonProperty("render_pipeline")]
+        public string RenderPipeline { get; set; } = "";
+
+        [JsonProperty("additional_defines")]
+        public List<string> AdditionalDefines { get; set; } = new();
+    }
+
+    public sealed class BuildConfig
+    {
+        [JsonProperty("environment_config", Required = Required.DisallowNull)]
+        public EnvironmentConfig EnvironmentConfig { get; set; } = new();
+
+        [JsonProperty("platforms", Required = Required.DisallowNull)]
+        public Dictionary<string, PlatformOverrides> Platforms { get; set; } = new();
+
+        [OnDeserialized]
+        private void Validate(StreamingContext context)
+        {
+            if (
+                !string.IsNullOrEmpty(EnvironmentConfig.DefaultPreset)
+                && !EnvironmentConfig.Presets.ContainsKey(EnvironmentConfig.DefaultPreset)
+            )
+            {
+                throw new BuildFailedException(
+                    $"default_preset '{EnvironmentConfig.DefaultPreset}' is not a declared preset (declared: {string.Join(", ", EnvironmentConfig.Presets.Keys)})"
+                );
+            }
+
+            foreach (KeyValuePair<string, string> preset in EnvironmentConfig.Presets)
+            {
+                if (!preset.Value.StartsWith("Assets/", StringComparison.Ordinal))
+                {
+                    throw new BuildFailedException(
+                        $"build-config.json field 'presets[{preset.Key}]' must be a project path starting with Assets/ — got '{preset.Value}'"
+                    );
+                }
+            }
+
+            foreach (KeyValuePair<string, EnvironmentField> entry in EnvironmentConfig.Fields)
+            {
+                if (entry.Value.Type == EnvironmentFieldType.Enum && entry.Value.Values is not { Count: > 0 })
+                {
+                    throw new BuildFailedException($"fields[{entry.Key}] is an enum without a values list");
+                }
+            }
+
+            foreach (KeyValuePair<string, PlatformOverrides> entry in Platforms)
+            {
+                if (
+                    entry.Value.RenderPipeline.Length > 0
+                    && !entry.Value.RenderPipeline.StartsWith("Assets/", StringComparison.Ordinal)
+                )
+                {
+                    throw new BuildFailedException(
+                        $"build-config.json field 'platforms[{entry.Key}].render_pipeline' must be a project path starting with Assets/ — got '{entry.Value.RenderPipeline}'"
+                    );
+                }
+            }
+        }
+    }
+}

unity_devkit-0.1.15/PlayerBuild/Assets/Package/Editor/BuildConfig.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5a05d4e7bcd9d3f8ca495774871563d1