diff --git a/.github/workflows/assemble.yml b/.github/workflows/assemble.yml
new file mode 100644
index 0000000..f9035cb
--- /dev/null
+++ b/.github/workflows/assemble.yml
@@ -0,0 +1,146 @@
+name: Assemble the bundle
+
+# The bundle's installers assembled from stagings, without compiling. The stagings are artifacts of this run, laid
+# in by resolve.yml, <staging>-staging-<job>. reusable.yml builds each platform as the stagings were built:
+# the stagings unpacked each into its own folder, given to the bundle as FETCHLAYER_PREFIX_<STAGING> (configure preset
+# bundle-prefixes), the commits as BUNDLE_REVISION_<LAYER>, the installer packed (package preset installer). Each
+# installer is then installed as a user would and smoke-checked by tests/installed.
+
+on:
+  workflow_call:
+    inputs:
+      revisions:
+        description: "The commit of each staging's layer: a JSON object, staging → full sha (resolve.yml's)"
+        type: string
+      platforms:
+        description: "The platforms: a JSON list of {job, triplet, generator, runner, modules} (resolve.yml's)"
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  plan:
+    name: Plan the build
+    runs-on: ubuntu-latest
+    outputs:
+      jobs: ${{ steps.plan.outputs.jobs }}
+      packages: ${{ steps.plan.outputs.packages }}
+      cmake-presets: ${{ steps.plan.outputs.cmake-presets }}
+      cpack-presets: ${{ steps.plan.outputs.cpack-presets }}
+      checks: ${{ steps.plan.outputs.checks }}
+    steps:
+      - name: Plan
+        id: plan
+        shell: python3 {0}
+        env:
+          REVISIONS: ${{ inputs.revisions }}
+          PLATFORMS: ${{ inputs.platforms }}
+        run: |
+          import json, os
+
+          # a staging → its layer, named as its repository (BUNDLE_REVISION_<LAYER>)
+          REPOSITORIES = {"opendaq": "openDAQ", "opcua-modules": "OpcUaModules", "mqtt-module": "MQTTStreamingModule",
+                          "lt-streaming-modules": "LTStreamingModulesModern", "asam-cmp-modules": "ASAM-CMP-Modules"}
+          revision = json.loads(os.environ["REVISIONS"])
+          platforms = json.loads(os.environ["PLATFORMS"])
+
+          packages, cmake_presets, cpack_presets, checks = [], [], [], []
+          for p in platforms:
+              job = p["job"]
+              # the commits resolved there, so configure takes the same ones and resolves no ref again
+              artifacts = []
+              cache_variables = {f"BUNDLE_REVISION_{REPOSITORIES[staging].upper()}": sha for staging, sha in revision.items()}
+              for staging in revision:
+                  artifacts.append({"name": f"{staging}-staging-{job}", "dir": f"stagings/{staging}"})
+                  # the core's tarball carries its install prefix, opt/opendaq, except on Windows
+                  inside = "/opt/opendaq" if staging == "opendaq" and not job.startswith("windows-") else ""
+                  cache_variables[f"FETCHLAYER_PREFIX_{staging.upper()}"] = "${sourceDir}/stagings/" + staging + inside
+              packages.append({"match-jobs": [job], "artifacts": artifacts})
+              cmake_presets.append({"match-jobs": [job], "configure-preset": "bundle-prefixes", "cache-variables": cache_variables})
+              cpack_presets.append({"match-jobs": [job], "installers": [{"name": "bundle", "package": p["generator"], "package-preset": "installer"}]})
+              checks.append({"job": job, "runner": p["runner"], "generator": p["generator"], "modules": p["modules"]})
+
+          # DEB names the libraries the stagings need in its Depends (dpkg-shlibdeps), so they must be there: ASAM's
+          # libpcap, ref_fb's renderer's X11, GL, udev and freetype, LT's OpenSSL; NSIS packs
+          packages += [{"match-jobs": ["ubuntu-*"], "apt-install": ["dpkg-dev", "file", "libpcap0.8", "libx11-6",
+                         "libxrandr2", "libxcursor1", "libxi6", "libgl1", "libudev1", "libfreetype6", "libssl3"]},
+                       {"match-jobs": ["windows-*"], "choco-install": ["nsis"]}]
+
+          outputs = {"jobs": [p["job"] for p in platforms], "packages": packages,
+                     "cmake-presets": cmake_presets, "cpack-presets": cpack_presets, "checks": checks}
+          print(json.dumps(outputs, indent=2))
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              for key, value in outputs.items():
+                  f.write(f"{key}={json.dumps(value)}\n")
+
+  build:
+    name: Build
+    needs: plan
+    uses: openDAQ/openDAQ-CI/.github/workflows/reusable.yml@bundle/extract-each-artifact-into-its-dir
+    with:
+      include-jobs: ${{ needs.plan.outputs.jobs }}
+      packages: ${{ needs.plan.outputs.packages }}
+      cmake-presets: ${{ needs.plan.outputs.cmake-presets }}
+      cpack-presets: ${{ needs.plan.outputs.cpack-presets }}
+
+  # installed as a user would, everything selected, and smoke-checked
+  check:
+    name: Check ${{ matrix.check.job }}
+    needs: [plan, build]
+    runs-on: ${{ matrix.check.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        check: ${{ fromJSON(needs.plan.outputs.checks) }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ job.workflow_repository }}
+          ref: ${{ job.workflow_sha }}
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: package-${{ matrix.check.job }}
+          path: installer
+
+      - name: Install
+        id: install
+        timeout-minutes: 10
+        run: |
+          find installer -type f
+          case "${{ matrix.check.generator }}" in
+            DEB)          sudo apt-get update -qq
+                          sudo apt-get install -y -qq "$(find "$PWD/installer" -name '*.deb' | head -1)"
+                          echo "prefix=/opt/opendaq" >> "$GITHUB_OUTPUT" ;;
+            productbuild) sudo installer -pkg "$(find installer -name '*.pkg' | head -1)" -target /
+                          echo "prefix=/opt/opendaq" >> "$GITHUB_OUTPUT" ;;
+            NSIS)         exe=$(cygpath -w "$(find installer -name '*.exe' | head -1)")
+                          pwsh -Command 'Write-Host "PATH: $($env:Path.Length) characters (the template reads 1024)"'
+                          pwsh -Command "Start-Process -Wait -FilePath '$exe' -ArgumentList '/S','/PATH=AllUsers','/D=C:\opendaq'"
+                          echo "prefix=C:/opendaq" >> "$GITHUB_OUTPUT" ;;
+          esac
+
+      - name: Smoke check
+        run: |
+          cmake -S tests/installed -B build/installed \
+                -DOPENDAQ_PREFIX=${{ steps.install.outputs.prefix }} -DEXPECT_MODULES=${{ matrix.check.modules }}
+          cmake --build build/installed --config Release
+          ctest --test-dir build/installed -C Release --output-on-failure
+
+      # the installer added its bin to the machine's PATH, and the uninstaller removes it
+      - name: PATH
+        if: matrix.check.generator == 'NSIS'
+        timeout-minutes: 5
+        shell: pwsh
+        run: |
+          $bin = 'C:\opendaq\bin'
+          $has = { ([Environment]::GetEnvironmentVariable('Path', 'Machine') -split ';') -contains $bin }
+          Write-Host "after install, machine PATH has ${bin}: $(& $has)"
+          if (-not (& $has)) { exit 1 }
+          Start-Process -Wait -FilePath 'C:\opendaq\Uninstall.exe' -ArgumentList '/S','_?=C:\opendaq'
+          Write-Host "after uninstall, machine PATH has ${bin}: $(& $has)"
+          if (& $has) { exit 1 }
diff --git a/.github/workflows/bundle.yml b/.github/workflows/bundle.yml
new file mode 100644
index 0000000..70ca0fb
--- /dev/null
+++ b/.github/workflows/bundle.yml
@@ -0,0 +1,78 @@
+name: Bundle
+
+# The bundle's installers: resolve.yml lays the stagings of the bundle's commits into this run, assemble.yml builds
+# the installers from them. A layer's revision can be given as an input (a commit, or a branch or tag taken at its
+# head now), in place of bundle.json's. Called by the bundle's own triggers and by a layer's CI.
+
+on:
+  workflow_dispatch:
+    inputs:
+      opendaq:
+        description: "openDAQ: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      opcua-modules:
+        description: "OpcUaModules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      mqtt-module:
+        description: "MQTTStreamingModule: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      lt-streaming-modules:
+        description: "LTStreamingModulesModern: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      asam-cmp-modules:
+        description: "ASAM-CMP-Modules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+  workflow_call:
+    inputs:
+      opendaq:
+        description: "openDAQ: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      opcua-modules:
+        description: "OpcUaModules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      mqtt-module:
+        description: "MQTTStreamingModule: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      lt-streaming-modules:
+        description: "LTStreamingModulesModern: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      asam-cmp-modules:
+        description: "ASAM-CMP-Modules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+  pull_request:
+
+permissions:
+  contents: read
+  packages: read
+
+jobs:
+  resolve:
+    name: Resolve
+    permissions:
+      contents: read
+      packages: write     # a missing staging's stage.yml asks for it; nothing is pushed from here
+    uses: ./.github/workflows/resolve.yml
+    with:
+      opendaq: ${{ inputs.opendaq }}
+      opcua-modules: ${{ inputs.opcua-modules }}
+      mqtt-module: ${{ inputs.mqtt-module }}
+      lt-streaming-modules: ${{ inputs.lt-streaming-modules }}
+      asam-cmp-modules: ${{ inputs.asam-cmp-modules }}
+
+  assemble:
+    name: Assemble
+    needs: resolve
+    uses: ./.github/workflows/assemble.yml
+    with:
+      revisions: ${{ needs.resolve.outputs.revisions }}
+      platforms: ${{ needs.resolve.outputs.platforms }}
diff --git a/.github/workflows/resolve.yml b/.github/workflows/resolve.yml
new file mode 100644
index 0000000..98ee2ae
--- /dev/null
+++ b/.github/workflows/resolve.yml
@@ -0,0 +1,297 @@
+name: Resolve the bundle
+
+# What the bundle is assembled of: a commit per layer and the platforms, and every staging laid into this run as an
+# artifact, <staging>-staging-<job>, as a layer's stage names it, for assemble.yml to build from. The commits are
+# bundle.json's, each replaced by an input that is set (a commit, or a branch or tag taken at its head now). The
+# stagings come from the registry, by staging-pull, each from the channel its commit lies in (openDAQ-CI's
+# resolve-channel: release/** stable, main dev, dev also for a commit on neither, staged by hand); a module's is asked
+# for by the core it was built against too, so the modules of one bundle share its core. A staging the registry lacks
+# is staged here by its layer's stage.yml, called, never pushed; a module after the core is in the run, which its
+# stage then does not pull again.
+
+on:
+  workflow_call:
+    inputs:
+      opendaq:
+        description: "openDAQ: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      opcua-modules:
+        description: "OpcUaModules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      mqtt-module:
+        description: "MQTTStreamingModule: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      lt-streaming-modules:
+        description: "LTStreamingModulesModern: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+      asam-cmp-modules:
+        description: "ASAM-CMP-Modules: a commit, branch or tag (empty: bundle.json's)"
+        type: string
+        default: ""
+    outputs:
+      revisions:
+        description: "The commit of each staging's layer: a JSON object, staging → full sha"
+        value: ${{ jobs.resolve.outputs.revisions }}
+      platforms:
+        description: "The platforms: a JSON list of {job, triplet, generator, runner, modules}"
+        value: ${{ jobs.resolve.outputs.platforms }}
+
+permissions:
+  contents: read
+  packages: read
+
+jobs:
+  resolve:
+    name: Resolve the stagings
+    runs-on: ubuntu-latest
+    outputs:
+      revisions: ${{ steps.stagings.outputs.revisions }}
+      platforms: ${{ steps.stagings.outputs.platforms }}
+      exclude-jobs: ${{ steps.stagings.outputs.exclude-jobs }}
+      staging-artifacts: ${{ steps.split.outputs.staging-artifacts }}
+      missing: ${{ steps.split.outputs.missing }}
+    steps:
+      # bundle.json of this workflow's own commit, whoever calls it
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ job.workflow_repository }}
+          ref: ${{ job.workflow_sha }}
+
+      - name: Resolve the commits
+        id: stagings
+        shell: python3 {0}
+        env:
+          INPUTS: ${{ toJSON(inputs) }}
+        run: |
+          import json, os, re, subprocess, sys
+
+          # one entry per platform the bundle is assembled for:
+          #   key        the reusable.yml job that packs it (its name picks the runner, the compiler, the generator)
+          #   triplet    the stagings it takes: com.opendaq.package.triplet of the packages pulled from ghcr
+          #   generator  the CPack generator of its installer
+          #   runner     where the installer is installed and smoke-checked (tests/installed)
+          #   modules    how many modules the smoke check expects to load (Windows: ASAM's two need Npcap, absent)
+          # runner and modules serve the smoke check, a debugging aid until the integration tests take the installers;
+          # they go with it
+          JOBS = {
+              # job                                          triplet                                 generator       runner              modules
+              "ubuntu-22.04-x86_64-ninja-gcc-release":       ("x86_64-linux-gcc-11-release",         "DEB",          "ubuntu-22.04",     14),
+              "ubuntu-22.04-armv8-ninja-gcc-release":        ("armv8-linux-gcc-11-release",          "DEB",          "ubuntu-24.04-arm", 14),
+              "windows-2022-x86_64-msvs-v143-release":       ("x86_64-windows-msvc-143-release",     "NSIS",         "windows-2022",     12),
+              "macos-26-armv8-ninja-appleclang-21-release":  ("armv8-macos-apple-clang-21-release",  "productbuild", "macos-26",         14),
+              "macos-26-x86_64-ninja-appleclang-21-release": ("x86_64-macos-apple-clang-21-release", "productbuild", "macos-26-intel",   14),
+          }
+          # the jobs of a layer's stage the bundle takes nothing from: not built when a layer is staged here
+          EXCLUDE_JOBS = ["manylinux*", "windows-*-x86-*"]
+          # a layer, named as its repository in bundle.json → its staging
+          STAGINGS = {"openDAQ": "opendaq", "OpcUaModules": "opcua-modules", "MQTTStreamingModule": "mqtt-module",
+                      "LTStreamingModulesModern": "lt-streaming-modules", "ASAM-CMP-Modules": "asam-cmp-modules"}
+          REPOSITORIES = {staging: layer for layer, staging in STAGINGS.items()}
+
+          inputs = json.loads(os.environ["INPUTS"] or "{}") or {}
+
+          def commit(staging, ref):
+              """A full sha as it is; a branch or a tag → its commit, as the repository has it now."""
+              if re.fullmatch(r"[0-9a-f]{40}", ref):
+                  return ref
+              url = f"https://github.com/openDAQ/{REPOSITORIES[staging]}.git"
+              out = subprocess.run(["git", "ls-remote", url, ref], capture_output=True, text=True, check=True).stdout
+              refs = dict(reversed(line.split("\t")) for line in out.splitlines())
+              for name in (f"refs/tags/{ref}^{{}}", f"refs/tags/{ref}", f"refs/heads/{ref}"):
+                  if name in refs:
+                      return refs[name]
+              sys.exit(f"::error::{REPOSITORIES[staging]} has no branch or tag {ref!r} (a commit is given in full)")
+
+          # bundle.json's revisions, each replaced by an input that is set
+          revision = {}
+          for layer, ref in json.load(open("bundle.json")).items():
+              staging = STAGINGS[layer]
+              given = (inputs.get(staging) or "").strip()
+              revision[staging] = commit(staging, given or ref)
+
+          summary = ["| Staging | Revision |", "|-|-|"]
+          for staging, sha in revision.items():
+              summary.append(f"| {staging} | [`{sha[:12]}`](https://github.com/openDAQ/{REPOSITORIES[staging]}/commit/{sha}) |")
+          print("\n".join(summary))
+          with open(os.environ["GITHUB_STEP_SUMMARY"], "a") as f:
+              f.write("\n".join(summary) + "\n")
+
+          platforms = [{"job": job, "triplet": triplet, "generator": generator, "runner": runner, "modules": modules}
+                       for job, (triplet, generator, runner, modules) in JOBS.items()]
+          # the modules' commits, by repository, for their channels
+          modules = {f"openDAQ/{REPOSITORIES[staging]}": sha for staging, sha in revision.items() if staging != "opendaq"}
+
+          outputs = {"revisions": revision, "platforms": platforms, "modules": modules, "exclude-jobs": EXCLUDE_JOBS,
+                     "repositories": {staging: f"openDAQ/{layer}" for staging, layer in REPOSITORIES.items()}}
+          print(json.dumps(outputs, indent=2))
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              for key, value in outputs.items():
+                  f.write(f"{key}={json.dumps(value)}\n")
+
+      # the channel each staging is published in, by where its commit lies: the core's commit given as the commit,
+      # the modules' as what it is built against, only to learn theirs (nothing is published here)
+      - name: Resolve the channels
+        id: channel
+        uses: openDAQ/openDAQ-CI/.github/actions/resolve-channel@bundle/extract-each-artifact-into-its-dir
+        with:
+          repository: openDAQ/openDAQ
+          commit: ${{ fromJSON(steps.stagings.outputs.revisions)['opendaq'] }}
+          depends: ${{ steps.stagings.outputs.modules }}
+
+      - name: Request the stagings
+        id: request
+        shell: python3 {0}
+        env:
+          REVISIONS: ${{ steps.stagings.outputs.revisions }}
+          PLATFORMS: ${{ steps.stagings.outputs.platforms }}
+          REPOSITORIES: ${{ steps.stagings.outputs.repositories }}
+          CORE_CHANNEL: ${{ steps.channel.outputs.channel }}
+          MODULE_CHANNELS: ${{ steps.channel.outputs.depends-channels }}
+        run: |
+          import json, os
+
+          revision = json.loads(os.environ["REVISIONS"])
+          repository = json.loads(os.environ["REPOSITORIES"])
+          # a staging is looked for in its commit's channel, and in dev when it lies on no main or release/** (staged
+          # by hand)
+          channels = {"openDAQ/openDAQ": os.environ["CORE_CHANNEL"], **json.loads(os.environ["MODULE_CHANNELS"])}
+          channel = {staging: channels[repository[staging]] or "dev" for staging in revision}
+
+          # every staging of every platform, by its triplet, into an artifact named as the staging's own stage names
+          # it; optional: the check tells what is there
+          pull = []
+          for platform in json.loads(os.environ["PLATFORMS"]):
+              job, triplet = platform["job"], platform["triplet"]
+              for staging, sha in revision.items():
+                  annotations = {"org.opencontainers.image.revision": sha, "com.opendaq.package.triplet": triplet}
+                  if staging != "opendaq":
+                      annotations["com.opendaq.dependencies.opendaq.revision"] = revision["opendaq"]
+                  pull.append({"artifact": f"{staging}-staging-{job}",
+                               "packages": [{"path": f"ghcr.io/openDAQ/{channel[staging]}/staging/{staging}",
+                                             "annotations": annotations, "optional": True}]})
+          print(json.dumps(channel, indent=2))
+
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              f.write(f"request={json.dumps(pull)}\n")
+
+      - name: Check the registry
+        id: check
+        uses: openDAQ/openDAQ-CI/.github/actions/staging-check@v4
+        with:
+          packages: ${{ steps.request.outputs.request }}
+
+      # a staging missing on any platform is staged here, on all of them; the rest is pulled
+      - name: Split
+        id: split
+        shell: python3 {0}
+        env:
+          REQUEST: ${{ steps.request.outputs.request }}
+          RESOLVED: ${{ steps.check.outputs.resolved }}
+        run: |
+          import json, os
+
+          request = json.loads(os.environ["REQUEST"])
+          found = {entry["artifact"] for entry in json.loads(os.environ["RESOLVED"]) if entry["packages"]}
+          staging_of = lambda entry: entry["packages"][0]["path"].rsplit("/", 1)[1]
+          missing = sorted({staging_of(entry) for entry in request if entry["artifact"] not in found})
+
+          pull = [{**entry, "packages": [{k: v for k, v in package.items() if k != "optional"} for package in entry["packages"]]}
+                  for entry in request if staging_of(entry) not in missing]
+          print(f"missing, staged here: {missing or 'none'}")
+
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              f.write(f"staging-artifacts={json.dumps(pull)}\n")
+              f.write(f"missing={json.dumps(missing)}\n")
+
+  pull:
+    name: Pull
+    needs: resolve
+    if: needs.resolve.outputs.staging-artifacts != '[]'
+    uses: openDAQ/openDAQ-CI/.github/workflows/staging-pull.yml@v4
+    with:
+      staging-artifacts: ${{ needs.resolve.outputs.staging-artifacts }}
+
+  stage-opendaq:
+    name: Stage openDAQ
+    needs: resolve
+    if: contains(fromJSON(needs.resolve.outputs.missing), 'opendaq')
+    permissions:
+      contents: read
+      packages: write     # asked for by the stage.yml's push, which is never run from here
+    uses: openDAQ/openDAQ/.github/workflows/stage.yml@bundle/stagings
+    with:
+      ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opendaq'] }}
+      exclude-jobs: ${{ needs.resolve.outputs.exclude-jobs }}
+
+  # after the core is in the run, pulled or staged, so the module's stage does not pull it again
+  stage-opcua-modules:
+    name: Stage OpcUaModules
+    needs: [resolve, pull, stage-opendaq]
+    if: >-
+      always() && needs.resolve.result == 'success'
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.pull.result)
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.stage-opendaq.result)
+      && contains(fromJSON(needs.resolve.outputs.missing), 'opcua-modules')
+    permissions:
+      contents: read
+      packages: write     # asked for by the stage.yml's push, which is never run from here
+    uses: openDAQ/OpcUaModules/.github/workflows/stage.yml@bundle/stagings
+    with:
+      ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opcua-modules'] }}
+      opendaq-ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opendaq'] }}
+      exclude-jobs: ${{ needs.resolve.outputs.exclude-jobs }}
+
+  stage-mqtt-module:
+    name: Stage MQTTStreamingModule
+    needs: [resolve, pull, stage-opendaq]
+    if: >-
+      always() && needs.resolve.result == 'success'
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.pull.result)
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.stage-opendaq.result)
+      && contains(fromJSON(needs.resolve.outputs.missing), 'mqtt-module')
+    permissions:
+      contents: read
+      packages: write     # asked for by the stage.yml's push, which is never run from here
+    uses: openDAQ/MQTTStreamingModule/.github/workflows/stage.yml@bundle/stagings
+    with:
+      ref: ${{ fromJSON(needs.resolve.outputs.revisions)['mqtt-module'] }}
+      opendaq-ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opendaq'] }}
+      exclude-jobs: ${{ needs.resolve.outputs.exclude-jobs }}
+
+  stage-lt-streaming-modules:
+    name: Stage LTStreamingModulesModern
+    needs: [resolve, pull, stage-opendaq]
+    if: >-
+      always() && needs.resolve.result == 'success'
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.pull.result)
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.stage-opendaq.result)
+      && contains(fromJSON(needs.resolve.outputs.missing), 'lt-streaming-modules')
+    permissions:
+      contents: read
+      packages: write     # asked for by the stage.yml's push, which is never run from here
+    uses: openDAQ/LTStreamingModulesModern/.github/workflows/stage.yml@bundle/stagings
+    with:
+      ref: ${{ fromJSON(needs.resolve.outputs.revisions)['lt-streaming-modules'] }}
+      opendaq-ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opendaq'] }}
+      exclude-jobs: ${{ needs.resolve.outputs.exclude-jobs }}
+
+  stage-asam-cmp-modules:
+    name: Stage ASAM-CMP-Modules
+    needs: [resolve, pull, stage-opendaq]
+    if: >-
+      always() && needs.resolve.result == 'success'
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.pull.result)
+      && !contains(fromJSON('["failure", "cancelled"]'), needs.stage-opendaq.result)
+      && contains(fromJSON(needs.resolve.outputs.missing), 'asam-cmp-modules')
+    permissions:
+      contents: read
+      packages: write     # asked for by the stage.yml's push, which is never run from here
+    uses: openDAQ/ASAM-CMP-Modules/.github/workflows/stage.yml@bundle/stagings
+    with:
+      ref: ${{ fromJSON(needs.resolve.outputs.revisions)['asam-cmp-modules'] }}
+      opendaq-ref: ${{ fromJSON(needs.resolve.outputs.revisions)['opendaq'] }}
+      exclude-jobs: ${{ needs.resolve.outputs.exclude-jobs }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d16b94..0b4f967 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,162 +1,32 @@
 set(CMAKE_POLICY_VERSION_MINIMUM 3.5)
 cmake_minimum_required(VERSION 3.25)
 
-set(REPO_NAME ReleaseRepo)
-set(REPO_OPTION_PREFIX RELEASE_REPO)
-set(CMAKE_FOLDER "${CMAKE_FOLDER}/${REPO_NAME}")
+project(openDAQ-bundle VERSION 1.0.0 LANGUAGES CXX)
 
-
-list(APPEND CMAKE_MESSAGE_CONTEXT ${REPO_NAME})
-
-project(${REPO_NAME} VERSION "1.0.0" LANGUAGES CXX)
-
-option(${REPO_OPTION_PREFIX}_ENABLE_TESTS "Enable testing" OFF)
-option(${REPO_OPTION_PREFIX}_ENABLE_OPCUA_MODULE "Enable OPC UA module" ON)
-option(${REPO_OPTION_PREFIX}_ENABLE_MQTT_MODULE "Enable MQTT module" ON)
-option(${REPO_OPTION_PREFIX}_ENABLE_LT_MODULE "Enable LT streaming module" ON)
-option(${REPO_OPTION_PREFIX}_ENABLE_ASAM_CMP_MODULE "Enable ASAM-CMP modules" ON)
+# The bundle: the stagings named, each from where the policy says — prebuilt from the store, or built from its
+# layer's sources (cmake/FetchLayer.cmake). What the bundle is made of is cmake/Layers.cmake; how it is packed,
+# cmake/Packing.cmake.
+set(BUNDLE_STAGINGS "opendaq;opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules"
+    CACHE STRING "The stagings to make available, dependencies first")
+option(BUNDLE_ENABLE_TESTS "Build the layers' tests, for the layers built from sources" OFF)
 
 include(FetchContent)
 
-# fetch the cmake utilities first, as they are used by the other modules
+# the cmake utilities first: the triplet, Boost, and what the layers built here use; the tag the core takes
 FetchContent_Declare(
     opendaq-cmake-utils
     GIT_REPOSITORY https://github.com/openDAQ/opendaq-cmake-utils.git
-    GIT_TAG        v1.0.1
+    GIT_TAG        v1.1.3
     GIT_PROGRESS   ON
 )
 FetchContent_MakeAvailable(opendaq-cmake-utils)
 
-FetchContent_Declare(
-    opendaq
-    GIT_REPOSITORY https://github.com/openDAQ/openDAQ.git
-    GIT_TAG main
-    GIT_PROGRESS   ON
-    GIT_SHALLOW    OFF
-    SOURCE_SUBDIR  "INVALID"
-    GIT_REMOTE_UPDATE_STRATEGY CHECKOUT
-)
-
-set(OPENDAQ_ENABLE_OPCUA OFF CACHE BOOL "")
-set(OPENDAQ_ENABLE_OPCUA_INTEGRATION_TESTS OFF CACHE BOOL "")
-
-set(OPENDAQ_GENERATE_DELPHI_BINDINGS OFF CACHE BOOL "" FORCE)
-set(OPENDAQ_GENERATE_PYTHON_BINDINGS ON CACHE BOOL "")
-set(OPENDAQ_GENERATE_CSHARP_BINDINGS ON CACHE BOOL "")
-set(OPENDAQ_GENERATE_C_BINDINGS ON CACHE BOOL "")
-
-set(OPENDAQ_ENABLE_TESTS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_TEST_UTILS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_OPTIONAL_TESTS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_COVERAGE OFF CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_REGRESSION_TESTS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_UNSTABLE_TEST_LABELS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-
-set(DAQMODULES_EMPTY_MODULE ON CACHE BOOL "")
-set(DAQMODULES_OPENDAQ_CLIENT_MODULE ON CACHE BOOL "")
-set(DAQMODULES_OPENDAQ_SERVER_MODULE ON CACHE BOOL "")
-set(DAQMODULES_REF_DEVICE_MODULE ON CACHE BOOL "")
-set(DAQMODULES_SIMULATOR_DEVICE_MODULE ON CACHE BOOL "")
-set(DAQMODULES_REF_FB_MODULE ON CACHE BOOL "")
-set(DAQMODULES_AUDIO_DEVICE_MODULE ON CACHE BOOL "")
-set(DAQMODULES_BASIC_CSV_RECORDER_MODULE ON CACHE BOOL "")
-set(DAQMODULES_LICENSING_MODULE ON CACHE BOOL "")
-set(DAQMODULES_PARQUET_RECORDER_MODULE OFF CACHE BOOL "")
-
-set(OPENDAQ_ENABLE_NATIVE_STREAMING ON CACHE BOOL "")
-set(OPENDAQ_ENABLE_WEBSOCKET_STREAMING OFF CACHE BOOL "")
-
-set(OPENDAQ_DOCUMENTATION_TESTS OFF CACHE BOOL "" FORCE)
-set(OPENDAQ_ENABLE_PYTHON_BINDINGS_TESTS OFF CACHE BOOL "" FORCE)
-set(APP_ENABLE_WEBPAGE_EXAMPLES OFF CACHE BOOL "")
-
-FetchContent_MakeAvailable(opendaq)
-include("${opendaq_SOURCE_DIR}/external/boost/Boost.cmake" OPTIONAL)
-
-if (${REPO_OPTION_PREFIX}_ENABLE_OPCUA_MODULE)
-FetchContent_Declare(
-    opcuamodules
-    GIT_REPOSITORY https://github.com/openDAQ/OpcUaModules.git
-    GIT_TAG        main
-    GIT_PROGRESS   ON
-    GIT_SHALLOW    OFF
-    SOURCE_SUBDIR  "INVALID"
-    GIT_REMOTE_UPDATE_STRATEGY CHECKOUT
-)
-
-set(DAQMODULES_OPCUA_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
-set(DAQMODULES_OPCUA_ENABLE_TESTS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(DAQMODULES_OPCUA_ENABLE_CLIENT ON CACHE BOOL "")
-set(DAQMODULES_OPCUA_ENABLE_SERVER ON CACHE BOOL "")
-set(DAQMODULES_OPCUA_ENABLE_GENERIC_CLIENT ON CACHE BOOL "")
-
-FetchContent_MakeAvailable(opcuamodules)
-include("${opcuamodules_SOURCE_DIR}/external/boost/Boost.cmake" OPTIONAL)
-endif()
-
-if (${REPO_OPTION_PREFIX}_ENABLE_MQTT_MODULE)
-FetchContent_Declare(
-    mqttmodule
-    GIT_REPOSITORY https://github.com/openDAQ/MQTTStreamingModule.git
-    GIT_TAG        main
-    GIT_PROGRESS   ON
-    GIT_SHALLOW    OFF
-    SOURCE_SUBDIR  "INVALID"
-    GIT_REMOTE_UPDATE_STRATEGY CHECKOUT
-)
-
-set(DAQMODULES_MQTT_ENABLE_TESTS ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(DAQMODULES_MQTT_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
-set(DAQMODULES_MQTT_ENABLE_SSL OFF CACHE BOOL "")
-
-FetchContent_MakeAvailable(mqttmodule)
-include("${mqttmodule_SOURCE_DIR}/external/boost/Boost.cmake" OPTIONAL)
-endif()
-
-
-if (${REPO_OPTION_PREFIX}_ENABLE_LT_MODULE)
-FetchContent_Declare(
-    ltstreamingmodulesmodern
-    GIT_REPOSITORY https://github.com/openDAQ/LTStreamingModulesModern.git
-    GIT_TAG        main
-    GIT_PROGRESS   ON
-    GIT_SHALLOW    OFF
-    SOURCE_SUBDIR  "INVALID"
-    GIT_REMOTE_UPDATE_STRATEGY CHECKOUT
-)
-
-set(DAQMODULES_LT_STREAMING_ENABLE_TESTS  ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(DAQMODULES_LT_STREAMING_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
-set(DAQMODULES_LT_STREAMING_ENABLE_CLIENT ON CACHE BOOL "")
-set(DAQMODULES_LT_STREAMING_ENABLE_SERVER ON CACHE BOOL "")
-
-FetchContent_MakeAvailable(ltstreamingmodulesmodern)
-include("${ltstreamingmodulesmodern_SOURCE_DIR}/external/boost/Boost.cmake" OPTIONAL)
-endif()
-
-if (${REPO_OPTION_PREFIX}_ENABLE_ASAM_CMP_MODULE)
-FetchContent_Declare(
-    asamcmpmodules
-    GIT_REPOSITORY https://github.com/openDAQ/ASAM-CMP-Modules.git
-    GIT_TAG        main
-    GIT_PROGRESS   ON
-    GIT_SHALLOW    OFF
-    SOURCE_SUBDIR  "INVALID"
-    GIT_REMOTE_UPDATE_STRATEGY CHECKOUT
-)
-
-set(ASAM_CMP_ENABLE_TESTS  ${${REPO_OPTION_PREFIX}_ENABLE_TESTS} CACHE BOOL "" FORCE)
-set(ASAM_CMP_ENABLE_EXAMPLE OFF CACHE BOOL "")
-set(ASAM_CMP_BUILD_DATA_SINK ON CACHE BOOL "")
-set(ASAM_CMP_BUILD_CAPTURE_MODULE ON CACHE BOOL "")
-
-FetchContent_MakeAvailable(asamcmpmodules)
-include("${asamcmpmodules_SOURCE_DIR}/external/boost/Boost.cmake" OPTIONAL)
-endif()
+include(cmake/FetchLayer.cmake)
+# the identity keys are the annotations staging-push writes
+set(FETCHLAYER_IDENTITY_REVISION_KEY   "org.opencontainers.image.revision")
+set(FETCHLAYER_IDENTITY_DEPENDENCY_KEY "com.opendaq.dependencies.<name>.revision")
+set(FETCHLAYER_IDENTITY_AXIS_KEY       "com.opendaq.package.<axis>")
 
-# add the subdirectories for the core and modules
-add_subdirectory(${opendaq_SOURCE_DIR} ${opendaq_BINARY_DIR})
-add_subdirectory(${opcuamodules_SOURCE_DIR} ${opcuamodules_BINARY_DIR})
-add_subdirectory(${mqttmodule_SOURCE_DIR} ${mqttmodule_BINARY_DIR})
-add_subdirectory(${ltstreamingmodulesmodern_SOURCE_DIR} ${ltstreamingmodulesmodern_BINARY_DIR})
-add_subdirectory(${asamcmpmodules_SOURCE_DIR} ${asamcmpmodules_BINARY_DIR})
+include(cmake/Layers.cmake)
+FetchLayer_MakeAvailable(${BUNDLE_STAGINGS})
+include(cmake/Packing.cmake)
diff --git a/CMakePresets.json b/CMakePresets.json
index ac83377..2ddeda7 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -1,5 +1,5 @@
 {
-    "version": 4,
+    "version": 6,
     "configurePresets": [
         {
             "name": "debug",
@@ -100,6 +100,29 @@
                 "msvc-x86"
             ]
         },
+        {
+            "name": "bundle-prefixes",
+            "displayName": "Bundle from stagings given as prefixes (FETCHLAYER_PREFIX_<STAGING>), nothing compiled; CI",
+            "inherits": [
+                "release"
+            ],
+            "cacheVariables": {
+                "BUNDLE_STAGINGS": "opendaq;opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules",
+                "FETCHLAYER_BUILD": "NEVER"
+            }
+        },
+        {
+            "name": "bundle-native",
+            "displayName": "Bundle by FetchLayer, this machine's triplet",
+            "inherits": [
+                "release",
+                "ninja"
+            ],
+            "cacheVariables": {
+                "BUNDLE_STAGINGS": "opendaq;opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules",
+                "FETCHLAYER_STORE": "${sourceDir}/build/store"
+            }
+        },
         {
             "name": "x64/msvc-17",
             "displayName": "[MSVC 17] Release - x64",
@@ -163,5 +186,49 @@
                 "ninja"
             ]
         }
+    ],
+    "buildPresets": [
+        {
+            "name": "bundle-native",
+            "configurePreset": "bundle-native"
+        }
+    ],
+    "packagePresets": [
+        {
+            "name": "core",
+            "displayName": "The core: runtime, C++ API, C",
+            "configurePreset": "bundle-native",
+            "generators": [
+                "TGZ"
+            ],
+            "variables": {
+                "BUNDLE_PACK_STAGINGS": "opendaq",
+                "BUNDLE_PACK_COMPONENTS": "Runtime;Development",
+                "CPACK_OPENDAQ_META_PACKAGE_NAME": "opendaq-core"
+            }
+        },
+        {
+            "name": "installer",
+            "displayName": "The core with the modules, the modules optional where the generator offers choices (-G DEB, NSIS, productbuild)",
+            "configurePreset": "bundle-native",
+            "variables": {
+                "BUNDLE_PACK_STAGINGS": "opendaq;opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules",
+                "BUNDLE_PACK_COMPONENTS": "Runtime;Development",
+                "CPACK_OPENDAQ_META_PACKAGE_NAME": "opendaq-bundle"
+            }
+        },
+        {
+            "name": "modules",
+            "displayName": "The modules, without the core",
+            "configurePreset": "bundle-native",
+            "generators": [
+                "TGZ"
+            ],
+            "variables": {
+                "BUNDLE_PACK_STAGINGS": "opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules",
+                "BUNDLE_PACK_COMPONENTS": "Runtime",
+                "CPACK_OPENDAQ_META_PACKAGE_NAME": "opendaq-modules"
+            }
+        }
     ]
 }
diff --git a/README.md b/README.md
index 93b91f8..5a596a4 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,11 @@ A CMake super-project that bundles [openDAQ](https://github.com/openDAQ/openDAQ)
 - [LTStreamingModulesModern](https://github.com/openDAQ/LTStreamingModulesModern)
 - [ASAM-CMP-Modules](https://github.com/openDAQ/ASAM-CMP-Modules)
 
-All dependencies are fetched automatically via CMake's `FetchContent`.
+Each of these repositories is a **layer** at one revision. What a layer publishes is its **staging**: `opendaq`,
+`opcua-modules`, `mqtt-module`, `lt-streaming-modules`, `asam-cmp-modules`. The bundle takes each staging prebuilt,
+from a store of stagings, when one fits its revision, its dependencies' revisions and this platform. Otherwise it
+builds the layer from its sources in the same tree, fetched with CMake's `FetchContent`. The engine is
+`cmake/FetchLayer.cmake`; what the bundle is made of is `cmake/Layers.cmake`.
 
 ## Prerequisites
 
@@ -14,6 +18,12 @@ All dependencies are fetched automatically via CMake's `FetchContent`.
 - Git
 - **Windows:** Visual Studio 2017 or 2022 (with C++ workload) — used as compiler toolchain only
 - **Linux:** GCC or Clang, Ninja
+- **macOS:** Xcode command line tools, Ninja
+- For prebuilt stagings: [oras](https://oras.land) and read access to `ghcr.io/opendaq/dev/staging`
+
+On an Intel Mac with Homebrew in `/usr/local`, Homebrew's `boost`, `spdlog`, `fmt` and `rapidjson` headers shadow
+the ones the build fetches. Unlink them for a build from sources (`brew unlink boost spdlog fmt rapidjson`, then
+`brew link …`).
 
 ## Configure
 
@@ -21,6 +31,7 @@ Use one of the available CMake presets:
 
 | Preset | Platform | Compiler | Arch | Config |
 |---|---|---|---|---|
+| `bundle-native` | this machine | default | this machine | Release, prebuilt stagings from `build/store` |
 | `x64/msvc-22` | Windows | MSVC 2022 | x64 | Release |
 | `x86/msvc-22` | Windows | MSVC 2022 | x86 | Release |
 | `x64/msvc-17` | Windows | MSVC 2017 | x64 | Release |
@@ -30,6 +41,9 @@ Use one of the available CMake presets:
 | `x64/clang/release` | Linux | Clang | x64 | Release |
 | `x64/clang/debug` | Linux | Clang | x64 | Debug |
 
+`bundle-native` pins every layer to a commit whose stagings are published. The others set no store, so they build
+every layer from its `main` branch.
+
 ```bash
 # Windows
 cmake --preset="x64/msvc-22"
@@ -52,14 +66,56 @@ cmake --build build/x64/gcc/release
 
 | Option | Default | Description |
 |---|---|---|
-| `RELEASE_REPO_ENABLE_TESTS` | `OFF` | Build and enable tests |
-| `RELEASE_REPO_ENABLE_OPCUA_MODULE` | `ON` | Include OPC UA module |
-| `RELEASE_REPO_ENABLE_MQTT_MODULE` | `ON` | Include MQTT streaming module |
-| `RELEASE_REPO_ENABLE_LT_MODULE` | `ON` | Include LT streaming module |
-| `RELEASE_REPO_ENABLE_ASAM_CMP_MODULE` | `ON` | Include ASAM-CMP modules |
+| `BUNDLE_STAGINGS` | all five | The stagings to make available, dependencies first: `opendaq;opcua-modules;mqtt-module;lt-streaming-modules;asam-cmp-modules` |
+| `BUNDLE_REVISION_<LAYER>` | `main` | The revision of a layer (a repository, its name upper-cased): a full sha, a tag or a branch, e.g. `BUNDLE_REVISION_OPCUAMODULES` |
+| `FETCHLAYER_BUILD` | `MISSING` | `NEVER`: prebuilt stagings only; `MISSING`: prebuilt where there is one, else from sources; `ALWAYS`: from sources. `FETCHLAYER_BUILD_<LAYER>` for one layer |
+| `FETCHLAYER_STORE` | — | The store of prebuilt stagings, `<store>/<staging>/idx-<hash>/<triplet>/`; without one, everything is built from sources |
+| `FETCHCONTENT_SOURCE_DIR_<LAYER>` | — | A layer from a local checkout, always built from it |
+| `BUNDLE_AXIS_TRIPLET` | this build's | The triplets to make available; others than this build's come prebuilt, as files only |
+| `BUNDLE_ENABLE_TESTS` | `OFF` | Build the tests of the layers built from sources |
 
 Pass options at configure time:
 
 ```bash
-cmake --preset="x64/gcc/release" -DRELEASE_REPO_ENABLE_TESTS=ON
+cmake --preset="x64/gcc/release" -DBUNDLE_ENABLE_TESTS=ON
+cmake --preset="x64/gcc/release" -DBUNDLE_STAGINGS="opendaq;opcua-modules" -DBUNDLE_REVISION_OPCUAMODULES=v4.0.1
+cmake --preset bundle-native -DFETCHLAYER_BUILD_OPCUAMODULES=ALWAYS     # OPC UA from sources, the rest prebuilt
+```
+
+## Prebuilt stagings
+
+The store is filled from the registry once, for the revisions `bundle-native` pins (see `CMakePresets.json`):
+
+```bash
+cmake -DSTORE=build/store -DREGISTRY=ghcr.io/opendaq/dev/staging \
+      [-DORAS_REGISTRY_CONFIG=$HOME/.oras/config.json] \
+      "-DLAYERS=opendaq=<sha>;opcua-modules=<sha>;mqtt-module=<sha>;lt-streaming-modules=<sha>;asam-cmp-modules=<sha>" \
+      -P tools/fill-store.cmake
+```
+
+It takes every platform of each staging; a build already in the store is kept. Configuring from a filled store
+needs no network, apart from the first fetch of `opendaq-cmake-utils`.
+
+## Package
+
+With prebuilt stagings in a store, `bundle-native` configures without building, and the package presets pack:
+
+```bash
+cmake --preset bundle-native
+cmake --build --preset bundle-native
+cpack --preset core       # the core: runtime, C++ API, C binding
+cpack --preset modules    # the modules, without the core
+```
+
+The packages land in `build/bundle-native/packages`, named `opendaq-<core|modules>-<version>-<triplet>.tar.gz`.
+
+## Tests
+
+```bash
+cmake -P tests/identity.cmake        # the identity hash against its check vector
+cmake -P tests/axis.cmake            # axes and variants
+cmake -S tests/fetchlayer-axes -B build/fetchlayer-axes      # variants by two axes, the layer's decision
+cmake -S tests/fetchlayer-git  -B build/fetchlayer-git       # the git origin (network)
+cmake -S tests/fetchlayer -B build/fetchlayer -G Ninja \
+      -DFETCHLAYER_STORE=$PWD/build/store -DFETCHLAYER_TRIPLET=<triplet>   # on the store, with a smoke test
 ```
diff --git a/bundle.json b/bundle.json
new file mode 100644
index 0000000..42ff56e
--- /dev/null
+++ b/bundle.json
@@ -0,0 +1,7 @@
+{
+    "openDAQ": "1a82fa899b78e23ddcf61975eb9255b22e713808",
+    "OpcUaModules": "485710c37d06bcc6b6c852e57fd27c0b2cce7d08",
+    "MQTTStreamingModule": "3a55f4bf710ca10513ed64464e74680246e35e9f",
+    "LTStreamingModulesModern": "322d770b08e033eb6033d417c2310fdb832e088a",
+    "ASAM-CMP-Modules": "a95b8cea31cca2c5e437c7e55d38bc9efc7703a6"
+}
diff --git a/cmake/CPackOptions.cmake b/cmake/CPackOptions.cmake
new file mode 100644
index 0000000..4df1213
--- /dev/null
+++ b/cmake/CPackOptions.cmake
@@ -0,0 +1,43 @@
+##
+## Read by cpack for every generator (CPACK_PROJECT_CONFIG_FILE): an installer puts the bundle
+## under /opt/opendaq, where the core installs itself; an archive holds the tree as it is.
+##
+## The package preset picks the stagings, BUNDLE_PACK_STAGINGS, and their components, BUNDLE_PACK_COMPONENTS
+## (Runtime, Development): the install components Packing.cmake recorded for each, CPACK_BUNDLE_<staging>_<component>,
+## the staging's name made a C identifier. The utils' config then names the package by CPACK_OPENDAQ_META_PACKAGE_NAME and writes its
+## staging-meta.json.
+##
+
+if (CPACK_GENERATOR MATCHES "^(DEB|RPM|productbuild)$")
+    set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/opendaq")
+else()
+    set(CPACK_PACKAGING_INSTALL_PREFIX "/")
+endif()
+
+if (NOT BUNDLE_PACK_STAGINGS OR NOT BUNDLE_PACK_COMPONENTS)
+    message(FATAL_ERROR "cpack: pick what to pack, -D BUNDLE_PACK_STAGINGS=<staging>… -D BUNDLE_PACK_COMPONENTS=Runtime… "
+                        "(a package preset does); the build has: ${CPACK_COMPONENTS_ALL}")
+endif()
+set(_picked)
+foreach(_staging IN LISTS BUNDLE_PACK_STAGINGS)
+    string(MAKE_C_IDENTIFIER "${_staging}" _c)
+    set(_found FALSE)
+    foreach(_component IN LISTS BUNDLE_PACK_COMPONENTS)
+        if (CPACK_BUNDLE_${_c}_${_component})
+            list(APPEND _picked ${CPACK_BUNDLE_${_c}_${_component}})
+            set(_found TRUE)
+        endif()
+    endforeach()
+    if (NOT _found)
+        message(FATAL_ERROR "cpack: nothing of ${_staging} to pack (${BUNDLE_PACK_COMPONENTS}); the build has: ${CPACK_COMPONENTS_ALL}")
+    endif()
+endforeach()
+# a macOS package carries the bundle's uninstall script (Packing.cmake)
+if (CPACK_GENERATOR STREQUAL "productbuild")
+    list(APPEND _picked bundle_Runtime)
+endif()
+set(CPACK_COMPONENTS_ALL ${_picked})
+
+include("${CPACK_OPENDAQ_PROJECT_CONFIG}")
+set(CPACK_PACKAGE_NAME "${CPACK_OPENDAQ_META_PACKAGE_NAME}")
+set(CPACK_DEBIAN_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}.deb")
diff --git a/cmake/FetchLayer.cmake b/cmake/FetchLayer.cmake
new file mode 100644
index 0000000..7ef20bf
--- /dev/null
+++ b/cmake/FetchLayer.cmake
@@ -0,0 +1,330 @@
+##
+## FetchLayer — FetchContent for layers, its sources swapped for prebuilt stagings where they exist. A layer is a
+## repository at a revision; a staging is what a layer gives as one whole, with its own dependencies and identity.
+## Stagings are made available, for one or more triplets, from where the policy says — prebuilt (System, later
+## OCI) or built from their layer's sources (Git).
+##
+##   FetchLayer_Declare(<layer> REVISION <ref> [<FetchContent content options>…] [POST_FETCH_INCLUDES <script>…])
+##   FetchLayer_DeclareStaging(<staging> LAYER <layer> [AXES <axis>…] [DEPENDS <staging>…] [FIND_PACKAGE_ARGS …])
+##   FetchLayer_DeclareAxis(<axis> NATIVE <value> [VALUES <value>…])
+##   FetchLayer_MakeAvailable(<staging>…)
+##   FetchLayer_GetProperties(<staging> [VARIANT <variant> | AXES <axis>=<value>…])
+##
+## Declare records a Layer, DeclareStaging a Staging of a layer declared before it, DeclareAxis a row of the
+## axes table; the first declaration of a name wins, a layer's and a staging's taken without case.
+## MakeAvailable makes an Instance of each variant of each staging, in the order given — the variants the axes
+## table names, each combination of the VALUES of the staging's axes: the policy, resolve, populate, integrate;
+## a staging's DEPENDS must be available first. It sets nothing in the caller's scope. GetProperties copies one
+## Instance into <staging>_* in the caller's scope.
+##
+## The axis triplet, when nothing declared it, is declared from FETCHLAYER_TRIPLET, the triplet this build is
+## configured for. Only this build's own variant — each axis at its NATIVE value — is built from sources and
+## installed; another comes prebuilt, files only. A variable for one layer or staging ends in its name
+## upper-cased, as FetchContent's do (FETCHLAYER_PREFIX_OPCUA-MODULES, FETCHCONTENT_SOURCE_DIR_OPCUAMODULES).
+##
+
+include_guard(GLOBAL)
+
+set(_FETCHLAYER_DIR "${CMAKE_CURRENT_LIST_DIR}/FetchLayer")
+include("${_FETCHLAYER_DIR}/layer.cmake")
+include("${_FETCHLAYER_DIR}/staging.cmake")
+include("${_FETCHLAYER_DIR}/axis.cmake")
+include("${_FETCHLAYER_DIR}/variant.cmake")
+include("${_FETCHLAYER_DIR}/instance.cmake")
+include("${_FETCHLAYER_DIR}/identity.cmake")
+include("${_FETCHLAYER_DIR}/policy.cmake")
+include("${_FETCHLAYER_DIR}/system.cmake")
+include("${_FETCHLAYER_DIR}/git.cmake")
+include("${_FETCHLAYER_DIR}/import.cmake")
+include("${_FETCHLAYER_DIR}/compile.cmake")
+
+set(FETCHLAYER_TRIPLET "" CACHE STRING "The triplet this build is configured for")
+set(FETCHLAYER_STORE "" CACHE PATH "The store of prebuilt stagings: <store>/<staging>/idx-<hash>/<variant>")
+
+
+# === FetchLayer_Declare ======================================================================================
+
+# FetchLayer_Declare(<layer> REVISION <ref> [<FetchContent content options>…] [POST_FETCH_INCLUDES <script>…])
+#   Records the layer; the first declaration of a name wins. POST_FETCH_INCLUDES (last: it takes what follows) are
+#   scripts of the layer's sources, <SOURCE_DIR>/… and <BINARY_DIR>/… standing for its directories: when the layer
+#   comes from its sources, each is included (OPTIONAL: a missing one is skipped) once every staging asked for is
+#   fetched and before any is integrated — so what one layer appends to (a Boost component list) is complete
+#   before another is added. A script sees <layer>_SOURCE_DIR and _BINARY_DIR, lower-cased, as FetchContent's;
+#   not the layer's project variables, its project not having started
+function(FetchLayer_Declare NAME)
+    __FetchLayer_layer_get("${NAME}" REVISION _known)
+    if (_known)
+        return()
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 1 _arg "" "REVISION" "DEPENDS;FIND_PACKAGE_ARGS;POST_FETCH_INCLUDES")
+    if (NOT _arg_REVISION)
+        message(FATAL_ERROR "FetchLayer_Declare(${NAME}): REVISION is required")
+    endif()
+    if (DEFINED _arg_DEPENDS OR DEFINED _arg_FIND_PACKAGE_ARGS)
+        message(FATAL_ERROR "FetchLayer_Declare(${NAME}): DEPENDS and FIND_PACKAGE_ARGS are a staging's, "
+                            "FetchLayer_DeclareStaging(<staging> LAYER ${NAME} …)")
+    endif()
+
+    __FetchLayer_layer_set("${NAME}" REVISION            "${_arg_REVISION}")
+    __FetchLayer_layer_set("${NAME}" ARGUMENTS           "${_arg_UNPARSED_ARGUMENTS}")
+    __FetchLayer_layer_set("${NAME}" POST_FETCH_INCLUDES "${_arg_POST_FETCH_INCLUDES}")
+endfunction()
+
+# FetchLayer_DeclareStaging(<staging> LAYER <layer> [AXES <axis>…] [DEPENDS <staging>…] [FIND_PACKAGE_ARGS …])
+#   Records the staging of a layer declared before it; the first declaration of a name wins. AXES are what it has
+#   variants by: triplet when not given, none when given empty; they are checked when it is made available, so
+#   an axis may be declared after it
+function(FetchLayer_DeclareStaging NAME)
+    __FetchLayer_staging_get("${NAME}" LAYER _known)
+    if (_known)
+        return()
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 1 _arg "" "LAYER" "AXES;DEPENDS;FIND_PACKAGE_ARGS")
+    if (_arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "FetchLayer_DeclareStaging(${NAME}): unknown arguments ${_arg_UNPARSED_ARGUMENTS}")
+    endif()
+    __FetchLayer_layer_get("${_arg_LAYER}" REVISION _layer_known)
+    if (NOT _arg_LAYER OR NOT _layer_known)
+        message(FATAL_ERROR "FetchLayer_DeclareStaging(${NAME}): LAYER must name a layer declared before it")
+    endif()
+
+    set(_axes triplet)
+    if (DEFINED _arg_AXES OR "AXES" IN_LIST _arg_KEYWORDS_MISSING_VALUES)
+        set(_axes ${_arg_AXES})
+    endif()
+
+    __FetchLayer_staging_set("${NAME}" LAYER             "${_arg_LAYER}")
+    __FetchLayer_staging_set("${NAME}" AXES              "${_axes}")
+    __FetchLayer_staging_set("${NAME}" DEPENDS           "${_arg_DEPENDS}")
+    __FetchLayer_staging_set("${NAME}" FIND_PACKAGE_ARGS "${_arg_FIND_PACKAGE_ARGS}")
+    __FetchLayer_layer_get("${_arg_LAYER}" STAGINGS _stagings)
+    list(APPEND _stagings "${NAME}")
+    __FetchLayer_layer_set("${_arg_LAYER}" STAGINGS "${_stagings}")
+endfunction()
+
+
+# FetchLayer_DeclareAxis(<axis> NATIVE <value> [VALUES <value>…])
+#   Adds the row of <axis> to the axes table: its native value, and the values made available (the native one
+#   when none is given); the first declaration of an axis wins
+function(FetchLayer_DeclareAxis AXIS)
+    __FetchLayer_axis_property("${AXIS}" NATIVE _property)
+    get_property(_known GLOBAL PROPERTY "${_property}")
+    if (_known)
+        return()
+    endif()
+    if (NOT AXIS MATCHES "^${_FETCHLAYER_AXIS_NAME}$")
+        message(FATAL_ERROR "FetchLayer_DeclareAxis(${AXIS}): an axis is named in lower case, a letter first")
+    endif()
+
+    cmake_parse_arguments(PARSE_ARGV 1 _arg "" "NATIVE" "VALUES")
+    if (_arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "FetchLayer_DeclareAxis(${AXIS}): unknown arguments ${_arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if (NOT _arg_NATIVE)
+        message(FATAL_ERROR "FetchLayer_DeclareAxis(${AXIS}): NATIVE, this build's value, is required")
+    endif()
+    set(_values ${_arg_VALUES})
+    if (NOT _values)
+        set(_values "${_arg_NATIVE}")
+    endif()
+    list(REMOVE_DUPLICATES _values)
+    foreach(_value IN LISTS _arg_NATIVE _values)
+        if (_value MATCHES "[+=]")
+            message(FATAL_ERROR "FetchLayer_DeclareAxis(${AXIS}): a value has no + or =: ${_value}")
+        endif()
+    endforeach()
+
+    set_property(GLOBAL PROPERTY "${_property}" "${_arg_NATIVE}")
+    __FetchLayer_axis_property("${AXIS}" VALUES _property)
+    set_property(GLOBAL PROPERTY "${_property}" "${_values}")
+    set_property(GLOBAL APPEND PROPERTY _FetchLayer_axes "${AXIS}")
+endfunction()
+
+
+# === FetchLayer_MakeAvailable ================================================================================
+
+# FetchLayer_MakeAvailable(<staging>…)
+#   Makes an Instance of each variant of each staging, in the order given, with all it has: its Runtime, and
+#   its Development when it has a CMake package. The variants are those the axes table names for the staging
+#   (__FetchLayer_variant_list). As FetchContent_MakeAvailable it takes no components and no ordering of its
+#   own: a staging's DEPENDS must be available before it, so they are named first.
+function(FetchLayer_MakeAvailable)
+    if (ARGN MATCHES "^TRIPLETS$|;TRIPLETS;|;TRIPLETS$")
+        message(FATAL_ERROR "FetchLayer_MakeAvailable: TRIPLETS is gone; the triplets are the VALUES of the axis "
+                            "triplet, FetchLayer_DeclareAxis(triplet NATIVE … VALUES …)")
+    endif()
+    foreach(_name IN LISTS ARGN)
+        __FetchLayer_staging_get("${_name}" LAYER _layer)
+        if (NOT _layer)
+            message(FATAL_ERROR "FetchLayer_MakeAvailable: no staging ${_name} is declared")
+        endif()
+        __FetchLayer_staging_get("${_name}" AXES _axes)
+        __FetchLayer_axis_check(${_axes})
+        # what of its layer is asked for: the layer's decision looks at these
+        __FetchLayer_layer_get("${_layer}" REQUESTED _requested)
+        string(TOLOWER "${_name}" _lower)
+        if (NOT _lower IN_LIST _requested)
+            list(APPEND _requested "${_lower}")
+            __FetchLayer_layer_set("${_layer}" REQUESTED "${_requested}")
+        endif()
+    endforeach()
+
+    # 1. fetch every variant asked for: find, then populate — a prefix, or sources downloaded
+    foreach(_name IN LISTS ARGN)
+        __FetchLayer_variant_list("${_name}" _variants)
+        foreach(_variant IN LISTS _variants)
+            __FetchLayer_instance_get("${_name}" "${_variant}" FETCHED _fetched)
+            if (NOT _fetched)
+                __FetchLayer_find("${_name}" "${_variant}")
+                __FetchLayer_instance_get("${_name}" "${_variant}" ORIGIN _origin)
+                cmake_language(CALL __FetchLayer_${_origin}_populate "${_name}" "${_variant}")
+                __FetchLayer_instance_set("${_name}" "${_variant}" FETCHED TRUE)
+            endif()
+        endforeach()
+    endforeach()
+
+    # 2. the post-fetch scripts of the layers from sources, before any is integrated
+    foreach(_name IN LISTS ARGN)
+        __FetchLayer_variant_select("${_name}" "" _variant)
+        __FetchLayer_instance_get("${_name}" "${_variant}" SOURCE_DIR _source_dir)
+        if (_source_dir)
+            __FetchLayer_compile_post_fetch("${_variant}" "${_name}")
+        endif()
+    endforeach()
+
+    # 3. integrate, in the order given: a prefix is imported, sources are compiled
+    foreach(_name IN LISTS ARGN)
+        __FetchLayer_variant_list("${_name}" _variants)
+        foreach(_variant IN LISTS _variants)
+            __FetchLayer_instance_get("${_name}" "${_variant}" POPULATED _populated)
+            if (_populated)
+                continue()
+            endif()
+            __FetchLayer_instance_get("${_name}" "${_variant}" ORIGIN _origin)
+            __FetchLayer_instance_get("${_name}" "${_variant}" PREFIX _prefix)
+            __FetchLayer_instance_get("${_name}" "${_variant}" SOURCE_DIR _source_dir)
+            if (_prefix)
+                __FetchLayer_import_make_available("${_variant}" "${_name}")
+                set(_where "${_prefix}")
+            elseif (_source_dir)
+                __FetchLayer_compile_make_available("${_variant}" "${_name}")
+                set(_where "${_source_dir}")
+            else()
+                message(FATAL_ERROR "FetchLayer: ${_name} from ${_origin} brought neither a prefix nor sources")
+            endif()
+            __FetchLayer_instance_set("${_name}" "${_variant}" POPULATED TRUE)
+            __FetchLayer_instance_get("${_name}" "${_variant}" REVISION _revision)
+            __FetchLayer_instance_get("${_name}" "${_variant}" IDENTITY_MATCH _match)
+            message(STATUS "FetchLayer: ${_name}@${_revision} ${_variant} from ${_origin} (${_match}): ${_where}")
+        endforeach()
+    endforeach()
+endfunction()
+
+# __FetchLayer_find(<staging> <variant>)
+#   The first origin that has it, of those the policy names, in order, recorded in the Instance;
+#   <staging> must be declared and its DEPENDS available for <variant>; none fails, with the facts the policy
+#   went by
+function(__FetchLayer_find STAGING VARIANT)
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    if (NOT _layer)
+        message(FATAL_ERROR "FetchLayer: no staging ${STAGING} is declared")
+    endif()
+    __FetchLayer_request("${STAGING}" "${VARIANT}" _request)
+
+    # the first origin that has it, of those the policy names
+    __FetchLayer_policy_lookup("${STAGING}" "${VARIANT}" _origins)
+    foreach(_origin IN LISTS _origins)
+        set(_candidate_REF "")
+        cmake_language(CALL __FetchLayer_${_origin}_resolve "${STAGING}" "${VARIANT}" _request _candidate)
+        if (_candidate_REF)
+            foreach(_field ORIGIN REF REVISION DEPENDS_REVISIONS VARIANT IDENTITY_MATCH)
+                __FetchLayer_instance_set("${STAGING}" "${VARIANT}" ${_field} "${_candidate_${_field}}")
+            endforeach()
+            return()
+        endif()
+    endforeach()
+
+    # none has it: the facts the policy went by
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_policy_build("${_layer}" _build)
+    __FetchLayer_variant_select("${STAGING}" "" _own)
+    list(JOIN _origins ", " _asked)
+    message(FATAL_ERROR "FetchLayer: no ${STAGING}@${_request_REVISION} for ${VARIANT} (depends "
+                        "${_request_DEPENDS_REVISIONS}; asked ${_asked}; FETCHLAYER_BUILD for ${_layer}: ${_build}; "
+                        "this build's own variant: ${_own})")
+endfunction()
+
+
+# __FetchLayer_request(<staging> <variant> <request>)
+#   The identity asked for, <request>_*: its layer's revision as a commit, the revisions of its DEPENDS for the
+#   variants that go with <variant>, the variant. A dependency of another layer must be available already; one
+#   of the same layer is at the layer's commit, available or not
+function(__FetchLayer_request STAGING VARIANT REQUEST)
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_git_commit("${_layer}" _revision)
+    __FetchLayer_staging_get("${STAGING}" DEPENDS _depends)
+    set(_pairs)
+    foreach(_dependency IN LISTS _depends)
+        string(TOLOWER "${_dependency}" _dependency)
+        # the dependency's variant that goes with this one: by its own axes
+        __FetchLayer_variant_select("${_dependency}" "${VARIANT}" _dependency_variant)
+        __FetchLayer_instance_get("${_dependency}" "${_dependency_variant}" REVISION _dependency_revision)
+        __FetchLayer_staging_get("${_dependency}" LAYER _dependency_layer)
+        if (NOT _dependency_revision AND _dependency_layer STREQUAL _layer)
+            set(_dependency_revision "${_revision}")
+        endif()
+        if (NOT _dependency_revision)
+            message(FATAL_ERROR "FetchLayer: ${STAGING} depends on ${_dependency}, which is not available for "
+                                "${_dependency_variant} yet; make it available first")
+        endif()
+        list(APPEND _pairs "${_dependency}=${_dependency_revision}")
+    endforeach()
+    list(SORT _pairs)
+    set(${REQUEST}_NAME "${STAGING}" PARENT_SCOPE)
+    set(${REQUEST}_REVISION "${_revision}" PARENT_SCOPE)
+    set(${REQUEST}_DEPENDS_REVISIONS "${_pairs}" PARENT_SCOPE)
+    set(${REQUEST}_VARIANT "${VARIANT}" PARENT_SCOPE)
+endfunction()
+
+
+# === FetchLayer_GetProperties ================================================================================
+
+# FetchLayer_GetProperties(<staging> [VARIANT <variant> | AXES <axis>=<value>…])
+#   Copies one Instance of <staging> into <staging>_<FIELD> in the caller's scope: this build's own variant; the
+#   variant given, as a string of <staging>_VARIANTS; or the one with these axes' values, its other axes at their
+#   native values. With it, each axis's value, <staging>_<AXIS> (opcua-modules_TRIPLET), and the variants made
+#   available, <staging>_VARIANTS
+function(FetchLayer_GetProperties NAME)
+    cmake_parse_arguments(PARSE_ARGV 1 _arg "" "VARIANT" "AXES")
+    if (_arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "FetchLayer_GetProperties(${NAME}): unknown arguments ${_arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if (DEFINED _arg_VARIANT AND DEFINED _arg_AXES)
+        message(FATAL_ERROR "FetchLayer_GetProperties(${NAME}): VARIANT or AXES, not both")
+    endif()
+    if (DEFINED _arg_VARIANT)
+        set(_variant "${_arg_VARIANT}")
+    else()
+        __FetchLayer_variant_format(_given ${_arg_AXES})
+        if (_given STREQUAL "any")
+            set(_given "")
+        endif()
+        __FetchLayer_variant_select("${NAME}" "${_given}" _variant)
+    endif()
+
+    string(TOLOWER "${NAME}" _name)
+    foreach(_field IN LISTS _FETCHLAYER_INSTANCE_FIELDS)
+        __FetchLayer_instance_get("${_name}" "${_variant}" ${_field} _value)
+        set(${_name}_${_field} "${_value}" PARENT_SCOPE)
+    endforeach()
+    __FetchLayer_staging_get("${_name}" AXES _axes)
+    foreach(_axis IN LISTS _axes)
+        __FetchLayer_variant_extract("${_variant}" "${_axis}" _value)
+        string(TOUPPER "${_axis}" _upper)
+        set(${_name}_${_upper} "${_value}" PARENT_SCOPE)
+    endforeach()
+    __FetchLayer_variant_list("${_name}" _variants)
+    set(${_name}_VARIANTS "${_variants}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/axis.cmake b/cmake/FetchLayer/axis.cmake
new file mode 100644
index 0000000..5b22221
--- /dev/null
+++ b/cmake/FetchLayer/axis.cmake
@@ -0,0 +1,49 @@
+##
+## Axes: what a staging has several variants by — triplet for every staging unless it says otherwise, python for
+## the Python binding, and so on. A table, one row per axis:
+##
+##   axis      NATIVE                                VALUES
+##   triplet   x86_64-macos-apple-clang-21-release   x86_64-macos-apple-clang-21-release;x86_64-linux-gcc-11-release
+##   python    3.12                                  3.11;3.12
+##
+##   NATIVE  this build's own value: the variant whose every axis is native is the one built from source and installed
+##   VALUES  the values made available; NATIVE when none is given
+##
+## One global property per cell, _FetchLayer_axis_<axis>_<COLUMN>; the rows, in _FetchLayer_axes. A row is added
+## by FetchLayer_DeclareAxis; triplet, when nothing declared it, is declared from FETCHLAYER_TRIPLET.
+##
+
+include_guard(GLOBAL)
+
+# what an axis is named: lower case, a letter first — it goes into a variant's string and an identity's key
+set(_FETCHLAYER_AXIS_NAME "[a-z][a-z0-9_]*")
+
+# __FetchLayer_axis_property(<axis> <column> <out>)
+#   The name of the global property that holds <column> of the row <axis>
+function(__FetchLayer_axis_property AXIS COLUMN OUT)
+    set(${OUT} "_FetchLayer_axis_${AXIS}_${COLUMN}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_axis_get(<axis> <column> <out>)
+#   NATIVE or VALUES of <axis>; triplet, when nothing declared it, declared from FETCHLAYER_TRIPLET first
+function(__FetchLayer_axis_get AXIS COLUMN OUT)
+    __FetchLayer_axis_property("${AXIS}" ${COLUMN} _property)
+    get_property(_value GLOBAL PROPERTY "${_property}")
+    if (NOT _value AND AXIS STREQUAL "triplet" AND FETCHLAYER_TRIPLET)
+        FetchLayer_DeclareAxis(triplet NATIVE "${FETCHLAYER_TRIPLET}")
+        get_property(_value GLOBAL PROPERTY "${_property}")
+    endif()
+    set(${OUT} "${_value}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_axis_check(<axis>…)
+#   Fails on an axis not declared
+function(__FetchLayer_axis_check)
+    foreach(_axis IN LISTS ARGN)
+        __FetchLayer_axis_get("${_axis}" NATIVE _native)
+        if (NOT _native)
+            message(FATAL_ERROR "FetchLayer: no axis ${_axis} is declared; FetchLayer_DeclareAxis(${_axis} NATIVE …)"
+                                " (triplet: or set FETCHLAYER_TRIPLET)")
+        endif()
+    endforeach()
+endfunction()
diff --git a/cmake/FetchLayer/compile.cmake b/cmake/FetchLayer/compile.cmake
new file mode 100644
index 0000000..2df74e7
--- /dev/null
+++ b/cmake/FetchLayer/compile.cmake
@@ -0,0 +1,69 @@
+##
+## The strategy compile: a layer's sources added to this build, as FetchContent_MakeAvailable adds them.
+##
+## Once per layer, at its first staging: add_subdirectory(<sources> <build tree> SYSTEM) — SYSTEM, so the layer's
+## headers do not turn its warnings into the consumers' errors; never EXCLUDE_FROM_ALL, so its install() rules
+## pack. Its settings are the set(... CACHE ...) before MakeAvailable. Its install components are those that
+## appear while it is added (get_cmake_property(COMPONENTS) before and after); what it installs without a
+## COMPONENT goes to <staging>_Development. They go to the staging of the layer; a layer whose several stagings
+## come from its sources would have to split them between them, which is not done yet.
+##
+## Before that, once every staging asked for is fetched, the layer's POST_FETCH_INCLUDES are included
+## (__FetchLayer_compile_post_fetch). Only this build's own variant is compiled: the policy never sends another
+## one here.
+##
+
+include_guard(GLOBAL)
+
+# __FetchLayer_compile_post_fetch(<variant> <staging>)
+#   Includes the POST_FETCH_INCLUDES of the staging's layer, once for the layer: <SOURCE_DIR> and <BINARY_DIR>
+#   replaced by the layer's directories, OPTIONAL; with <layer>_SOURCE_DIR and _BINARY_DIR set, lower-cased
+function(__FetchLayer_compile_post_fetch VARIANT STAGING)
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_layer_get("${_layer}" INCLUDED _included)
+    if (_included)
+        return()
+    endif()
+    __FetchLayer_layer_set("${_layer}" INCLUDED TRUE)
+    __FetchLayer_layer_get("${_layer}" POST_FETCH_INCLUDES _scripts)
+    __FetchLayer_instance_get("${STAGING}" "${VARIANT}" SOURCE_DIR _source_dir)
+    __FetchLayer_instance_get("${STAGING}" "${VARIANT}" BINARY_DIR _binary_dir)
+    string(TOLOWER "${_layer}" _lower)
+    set(${_lower}_SOURCE_DIR "${_source_dir}")
+    set(${_lower}_BINARY_DIR "${_binary_dir}")
+    foreach(_script IN LISTS _scripts)
+        string(REPLACE "<SOURCE_DIR>" "${_source_dir}" _script "${_script}")
+        string(REPLACE "<BINARY_DIR>" "${_binary_dir}" _script "${_script}")
+        include("${_script}" OPTIONAL)
+    endforeach()
+endfunction()
+
+# __FetchLayer_compile_make_available(<variant> <staging>)
+function(__FetchLayer_compile_make_available VARIANT STAGING)
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_layer_get("${_layer}" COMPILED _compiled)
+    if (NOT _compiled)
+        __FetchLayer_layer_get("${_layer}" REQUESTED _requested)
+        list(LENGTH _requested _count)
+        if (_count GREATER 1)
+            message(FATAL_ERROR "FetchLayer: ${_layer} is built from its sources for ${_requested}; giving its "
+                                "install components to several stagings is not done yet")
+        endif()
+        __FetchLayer_instance_get("${STAGING}" "${VARIANT}" SOURCE_DIR _source_dir)
+        __FetchLayer_instance_get("${STAGING}" "${VARIANT}" BINARY_DIR _binary_dir)
+        string(MAKE_C_IDENTIFIER "${STAGING}" _c)
+
+        get_cmake_property(_before COMPONENTS)
+        set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME "${_c}_Development")
+        add_subdirectory("${_source_dir}" "${_binary_dir}" SYSTEM)
+        get_cmake_property(_components COMPONENTS)
+        if (_before)
+            list(REMOVE_ITEM _components ${_before})
+        endif()
+
+        __FetchLayer_layer_set("${_layer}" COMPONENTS "${_components}")
+        __FetchLayer_layer_set("${_layer}" COMPILED TRUE)
+    endif()
+    __FetchLayer_layer_get("${_layer}" COMPONENTS _components)
+    __FetchLayer_instance_set("${STAGING}" "${VARIANT}" INSTALL_COMPONENTS "${_components}")
+endfunction()
diff --git a/cmake/FetchLayer/git.cmake b/cmake/FetchLayer/git.cmake
new file mode 100644
index 0000000..aa8d287
--- /dev/null
+++ b/cmake/FetchLayer/git.cmake
@@ -0,0 +1,161 @@
+##
+## The origin git: a layer's sources at a commit, by FetchContent.
+##
+## A layer is git's when its declaration names GIT_REPOSITORY; the other content options pass to
+## FetchContent_Declare as they are, but GIT_TAG and SOURCE_SUBDIR, which are git's own: the commit resolved,
+## and a subdirectory that does not exist, so FetchContent downloads only and adds nothing. The layer is the
+## content FetchContent knows, under the layer's name; its stagings come from that one tree.
+##
+## Before any origin is asked, find turns the declared revision into a commit, __FetchLayer_git_commit: a
+## full sha as it is, a tag or a branch by git ls-remote; a short sha is refused — no ref names it, and
+## finding it needs the history. The commit replaces the declared revision, so the next triplet takes it as
+## it is, and every triplet gets the same one; every origin then looks for it.
+##
+## resolve, for a staging: sources are built for this build's own variant only, so another variant gets nothing.
+## The identity is exact: the staging is built here against what is available.
+## populate downloads its layer: the Instance's SOURCE_DIR and BINARY_DIR. FetchContent's own variables hold,
+## among them FETCHCONTENT_SOURCE_DIR_<LAYER> (the layer's name upper-cased, as FetchContent does), a local
+## checkout taken as it is — its HEAD is the revision, and one other than declared, or with changes, is
+## warned about.
+##
+
+include_guard(GLOBAL)
+
+include(FetchContent)
+find_package(Git QUIET)
+
+set(_FETCHLAYER_GIT_NO_SUBDIR "__fetchlayer_download_only__")
+
+# __FetchLayer_git_repository(<layer> <out>)
+#   The GIT_REPOSITORY of the layer, empty when none
+function(__FetchLayer_git_repository LAYER OUT)
+    __FetchLayer_layer_get("${LAYER}" ARGUMENTS _arguments)
+    cmake_parse_arguments(_git "" "GIT_REPOSITORY;GIT_TAG;SOURCE_SUBDIR" "" ${_arguments})
+    if (DEFINED _git_GIT_TAG OR DEFINED _git_SOURCE_SUBDIR)
+        message(FATAL_ERROR "FetchLayer_Declare(${LAYER}): GIT_TAG and SOURCE_SUBDIR are FetchLayer's; "
+                            "the commit is REVISION")
+    endif()
+    set(${OUT} "${_git_GIT_REPOSITORY}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_git_run(<out> <arg>…)
+#   git <arg>…, its output stripped; fails with git's error
+function(__FetchLayer_git_run OUT)
+    if (NOT GIT_EXECUTABLE)
+        message(FATAL_ERROR "FetchLayer: git is not found")
+    endif()
+    execute_process(COMMAND "${GIT_EXECUTABLE}" ${ARGN}
+                    OUTPUT_VARIABLE _out ERROR_VARIABLE _err RESULT_VARIABLE _rc
+                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if (NOT _rc EQUAL 0)
+        list(JOIN ARGN " " _command)
+        message(FATAL_ERROR "FetchLayer: git ${_command}:\n${_err}")
+    endif()
+    set(${OUT} "${_out}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_git_commit(<layer> <out>)
+#   The declared revision of <layer> as a full sha: as it is, or a tag (an annotated one by the commit it points
+#   to) or a branch of its GIT_REPOSITORY by git ls-remote, then written over the declared REVISION: once per
+#   layer, every variant the same commit, though the branch moves meanwhile
+function(__FetchLayer_git_commit LAYER OUT)
+    __FetchLayer_layer_get("${LAYER}" REVISION _revision)
+    string(LENGTH "${_revision}" _length)
+    if (_revision MATCHES "^[0-9a-f]+$" AND _length EQUAL 40)
+        set(_sha "${_revision}")
+    else()
+        __FetchLayer_git_repository("${LAYER}" _repository)
+        if (NOT _repository)
+            message(FATAL_ERROR "FetchLayer: ${LAYER} revision ${_revision} is not a full sha, and the layer has no "
+                                "GIT_REPOSITORY to resolve it by")
+        endif()
+        if (FETCHCONTENT_FULLY_DISCONNECTED)
+            message(FATAL_ERROR "FetchLayer: ${LAYER} revision ${_revision} is not a full sha, and "
+                                "FETCHCONTENT_FULLY_DISCONNECTED forbids asking ${_repository}")
+        endif()
+        __FetchLayer_git_run(_lines ls-remote "${_repository}"
+                             "refs/tags/${_revision}" "refs/tags/${_revision}^{}" "refs/heads/${_revision}")
+        # <sha>\t<ref> lines, as a <ref>=<sha> list
+        string(REPLACE "\n" ";" _lines "${_lines}")
+        set(_refs)
+        foreach(_line IN LISTS _lines)
+            string(REPLACE "\t" ";" _fields "${_line}")
+            list(GET _fields 0 _line_sha)
+            list(GET _fields 1 _line_ref)
+            list(APPEND _refs "${_line_ref}=${_line_sha}")
+        endforeach()
+        foreach(_ref_name "refs/tags/${_revision}^{}" "refs/tags/${_revision}" "refs/heads/${_revision}")
+            foreach(_entry IN LISTS _refs)
+                if (_entry MATCHES "^(.*)=([0-9a-f]+)$" AND CMAKE_MATCH_1 STREQUAL _ref_name)
+                    set(_sha "${CMAKE_MATCH_2}")
+                endif()
+            endforeach()
+            if (_sha)
+                break()
+            endif()
+        endforeach()
+        if (NOT _sha)
+            message(FATAL_ERROR "FetchLayer: ${LAYER} revision ${_revision} is neither a full sha nor a tag or a branch "
+                                "of ${_repository}; a short sha is not resolved, give the full one")
+        endif()
+        message(STATUS "FetchLayer: ${LAYER} ${_revision} is ${_sha}")
+        __FetchLayer_layer_set("${LAYER}" REVISION "${_sha}")
+    endif()
+    set(${OUT} "${_sha}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_git_resolve(<staging> <variant> <request> <candidate>)
+function(__FetchLayer_git_resolve STAGING VARIANT REQUEST CANDIDATE)
+    __FetchLayer_variant_native("${VARIANT}" _native)
+    if (NOT _native)
+        return()
+    endif()
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_git_repository("${_layer}" _repository)
+    if (NOT _repository)
+        message(WARNING "FetchLayer: ${STAGING} is to be built from sources, and its layer ${_layer} has no "
+                        "GIT_REPOSITORY to build from")
+        return()
+    endif()
+    set(_wanted "${${REQUEST}_REVISION}")
+    string(TOUPPER "${_layer}" _upper)
+    set(_local "${FETCHCONTENT_SOURCE_DIR_${_upper}}")
+
+    if (_local)
+        # a local checkout, as it is: its HEAD
+        __FetchLayer_git_run(_sha -C "${_local}" rev-parse HEAD)
+        __FetchLayer_git_run(_changes -C "${_local}" status --porcelain --untracked-files=no)
+        if (NOT _sha STREQUAL _wanted OR _changes)
+            set(_with "")
+            if (_changes)
+                set(_with " with changes")
+            endif()
+            message(WARNING "FetchLayer: ${_layer} from the local checkout ${_local}: ${_sha}${_with}, "
+                            "not the declared ${_wanted}")
+        endif()
+        set(_ref "${_local}")
+    else()
+        set(_sha "${_wanted}")
+        set(_ref "${_sha}")
+    endif()
+
+    set(${CANDIDATE}_ORIGIN git PARENT_SCOPE)
+    set(${CANDIDATE}_REF "${_ref}" PARENT_SCOPE)
+    set(${CANDIDATE}_REVISION "${_sha}" PARENT_SCOPE)
+    set(${CANDIDATE}_DEPENDS_REVISIONS "${${REQUEST}_DEPENDS_REVISIONS}" PARENT_SCOPE)
+    set(${CANDIDATE}_VARIANT "${VARIANT}" PARENT_SCOPE)
+    set(${CANDIDATE}_IDENTITY_MATCH EXACT PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_git_populate(<staging> <variant>)
+#   Downloads the Instance's REVISION of its layer, once for the layer; the Instance's SOURCE_DIR and BINARY_DIR
+function(__FetchLayer_git_populate STAGING VARIANT)
+    __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+    __FetchLayer_layer_get("${_layer}" ARGUMENTS _arguments)
+    __FetchLayer_instance_get("${STAGING}" "${VARIANT}" REVISION _sha)
+    FetchContent_Declare(${_layer} ${_arguments} GIT_TAG "${_sha}" SOURCE_SUBDIR "${_FETCHLAYER_GIT_NO_SUBDIR}")
+    FetchContent_MakeAvailable(${_layer})
+    FetchContent_GetProperties(${_layer} SOURCE_DIR _source_dir BINARY_DIR _binary_dir)
+    __FetchLayer_instance_set("${STAGING}" "${VARIANT}" SOURCE_DIR "${_source_dir}")
+    __FetchLayer_instance_set("${STAGING}" "${VARIANT}" BINARY_DIR "${_binary_dir}")
+endfunction()
diff --git a/cmake/FetchLayer/identity.cmake b/cmake/FetchLayer/identity.cmake
new file mode 100644
index 0000000..df0116d
--- /dev/null
+++ b/cmake/FetchLayer/identity.cmake
@@ -0,0 +1,76 @@
+##
+## The identity of a staging and of a variant of it, its hash and its place in the store.
+##
+## An identity is variables with one prefix, <id>_*:
+##
+##   <id>_NAME               the staging                            opcua-modules
+##   <id>_REVISION           the commit it is built from            ad11c59ad433…
+##   <id>_DEPENDS_REVISIONS  the commits it is built against        opendaq=3039ee6d…;libx=…
+##   <id>_VARIANT            what it is built for (variant.cmake); empty for the identity of the staging itself
+##
+## Its hash is that of its key=value lines — the revision, one per dependency, one per axis of the variant —
+## sorted bytewise and joined by \n, sha256, after a prefix: idx-<hash> for a staging, pkg-<hash> for a variant.
+## The keys are those the registry annotates its packages with, so the hash names the tags there too; whoever
+## names them sets them:
+##
+##   FETCHLAYER_IDENTITY_REVISION_KEY     the revision
+##   FETCHLAYER_IDENTITY_DEPENDENCY_KEY   a dependency's revision, <name> standing for the dependency
+##   FETCHLAYER_IDENTITY_AXIS_KEY         the value of an axis, <axis> standing for the axis
+##
+## Only stagings (DEPENDS) and axes enter an identity: what else a package is annotated with must use other keys.
+## A variant lies in the store at <FETCHLAYER_STORE>/<name>/idx-<hash>/<variant>.
+##
+
+include_guard(GLOBAL)
+
+include("${CMAKE_CURRENT_LIST_DIR}/variant.cmake")
+
+set(FETCHLAYER_IDENTITY_REVISION_KEY   "revision"              CACHE STRING "Key of the revision in an identity")
+set(FETCHLAYER_IDENTITY_DEPENDENCY_KEY "dependency.<name>.revision" CACHE STRING "Key of a dependency's revision in an identity; <name> is the dependency")
+set(FETCHLAYER_IDENTITY_AXIS_KEY       "<axis>"                CACHE STRING "Key of an axis's value in an identity; <axis> is the axis")
+
+# __FetchLayer_identity_hash(<id> <prefix> <out>)
+#   <prefix>-<sha256> of the identity <id>; with the variant left out for a staging's own hash
+function(__FetchLayer_identity_hash ID PREFIX OUT)
+    if (NOT ${ID}_REVISION)
+        message(FATAL_ERROR "FetchLayer: the identity ${ID} has no revision")
+    endif()
+    set(_lines "${FETCHLAYER_IDENTITY_REVISION_KEY}=${${ID}_REVISION}")
+    foreach(_pair IN LISTS ${ID}_DEPENDS_REVISIONS)
+        if (NOT _pair MATCHES "^([^=]+)=(.+)$")
+            message(FATAL_ERROR "FetchLayer: not a <dependency>=<revision> pair in ${ID}: ${_pair}")
+        endif()
+        string(REPLACE "<name>" "${CMAKE_MATCH_1}" _key "${FETCHLAYER_IDENTITY_DEPENDENCY_KEY}")
+        list(APPEND _lines "${_key}=${CMAKE_MATCH_2}")
+    endforeach()
+    if (${ID}_VARIANT)
+        __FetchLayer_variant_parse("${${ID}_VARIANT}" _axes)
+        foreach(_pair IN LISTS _axes)
+            string(REGEX MATCH "^([^=]+)=(.*)$" _ "${_pair}")
+            string(REPLACE "<axis>" "${CMAKE_MATCH_1}" _key "${FETCHLAYER_IDENTITY_AXIS_KEY}")
+            list(APPEND _lines "${_key}=${CMAKE_MATCH_2}")
+        endforeach()
+    endif()
+    list(SORT _lines)
+    list(JOIN _lines "\n" _text)
+    string(SHA256 _hash "${_text}")
+    set(${OUT} "${PREFIX}-${_hash}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_identity_path(<id> <out>)
+#   Where the variant <id> lies in the store: <FETCHLAYER_STORE>/<staging>/idx-<hash>/<variant>
+function(__FetchLayer_identity_path ID OUT)
+    if (NOT FETCHLAYER_STORE)
+        message(FATAL_ERROR "FetchLayer: FETCHLAYER_STORE is not set")
+    endif()
+    if (NOT ${ID}_NAME OR NOT ${ID}_VARIANT)
+        message(FATAL_ERROR "FetchLayer: the identity ${ID} needs a name and a variant for a place in the store")
+    endif()
+    # the staging's own hash: the same revisions, without the variant
+    set(_staging_NAME "${${ID}_NAME}")
+    set(_staging_REVISION "${${ID}_REVISION}")
+    set(_staging_DEPENDS_REVISIONS "${${ID}_DEPENDS_REVISIONS}")
+    set(_staging_VARIANT "")
+    __FetchLayer_identity_hash(_staging idx _idx)
+    set(${OUT} "${FETCHLAYER_STORE}/${${ID}_NAME}/${_idx}/${${ID}_VARIANT}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/import.cmake b/cmake/FetchLayer/import.cmake
new file mode 100644
index 0000000..fa9880b
--- /dev/null
+++ b/cmake/FetchLayer/import.cmake
@@ -0,0 +1,102 @@
+##
+## The strategy import: a prefix made available to this build.
+##
+## For this build's own variant, the prefix is installed under the staging's install components: each module
+## (a *.module.* file in lib/modules or bin/modules) under one of its own, <module>_Runtime, so an installer can offer it
+## apart (no staging in the name: NSIS makes variables of component names, 60 characters at most); other shared libraries under <staging>_Runtime; the rest — headers, CMake configs, static
+## and import libraries — under <staging>_Development. When the prefix holds the staging's CMake package, it is
+## found from the prefix only (find_package … GLOBAL), so its targets exist. Each module file becomes an
+## imported MODULE target, <staging>::<module>.
+## For another variant nothing is installed or imported: the prefix is only recorded, files for whoever
+## lays them out (a multi-variant target).
+##
+## <staging> in a component name is the staging's name made a C identifier (opcua_modules_Runtime).
+##
+
+include_guard(GLOBAL)
+
+set(_FETCHLAYER_RUNTIME_PATTERNS "*.so" "*.so.*" "*.dylib" "*.dll")
+
+# __FetchLayer_import_module_stem(<file name> <out>)
+#   A module's name from its file: libref_fb_module-64-3.module.so → ref_fb_module
+function(__FetchLayer_import_module_stem FILE OUT)
+    string(REGEX REPLACE "^lib" "" _stem "${FILE}")
+    string(REGEX REPLACE "(-[0-9]+-[0-9]+)?\\.module\\..*$" "" _stem "${_stem}")
+    set(${OUT} "${_stem}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_import_make_available(<variant> <staging>…)
+function(__FetchLayer_import_make_available VARIANT)
+    foreach(_name IN LISTS ARGN)
+        __FetchLayer_instance_get("${_name}" "${VARIANT}" PREFIX _prefix)
+        __FetchLayer_variant_native("${VARIANT}" _native)
+        if (NOT _native)
+            __FetchLayer_instance_set("${_name}" "${VARIANT}" INSTALL_COMPONENTS "")
+            continue()
+        endif()
+        string(MAKE_C_IDENTIFIER "${_name}" _c)
+        set(_components)
+
+        # the prefix's files, split: a module is a component of its own, <module>_Runtime, so an installer can
+        # offer it apart; other shared libraries are <staging>_Runtime, the rest Development;
+        # file by file, so no empty directory lands in a component
+        file(GLOB_RECURSE _files LIST_DIRECTORIES false RELATIVE "${_prefix}" "${_prefix}/*")
+        set(_places)
+        foreach(_f IN LISTS _files)
+            get_filename_component(_n "${_f}" NAME)
+            get_filename_component(_d "${_f}" DIRECTORY)
+            set(_component ${_c}_Development)
+            foreach(_p IN LISTS _FETCHLAYER_RUNTIME_PATTERNS)
+                string(REPLACE "." "\\." _rx "${_p}")
+                string(REPLACE "*" ".*" _rx "${_rx}")
+                if (_n MATCHES "^${_rx}$")
+                    set(_component ${_c}_Runtime)
+                endif()
+            endforeach()
+            if (_d MATCHES "^(lib|bin)/modules$" AND _n MATCHES "\\.module\\.")    # not an import library beside it
+                __FetchLayer_import_module_stem("${_n}" _stem)
+                set(_component ${_stem}_Runtime)
+                set(_target "${_name}::${_stem}")                 # a module file → an imported MODULE target
+                if (NOT TARGET ${_target})
+                    add_library(${_target} MODULE IMPORTED GLOBAL)
+                    set_target_properties(${_target} PROPERTIES IMPORTED_LOCATION "${_prefix}/${_f}")
+                endif()
+            endif()
+            string(MAKE_C_IDENTIFIER "${_component}_${_d}" _key)
+            list(APPEND _files_${_key} "${_prefix}/${_f}")
+            list(APPEND _places "${_component}|${_d}")
+        endforeach()
+        list(REMOVE_DUPLICATES _places)
+        foreach(_e IN LISTS _places)
+            string(REPLACE "|" ";" _e "${_e}")
+            list(GET _e 0 _component)
+            list(LENGTH _e _len)
+            set(_d "")
+            if (_len GREATER 1)
+                list(GET _e 1 _d)
+            endif()
+            string(MAKE_C_IDENTIFIER "${_component}_${_d}" _key)
+            if (_d STREQUAL "")
+                set(_d .)
+            endif()
+            install(FILES ${_files_${_key}} DESTINATION "${_d}" COMPONENT ${_component})
+            list(APPEND _components ${_component})
+        endforeach()
+        list(REMOVE_DUPLICATES _components)
+
+        # the staging's package, when the prefix holds it, found from the prefix only
+        __FetchLayer_system_config("${_name}" "${_prefix}" _config)
+        if (_config)
+            __FetchLayer_staging_get("${_name}" FIND_PACKAGE_ARGS _args)
+            cmake_parse_arguments(_find "" "" "NAMES" ${_args})
+            set(_package "${_name}")
+            if (_find_NAMES)
+                list(GET _find_NAMES 0 _package)
+            endif()
+            list(PREPEND CMAKE_PREFIX_PATH "${_prefix}")   # for the package's own dependencies
+            find_package(${_package} CONFIG REQUIRED GLOBAL BYPASS_PROVIDER PATHS "${_prefix}" NO_DEFAULT_PATH)
+        endif()
+
+        __FetchLayer_instance_set("${_name}" "${VARIANT}" INSTALL_COMPONENTS "${_components}")
+    endforeach()
+endfunction()
diff --git a/cmake/FetchLayer/instance.cmake b/cmake/FetchLayer/instance.cmake
new file mode 100644
index 0000000..23ed37c
--- /dev/null
+++ b/cmake/FetchLayer/instance.cmake
@@ -0,0 +1,44 @@
+##
+## The Instance: a variant of a staging made available, one per staging and variant. One global property per
+## field, _FetchLayer_instance_<staging>_<variant>_<FIELD>, the name lower-cased:
+##
+##   ORIGIN              where it came from: system, git                                    find
+##   REF                 the origin's reference: a store path, a sha, a local checkout       find
+##   REVISION            the commit of its layer it is built from                            find
+##   DEPENDS_REVISIONS   the commits it is built against, <staging>=<sha>…                   find
+##   VARIANT             what it is built for, one value per axis (variant.cmake)            find
+##   IDENTITY_MATCH      EXACT: its identity was read or it is built here; VERSION: guessed  find
+##   PREFIX              prebuilt: its install prefix                                        populate
+##   SOURCE_DIR          from source: its sources …                                          populate
+##   BINARY_DIR          … and their build tree                                              populate
+##   INSTALL_COMPONENTS  its install components, <staging>_Runtime / _Development            integration
+##   FETCHED             found and brought, not integrated yet                               MakeAvailable
+##   POPULATED           made available: integrated                                          MakeAvailable
+##
+## FetchLayer_GetProperties copies every field into <staging>_<FIELD>.
+##
+
+include_guard(GLOBAL)
+
+set(_FETCHLAYER_INSTANCE_FIELDS
+    FETCHED POPULATED ORIGIN REF PREFIX SOURCE_DIR BINARY_DIR REVISION DEPENDS_REVISIONS VARIANT IDENTITY_MATCH INSTALL_COMPONENTS)
+
+# __FetchLayer_instance_property(<staging> <variant> <field> <out>)
+#   The name of the global property that holds <field> of the staging <staging> for <variant>
+function(__FetchLayer_instance_property STAGING VARIANT FIELD OUT)
+    string(TOLOWER "${STAGING}" _name)
+    set(${OUT} "_FetchLayer_instance_${_name}_${VARIANT}_${FIELD}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_instance_set(<staging> <variant> <field> <value>)
+function(__FetchLayer_instance_set STAGING VARIANT FIELD VALUE)
+    __FetchLayer_instance_property("${STAGING}" "${VARIANT}" ${FIELD} _property)
+    set_property(GLOBAL PROPERTY "${_property}" "${VALUE}")
+endfunction()
+
+# __FetchLayer_instance_get(<staging> <variant> <field> <out>)
+function(__FetchLayer_instance_get STAGING VARIANT FIELD OUT)
+    __FetchLayer_instance_property("${STAGING}" "${VARIANT}" ${FIELD} _property)
+    get_property(_value GLOBAL PROPERTY "${_property}")
+    set(${OUT} "${_value}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/layer.cmake b/cmake/FetchLayer/layer.cmake
new file mode 100644
index 0000000..5513d06
--- /dev/null
+++ b/cmake/FetchLayer/layer.cmake
@@ -0,0 +1,39 @@
+##
+## The Layer: a repository at a revision, as FetchLayer_Declare was given it — what FetchContent knows. One
+## global property per field, _FetchLayer_layer_<name>_<FIELD>, the name lower-cased:
+##
+##   REVISION   a full sha, a tag or a branch; a tag or a branch is replaced by its commit when one of its
+##              stagings is first looked for (__FetchLayer_git_commit)
+##   ARGUMENTS  the rest, as given — FetchContent's content options; origins parse their own keywords from it
+##              (GIT_REPOSITORY, …)
+##   POST_FETCH_INCLUDES  scripts of its sources to include once fetched, before any layer is integrated
+##   STAGINGS   the stagings it gives, as FetchLayer_DeclareStaging adds them
+##   REQUESTED  those of its stagings FetchLayer_MakeAvailable was asked for
+##   ORIGIN     where this build's own variants of its stagings come from, decided once for the layer:
+##              system, all prebuilt, or git, all from its sources (__FetchLayer_policy_layer_origin)
+##   INCLUDED   its POST_FETCH_INCLUDES included, once (compile.cmake)
+##   COMPILED   its sources added to this build, once (compile.cmake)
+##   COMPONENTS the install components its sources gave
+##
+
+include_guard(GLOBAL)
+
+# __FetchLayer_layer_property(<layer> <field> <out>)
+#   The name of the global property that holds <field> of the layer <layer>
+function(__FetchLayer_layer_property LAYER FIELD OUT)
+    string(TOLOWER "${LAYER}" _name)
+    set(${OUT} "_FetchLayer_layer_${_name}_${FIELD}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_layer_set(<layer> <field> <value>)
+function(__FetchLayer_layer_set LAYER FIELD VALUE)
+    __FetchLayer_layer_property("${LAYER}" ${FIELD} _property)
+    set_property(GLOBAL PROPERTY "${_property}" "${VALUE}")
+endfunction()
+
+# __FetchLayer_layer_get(<layer> <field> <out>)
+function(__FetchLayer_layer_get LAYER FIELD OUT)
+    __FetchLayer_layer_property("${LAYER}" ${FIELD} _property)
+    get_property(_value GLOBAL PROPERTY "${_property}")
+    set(${OUT} "${_value}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/policy.cmake b/cmake/FetchLayer/policy.cmake
new file mode 100644
index 0000000..d0d21b2
--- /dev/null
+++ b/cmake/FetchLayer/policy.cmake
@@ -0,0 +1,86 @@
+##
+## The policy: whether a staging is built from its layer's sources. One setting, as Conan's --build, for all
+## layers and, overriding it, for one:
+##
+##   FETCHLAYER_BUILD          for all layers, MISSING by default
+##   FETCHLAYER_BUILD_<LAYER>  for one layer, the layer's name upper-cased as FetchContent's <uppercaseName>
+##                             (FETCHLAYER_BUILD_OPCUAMODULES)
+##
+##   NEVER    prebuilt stagings only; one missing is an error
+##   MISSING  prebuilt where there is one, else built from sources
+##   ALWAYS   built from sources, prebuilt ones not looked for
+##
+## A layer from a local checkout (FETCHCONTENT_SOURCE_DIR_<LAYER>) is always built from it, as the bundle spec
+## says. A setting is a plain variable, as FetchContent's: set by a preset, -D, cmake -C or the project;
+## __FetchLayer_policy_build reads it for a layer.
+##
+## Not the policy, a fact: only this build's own variant can be built here; another variant — another
+## triplet, another Python — comes prebuilt or not at all.
+##
+
+include_guard(GLOBAL)
+
+set(FETCHLAYER_BUILD "MISSING" CACHE STRING "Whether stagings are built from sources: NEVER, MISSING, ALWAYS")
+set_property(CACHE FETCHLAYER_BUILD PROPERTY STRINGS NEVER MISSING ALWAYS)
+
+# __FetchLayer_policy_build(<layer> <out>)
+#   NEVER, MISSING or ALWAYS for <layer>: ALWAYS for a local checkout, else FETCHLAYER_BUILD_<LAYER>, else
+#   FETCHLAYER_BUILD
+function(__FetchLayer_policy_build LAYER OUT)
+    string(TOUPPER "${LAYER}" _upper)
+    if (FETCHCONTENT_SOURCE_DIR_${_upper})
+        set(_build ALWAYS)
+    elseif (DEFINED FETCHLAYER_BUILD_${_upper})
+        set(_build "${FETCHLAYER_BUILD_${_upper}}")
+    else()
+        set(_build "${FETCHLAYER_BUILD}")
+    endif()
+    set(${OUT} "${_build}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_policy_layer_origin(<layer> <out>)
+#   Where this build's own variants of the layer's stagings come from, decided once for the layer and kept as its
+#   ORIGIN: git when FETCHLAYER_BUILD is ALWAYS (or the layer is a local checkout); system when it is NEVER; when
+#   it is MISSING, system if the store has the own variant of every staging of the layer asked for, else git —
+#   for all of them, as two copies of a layer's targets cannot live in one tree
+function(__FetchLayer_policy_layer_origin LAYER OUT)
+    __FetchLayer_layer_get("${LAYER}" ORIGIN _origin)
+    if (NOT _origin)
+        __FetchLayer_policy_build("${LAYER}" _build)
+        if (_build STREQUAL "ALWAYS")
+            set(_origin git)
+        elseif (_build STREQUAL "NEVER")
+            set(_origin system)
+        else()
+            set(_origin system)
+            __FetchLayer_layer_get("${LAYER}" REQUESTED _requested)
+            foreach(_staging IN LISTS _requested)
+                __FetchLayer_variant_select("${_staging}" "" _variant)
+                __FetchLayer_request("${_staging}" "${_variant}" _request)
+                set(_candidate_REF "")
+                __FetchLayer_system_resolve("${_staging}" "${_variant}" _request _candidate)
+                if (NOT _candidate_REF)
+                    message(STATUS "FetchLayer: ${LAYER} from its sources: no prebuilt ${_staging} for ${_variant}")
+                    set(_origin git)
+                    break()
+                endif()
+            endforeach()
+        endif()
+        __FetchLayer_layer_set("${LAYER}" ORIGIN "${_origin}")
+    endif()
+    set(${OUT} "${_origin}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_policy_lookup(<staging> <variant> <out-origins>)
+#   The origin to ask: for this build's own variant, its layer's (__FetchLayer_policy_layer_origin); for another
+#   variant, system — it cannot be built here
+function(__FetchLayer_policy_lookup STAGING VARIANT OUT)
+    __FetchLayer_variant_native("${VARIANT}" _native)
+    if (_native)
+        __FetchLayer_staging_get("${STAGING}" LAYER _layer)
+        __FetchLayer_policy_layer_origin("${_layer}" _origin)
+    else()
+        set(_origin system)
+    endif()
+    set(${OUT} "${_origin}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/staging.cmake b/cmake/FetchLayer/staging.cmake
new file mode 100644
index 0000000..249f5d1
--- /dev/null
+++ b/cmake/FetchLayer/staging.cmake
@@ -0,0 +1,32 @@
+##
+## The Staging: what a layer gives as one whole — declared, made available and published with one identity;
+## its builds are its Instances. One global property per field, _FetchLayer_staging_<name>_<FIELD>, the name
+## lower-cased:
+##
+##   LAYER              the layer that gives it, its revision and its sources
+##   AXES               what it has variants by: triplet by default, none when declared empty (axis.cmake)
+##   DEPENDS            the stagings it is built against
+##   FIND_PACKAGE_ARGS  how to find it as a package
+##
+
+include_guard(GLOBAL)
+
+# __FetchLayer_staging_property(<staging> <field> <out>)
+#   The name of the global property that holds <field> of the staging <staging>
+function(__FetchLayer_staging_property STAGING FIELD OUT)
+    string(TOLOWER "${STAGING}" _name)
+    set(${OUT} "_FetchLayer_staging_${_name}_${FIELD}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_staging_set(<staging> <field> <value>)
+function(__FetchLayer_staging_set STAGING FIELD VALUE)
+    __FetchLayer_staging_property("${STAGING}" ${FIELD} _property)
+    set_property(GLOBAL PROPERTY "${_property}" "${VALUE}")
+endfunction()
+
+# __FetchLayer_staging_get(<staging> <field> <out>)
+function(__FetchLayer_staging_get STAGING FIELD OUT)
+    __FetchLayer_staging_property("${STAGING}" ${FIELD} _property)
+    get_property(_value GLOBAL PROPERTY "${_property}")
+    set(${OUT} "${_value}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/FetchLayer/system.cmake b/cmake/FetchLayer/system.cmake
new file mode 100644
index 0000000..eba1d6d
--- /dev/null
+++ b/cmake/FetchLayer/system.cmake
@@ -0,0 +1,81 @@
+##
+## The origin system: a staging already on the disk.
+##
+## resolve looks first in the store, <FETCHLAYER_STORE>/<staging>/idx-<hash>/<variant>, by the hash of the identity
+## requested (its revision a full sha: find turns a tag or a branch into one first). A directory there is the
+## variant requested by construction — its path is its identity — so the identity is exact; and it is complete,
+## renamed into place once unpacked. Else FETCHLAYER_PREFIX_<NAME>, a directory named by hand for the staging (its
+## name upper-cased): taken for what was asked, as asked for, its identity a version.
+## Whatever the prefix holds is taken: Runtime always, Development when the staging's CMake config is there.
+## populate brings nothing: the prefix is where it was found.
+##
+
+include_guard(GLOBAL)
+
+# __FetchLayer_system_config(<staging> <prefix> <out>)
+#   The staging's CMake config in <prefix>, by the package name FIND_PACKAGE_ARGS gives (NAMES …), else the staging's
+function(__FetchLayer_system_config STAGING PREFIX OUT)
+    __FetchLayer_staging_get("${STAGING}" FIND_PACKAGE_ARGS _args)
+    cmake_parse_arguments(_F "" "" "NAMES" ${_args})
+    set(_pkgs ${_F_NAMES})
+    if (NOT _pkgs)
+        set(_pkgs "${STAGING}")
+    endif()
+    set(_found "")
+    foreach(_p IN LISTS _pkgs)
+        string(TOLOWER "${_p}" _lp)
+        foreach(_dir lib/cmake/${_p} lib/cmake/${_lp} lib/${_p}/cmake share/cmake/${_p} CMake cmake)
+            foreach(_f ${_p}Config.cmake ${_lp}-config.cmake)
+                if (EXISTS "${PREFIX}/${_dir}/${_f}")
+                    set(_found "${PREFIX}/${_dir}/${_f}")
+                    break()
+                endif()
+            endforeach()
+            if (_found)
+                break()
+            endif()
+        endforeach()
+        if (_found)
+            break()
+        endif()
+    endforeach()
+    set(${OUT} "${_found}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_system_resolve(<staging> <variant> <request> <candidate>)
+function(__FetchLayer_system_resolve STAGING VARIANT REQUEST CANDIDATE)
+    string(TOUPPER "${STAGING}" _upper)
+    set(_prefix "")
+    set(_match VERSION)
+
+    # the store, by the hash of the identity requested: exact
+    if (FETCHLAYER_STORE)
+        __FetchLayer_identity_path(${REQUEST} _path)
+        if (IS_DIRECTORY "${_path}")
+            set(_prefix "${_path}")
+            set(_match EXACT)
+        endif()
+    endif()
+
+    # else a prefix named by hand for the staging: taken for what was asked, as a version
+    if (NOT _prefix AND FETCHLAYER_PREFIX_${_upper})
+        set(_prefix "${FETCHLAYER_PREFIX_${_upper}}")
+    endif()
+
+    if (NOT _prefix OR NOT IS_DIRECTORY "${_prefix}")
+        return()
+    endif()
+    set(${CANDIDATE}_ORIGIN system PARENT_SCOPE)
+    set(${CANDIDATE}_REF "${_prefix}" PARENT_SCOPE)
+    set(${CANDIDATE}_REVISION "${${REQUEST}_REVISION}" PARENT_SCOPE)
+    set(${CANDIDATE}_DEPENDS_REVISIONS "${${REQUEST}_DEPENDS_REVISIONS}" PARENT_SCOPE)
+    set(${CANDIDATE}_VARIANT "${VARIANT}" PARENT_SCOPE)
+    set(${CANDIDATE}_IDENTITY_MATCH ${_match} PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_system_populate(<staging> <variant>)
+#   The Instance's REF is its prefix already
+function(__FetchLayer_system_populate STAGING VARIANT)
+    __FetchLayer_instance_get("${STAGING}" "${VARIANT}" REF _ref)
+    __FetchLayer_instance_set("${STAGING}" "${VARIANT}" PREFIX "${_ref}")
+endfunction()
diff --git a/cmake/FetchLayer/variant.cmake b/cmake/FetchLayer/variant.cmake
new file mode 100644
index 0000000..52c77d0
--- /dev/null
+++ b/cmake/FetchLayer/variant.cmake
@@ -0,0 +1,147 @@
+##
+## Variants: a variant of a staging is one value of each of its axes — what it is built for, as against what it
+## is built from. Its identity, pkg-, is the staging's at a revision, idx- (what it is built from), together with
+## these values.
+##
+## A variant is written as one string: the triplet, then +<axis>=<value> for each other axis by name —
+## x86_64-macos-apple-clang-21-release+python=3.12; without a triplet the pairs alone, python=3.12; without any
+## axis, any. The same values give the same string, whatever their order. It names the Instance and the
+## variant's directory under idx- in the store.
+##
+
+include_guard(GLOBAL)
+include("${CMAKE_CURRENT_LIST_DIR}/axis.cmake")    # what an axis is named
+
+# __FetchLayer_variant_format(<out> <axis>=<value>…)
+#   The variant with these values, written as one string; a pair not <axis>=<value>, or an axis given twice, is
+#   an error
+function(__FetchLayer_variant_format OUT)
+    set(_triplet "")
+    set(_pairs)
+    set(_seen)
+    foreach(_pair IN LISTS ARGN)
+        if (NOT _pair MATCHES "^(${_FETCHLAYER_AXIS_NAME})=.+$")
+            message(FATAL_ERROR "FetchLayer: not an <axis>=<value> pair: ${_pair}")
+        endif()
+        set(_axis "${CMAKE_MATCH_1}")
+        if (_axis IN_LIST _seen)
+            message(FATAL_ERROR "FetchLayer: the axis ${_axis} is given twice: ${ARGN}")
+        endif()
+        list(APPEND _seen "${_axis}")
+        if (_pair MATCHES "^triplet=(.+)$")
+            set(_triplet "${CMAKE_MATCH_1}")
+        else()
+            list(APPEND _pairs "${_pair}")
+        endif()
+    endforeach()
+    list(SORT _pairs)
+    set(_variant "${_triplet}")
+    foreach(_pair IN LISTS _pairs)
+        if (_variant)
+            string(APPEND _variant "+")
+        endif()
+        string(APPEND _variant "${_pair}")
+    endforeach()
+    if (NOT _variant)
+        set(_variant "any")
+    endif()
+    set(${OUT} "${_variant}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_variant_parse(<variant> <out>)
+#   The <axis>=<value> pairs of the variant <variant>: the string variant_format wrote, taken apart
+function(__FetchLayer_variant_parse VARIANT OUT)
+    set(_pairs)
+    if (NOT VARIANT STREQUAL "any")
+        string(REPLACE "+" ";" _parts "${VARIANT}")
+        foreach(_part IN LISTS _parts)
+            if (_part MATCHES "=")
+                list(APPEND _pairs "${_part}")
+            else()
+                list(APPEND _pairs "triplet=${_part}")
+            endif()
+        endforeach()
+    endif()
+    set(${OUT} "${_pairs}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_variant_extract(<variant> <axis> <out>)
+#   The value of <axis> in the variant <variant>, empty when it has none
+function(__FetchLayer_variant_extract VARIANT AXIS OUT)
+    __FetchLayer_variant_parse("${VARIANT}" _pairs)
+    set(_value "")
+    foreach(_pair IN LISTS _pairs)
+        if (_pair MATCHES "^${AXIS}=(.*)$")
+            set(_value "${CMAKE_MATCH_1}")
+        endif()
+    endforeach()
+    set(${OUT} "${_value}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_variant_select(<staging> <variant> <out>)
+#   The variant of <staging> that goes with <variant>: its own axes' values in it, the others dropped — a
+#   dependency's variant. An axis of <staging> that <variant> lacks takes its native value
+function(__FetchLayer_variant_select STAGING VARIANT OUT)
+    __FetchLayer_staging_get("${STAGING}" AXES _axes)
+    set(_pairs)
+    foreach(_axis IN LISTS _axes)
+        __FetchLayer_variant_extract("${VARIANT}" "${_axis}" _value)
+        if (NOT _value)
+            __FetchLayer_axis_get("${_axis}" NATIVE _value)
+        endif()
+        list(APPEND _pairs "${_axis}=${_value}")
+    endforeach()
+    __FetchLayer_variant_format(_variant ${_pairs})
+    set(${OUT} "${_variant}" PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_variant_native(<variant> <out>)
+#   TRUE when every axis of <variant> has its native value
+function(__FetchLayer_variant_native VARIANT OUT)
+    __FetchLayer_variant_parse("${VARIANT}" _pairs)
+    set(_native TRUE)
+    foreach(_pair IN LISTS _pairs)
+        string(REGEX MATCH "^([^=]+)=(.*)$" _ "${_pair}")
+        set(_axis "${CMAKE_MATCH_1}")
+        set(_given "${CMAKE_MATCH_2}")
+        __FetchLayer_axis_get("${_axis}" NATIVE _value)
+        if (NOT _given STREQUAL _value)
+            set(_native FALSE)
+        endif()
+    endforeach()
+    set(${OUT} ${_native} PARENT_SCOPE)
+endfunction()
+
+# __FetchLayer_variant_list(<staging> <out>)
+#   Every variant of <staging> to make available: each combination of its axes' VALUES
+function(__FetchLayer_variant_list STAGING OUT)
+    __FetchLayer_staging_get("${STAGING}" AXES _axes)
+    set(_combinations "")          # each a list of pairs, joined by + for now
+    set(_first TRUE)
+    foreach(_axis IN LISTS _axes)
+        __FetchLayer_axis_get("${_axis}" VALUES _values)
+        set(_next)
+        foreach(_value IN LISTS _values)
+            if (_first)
+                list(APPEND _next "${_axis}=${_value}")
+            else()
+                foreach(_combination IN LISTS _combinations)
+                    list(APPEND _next "${_combination}+${_axis}=${_value}")
+                endforeach()
+            endif()
+        endforeach()
+        set(_combinations ${_next})
+        set(_first FALSE)
+    endforeach()
+    set(_variants)
+    if (_first)
+        set(_variants any)
+    else()
+        foreach(_combination IN LISTS _combinations)
+            string(REPLACE "+" ";" _pairs "${_combination}")
+            __FetchLayer_variant_format(_variant ${_pairs})
+            list(APPEND _variants "${_variant}")
+        endforeach()
+    endif()
+    set(${OUT} "${_variants}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/Layers.cmake b/cmake/Layers.cmake
new file mode 100644
index 0000000..a965870
--- /dev/null
+++ b/cmake/Layers.cmake
@@ -0,0 +1,155 @@
+##
+## What the bundle is made of: the axes its stagings have variants by; one FetchLayer_Declare per layer — a
+## repository, named as in the manifest — its stagings under it, and its settings — they matter only when the
+## layer compiles here.
+##
+## The revisions, one per layer — a full sha, a tag or a branch — from bundle.json, the layer named as the repository;
+## BUNDLE_REVISION_<LAYER>, the name upper-cased, in place of one (a preset or -D). From the cache: each axis's
+## values, BUNDLE_AXIS_<AXIS>, and its own value where it can be given, BUNDLE_<AXIS>.
+##
+
+include_guard(GLOBAL)
+
+
+# === the axes ================================================================================================
+
+# triplet: this build's own, as the utils compose it; the ones made available, this build's own alone by default
+set(BUNDLE_TRIPLET "" CACHE STRING "The triplet this build is for; empty: the one the utils compose")
+set(BUNDLE_AXIS_TRIPLET "" CACHE STRING "The triplets to make available; empty: this build's own alone")
+set(_triplet "${BUNDLE_TRIPLET}")
+if (NOT _triplet)
+    opendaq_compose_package_triplet(OUTPUT_VARIABLE _triplet)
+endif()
+FetchLayer_DeclareAxis(
+    triplet
+    NATIVE "${_triplet}"
+    VALUES ${BUNDLE_AXIS_TRIPLET}
+)
+
+
+# === the layers ==============================================================================================
+
+# a layer's revision: BUNDLE_REVISION_<LAYER> when given, else bundle.json's — read at every configure, so an edit
+# of it is taken without clearing the cache
+set(_bundle_json "${CMAKE_CURRENT_LIST_DIR}/../bundle.json")
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${_bundle_json}")
+file(READ "${_bundle_json}" _bundle)
+foreach(_layer openDAQ OpcUaModules MQTTStreamingModule LTStreamingModulesModern ASAM-CMP-Modules)
+    string(TOUPPER "${_layer}" _upper)
+    set(BUNDLE_REVISION_${_upper} "" CACHE STRING "The revision of ${_layer}: a full sha, a tag or a branch; empty: bundle.json's")
+    if (NOT BUNDLE_REVISION_${_upper})
+        string(JSON BUNDLE_REVISION_${_upper} ERROR_VARIABLE _error GET "${_bundle}" "${_layer}")
+        if (_error)
+            message(FATAL_ERROR "bundle.json names no revision of ${_layer}: ${_error}")
+        endif()
+    endif()
+endforeach()
+
+
+# === the core ================================================================================================
+
+FetchLayer_Declare(
+    openDAQ
+    REVISION            "${BUNDLE_REVISION_OPENDAQ}"
+    GIT_REPOSITORY      https://github.com/openDAQ/openDAQ.git
+    POST_FETCH_INCLUDES <SOURCE_DIR>/external/boost/Boost.cmake
+)
+FetchLayer_DeclareStaging(
+    opendaq
+    LAYER             openDAQ
+    FIND_PACKAGE_ARGS NAMES openDAQ
+)
+
+set(OPENDAQ_ENABLE_OPCUA OFF CACHE BOOL "")
+set(OPENDAQ_GENERATE_DELPHI_BINDINGS OFF CACHE BOOL "")
+set(OPENDAQ_GENERATE_PYTHON_BINDINGS ON CACHE BOOL "")
+set(OPENDAQ_GENERATE_CSHARP_BINDINGS ON CACHE BOOL "")
+set(OPENDAQ_GENERATE_C_BINDINGS ON CACHE BOOL "")
+set(OPENDAQ_ENABLE_NATIVE_STREAMING ON CACHE BOOL "")
+set(OPENDAQ_ENABLE_WEBSOCKET_STREAMING OFF CACHE BOOL "")
+set(OPENDAQ_ENABLE_TESTS ${BUNDLE_ENABLE_TESTS} CACHE BOOL "")
+set(OPENDAQ_DOCUMENTATION_TESTS OFF CACHE BOOL "")
+set(APP_ENABLE_WEBPAGE_EXAMPLES OFF CACHE BOOL "")
+# the core's own modules, as main had them; built only when the core comes from sources — its staging has none,
+# they are to be a staging of their own (opendaq-modules)
+set(DAQMODULES_EMPTY_MODULE ON CACHE BOOL "")
+set(DAQMODULES_OPENDAQ_CLIENT_MODULE ON CACHE BOOL "")
+set(DAQMODULES_OPENDAQ_SERVER_MODULE ON CACHE BOOL "")
+set(DAQMODULES_REF_DEVICE_MODULE ON CACHE BOOL "")
+set(DAQMODULES_SIMULATOR_DEVICE_MODULE ON CACHE BOOL "")
+set(DAQMODULES_REF_FB_MODULE ON CACHE BOOL "")
+set(DAQMODULES_AUDIO_DEVICE_MODULE ON CACHE BOOL "")
+set(DAQMODULES_BASIC_CSV_RECORDER_MODULE ON CACHE BOOL "")
+set(DAQMODULES_LICENSING_MODULE ON CACHE BOOL "")
+set(DAQMODULES_PARQUET_RECORDER_MODULE OFF CACHE BOOL "")
+
+
+# === the modules =============================================================================================
+
+FetchLayer_Declare(
+    OpcUaModules
+    REVISION            "${BUNDLE_REVISION_OPCUAMODULES}"
+    GIT_REPOSITORY      https://github.com/openDAQ/OpcUaModules.git
+    POST_FETCH_INCLUDES <SOURCE_DIR>/external/boost/Boost.cmake
+)
+FetchLayer_DeclareStaging(
+    opcua-modules
+    LAYER   OpcUaModules
+    DEPENDS opendaq
+)
+
+set(DAQMODULES_OPCUA_ENABLE_TESTS ${BUNDLE_ENABLE_TESTS} CACHE BOOL "")
+set(DAQMODULES_OPCUA_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
+set(DAQMODULES_OPCUA_ENABLE_CLIENT ON CACHE BOOL "")
+set(DAQMODULES_OPCUA_ENABLE_SERVER ON CACHE BOOL "")
+set(DAQMODULES_OPCUA_ENABLE_GENERIC_CLIENT ON CACHE BOOL "")
+
+FetchLayer_Declare(
+    MQTTStreamingModule
+    REVISION            "${BUNDLE_REVISION_MQTTSTREAMINGMODULE}"
+    GIT_REPOSITORY      https://github.com/openDAQ/MQTTStreamingModule.git
+    POST_FETCH_INCLUDES <SOURCE_DIR>/external/boost/Boost.cmake
+)
+FetchLayer_DeclareStaging(
+    mqtt-module
+    LAYER   MQTTStreamingModule
+    DEPENDS opendaq
+)
+
+set(DAQMODULES_MQTT_ENABLE_TESTS ${BUNDLE_ENABLE_TESTS} CACHE BOOL "")
+set(DAQMODULES_MQTT_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
+set(DAQMODULES_MQTT_ENABLE_SSL OFF CACHE BOOL "")
+
+FetchLayer_Declare(
+    LTStreamingModulesModern
+    REVISION            "${BUNDLE_REVISION_LTSTREAMINGMODULESMODERN}"
+    GIT_REPOSITORY      https://github.com/openDAQ/LTStreamingModulesModern.git
+    POST_FETCH_INCLUDES <SOURCE_DIR>/external/boost/Boost.cmake
+)
+FetchLayer_DeclareStaging(
+    lt-streaming-modules
+    LAYER   LTStreamingModulesModern
+    DEPENDS opendaq
+)
+
+set(DAQMODULES_LT_STREAMING_ENABLE_TESTS ${BUNDLE_ENABLE_TESTS} CACHE BOOL "")
+set(DAQMODULES_LT_STREAMING_ENABLE_EXAMPLE_APP OFF CACHE BOOL "")
+set(DAQMODULES_LT_STREAMING_ENABLE_CLIENT ON CACHE BOOL "")
+set(DAQMODULES_LT_STREAMING_ENABLE_SERVER ON CACHE BOOL "")
+
+FetchLayer_Declare(
+    ASAM-CMP-Modules
+    REVISION            "${BUNDLE_REVISION_ASAM-CMP-MODULES}"
+    GIT_REPOSITORY      https://github.com/openDAQ/ASAM-CMP-Modules.git
+    POST_FETCH_INCLUDES <SOURCE_DIR>/external/boost/Boost.cmake
+)
+FetchLayer_DeclareStaging(
+    asam-cmp-modules
+    LAYER   ASAM-CMP-Modules
+    DEPENDS opendaq
+)
+
+set(ASAM_CMP_ENABLE_TESTS ${BUNDLE_ENABLE_TESTS} CACHE BOOL "")
+set(ASAM_CMP_ENABLE_EXAMPLE OFF CACHE BOOL "")
+set(ASAM_CMP_BUILD_DATA_SINK ON CACHE BOOL "")
+set(ASAM_CMP_BUILD_CAPTURE_MODULE ON CACHE BOOL "")
diff --git a/cmake/Packing.cmake b/cmake/Packing.cmake
new file mode 100644
index 0000000..0fd3ad5
--- /dev/null
+++ b/cmake/Packing.cmake
@@ -0,0 +1,184 @@
+##
+## The bundle's targets as packages. A package preset picks what goes in — stagings × components — and the
+## generator and the name; see CPackOptions.cmake. The utils name the package <name>-<version>-<triplet>,
+## as the core's and the modules', and write staging-meta.json next to it.
+##
+##   cpack --preset core       opendaq × Runtime, Development
+##   cpack --preset modules    the four module stagings × Runtime
+##
+
+include_guard(GLOBAL)
+
+set(BUNDLE_VERSION "${PROJECT_VERSION}" CACHE STRING "Version of the bundle, the version of its packages")
+
+# each staging's install components, of this build's own variant, by what they are for: Runtime when the name
+# says so, Development else — prebuilt, <staging>_Runtime/_Development; from sources, the names the layer gave
+# (openDAQ_opcua_client_module_Runtime, External); for CPackOptions.cmake to pick from at cpack time
+foreach(_staging IN LISTS BUNDLE_STAGINGS)
+    FetchLayer_GetProperties(${_staging})
+    string(TOLOWER "${_staging}" _name)
+    string(MAKE_C_IDENTIFIER "${_name}" _c)
+    set(CPACK_BUNDLE_${_c}_Runtime)
+    set(CPACK_BUNDLE_${_c}_Development)
+    foreach(_component IN LISTS ${_name}_INSTALL_COMPONENTS)
+        if (_component MATCHES "_Runtime$")
+            list(APPEND CPACK_BUNDLE_${_c}_Runtime ${_component})
+        else()
+            list(APPEND CPACK_BUNDLE_${_c}_Development ${_component})
+        endif()
+    endforeach()
+endforeach()
+
+# the name, the version and the triplet, by the utils; a package preset renames it
+set(CPACK_OPENDAQ_META_PACKAGE_NAME "opendaq-bundle")
+set(CPACK_OPENDAQ_META_PACKAGE_VERSION "${BUNDLE_VERSION}")
+opendaq_detect_settings()
+opendaq_detect_package()
+__FetchLayer_axis_get(triplet NATIVE _triplet)                 # this build's own, BUNDLE_TRIPLET when given
+opendaq_compose_package_triplet()
+set(CPACK_OPENDAQ_META_PACKAGE_TRIPLET "${_triplet}")
+opendaq_compose_package_file_name()
+
+set(CPACK_PACKAGE_NAME "${CPACK_OPENDAQ_META_PACKAGE_NAME}")
+set(CPACK_PACKAGE_VENDOR "openDAQ d.o.o.")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "openDAQ SDK with its modules")
+set(CPACK_PACKAGE_HOMEPAGE_URL "https://opendaq.io/")
+set(CPACK_PACKAGE_CONTACT "info@opendaq.io")
+set(CPACK_PACKAGE_VERSION "${BUNDLE_VERSION}")
+set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}/packages")
+# a macOS package's receipts, io.opendaq.bundle.<component>; by default from the vendor, with its spaces and dots
+set(CPACK_PRODUCTBUILD_IDENTIFIER "io.opendaq.bundle")
+
+set(CPACK_GENERATOR TGZ)
+set(CPACK_VERBATIM_VARIABLES ON)
+set(CPACK_THREADS 0)
+
+# the components picked go into one package
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
+
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_VENDOR} <${CPACK_PACKAGE_CONTACT}>")
+set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS_PRIVATE_DIRS "opt/opendaq/lib")
+
+# NSIS: the core's installer as it is (its images, the PATH page, the old version removed first), under a name and a
+# registry key of the bundle's own, so it neither replaces nor uninstalls the core's
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "openDAQ")
+set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "openDAQ bundle")
+set(CPACK_NSIS_PACKAGE_NAME "openDAQ bundle")
+set(CPACK_NSIS_DISPLAY_NAME "openDAQ bundle ${BUNDLE_VERSION}")
+set(CPACK_NSIS_WELCOME_TITLE "Welcome to openDAQ Setup")
+set(CPACK_NSIS_BRANDING_TEXT "${CPACK_PACKAGE_VENDOR}")
+set(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/packaging/nsis/opendaq.ico")
+set(CPACK_NSIS_MUI_UNIICON "${PROJECT_SOURCE_DIR}/packaging/nsis/opendaq.ico")
+file(TO_NATIVE_PATH "${PROJECT_SOURCE_DIR}/packaging/nsis/nsis_header.bmp" CPACK_NSIS_MUI_HEADERIMAGE)        # NSIS wants \
+file(TO_NATIVE_PATH "${PROJECT_SOURCE_DIR}/packaging/nsis/nsis_welcome.bmp" CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP)
+set(CPACK_NSIS_MANIFEST_DPI_AWARE ON)
+set(CPACK_NSIS_MODIFY_PATH ON)
+set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL ON)
+
+# A silent install (/S) shows no page, so it never adds to PATH; /PATH=AllUsers|CurrentUser|No chooses it on the
+# command line, as the page would, and records it for the uninstaller:
+#   opendaq-bundle-<version>-<triplet>.exe /S /PATH=AllUsers /D=C:\openDAQ        (/D last, unquoted)
+# (CPack sets CPACK_NSIS_DEFINES itself, so no FileFunc.nsh: the option is looked for in $CMDLINE by hand)
+#
+# PATH is then written by the EnVar plugin (packaging/nsis/EnVar, zlib licence), not by the template: the template
+# reads PATH into an NSIS string, 1024 characters, finds it empty when PATH is longer, and shows a message box,
+# which a silent install waits on forever (a CI runner's PATH is longer). $DO_NOT_ADD_TO_PATH is set to 1 in the
+# installer once the registry holds the choice, so the template's AddToPath is skipped; its RemoveFromPath at
+# uninstall then finds nothing left to remove.
+file(TO_NATIVE_PATH "${PROJECT_SOURCE_DIR}/packaging/nsis/EnVar" _envar)
+string(CONFIGURE [=[
+  !addplugindir /x86-ansi "@_envar@\x86-ansi"
+  !addplugindir /x86-unicode "@_envar@\x86-unicode"
+  StrCpy $R1 ""
+  StrCpy $R2 0
+  bundle_path_scan:
+    StrCpy $R3 $CMDLINE 14 $R2
+    StrCmp $R3 "/PATH=AllUsers" 0 +3
+      StrCpy $R1 "AllUsers"
+      Goto bundle_path_found
+    StrCpy $R3 $CMDLINE 17 $R2
+    StrCmp $R3 "/PATH=CurrentUser" 0 +3
+      StrCpy $R1 "CurrentUser"
+      Goto bundle_path_found
+    StrCpy $R3 $CMDLINE 8 $R2
+    StrCmp $R3 "/PATH=No" 0 +3
+      StrCpy $R1 "No"
+      Goto bundle_path_found
+    IntOp $R2 $R2 + 1
+    StrCpy $R3 $CMDLINE 1 $R2
+    StrCmp $R3 "" bundle_path_done bundle_path_scan
+  bundle_path_found:
+    StrCpy $DO_NOT_ADD_TO_PATH 1
+    StrCpy $ADD_TO_PATH_ALL_USERS 0
+    StrCpy $ADD_TO_PATH_CURRENT_USER 0
+    StrCmp $R1 "AllUsers" 0 +3
+      StrCpy $DO_NOT_ADD_TO_PATH 0
+      StrCpy $ADD_TO_PATH_ALL_USERS 1
+    StrCmp $R1 "CurrentUser" 0 +3
+      StrCpy $DO_NOT_ADD_TO_PATH 0
+      StrCpy $ADD_TO_PATH_CURRENT_USER 1
+    Push "DoNotAddToPath"
+    Push "$DO_NOT_ADD_TO_PATH"
+    Call ConditionalAddToRegistry
+    Push "AddToPathAllUsers"
+    Push "$ADD_TO_PATH_ALL_USERS"
+    Call ConditionalAddToRegistry
+    Push "AddToPathCurrentUser"
+    Push "$ADD_TO_PATH_CURRENT_USER"
+    Call ConditionalAddToRegistry
+  bundle_path_done:
+  StrCmp $DO_NOT_ADD_TO_PATH "1" bundle_path_added
+    StrCmp $ADD_TO_PATH_ALL_USERS "1" 0 bundle_path_add
+      EnVar::SetHKLM
+    bundle_path_add:
+    EnVar::AddValue "Path" "$INSTDIR\bin"
+    Pop $R0
+    StrCmp $R0 "0" bundle_path_template
+      DetailPrint "$INSTDIR\bin not added to PATH: EnVar error $R0"
+    bundle_path_template:
+    StrCpy $DO_NOT_ADD_TO_PATH 1
+  bundle_path_added:
+]=] CPACK_NSIS_EXTRA_INSTALL_COMMANDS @ONLY)
+set(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS [=[
+  StrCmp $DO_NOT_ADD_TO_PATH "1" bundle_path_removed
+    StrCmp $ADD_TO_PATH_ALL_USERS "1" 0 bundle_path_remove
+      EnVar::SetHKLM
+    bundle_path_remove:
+    EnVar::DeleteValue "Path" "$INSTDIR\bin"
+    Pop $R0
+  bundle_path_removed:
+]=])
+
+# the layers and components, the name and the install prefix, at cpack time
+set(CPACK_PROJECT_CONFIG_FILE "${CMAKE_CURRENT_LIST_DIR}/CPackOptions.cmake")
+
+include(CPack)
+
+# macOS has no uninstall: the package brings a script that removes its files by its receipts, a component of the
+# bundle's own, which CPackOptions.cmake adds to a productbuild package
+if (APPLE)
+    install(PROGRAMS "${PROJECT_SOURCE_DIR}/packaging/productbuild/uninstall-opendaq-bundle.sh" DESTINATION bin COMPONENT bundle_Runtime)
+    cpack_add_component(bundle_Runtime DISPLAY_NAME "uninstall script" REQUIRED)
+endif()
+
+# an installer's choices (NSIS, productbuild): each module a choice of its own in the group Modules, selected;
+# the rest required. A prebuilt staging has <staging>_Runtime, <staging>_Development and a <module>_Runtime per
+# module (FetchLayer/import.cmake); a layer built here has no choices of its own, all its components required
+cpack_add_component_group(modules DISPLAY_NAME "Modules" DESCRIPTION "openDAQ modules" EXPANDED)
+foreach(_staging IN LISTS BUNDLE_STAGINGS)
+    string(TOLOWER "${_staging}" _name)
+    string(MAKE_C_IDENTIFIER "${_name}" _c)
+    foreach(_component IN LISTS ${_name}_INSTALL_COMPONENTS)
+        if (${_name}_PREFIX AND _component MATCHES "^(.+)_Runtime$" AND NOT _component STREQUAL "${_c}_Runtime")
+            cpack_add_component(${_component} DISPLAY_NAME "${CMAKE_MATCH_1}" GROUP modules)
+        elseif (_component MATCHES "_Runtime$")
+            cpack_add_component(${_component} DISPLAY_NAME "${_name} runtime" REQUIRED)
+        else()
+            cpack_add_component(${_component} DISPLAY_NAME "${_name} development" REQUIRED)
+        endif()
+    endforeach()
+endforeach()
diff --git a/packaging/nsis/EnVar/license.txt b/packaging/nsis/EnVar/license.txt
new file mode 100644
index 0000000..3225934
--- /dev/null
+++ b/packaging/nsis/EnVar/license.txt
@@ -0,0 +1,18 @@
+EnVar plugin for NSIS
+
+Coded by Jason Ross aka JasonFriday13 on the forums.
+
+Copyright (C) 2014-2016, 2018, 2020-2021, 2026 MouseHelmet Software
+
+
+EULA - End User License Agreement
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the author be held liable for any damages arising from the use of this software. 
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
\ No newline at end of file
diff --git a/packaging/nsis/EnVar/x86-ansi/EnVar.dll b/packaging/nsis/EnVar/x86-ansi/EnVar.dll
new file mode 100644
index 0000000..10d2e67
Binary files /dev/null and b/packaging/nsis/EnVar/x86-ansi/EnVar.dll differ
diff --git a/packaging/nsis/EnVar/x86-unicode/EnVar.dll b/packaging/nsis/EnVar/x86-unicode/EnVar.dll
new file mode 100644
index 0000000..7b4b146
Binary files /dev/null and b/packaging/nsis/EnVar/x86-unicode/EnVar.dll differ
diff --git a/packaging/nsis/nsis_header.bmp b/packaging/nsis/nsis_header.bmp
new file mode 100644
index 0000000..e1ef408
Binary files /dev/null and b/packaging/nsis/nsis_header.bmp differ
diff --git a/packaging/nsis/nsis_welcome.bmp b/packaging/nsis/nsis_welcome.bmp
new file mode 100644
index 0000000..1fd8327
Binary files /dev/null and b/packaging/nsis/nsis_welcome.bmp differ
diff --git a/packaging/nsis/opendaq.ico b/packaging/nsis/opendaq.ico
new file mode 100644
index 0000000..6723681
Binary files /dev/null and b/packaging/nsis/opendaq.ico differ
diff --git a/packaging/productbuild/uninstall-opendaq-bundle.sh b/packaging/productbuild/uninstall-opendaq-bundle.sh
new file mode 100755
index 0000000..b25721f
--- /dev/null
+++ b/packaging/productbuild/uninstall-opendaq-bundle.sh
@@ -0,0 +1,28 @@
+#!/bin/sh
+# Removes what the openDAQ bundle's macOS package installed, and the package's receipts: macOS has no uninstall
+# of its own. Only the bundle's files go, by the receipts, so a core installed beside it stays.
+#
+#   sudo /opt/opendaq/bin/uninstall-opendaq-bundle.sh
+
+if [ "$(id -u)" -ne 0 ]; then
+    echo "run it as root: sudo $0" >&2
+    exit 1
+fi
+
+ids=$(pkgutil --pkgs='io\.opendaq\.bundle\..*')
+if [ -z "$ids" ]; then
+    echo "the openDAQ bundle is not installed"
+    exit 0
+fi
+
+for id in $ids; do
+    pkgutil --only-files --files "$id" | while IFS= read -r f; do
+        rm -f "/$f"
+    done
+    pkgutil --forget "$id" >/dev/null
+    echo "removed $id"
+done
+
+# the directories the files leave empty
+find /opt/opendaq -depth -type d -empty -delete 2>/dev/null
+exit 0
diff --git a/tests/axis.cmake b/tests/axis.cmake
new file mode 100644
index 0000000..337d8b0
--- /dev/null
+++ b/tests/axis.cmake
@@ -0,0 +1,77 @@
+# Axes and variants, without a store:  cmake -P tests/axis.cmake
+cmake_minimum_required(VERSION 3.25)
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/FetchLayer.cmake")
+
+set(_failed FALSE)
+function(expect WHAT GOT WANT)
+    if (GOT STREQUAL WANT)
+        message(STATUS "ok    ${WHAT}: ${GOT}")
+    else()
+        message(SEND_ERROR "FAIL  ${WHAT}: ${GOT}, not ${WANT}")
+    endif()
+endfunction()
+
+set(A x86_64-macos-apple-clang-21-release)
+set(B x86_64-linux-gcc-11-release)
+
+# triplet, declared from FETCHLAYER_TRIPLET when nothing declared it
+set(FETCHLAYER_TRIPLET ${A})
+__FetchLayer_axis_get(triplet NATIVE _native)
+expect("triplet from FETCHLAYER_TRIPLET" "${_native}" "${A}")
+FetchLayer_DeclareAxis(triplet NATIVE ${B})                       # ignored: first wins
+__FetchLayer_axis_get(triplet NATIVE _native)
+expect("first declaration wins" "${_native}" "${A}")
+
+FetchLayer_DeclareAxis(python NATIVE 3.12 VALUES 3.11 3.12)
+__FetchLayer_axis_get(python VALUES _values)
+expect("values" "${_values}" "3.11;3.12")
+
+# variants: the triplet first, then the others by name; values back
+__FetchLayer_variant_format(_variant python=3.12 triplet=${A})
+expect("variant, triplet and python" "${_variant}" "${A}+python=3.12")
+__FetchLayer_variant_format(_variant triplet=${A})
+expect("variant, triplet alone: the triplet" "${_variant}" "${A}")
+__FetchLayer_variant_format(_variant python=3.12)
+expect("variant, no triplet" "${_variant}" "python=3.12")
+__FetchLayer_variant_format(_variant)
+expect("variant, no axis" "${_variant}" "any")
+__FetchLayer_variant_parse("${A}+python=3.12" _pairs)
+expect("values of a variant" "${_pairs}" "triplet=${A};python=3.12")
+__FetchLayer_variant_extract("${A}+python=3.12" python _python)
+expect("value of an axis" "${_python}" "3.12")
+
+# native: every axis at its native value
+__FetchLayer_variant_native("${A}+python=3.12" _native)
+expect("native" "${_native}" "TRUE")
+__FetchLayer_variant_native("${A}+python=3.11" _native)
+expect("another python is not native" "${_native}" "FALSE")
+__FetchLayer_variant_native("${B}" _native)
+expect("another triplet is not native" "${_native}" "FALSE")
+__FetchLayer_variant_native("any" _native)
+expect("no axis is native" "${_native}" "TRUE")
+
+# stagings: the variants to make available; a dependency's variant by its own axes
+FetchLayer_Declare(core REVISION 0000000000000000000000000000000000000000)
+FetchLayer_DeclareStaging(runtime LAYER core)                                       # triplet by default
+FetchLayer_DeclareStaging(binding LAYER core AXES triplet python DEPENDS runtime)
+FetchLayer_DeclareStaging(schema  LAYER core AXES)                                  # none
+__FetchLayer_staging_get(runtime AXES _axes)
+expect("axes by default" "${_axes}" "triplet")
+__FetchLayer_staging_get(binding AXES _axes)
+expect("axes declared" "${_axes}" "triplet;python")
+__FetchLayer_staging_get(binding DEPENDS _depends)
+expect("DEPENDS after AXES" "${_depends}" "runtime")
+__FetchLayer_staging_get(schema AXES _axes)
+expect("axes declared empty" "${_axes}" "")
+__FetchLayer_variant_list(runtime _variants)
+expect("variants, triplet" "${_variants}" "${A}")
+__FetchLayer_variant_list(binding _variants)
+expect("variants, triplet × python" "${_variants}" "${A}+python=3.11;${A}+python=3.12")
+__FetchLayer_variant_list(schema _variants)
+expect("variants, no axis" "${_variants}" "any")
+__FetchLayer_variant_select(runtime "${A}+python=3.11" _dependency)
+expect("a dependency by its own axes" "${_dependency}" "${A}")
+__FetchLayer_variant_select(binding "${A}" _variant)
+expect("an axis missing takes its native value" "${_variant}" "${A}+python=3.12")
+__FetchLayer_variant_select(schema "${A}+python=3.11" _variant)
+expect("a dependency without axes" "${_variant}" "any")
diff --git a/tests/fetchlayer-axes/CMakeLists.txt b/tests/fetchlayer-axes/CMakeLists.txt
new file mode 100644
index 0000000..67c8d1a
--- /dev/null
+++ b/tests/fetchlayer-axes/CMakeLists.txt
@@ -0,0 +1,77 @@
+# Variants by two axes, triplet and python, against a store this test lays out itself; no network.
+#   cmake -S tests/fetchlayer-axes -B build/fetchlayer-axes
+# The layer's decision: -DWITHOUT_OWN_BINDING=ON leaves binding for python 3.12, this build's own, out of the
+# store, so the layer core is to come from its sources — core too — or, with -DFETCHLAYER_BUILD=NEVER, fails.
+cmake_minimum_required(VERSION 3.25)
+project(fetchlayer_axes_test NONE)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/FetchLayer.cmake")
+
+function(expect WHAT GOT WANT)
+    if (GOT STREQUAL WANT)
+        message(STATUS "ok    ${WHAT}: ${GOT}")
+    else()
+        message(SEND_ERROR "FAIL  ${WHAT}: ${GOT}, not ${WANT}")
+    endif()
+endfunction()
+
+set(_triplet x86_64-macos-apple-clang-21-release)
+set(_commit 1111111111111111111111111111111111111111)
+
+FetchLayer_DeclareAxis(triplet NATIVE ${_triplet})
+FetchLayer_DeclareAxis(python  NATIVE 3.12 VALUES 3.11 3.12)
+
+FetchLayer_Declare(core REVISION ${_commit})
+FetchLayer_DeclareStaging(core    LAYER core)
+FetchLayer_DeclareStaging(binding LAYER core AXES triplet python DEPENDS core)
+
+# the store: core for the triplet, binding for python 3.11 and 3.12 — each a directory with a library in it
+set(FETCHLAYER_STORE "${CMAKE_BINARY_DIR}/store")
+file(REMOVE_RECURSE "${FETCHLAYER_STORE}")
+function(lay NAME VARIANT DEPENDS LIBRARY)
+    set(r_NAME "${NAME}")
+    set(r_REVISION "${_commit}")
+    set(r_DEPENDS_REVISIONS "${DEPENDS}")
+    set(r_VARIANT "${VARIANT}")
+    __FetchLayer_identity_path(r _path)
+    file(WRITE "${_path}/lib/${LIBRARY}" "")
+endfunction()
+lay(core    "${_triplet}"             ""                "libcore.dylib")
+lay(binding "${_triplet}+python=3.11" "core=${_commit}" "binding.cpython-311-darwin.so")
+if (NOT WITHOUT_OWN_BINDING)
+    lay(binding "${_triplet}+python=3.12" "core=${_commit}" "binding.cpython-312-darwin.so")
+endif()
+
+FetchLayer_MakeAvailable(core binding)
+
+# the layer's decision: every own variant asked for is in the store, so all prebuilt
+__FetchLayer_layer_get(core ORIGIN _origin)
+expect("the layer, prebuilt" "${_origin}" "system")
+
+# the variants: one of core, two of binding — binding found in the store only if core, its dependency, was
+# taken by its own axis alone: the path is the hash of core's commit
+FetchLayer_GetProperties(core)
+expect("core, its variants" "${core_VARIANTS}" "${_triplet}")
+FetchLayer_GetProperties(binding)
+expect("binding, its variants" "${binding_VARIANTS}" "${_triplet}+python=3.11;${_triplet}+python=3.12")
+
+# binding by default: the own variant, python 3.12, installed
+expect("binding, own variant" "${binding_VARIANT}" "${_triplet}+python=3.12")
+expect("binding, own: python" "${binding_PYTHON}" "3.12")
+expect("binding, own: triplet" "${binding_TRIPLET}" "${_triplet}")
+expect("binding, own: exact" "${binding_IDENTITY_MATCH}" "EXACT")
+expect("binding, own: installed" "${binding_INSTALL_COMPONENTS}" "binding_Runtime")
+expect("binding, own: against core" "${binding_DEPENDS_REVISIONS}" "core=${_commit}")
+
+# binding for python 3.11, by its axis: found, files only
+FetchLayer_GetProperties(binding AXES python=3.11)
+expect("binding 3.11, variant" "${binding_VARIANT}" "${_triplet}+python=3.11")
+expect("binding 3.11, populated" "${binding_POPULATED}" "TRUE")
+expect("binding 3.11, files only" "${binding_INSTALL_COMPONENTS}" "")
+if (NOT EXISTS "${binding_PREFIX}/lib/binding.cpython-311-darwin.so")
+    message(SEND_ERROR "FAIL  binding 3.11, prefix: ${binding_PREFIX}")
+endif()
+
+# by its string, as one of binding_VARIANTS
+FetchLayer_GetProperties(binding VARIANT "${_triplet}+python=3.12")
+expect("binding by its string" "${binding_PYTHON}" "3.12")
diff --git a/tests/fetchlayer-git/CMakeLists.txt b/tests/fetchlayer-git/CMakeLists.txt
new file mode 100644
index 0000000..d071fc5
--- /dev/null
+++ b/tests/fetchlayer-git/CMakeLists.txt
@@ -0,0 +1,100 @@
+# The origin git alone: resolve and populate called directly, as find and MakeAvailable will.
+#   cmake -S tests/fetchlayer-git -B build/fetchlayer-git -G Ninja
+cmake_minimum_required(VERSION 3.25)
+project(fetchlayer_git_test NONE)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/FetchLayer.cmake")
+set(FETCHLAYER_TRIPLET x86_64-macos-apple-clang-21-release)
+set(_repository https://github.com/openDAQ/OpcUaModules.git)
+
+function(expect WHAT GOT WANT)
+    if (GOT STREQUAL WANT)
+        message(STATUS "ok    ${WHAT}: ${GOT}")
+    else()
+        message(SEND_ERROR "FAIL  ${WHAT}: ${GOT}, not ${WANT}")
+    endif()
+endfunction()
+
+# resolve <name> <revision> [<triplet>] → <name>_c_*
+function(resolve NAME REVISION)
+    set(_triplet "${FETCHLAYER_TRIPLET}")
+    if (ARGC GREATER 2)
+        set(_triplet "${ARGV2}")
+    endif()
+    set(r_NAME "${NAME}")
+    set(r_REVISION "${REVISION}")
+    set(r_DEPENDS_REVISIONS "opendaq=3039ee6d068c6c5e6e4d3de367c91820088ab30e")
+    set(r_TRIPLET "${_triplet}")
+    __FetchLayer_git_resolve("${NAME}" "${_triplet}" r c)
+    foreach(_field ORIGIN REF REVISION DEPENDS_REVISIONS TRIPLET IDENTITY_MATCH)
+        set(${NAME}_c_${_field} "${c_${_field}}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+# resolve: the commit, exact, the dependencies as requested
+FetchLayer_Declare(opcua-sha REVISION ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-sha LAYER opcua-sha)
+resolve(opcua-sha ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+expect("resolve" "${opcua-sha_c_REVISION}" "ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5")
+expect("resolve, exact" "${opcua-sha_c_IDENTITY_MATCH}" "EXACT")
+expect("resolve, depends as requested" "${opcua-sha_c_DEPENDS_REVISIONS}" "opendaq=3039ee6d068c6c5e6e4d3de367c91820088ab30e")
+
+# the revision as a commit, before any origin: a full sha as it is; an annotated tag by the commit it points to;
+# a lightweight tag; a branch
+__FetchLayer_git_commit(opcua-sha _commit)
+expect("commit, full sha" "${_commit}" "ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5")
+FetchLayer_Declare(opcua-tag REVISION v4.0.0 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-tag LAYER opcua-tag)
+__FetchLayer_git_commit(opcua-tag _commit)
+expect("commit, annotated tag" "${_commit}" "3e02ec1330224b819bfc5342d9b00a303dd4d9ee")
+__FetchLayer_layer_get(opcua-tag REVISION _declared)
+expect("commit, written over the declared tag" "${_declared}" "3e02ec1330224b819bfc5342d9b00a303dd4d9ee")
+FetchLayer_Declare(opcua-light REVISION v4.0.1 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-light LAYER opcua-light)
+__FetchLayer_git_commit(opcua-light _commit)
+expect("commit, lightweight tag" "${_commit}" "4ed45f0102abc5d9489b8d3151e5c72da1440544")
+FetchLayer_Declare(opcua-branch REVISION release/4.0 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-branch LAYER opcua-branch)
+__FetchLayer_git_commit(opcua-branch _commit)
+expect("commit, branch" "${_commit}" "4ed45f0102abc5d9489b8d3151e5c72da1440544")
+
+# not git's: another triplet; a layer without GIT_REPOSITORY
+resolve(opcua-sha ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5 x86_64-linux-gcc-11-release)
+expect("another triplet" "${opcua-sha_c_ORIGIN}" "")
+FetchLayer_Declare(no-repository REVISION ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+FetchLayer_DeclareStaging(no-repository LAYER no-repository)
+resolve(no-repository ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+expect("no GIT_REPOSITORY" "${no-repository_c_ORIGIN}" "")
+
+# populate: the commit, downloaded only; main's (ad11c59 is on a branch since deleted, out of a clone's reach)
+FetchLayer_Declare(opcua-main REVISION 485710c37d06bcc6b6c852e57fd27c0b2cce7d08 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-main LAYER opcua-main)
+resolve(opcua-main 485710c37d06bcc6b6c852e57fd27c0b2cce7d08)
+__FetchLayer_instance_set(opcua-main ${FETCHLAYER_TRIPLET} REVISION "${opcua-main_c_REVISION}")
+__FetchLayer_git_populate(opcua-main ${FETCHLAYER_TRIPLET})
+__FetchLayer_instance_get(opcua-main ${FETCHLAYER_TRIPLET} SOURCE_DIR _source)
+__FetchLayer_instance_get(opcua-main ${FETCHLAYER_TRIPLET} BINARY_DIR _binary)
+expect("populate, sources" "${_source}" "${CMAKE_BINARY_DIR}/_deps/opcua-main-src")
+expect("populate, binary dir" "${_binary}" "${CMAKE_BINARY_DIR}/_deps/opcua-main-build")
+if (NOT EXISTS "${_source}/CMakeLists.txt")
+    message(SEND_ERROR "FAIL  populate: no ${_source}/CMakeLists.txt")
+endif()
+__FetchLayer_git_run(_head -C "${_source}" rev-parse HEAD)
+expect("populate, commit" "${_head}" "485710c37d06bcc6b6c852e57fd27c0b2cce7d08")
+if (TARGET opcua_client_module)
+    message(SEND_ERROR "FAIL  populate added the project")
+endif()
+
+# a local checkout: its HEAD, warned when not the declared one
+get_filename_component(_local "${CMAKE_CURRENT_LIST_DIR}/../../../OpcUaModules" ABSOLUTE)
+set(FETCHCONTENT_SOURCE_DIR_OPCUA-LOCAL "${_local}")
+FetchLayer_Declare(opcua-local REVISION ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5 GIT_REPOSITORY ${_repository})
+FetchLayer_DeclareStaging(opcua-local LAYER opcua-local)
+resolve(opcua-local ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+__FetchLayer_git_run(_local_head -C "${_local}" rev-parse HEAD)
+expect("local checkout, its HEAD" "${opcua-local_c_REVISION}" "${_local_head}")
+expect("local checkout, exact" "${opcua-local_c_IDENTITY_MATCH}" "EXACT")
+__FetchLayer_instance_set(opcua-local ${FETCHLAYER_TRIPLET} REVISION "${opcua-local_c_REVISION}")
+__FetchLayer_git_populate(opcua-local ${FETCHLAYER_TRIPLET})
+__FetchLayer_instance_get(opcua-local ${FETCHLAYER_TRIPLET} SOURCE_DIR _source)
+expect("local checkout, sources" "${_source}" "${_local}")
diff --git a/tests/fetchlayer/CMakeLists.txt b/tests/fetchlayer/CMakeLists.txt
new file mode 100644
index 0000000..161cfff
--- /dev/null
+++ b/tests/fetchlayer/CMakeLists.txt
@@ -0,0 +1,49 @@
+# The first iteration of FetchLayer against a filled store: the core and the four module layers,
+# prebuilt, for this machine's triplet.
+#   cmake -S tests/fetchlayer -B build/fetchlayer -G Ninja -DFETCHLAYER_STORE=$PWD/build/store \
+#         -DFETCHLAYER_TRIPLET=x86_64-macos-apple-clang-21-release
+cmake_minimum_required(VERSION 3.25)
+project(fetchlayer_test LANGUAGES CXX)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../cmake/FetchLayer.cmake")
+set(FETCHLAYER_IDENTITY_REVISION_KEY   "org.opencontainers.image.revision")
+set(FETCHLAYER_IDENTITY_DEPENDENCY_KEY "com.opendaq.dependencies.<name>.revision")
+set(FETCHLAYER_IDENTITY_AXIS_KEY       "com.opendaq.package.<axis>")
+
+FetchLayer_Declare(openDAQ                  REVISION 3039ee6d068c6c5e6e4d3de367c91820088ab30e)
+FetchLayer_Declare(OpcUaModules             REVISION ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+FetchLayer_Declare(MQTTStreamingModule      REVISION 892f654d11a1dac7b18f9f21265c148010568c59)
+FetchLayer_Declare(LTStreamingModulesModern REVISION caa7a57c3a6f838bcf1477b96937073ef4b2b0e3)
+FetchLayer_Declare(ASAM-CMP-Modules         REVISION 2f643a2c83f59ade54c156900e1f1088268429bb)
+FetchLayer_Declare(openDAQ                  REVISION 0000000000000000000000000000000000000000)   # ignored: first wins
+
+FetchLayer_DeclareStaging(opendaq              LAYER openDAQ FIND_PACKAGE_ARGS NAMES openDAQ)
+FetchLayer_DeclareStaging(opcua-modules        LAYER OpcUaModules             DEPENDS opendaq)
+FetchLayer_DeclareStaging(mqtt-module          LAYER MQTTStreamingModule      DEPENDS opendaq)
+FetchLayer_DeclareStaging(lt-streaming-modules LAYER LTStreamingModulesModern DEPENDS opendaq)
+FetchLayer_DeclareStaging(asam-cmp-modules     LAYER ASAM-CMP-Modules         DEPENDS opendaq)
+FetchLayer_DeclareStaging(opendaq              LAYER OpcUaModules)   # ignored: first wins
+
+FetchLayer_MakeAvailable(opendaq opcua-modules mqtt-module lt-streaming-modules asam-cmp-modules)
+
+foreach(_l opendaq opcua-modules mqtt-module lt-streaming-modules asam-cmp-modules)
+    FetchLayer_GetProperties(${_l})
+    message(STATUS "${_l}: ${${_l}_ORIGIN} ${${_l}_IDENTITY_MATCH} rev=${${_l}_REVISION} deps=${${_l}_DEPENDS_REVISIONS}")
+    message(STATUS "    components=${${_l}_INSTALL_COMPONENTS}")
+endforeach()
+foreach(_t daq::opendaq opcua-modules::opcua_client_module asam-cmp-modules::asam_cmp_capture_module)
+    if (TARGET ${_t})
+        message(STATUS "target ${_t}: yes")
+    else()
+        message(SEND_ERROR "target ${_t}: missing")
+    endif()
+endforeach()
+
+# links against the core from the store and loads the modules from it
+add_executable(smoke smoke.cpp)
+target_link_libraries(smoke PRIVATE daq::opendaq)
+FetchLayer_GetProperties(opcua-modules)
+get_filename_component(_modules "${opcua-modules_PREFIX}/lib/modules" ABSOLUTE)
+target_compile_definitions(smoke PRIVATE MODULES_DIR="${_modules}")
+FetchLayer_GetProperties(opendaq)
+set_target_properties(smoke PROPERTIES BUILD_RPATH "${opendaq_PREFIX}/lib")
diff --git a/tests/fetchlayer/smoke.cpp b/tests/fetchlayer/smoke.cpp
new file mode 100644
index 0000000..aea146a
--- /dev/null
+++ b/tests/fetchlayer/smoke.cpp
@@ -0,0 +1,12 @@
+// Loads the modules of one layer from the store into the core from the store.
+#include <opendaq/opendaq.h>
+#include <iostream>
+
+int main()
+{
+    const auto instance = daq::Instance(MODULES_DIR);
+    const auto modules = instance.getModuleManager().getModules();
+    for (const auto& module : modules)
+        std::cout << "loaded " << module.getModuleInfo().getId() << "\n";
+    return modules.getCount() > 0 ? 0 : 1;
+}
diff --git a/tests/identity.cmake b/tests/identity.cmake
new file mode 100644
index 0000000..9816549
--- /dev/null
+++ b/tests/identity.cmake
@@ -0,0 +1,84 @@
+# cmake -P tests/identity.cmake — the identity hash against values computed apart (Python, the registry tags)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/FetchLayer/identity.cmake")
+
+# the keys staging-push annotates packages with
+set(FETCHLAYER_IDENTITY_REVISION_KEY   "org.opencontainers.image.revision")
+set(FETCHLAYER_IDENTITY_DEPENDENCY_KEY "com.opendaq.dependencies.<name>.revision")
+set(FETCHLAYER_IDENTITY_AXIS_KEY       "com.opendaq.package.<axis>")
+
+set(_failed 0)
+function(expect WHAT GOT WANT)
+    if (GOT STREQUAL WANT)
+        message(STATUS "ok    ${WHAT}")
+    else()
+        message(STATUS "FAIL  ${WHAT}\n        got  ${GOT}\n        want ${WANT}")
+        set(_failed 1 PARENT_SCOPE)
+    endif()
+endfunction()
+
+set(_core     3039ee6d068c6c5e6e4d3de367c91820088ab30e)
+set(_opcua    ad11c59ad43348f7099b794d8d8c5c94b8e9ccf5)
+set(_triplet  x86_64-macos-apple-clang-21-release)
+
+# the core: no dependencies
+set(core_NAME opendaq)
+set(core_REVISION ${_core})
+__FetchLayer_identity_hash(core idx _got)
+expect("core, layer" "${_got}" "idx-371b0bd304e31a41c4d93940e84aa4630c7bbdb1ba1d5f9d6d3376c6e7930f1e")
+set(core_VARIANT ${_triplet})
+__FetchLayer_identity_hash(core pkg _got)
+expect("core, build" "${_got}" "pkg-293b916ec80f1e85b403b0819e799ca6a873b109511e552f429ac56483db665c")
+
+# a module against the core
+set(opcua_NAME opcua-modules)
+set(opcua_REVISION ${_opcua})
+set(opcua_DEPENDS_REVISIONS "opendaq=${_core}")
+__FetchLayer_identity_hash(opcua idx _got)
+expect("module, layer" "${_got}" "idx-8bf766d81df141f0afbf3004975cb0996f54338dffeea01a05ac2a6ff8c3881e")
+set(opcua_VARIANT ${_triplet})
+__FetchLayer_identity_hash(opcua pkg _got)
+expect("module, build" "${_got}" "pkg-e2337ceee0d7acbc2b20adc6e951948125d12f6ec737bc694ace919f142f6f0b")
+
+# the order of the dependencies does not count
+set(a_REVISION ${_opcua})
+set(a_DEPENDS_REVISIONS "opendaq=${_core};libx=1111111")
+set(b_REVISION ${_opcua})
+set(b_DEPENDS_REVISIONS "libx=1111111;opendaq=${_core}")
+__FetchLayer_identity_hash(a idx _a)
+__FetchLayer_identity_hash(b idx _b)
+expect("order of dependencies" "${_a}" "${_b}")
+
+# another axis: a line of its own in the variant's hash; the staging's hash is the same
+set(binding_NAME opendaq-python)
+set(binding_REVISION ${_core})
+set(binding_DEPENDS_REVISIONS "opendaq=${_core}")
+__FetchLayer_identity_hash(binding idx _binding_idx)
+set(binding_VARIANT "${_triplet}+python=3.12")
+__FetchLayer_identity_hash(binding pkg _binding_312)
+set(binding_VARIANT "${_triplet}+python=3.11")
+__FetchLayer_identity_hash(binding pkg _binding_311)
+if (_binding_312 STREQUAL _binding_311)
+    expect("another python, another variant's hash" "${_binding_312}" "not ${_binding_311}")
+else()
+    expect("another python, another variant's hash" "" "")
+endif()
+set(_lines "com.opendaq.dependencies.opendaq.revision=${_core}\ncom.opendaq.package.python=3.12\ncom.opendaq.package.triplet=${_triplet}\norg.opencontainers.image.revision=${_core}")
+string(SHA256 _want "${_lines}")
+set(binding_VARIANT "${_triplet}+python=3.12")
+__FetchLayer_identity_hash(binding pkg _got)
+expect("a variant's hash is its annotations' lines" "${_got}" "pkg-${_want}")
+set(binding_VARIANT "")
+__FetchLayer_identity_hash(binding idx _got)
+expect("a staging's hash leaves the variant out" "${_got}" "${_binding_idx}")
+
+# the place in the store: the staging's hash, then the variant
+set(FETCHLAYER_STORE /store)
+__FetchLayer_identity_path(opcua _got)
+expect("store path" "${_got}"
+       "/store/opcua-modules/idx-8bf766d81df141f0afbf3004975cb0996f54338dffeea01a05ac2a6ff8c3881e/${_triplet}")
+
+if (_failed)
+    message(FATAL_ERROR "identity: some checks failed")
+endif()
+message(STATUS "identity: all checks passed")
diff --git a/tests/installed/CMakeLists.txt b/tests/installed/CMakeLists.txt
new file mode 100644
index 0000000..d86bae0
--- /dev/null
+++ b/tests/installed/CMakeLists.txt
@@ -0,0 +1,44 @@
+##
+## A smoke check of an installed bundle: built against an installed prefix (an installer's, or one unpacked),
+## not against the build tree. The C++ API and the C binding each load every module of the prefix.
+##
+##   cmake -S tests/installed -B build/installed [-DOPENDAQ_PREFIX=/opt/opendaq] [-DEXPECT_MODULES=14]
+##   cmake --build build/installed && ctest --test-dir build/installed --output-on-failure
+##
+
+cmake_minimum_required(VERSION 3.25)
+project(installed-smoke C CXX)
+
+set(OPENDAQ_PREFIX "/opt/opendaq" CACHE PATH "Where the bundle is installed")
+set(EXPECT_MODULES "" CACHE STRING "How many modules must load; empty: at least one")
+
+find_package(openDAQ REQUIRED PATHS "${OPENDAQ_PREFIX}" NO_DEFAULT_PATH)
+
+if (WIN32)
+    set(_modules "${OPENDAQ_PREFIX}/bin/modules")
+else()
+    set(_modules "${OPENDAQ_PREFIX}/lib/modules")
+endif()
+
+# the C++ API: an instance loads the modules
+add_executable(modules modules.cpp)
+target_link_libraries(modules PRIVATE daq::opendaq)
+set(_expect 0)
+if (EXPECT_MODULES)
+    set(_expect ${EXPECT_MODULES})
+endif()
+target_compile_definitions(modules PRIVATE MODULES_DIR="${_modules}" EXPECT_MODULES=${_expect})
+
+# the C binding: the same, through copendaq
+add_executable(c_binding c_binding.c)
+target_link_libraries(c_binding PRIVATE daq::copendaq)
+target_compile_definitions(c_binding PRIVATE MODULES_DIR="${_modules}" EXPECT_MODULES=${_expect})
+
+set_target_properties(modules c_binding PROPERTIES BUILD_RPATH "${OPENDAQ_PREFIX}/lib")
+
+enable_testing()
+add_test(NAME modules COMMAND modules)
+add_test(NAME c_binding COMMAND c_binding)
+if (WIN32)
+    set_tests_properties(modules c_binding PROPERTIES ENVIRONMENT_MODIFICATION "PATH=path_list_prepend:${OPENDAQ_PREFIX}/bin")
+endif()
diff --git a/tests/installed/c_binding.c b/tests/installed/c_binding.c
new file mode 100644
index 0000000..ecad55f
--- /dev/null
+++ b/tests/installed/c_binding.c
@@ -0,0 +1,59 @@
+/* Loads every module of the installed bundle through the C binding, as modules.cpp does through the C++ API;
+   fails when a call fails, when none loads, or not as many as expected. */
+#include <copendaq.h>
+#include <stdio.h>
+
+#define CHECK(call)                                              \
+    if (DAQ_FAILED(call))                                        \
+    {                                                            \
+        fprintf(stderr, "failed: %s\n", #call);                  \
+        return 1;                                                \
+    }
+
+int main(void)
+{
+    daqString* path = NULL;
+    CHECK(daqString_createString(&path, MODULES_DIR));
+
+    daqInstanceBuilder* builder = NULL;
+    CHECK(daqInstanceBuilder_createInstanceBuilder(&builder));
+    CHECK(daqInstanceBuilder_setModulePath(builder, path));
+
+    daqInstance* instance = NULL;
+    CHECK(daqInstance_createInstanceFromBuilder(&instance, builder));
+
+    daqModuleManager* manager = NULL;
+    CHECK(daqInstance_getModuleManager(instance, &manager));
+    daqList* modules = NULL;
+    CHECK(daqModuleManager_getModules(manager, &modules));
+
+    daqSizeT count = 0;
+    CHECK(daqList_getCount(modules, &count));
+    for (daqSizeT i = 0; i < count; ++i)
+    {
+        daqModule* module = NULL;
+        CHECK(daqList_getItemAt(modules, i, (daqBaseObject**) &module));
+        daqModuleInfo* info = NULL;
+        CHECK(daqModule_getModuleInfo(module, &info));
+        daqString* id = NULL;
+        CHECK(daqModuleInfo_getId(info, &id));
+        daqConstCharPtr text = NULL;
+        CHECK(daqString_getCharPtr(id, &text));
+        printf("loaded %s\n", text);
+
+        daqReleaseRef((daqBaseObject*) id);
+        daqReleaseRef((daqBaseObject*) info);
+        daqReleaseRef((daqBaseObject*) module);
+    }
+    printf("%d modules\n", (int) count);
+
+    daqReleaseRef((daqBaseObject*) modules);
+    daqReleaseRef((daqBaseObject*) manager);
+    daqReleaseRef((daqBaseObject*) instance);
+    daqReleaseRef((daqBaseObject*) builder);
+    daqReleaseRef((daqBaseObject*) path);
+
+    if (EXPECT_MODULES > 0)
+        return (int) count == EXPECT_MODULES ? 0 : 1;
+    return count > 0 ? 0 : 1;
+}
diff --git a/tests/installed/modules.cpp b/tests/installed/modules.cpp
new file mode 100644
index 0000000..9c9bb18
--- /dev/null
+++ b/tests/installed/modules.cpp
@@ -0,0 +1,17 @@
+// Loads every module of the installed bundle; fails when none loads, or not as many as expected.
+#include <opendaq/opendaq.h>
+#include <iostream>
+
+int main()
+{
+    const auto instance = daq::Instance(MODULES_DIR);
+    const auto modules = instance.getModuleManager().getModules();
+    for (const auto& module : modules)
+        std::cout << "loaded " << module.getModuleInfo().getId() << "\n";
+
+    const auto count = static_cast<int>(modules.getCount());
+    std::cout << count << " modules\n";
+    if (EXPECT_MODULES > 0)
+        return count == EXPECT_MODULES ? 0 : 1;
+    return count > 0 ? 0 : 1;
+}
diff --git a/tools/fill-store.cmake b/tools/fill-store.cmake
new file mode 100644
index 0000000..f4f4ac3
--- /dev/null
+++ b/tools/fill-store.cmake
@@ -0,0 +1,165 @@
+# Fills a store from the registry: every triplet of every layer, or the triplets given. The bundle's CI fills its
+# store so; locally a debugging aid.
+#
+#   cmake -DSTORE=build/store -DREGISTRY=ghcr.io/opendaq/dev/staging \
+#         -DLAYERS="opendaq=<sha>;opcua-modules=<sha>;…" [-DTRIPLETS="<triplet>;…"] \
+#         [-DORAS_REGISTRY_CONFIG=~/.oras/config.json] -P tools/fill-store.cmake
+#
+# For each layer: the newest index whose revision is the one given; for each package in it, the identity
+# from its annotations, the place from cmake/FetchLayer/identity.cmake, the tarball into
+# <store>/.downloads/sha256-<digest>.tar.gz, unpacked beside the place and renamed into it (opt/opendaq taken
+# off), so a place is whole once it exists. A place already there is kept.
+
+cmake_minimum_required(VERSION 3.25)
+include("${CMAKE_CURRENT_LIST_DIR}/../cmake/FetchLayer/identity.cmake")
+
+set(FETCHLAYER_IDENTITY_REVISION_KEY   "org.opencontainers.image.revision")
+set(FETCHLAYER_IDENTITY_DEPENDENCY_KEY "com.opendaq.dependencies.<name>.revision")
+set(FETCHLAYER_IDENTITY_AXIS_KEY       "com.opendaq.package.<axis>")
+
+foreach(_var STORE REGISTRY LAYERS)
+    if (NOT ${_var})
+        message(FATAL_ERROR "fill-store: -D${_var}= is required")
+    endif()
+endforeach()
+get_filename_component(STORE "${STORE}" ABSOLUTE)
+set(FETCHLAYER_STORE "${STORE}")
+
+find_program(ORAS oras REQUIRED)
+set(_config)
+if (ORAS_REGISTRY_CONFIG)
+    set(_config --registry-config "${ORAS_REGISTRY_CONFIG}")
+endif()
+
+function(oras OUT)
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "OPTIONAL" "" "")
+    execute_process(COMMAND "${ORAS}" ${ARG_UNPARSED_ARGUMENTS} ${_config}
+                    OUTPUT_VARIABLE _out ERROR_VARIABLE _err RESULT_VARIABLE _rc OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if (NOT _rc EQUAL 0)
+        if (NOT ARG_OPTIONAL)
+            list(JOIN ARG_UNPARSED_ARGUMENTS " " _args)
+            message(FATAL_ERROR "oras ${_args}:\n${_err}")
+        endif()
+        set(_out "")
+    endif()
+    set(${OUT} "${_out}" PARENT_SCOPE)
+endfunction()
+
+# the newest index of <repo> whose revision is <revision>
+function(find_index OUT REPO REVISION)
+    oras(_tags repo tags "${REPO}")
+    string(REGEX REPLACE "[\r\n]+" ";" _tags "${_tags}")
+    set(_best "")
+    set(_best_created "")
+    set(_seen)
+    foreach(_tag IN LISTS _tags)
+        if (NOT _tag OR _tag MATCHES "^pkg-")
+            continue()
+        endif()
+        oras(_index manifest fetch "${REPO}:${_tag}" OPTIONAL)
+        string(SHA256 _h "${_index}")
+        if (NOT _index OR _h IN_LIST _seen)
+            continue()
+        endif()
+        list(APPEND _seen ${_h})
+        string(JSON _rev ERROR_VARIABLE _e GET "${_index}" annotations "org.opencontainers.image.revision")
+        if (NOT _rev STREQUAL REVISION)
+            continue()
+        endif()
+        string(JSON _created ERROR_VARIABLE _e GET "${_index}" annotations "org.opencontainers.image.created")
+        if (NOT _best OR _created STRGREATER _best_created)
+            set(_best "${_index}")
+            set(_best_created "${_created}")
+        endif()
+    endforeach()
+    if (NOT _best)
+        message(FATAL_ERROR "fill-store: no index of ${REPO} has revision ${REVISION}")
+    endif()
+    set(${OUT} "${_best}" PARENT_SCOPE)
+endfunction()
+
+# the dependency pairs <dep>=<sha> in an annotations object
+function(dependencies OUT ANNOTATIONS)
+    set(_pairs)
+    string(JSON _n LENGTH "${ANNOTATIONS}")
+    math(EXPR _last "${_n} - 1")
+    foreach(_i RANGE ${_last})
+        string(JSON _key MEMBER "${ANNOTATIONS}" ${_i})
+        if (_key MATCHES "^com\\.opendaq\\.dependencies\\.(.+)\\.revision$")
+            set(_dep "${CMAKE_MATCH_1}")
+            string(JSON _sha GET "${ANNOTATIONS}" "${_key}")
+            list(APPEND _pairs "${_dep}=${_sha}")
+        endif()
+    endforeach()
+    list(SORT _pairs)
+    set(${OUT} "${_pairs}" PARENT_SCOPE)
+endfunction()
+
+set(_total 0)
+set(_kept 0)
+foreach(_entry IN LISTS LAYERS)
+    string(REGEX MATCH "^([^=]+)=(.+)$" _ "${_entry}")
+    set(_layer "${CMAKE_MATCH_1}")
+    set(_revision "${CMAKE_MATCH_2}")
+    set(_repo "${REGISTRY}/${_layer}")
+    message(STATUS "${_layer}@${_revision}")
+
+    find_index(_index "${_repo}" "${_revision}")
+    string(JSON _index_ann ERROR_VARIABLE _e GET "${_index}" annotations)
+    string(JSON _count LENGTH "${_index}" manifests)
+    math(EXPR _last "${_count} - 1")
+    foreach(_i RANGE ${_last})
+        string(JSON _digest GET "${_index}" manifests ${_i} digest)
+        string(JSON _ann GET "${_index}" manifests ${_i} annotations)
+        string(JSON _triplet GET "${_ann}" "com.opendaq.package.triplet")
+        string(JSON _title GET "${_ann}" "org.opencontainers.image.title")
+        if (TRIPLETS AND NOT _triplet IN_LIST TRIPLETS)
+            continue()
+        endif()
+
+        # the build's identity: the package's annotations, the index's where it has none
+        set(b_NAME "${_layer}")
+        string(JSON b_REVISION ERROR_VARIABLE _e GET "${_ann}" "org.opencontainers.image.revision")
+        if (_e)
+            string(JSON b_REVISION GET "${_index_ann}" "org.opencontainers.image.revision")
+        endif()
+        dependencies(b_DEPENDS_REVISIONS "${_ann}")
+        if (NOT b_DEPENDS_REVISIONS)
+            dependencies(b_DEPENDS_REVISIONS "${_index_ann}")
+        endif()
+        __FetchLayer_variant_format(b_VARIANT "triplet=${_triplet}")
+        __FetchLayer_identity_path(b _place)
+        math(EXPR _total "${_total} + 1")
+
+        if (IS_DIRECTORY "${_place}")
+            message(STATUS "  ${_triplet}: kept")
+            math(EXPR _kept "${_kept} + 1")
+            continue()
+        endif()
+
+        # download once per digest
+        string(REPLACE ":" "-" _file "${_digest}")
+        set(_archive "${STORE}/.downloads/${_file}.tar.gz")
+        if (NOT EXISTS "${_archive}")
+            set(_tmp "${STORE}/.downloads/.tmp")
+            file(REMOVE_RECURSE "${_tmp}")
+            oras(_ pull "${_repo}@${_digest}" -o "${_tmp}")
+            file(RENAME "${_tmp}/${_title}" "${_archive}")
+            file(REMOVE_RECURSE "${_tmp}")
+        endif()
+
+        # unpack; a prefix carried inside the tarball (opt/opendaq) is taken off
+        set(_unpack "${_place}.tmp")
+        file(REMOVE_RECURSE "${_unpack}" "${_place}")
+        file(ARCHIVE_EXTRACT INPUT "${_archive}" DESTINATION "${_unpack}")
+        if (IS_DIRECTORY "${_unpack}/opt/opendaq")
+            file(RENAME "${_unpack}/opt/opendaq" "${_place}")
+            file(REMOVE_RECURSE "${_unpack}")
+        else()
+            file(RENAME "${_unpack}" "${_place}")
+        endif()
+
+        message(STATUS "  ${_triplet}: ${_digest}")
+    endforeach()
+endforeach()
+message(STATUS "fill-store: ${_total} builds, ${_kept} kept, into ${STORE}")