valise-sh 0.2.0 → 0.3.0

package/package.json

@@ -1,20 +1,101 @@
 {
   "name": "valise-sh",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pure POSIX shell profile engine and CLI",
   "bin": {
     "valise": "./bin/valise"
   },
   "files": [
-    "bin/",
-    "lib/",
-    "modules/",
-    "entrypoints/",
-    "module.d/",
-    "manifests/",
-    "docs/",
-    "examples/",
-    "!examples/**/build/",
+    "bin/valise",
+    "docs/architecture.md",
+    "docs/contrib-modules.md",
+    "docs/installation.md",
+    "docs/module-abi.md",
+    "docs/projects.md",
+    "docs/release-policy.md",
+    "docs/shared-modules.md",
+    "entrypoints/profile.sh",
+    "examples/README.md",
+    "examples/e2e/README.md",
+    "examples/e2e/bundles.tsv",
+    "examples/e2e/module.d/e2e_aliases.meta",
+    "examples/e2e/module.d/e2e_completions_bash.meta",
+    "examples/e2e/module.d/e2e_completions_zsh.meta",
+    "examples/e2e/module.d/e2e_env_setup.meta",
+    "examples/e2e/module.d/e2e_fish_features.meta",
+    "examples/e2e/module.d/e2e_generated_config.meta",
+    "examples/e2e/module.d/e2e_ksh_features.meta",
+    "examples/e2e/module.d/e2e_layer_probe.meta",
+    "examples/e2e/module.d/e2e_optional_network.meta",
+    "examples/e2e/module.d/e2e_platform_tools.meta",
+    "examples/e2e/module.d/e2e_platform_tools_bsd.meta",
+    "examples/e2e/module.d/e2e_platform_tools_darwin.meta",
+    "examples/e2e/module.d/e2e_platform_tools_linux.meta",
+    "examples/e2e/modules/e2e/aliases.sh",
+    "examples/e2e/modules/e2e/completions_bash.sh",
+    "examples/e2e/modules/e2e/completions_zsh.sh",
+    "examples/e2e/modules/e2e/env_setup.sh",
+    "examples/e2e/modules/e2e/fish_features.fish",
+    "examples/e2e/modules/e2e/generated_config.sh",
+    "examples/e2e/modules/e2e/ksh_features.sh",
+    "examples/e2e/modules/e2e/layer_probe.sh",
+    "examples/e2e/modules/e2e/optional_network.sh",
+    "examples/e2e/modules/e2e/platform_tools_bsd.sh",
+    "examples/e2e/modules/e2e/platform_tools_darwin.sh",
+    "examples/e2e/modules/e2e/platform_tools_linux.sh",
+    "examples/e2e/valise.conf",
+    "examples/e2e/variants.tsv",
+    "examples/local/module.d/hello_valise.meta",
+    "examples/local/modules/hello_valise.sh",
+    "examples/profile-project/README.md",
+    "examples/profile-project/bundles.tsv",
+    "examples/profile-project/layers/demo/module.d/contrib_demo_greeting.meta",
+    "examples/profile-project/layers/demo/modules/shared/contrib_demo_greeting.sh",
+    "examples/profile-project/module.d/greeting.meta",
+    "examples/profile-project/module.d/profile_main.meta",
+    "examples/profile-project/modules/greeting.sh",
+    "examples/profile-project/valise.conf",
+    "examples/profile-project/variants.tsv",
+    "examples/shared/README.md",
+    "examples/shared/module.d/contrib_shared_paths.meta",
+    "examples/shared/module.d/contrib_shared_umask.meta",
+    "examples/shared/modules/shared/contrib_shared_paths.sh",
+    "examples/shared/modules/shared/contrib_shared_umask.sh",
+    "lib/capabilities.sh",
+    "lib/cli/commands.sh",
+    "lib/cli/common.sh",
+    "lib/cli/devtools.sh",
+    "lib/cli/fish-hook.sh",
+    "lib/cli/integration.sh",
+    "lib/cli/lifecycle.sh",
+    "lib/cli/project.sh",
+    "lib/cli/store.sh",
+    "lib/cli/usage.sh",
+    "lib/compiler.awk",
+    "lib/fish/loader.fish",
+    "lib/fish/metadata.fish",
+    "lib/fish/profile.fish",
+    "lib/loader.sh",
+    "lib/metadata.sh",
+    "manifests/parser-support.tsv",
+    "module.d/valise_editor.meta",
+    "module.d/valise_history.meta",
+    "module.d/valise_pager.meta",
+    "module.d/valise_path.meta",
+    "module.d/valise_platform_bsd.meta",
+    "module.d/valise_platform_linux.meta",
+    "module.d/valise_platform_macos.meta",
+    "module.d/valise_platform_posix.meta",
+    "module.d/valise_xdg.meta",
+    "modules/platform/bsd/capabilities.sh",
+    "modules/platform/linux/capabilities.sh",
+    "modules/platform/macos/capabilities.sh",
+    "modules/platform/posix.sh",
+    "modules/system/valise_editor.sh",
+    "modules/system/valise_history.sh",
+    "modules/system/valise_pager.sh",
+    "modules/system/valise_path.sh",
+    "modules/system/valise_xdg.sh",
     "LICENSE",
     "CHANGELOG.md"
   ],

package/docs/variants.md

@@ -1,327 +0,0 @@
-# The compile and build contract
-
-This document describes how a consuming project turns metadata into an
-installed release: what each input file contains, what `valise compile`
-produces, what `valise build` packages, and how the two fail.
-
-Two different mechanisms share the word "variant". They compose, but they are
-not the same command.
-
-- **Build variants** are exclusion lists decided at compile time inside the
-  consuming project. They live in `shell/release/install-variants`.
-- **Installed releases** are sealed directories on this machine. They are
-  listed, switched, and pruned with `valise release list|use|prune`.
-
-Neither reads the other's file. `release use` never reads `install-variants`;
-variant exclusion is decided when the plans are compiled.
-
-## The project layout
-
-A consuming project that uses the CLI has this shape:
-
-```
-shell/
-  module.d/            primary modules: <name>.meta
-  modules/             primary module bodies
-  layers/<provider>/   provider layers (optional)
-    module.d/          layer modules: <name>.meta
-    modules/           layer module bodies
-  release/
-    bundle-roots       which modules seed each bundle, per shell
-    install-variants   build variants and their exclusion lists
-    module-registry.tsv  GENERATED from the metadata above
-    project.conf       project defaults (optional)
-```
-
-`shell/module.d/` and `shell/release/module-registry.tsv` are the two markers
-that identify a directory as a valise project. A layer's `<provider>` is a
-path component made of letters, digits, `_`, `-`, and `.`; it may not start
-with `.` or contain `..`. The registry rejects any other provider name,
-because the compiler emits module identities from it as shell source text. The CLI resolves the project
-root from the working directory first, then from the engine's own location, so
-running `valise compile` from the project root always compiles *that* project
-rather than a tree that merely happens to contain the engine.
-
-## Metadata is the source of truth
-
-Module metadata is data: `key=value` lines in a `.meta` file, parsed and
-validated, never sourced. See [module-abi.md](module-abi.md) for the full
-field list and the grammar each value must satisfy.
-
-The registry is a **generated artifact**, not a second source of truth. The
-generator is `valise registry`:
-
-```sh
-valise registry                       # write shell/release/module-registry.tsv
-valise registry --check               # compare, fail on drift, write nothing
-valise registry path/to/registry.tsv  # write somewhere else
-```
-
-`valise build` regenerates the registry before it builds, so a project
-that only has `.meta` files and bodies builds with no hand-written TSV. The
-generator refuses to publish a registry when the metadata is inconsistent:
-a `name` that does not match its filename, a missing body, a layer module
-without the `contrib_` prefix, a load path that is not representable, or an
-export name that is not a shell identifier.
-
-The registry is a tab-separated file with one header row and one row per
-module:
-
-| # | Column | Meaning |
-|---|---|---|
-| 1 | `name` | Module identifier. |
-| 2 | `version` | Optional version string; empty means unversioned. |
-| 3 | `side_effect` | Startup side-effect class. |
-| 4 | `requires` | Space-separated required dependencies. |
-| 5 | `optional` | Space-separated optional dependencies. |
-| 6 | `shells` | Space-separated shell identifiers. |
-| 7 | `platforms` | Space-separated platform identifiers. |
-| 8 | `exports` | Space-separated exported identifiers. |
-| 9 | `load` | Repository-relative body path, or empty for a meta module. |
-| 10 | `updates` | Space-separated update registration identifiers. |
-| 11 | `source` | Directory that holds the `.meta`: `shell/module.d` or `shell/layers/<provider>/module.d`. |
-
-Rows come out in a fixed order: the primary modules of `shell/module.d/`
-first, then the layer modules of each `shell/layers/<provider>/module.d/`,
-each group in C-locale name order. The order does not depend on the caller's
-locale, so regenerating an unchanged project produces a byte-identical file.
-
-## Bundles: which modules seed each shell
-
-A bundle names the root modules for each shell. The file is
-`shell/release/bundle-roots`, tab-separated:
-
-```
-# bundle	shell	roots
-default	bash	profile_main
-default	zsh	profile_main
-default	ksh	profile_main
-```
-
-- Column 1 is the bundle name.
-- Column 2 is the shell the roots apply to.
-- Column 3 is a space-separated list of root module names.
-
-A root may be a bare name (`profile_main`), which resolves against
-`shell/module.d/`, or a qualified name (`contrib_tool@shell/layers/vendor/module.d`)
-that names its source directory explicitly. Use the qualified form when a
-layer module and a primary module share a name.
-
-The first row may be a header (`bundle`, `shell`, `roots`); it is not a bundle
-definition.
-
-A bundle names the **starting points**, not the final set. `valise compile`
-walks each root's `requires` and `optional` edges, so the installed plan
-contains the whole reachable closure. `valise explain-bundles` prints that
-closure per shell, which is the fastest way to see what a bundle actually
-loads:
-
-```sh
-valise explain-bundles
-valise explain-bundles --bundle=default
-```
-
-It reads `bundle-roots` and the registry directly, and needs no Python. An
-unknown `--bundle` name is an error, not an empty report.
-
-## Variants: what to leave out
-
-A build variant is an exclusion list. The file is
-`shell/release/install-variants`, tab-separated:
-
-```
-variant_name	description	excluded_modules
-default	All project modules	
-workstation-lean	No editor defaults	contrib_editor
-```
-
-- Column 1 is the variant name.
-- Column 2 is a human-readable description.
-- Column 3 is a space-separated list of excluded modules.
-
-An exclusion is a bare module name (matching a `shell/module.d/` module) or a
-qualified name (`<name>@<source>`) that names the source directory
-explicitly. Every exclusion must match exactly one registry row; an unknown
-or ambiguous exclusion fails the compile rather than silently excluding
-nothing.
-
-Exclusion is applied to the whole resolved graph, not just the roots. A module
-excluded by name is not loaded, and neither is anything that depends on it.
-`valise explain-variant <name>` shows a variant's description, its exclusion
-list, and the per-shell impact.
-
-The variant and the bundle compose: the bundle decides the starting points
-and the layers they reach, and the variant then removes modules from the
-resolved graph.
-
-## `valise compile`
-
-```sh
-valise compile [--bundle=<name>] [--variant=<name>] <output-dir>
-```
-
-Compile resolves the module graph and writes one plan per shell. It does not
-copy module bodies; that is `build`'s job.
-
-The steps, in order:
-
-1. Resolve the project root. Fail with `cannot find source tree` when the
-   project has no `shell/release/module-registry.tsv`.
-2. Validate the variant: the name must appear exactly once in
-   `install-variants`, and every exclusion must match exactly one registry
-   row.
-3. Validate the bundle when `--bundle` is given: the name must exist, and
-   its roots must resolve.
-4. For each of `bash`, `zsh`, and `ksh`, resolve the
-   bundle's roots for that shell, walk the dependency closure, drop the
-   variant's exclusions, select each module by `shells=`, emit its
-   `platforms=` gate, and emit a plan.
-5. Replace the output directory atomically.
-
-The output directory must be empty or absent. Compile stages into a private
-sibling directory and publishes only after every plan has compiled, so a
-failed compile never leaves a half-written output tree.
-
-### What a plan contains
-
-Each plan is a POSIX shell file at `generated/installed-modules.<shell>`:
-
-```
-# shell-profile-installed-modules-v1
-# Generated by valise compile; DO NOT EDIT.
-# plan=bash
-# roots=profile_main
-# order=hello profile_main
-```
-
-The header names the format, the generator, the shell, the roots, and the
-resolved load order. The body then:
-
-- validates `VALISE_MODE` (`strict` or `permissive`; default `strict`);
-- probes the platform once and gates each module by `platforms=`;
-- sources `vendor/shell-profile/lib/capabilities.sh`, so `sp_cap_*` helpers
-  stay available to module functions after the plan finishes;
-- checks each module's declared exports before and after loading it;
-- does not run a module whose required dependency is unavailable, whether that
-  dependency failed or was skipped for this platform, and reports it by name;
-- in strict mode, returns nonzero at the first failure in the required closure:
-  the bundle's roots and everything they require;
-- in permissive mode, reports each failure, continues with the unrelated
-  modules, and returns zero;
-- treats an optional dependency as best effort: it loads first when it can, and
-  its absence never affects the module that declared it. A failure is reported;
-  an unsupported platform is expected and prints nothing;
-- when `VALISE_RELOAD=1` is set, clears the plan's declared exports first, so
-  the plan can be sourced again.
-
-The plan is the compiled equivalent of the loader: same dependency rules,
-same export checks, same strict and permissive behavior. The plan is static and fast;
-the loader parses metadata at runtime and is the fallback for releases that
-ship an `entrypoints/` tree instead of `generated/` plans.
-
-### Failure behavior
-
-Compile fails closed, before writing anything, when:
-
-- the project root cannot be resolved;
-- the variant is unknown or ambiguous;
-- a variant exclusion matches no registry row, or more than one;
-- the bundle is unknown, or its roots do not resolve;
-- a module in the closure has a `side_effect` that is not safe to source at
-  startup (`generated-file`, `update-network`, `install-time`);
-- the capabilities prelude is missing or defines no `sp_cap_*` functions;
-- the registry names a module whose source, load path, or export name is not
-  representable.
-
-Fish plans are not produced by the POSIX plan generator. `valise compile`
-emits POSIX plans only; a Fish integration uses the native Fish loader.
-
-## `valise build`
-
-```sh
-valise build [--bundle=<name>] [--variant=<name>] [out]
-```
-
-Build a complete, installable release tree. It runs `valise
-compile` internally, so everything compile validates is validated here too.
-
-The built tree has this layout:
-
-```
-generated/installed-modules.bash      compiled plans
-generated/installed-modules.zsh
-generated/installed-modules.ksh
-module.d/<name>.meta                  primary module metadata
-modules/<path>                        primary module bodies
-layers/<provider>/module.d/<name>.meta   layer metadata
-layers/<provider>/<path>                 layer bodies
-vendor/shell-profile/lib/capabilities.sh the capability prelude
-shell/release/                        bundle-roots, install-variants, registry
-shell/install/profile-release.manifest  the release manifest
-```
-
-Build:
-
-1. Runs from the project root — it needs `shell/module.d/`.
-2. Regenerates `shell/release/module-registry.tsv` from the metadata.
-3. Compiles the plans into a staging directory.
-4. Copies the capability prelude from the installed engine. The packaged
-   file is the same file the plans were built against.
-5. Copies each module's metadata and body to its release path. A primary
-   module lands at the release root; a layer module lands at
-   `layers/<provider>/`, matching the paths the plan references.
-6. Normalizes file modes to `0644` and writes the release manifest.
-7. Publishes the tree at the destination.
-
-Like compile, build stages beside the destination and publishes only after
-the complete tree and its manifest exist. A failed build never leaves a
-partial release. The default destination is `build/release`; an existing
-default tree is replaced only after the new tree has compiled and been
-manifested. An explicit destination must be empty or absent.
-
-Building the same project twice produces byte-identical output, including
-the manifest.
-
-## `valise build` and `valise apply`
-
-`valise build` produces the tree; `valise apply` adds install and shell
-integration on top of it:
-
-- `valise build [--variant=<name>] [--bundle=<name>] [out]` builds to
-  `build/release` by default, reading the variant and bundle defaults from
-  `shell/release/project.conf`.
-- `valise apply [--variant=<name>] [--bundle=<name>] [--no-integration]`
-  builds, installs the release, writes the managed shell integration,
-  verifies the active release, and reports what changed.
-
-Both are idempotent: running them twice leaves the same state.
-
-`shell/release/project.conf` holds the defaults:
-
-```
-variant=default
-bundle=default
-```
-
-## `valise release list`, `use`, and `prune`
-
-These operate on the releases installed on this machine. No source tree is
-needed.
-
-```sh
-valise release list
-valise release use <release-id>
-valise release prune --keep=3
-```
-
-Release directories are named by the content-derived SHA-256 of their
-manifest, and the active one is marked in the list. `release use` verifies
-the named release byte-for-byte against its own manifest before switching the
-active pointer.
-
-`release prune --keep=N` removes old releases. It keeps the active release
-and the `N` newest others, ordered by directory modification time. Before
-removing any candidate it verifies the candidate against its own manifest; a
-release that fails verification is **kept** and reported, because a release
-that cannot be verified may be the only recoverable copy. The default is
-`--keep=3`.

package/entrypoints/fish/profile.fish

@@ -1,99 +0,0 @@
-# Copyright (c) 2026 Joseph Cumines
-# SPDX-License-Identifier: MIT
-
-# Generic Fish entrypoint adapter shipped with the valise engine.
-#
-# The valise Fish integration authenticates the active sealed release and
-# exports SHELL_PROJECT_ROOT pointing at its root before sourcing this file.
-# This adapter then requests modules the same way the POSIX entrypoint does:
-# VALISE_MODULES selects the graph (unset loads nothing), VALISE_MODE selects
-# strict or permissive failure handling (default permissive). It sources the
-# release's native Fish metadata and loader, consumes the loader's bootstrap
-# status marker, and publishes VALISE_FISH_READY=1 only after a successful
-# activation. Consuming projects may ship their own adapter at the same
-# release path to add project-specific selection policy.
-
-if not builtin set -q SHELL_PROJECT_ROOT
-    builtin printf '%s\n' 'valise Fish entrypoint: SHELL_PROJECT_ROOT is not set' >&2
-    return 1
-end
-set -l _valise_fish_entrypoint_root "$SHELL_PROJECT_ROOT"
-
-if not builtin test -r "$_valise_fish_entrypoint_root/lib/fish/metadata.fish"
-    builtin printf '%s\n' "valise Fish entrypoint: metadata library is not readable: $_valise_fish_entrypoint_root/lib/fish/metadata.fish" >&2
-    return 1
-end
-if not builtin test -r "$_valise_fish_entrypoint_root/lib/fish/loader.fish"
-    builtin printf '%s\n' "valise Fish entrypoint: loader library is not readable: $_valise_fish_entrypoint_root/lib/fish/loader.fish" >&2
-    return 1
-end
-
-# The bootstrap handshake variables are engine-private state. A forged or
-# stale marker must not survive into this activation: erase every visible
-# scope before requesting a fresh bootstrap, failing closed if an erase
-# is refused.
-for _valise_fish_entrypoint_stale in _sp_fish_loader_bootstrap_mode _sp_fish_loader_bootstrap_seeds _sp_fish_loader_bootstrap_status
-    if builtin set -q -g "$_valise_fish_entrypoint_stale"; and not builtin set -e -g "$_valise_fish_entrypoint_stale"
-        builtin printf '%s\n' "valise Fish entrypoint: cannot clear stale global $_valise_fish_entrypoint_stale" >&2
-        return 1
-    end
-    if builtin set -q -U "$_valise_fish_entrypoint_stale"; and not builtin set -e -U "$_valise_fish_entrypoint_stale"
-        builtin printf '%s\n' "valise Fish entrypoint: cannot clear stale universal $_valise_fish_entrypoint_stale" >&2
-        return 1
-    end
-end
-
-set -l _valise_fish_entrypoint_mode permissive
-if builtin set -q VALISE_MODE
-    set _valise_fish_entrypoint_mode "$VALISE_MODE"
-end
-
-set -l _valise_fish_entrypoint_seeds
-if builtin set -q VALISE_MODULES; and builtin test -n "$VALISE_MODULES"
-    set _valise_fish_entrypoint_seeds (builtin string split ' ' -- $VALISE_MODULES)
-end
-
-builtin set -gx _sp_fish_loader_bootstrap_mode "$_valise_fish_entrypoint_mode"
-builtin set -gx _sp_fish_loader_bootstrap_seeds $_valise_fish_entrypoint_seeds
-
-builtin source "$_valise_fish_entrypoint_root/lib/fish/metadata.fish"
-set -l _valise_fish_entrypoint_metadata_status $status
-if builtin test $_valise_fish_entrypoint_metadata_status -ne 0
-    builtin set -e _sp_fish_loader_bootstrap_mode
-    builtin set -e _sp_fish_loader_bootstrap_seeds
-    return $_valise_fish_entrypoint_metadata_status
-end
-
-builtin source "$_valise_fish_entrypoint_root/lib/fish/loader.fish"
-set -l _valise_fish_entrypoint_loader_status $status
-# The loader consumes the bootstrap request when it sources cleanly; erase
-# any request a failed source left behind so it cannot leak to callers.
-if builtin set -q _sp_fish_loader_bootstrap_mode
-    builtin set -e _sp_fish_loader_bootstrap_mode
-end
-if builtin set -q _sp_fish_loader_bootstrap_seeds
-    builtin set -e _sp_fish_loader_bootstrap_seeds
-end
-if builtin test $_valise_fish_entrypoint_loader_status -ne 0
-    # A failed source may have published a partial status marker; erase it
-    # so the caller's fresh-marker check below cannot see stale state.
-    if builtin set -q _sp_fish_loader_bootstrap_status
-        builtin set -e _sp_fish_loader_bootstrap_status
-    end
-    return $_valise_fish_entrypoint_loader_status
-end
-
-# The loader publishes a fresh bootstrap status marker on every activation;
-# its absence means the loader never completed its handshake.
-if not builtin set -q _sp_fish_loader_bootstrap_status
-    builtin printf '%s\n' 'valise Fish entrypoint: loader bootstrap status marker is absent' >&2
-    return 1
-end
-set -l _valise_fish_entrypoint_status $_sp_fish_loader_bootstrap_status
-builtin set -e _sp_fish_loader_bootstrap_status
-if builtin test $_valise_fish_entrypoint_status -ne 0
-    return $_valise_fish_entrypoint_status
-end
-
-builtin set -gx VALISE_FISH_READY 1
-return 0

package/examples/e2e/build-manifest.sh

@@ -1,138 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2026 Joseph Cumines
-# SPDX-License-Identifier: MIT
-
-# build-manifest.sh: vendor engine files into an e2e release tree and
-# generate a profile-release.manifest with correct sizes and SHA-256 digests.
-#
-# Usage: sh build-manifest.sh [output-dir]
-# Default output-dir: examples/e2e/build/release
-
-set -eu
-
-_script_dir=$(cd "$(dirname "$0")" && pwd -P)
-_repo_root=$(cd "$_script_dir/../.." && pwd -P)
-_e2e_root="$_script_dir"
-_out_dir="${1:-$_e2e_root/build/release}"
-_valise="$_repo_root/bin/valise"
-
-[ -x "$_valise" ] || { printf 'ERROR: valise CLI not found at %s\n' "$_valise" >&2; exit 1; }
-
-# Prepare clean output directory
-rm -rf "$_out_dir"
-mkdir -p "$_out_dir"
-
-_vendor_copy() {
-  _src="$_repo_root/$1"
-  _dst="$_out_dir/$1"
-  _dst_dir=$(dirname "$_dst")
-  [ -f "$_src" ] || { printf 'ERROR: engine source missing: %s\n' "$_src" >&2; exit 1; }
-  mkdir -p "$_dst_dir"
-  cp "$_src" "$_dst"
-  chmod 0644 "$_dst"
-}
-
-printf 'Vendoring engine files into %s...\n' "$_out_dir"
-
-# Core libraries
-_vendor_copy lib/metadata.sh
-_vendor_copy lib/loader.sh
-_vendor_copy lib/capabilities.sh
-_vendor_copy lib/compiler.awk
-
-# Fish libraries
-_vendor_copy lib/fish/loader.fish
-_vendor_copy lib/fish/metadata.fish
-
-# Generic Fish entrypoint adapter
-_vendor_copy entrypoints/fish/profile.fish
-
-# Entrypoint
-_vendor_copy entrypoints/profile.sh
-
-# Platform module metadata
-_vendor_copy module.d/platform_posix.meta
-_vendor_copy module.d/platform_macos.meta
-_vendor_copy module.d/platform_linux.meta
-_vendor_copy module.d/platform_bsd.meta
-
-# Platform module bodies
-_vendor_copy modules/platform/posix.sh
-_vendor_copy modules/platform/macos/capabilities.sh
-_vendor_copy modules/platform/linux/capabilities.sh
-_vendor_copy modules/platform/bsd/capabilities.sh
-
-# Shareable engine catalog (ships in every release built from this engine)
-_engine_contrib_count=0
-for _contrib_src in "$_repo_root"/module.d/contrib_*.meta; do
-  [ -f "$_contrib_src" ] || continue
-  _vendor_copy "module.d/$(basename "$_contrib_src")"
-  _engine_contrib_count=$((_engine_contrib_count + 1))
-done
-for _contrib_src in "$_repo_root"/modules/system/contrib_*.sh; do
-  [ -f "$_contrib_src" ] || continue
-  _vendor_copy "modules/system/$(basename "$_contrib_src")"
-  _engine_contrib_count=$((_engine_contrib_count + 1))
-done
-if [ "$_engine_contrib_count" -eq 0 ]; then
-  printf 'ERROR: no shareable engine modules found in %s\n' "$_repo_root" >&2
-  exit 1
-fi
-
-# --- Native e2e example modules ---
-_e2e_meta_count=0
-mkdir -p "$_out_dir/module.d"
-for _meta in "$_e2e_root"/module.d/e2e_*.meta; do
-  [ -f "$_meta" ] || continue
-  cp "$_meta" "$_out_dir/module.d/"
-  chmod 0644 "$_out_dir/module.d/$(basename "$_meta")"
-  _e2e_meta_count=$((_e2e_meta_count + 1))
-done
-
-_e2e_body_count=0
-mkdir -p "$_out_dir/modules/e2e"
-for _body in "$_e2e_root"/modules/e2e/*.sh "$_e2e_root"/modules/e2e/*.fish; do
-  [ -f "$_body" ] || continue
-  cp "$_body" "$_out_dir/modules/e2e/"
-  chmod 0644 "$_out_dir/modules/e2e/$(basename "$_body")"
-  _e2e_body_count=$((_e2e_body_count + 1))
-done
-
-if [ "$_e2e_meta_count" -eq 0 ]; then
-  printf 'ERROR: no e2e module metadata found in %s\n' "$_e2e_root/module.d" >&2
-  exit 1
-fi
-if [ "$_e2e_body_count" -eq 0 ]; then
-  printf 'ERROR: no e2e module bodies found in %s\n' "$_e2e_root/modules/e2e" >&2
-  exit 1
-fi
-
-# --- Vendor shared layer (cross-repo composition) ---
-_shared_src="$_repo_root/examples/shared"
-_shared_dst="$_out_dir/layer/shared"
-[ -d "$_shared_src/module.d" ] || { printf 'ERROR: shared provider missing: %s\n' "$_shared_src" >&2; exit 1; }
-mkdir -p "$_shared_dst/module.d" "$_shared_dst/modules"
-for _shared_meta in "$_shared_src"/module.d/*.meta; do
-  [ -f "$_shared_meta" ] || { printf 'ERROR: no shared provider metadata in %s\n' "$_shared_src/module.d" >&2; exit 1; }
-  cp "$_shared_meta" "$_shared_dst/module.d/"
-  chmod 0644 "$_shared_dst/module.d/$(basename "$_shared_meta")"
-done
-for _shared_area in "$_shared_src"/modules/*; do
-  [ -d "$_shared_area" ] || continue
-  mkdir -p "$_shared_dst/modules/$(basename "$_shared_area")"
-  for _shared_body in "$_shared_area"/*.sh; do
-    [ -f "$_shared_body" ] || continue
-    cp "$_shared_body" "$_shared_dst/modules/$(basename "$_shared_area")/"
-    chmod 0644 "$_shared_dst/modules/$(basename "$_shared_area")/$(basename "$_shared_body")"
-  done
-done
-_shared_rev=$(cd "$_shared_src" && git rev-parse HEAD 2>/dev/null || printf 'unknown')
-printf 'provider=examples/shared\nrevision=%s\n' "$_shared_rev" > "$_shared_dst/layer-pin.txt"
-chmod 0644 "$_shared_dst/layer-pin.txt"
-
-# Normalise file modes before manifesting
-find "$_out_dir" -type f -exec chmod 0644 {} +
-
-# --- Generate manifest using valise CLI ---
-"$_valise" make-manifest "$_out_dir"