Track upstream main at afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0 (2026-11-07), 22 commits past the de3e99c8 pin. Upstream still ships no tags or releases and Cargo.toml still reads version 1.0.0, so the dated 0-unstable-* string stays. cargoHash moves on its own: the new crates/zim-search workspace member grew Cargo.lock from 399 to 621 entries, and cargo vendor hashes the whole workspace. The real packaging work is the TMPDIR override appended to preCheck. Upstream's new harness::fs::path_tests scratch-root helper puts its scratch dirs under <cwd>/target/ and first asserts that root lies outside std::env::temp_dir(). The build sandbox exports TMPDIR=/build, which is an ancestor of the unpacked source at /build/source, so that premise check tripped and all 8 path-security tests failed with "scoped root /build/source/target/marmel-path-tests-N sits inside the temp allow-list entry /build". Pointing TMPDIR at /tmp/marmel-check-tmp, outside $NIX_BUILD_TOP, restores upstream's premise, so all 8 tests keep running for real instead of being filtered out of cargoTestFlags. Build-time only; the installed binary is untouched. Two derivation comments carried stale facts and are corrected: - meta.license claimed the repository shipped no LICENSE file and that Cargo.toml had no license field. Upstream c98179d023 (Na1w/marmel#40) added a root LICENSE file and declared license = "MIT" in Cargo.toml, so the comment now records that MIT is asserted in the README, Cargo.toml and LICENSE alike; lib.licenses.mit was already the right value. - the cargoTestFlags comment quoted "the lib suite passes at 1055 tests". Roughly 500 test fns landed since (TUI, fs-path, PTY and dispatch-integrity suites), so the figure is dropped rather than refreshed: nothing checks it and it rots on every bump. Also adds the two research notes behind the bump under docs/: the de3e99c8..afcc1dc9 upstream delta audit and the update-tooling findings. Verified: clean nix build .#marmel including the serialised test suite (--test-threads=1) — 2146 passed, 0 failed.
25 KiB
marmel bump — tooling / feasibility inventory
Repo: /home/minder/GIT/millerson.name/nix-overlay (nix flake, numtide/blueprint + flake-parts)
Target file: packages/marmel/package.nix (passthru.updateScript = [ "nix-update" "--flake" "marmel" "--version=branch=main" ])
Probed: 2026-11-07 ~11:00 UTC. Nothing in the repo was modified by this research
(git diff --quiet -- packages/marmel/package.nix → clean).
0. TL;DR — recommended command sequence
Run from the repo root (nix-update requires a git working tree, see §5.4):
cd /home/minder/GIT/millerson.name/nix-overlay
# nix-update is NOT on PATH but is one command away (substituted from cache in ~5 s)
nix shell nixpkgs#nix-update --command \
nix-update --flake --version=branch=main marmel
That command was executed end-to-end in a throwaway copy of this repo and succeeded
— it rewrote version, rev, src.hash and cargoHash in
packages/marmel/package.nix (exact diff in §4.4).
Then verify + format:
nix build .#marmel # long: ~621 crates compiled from the vendor tree
nix fmt packages/marmel/package.nix # already clean after nix-update (verified "0 changed")
Verified result values (as of 2026-11-07)
| field | old | new |
|---|---|---|
version |
0-unstable-2026-10-23 |
0-unstable-2026-11-07 |
src.rev |
de3e99c89b18bf43fbb471930bd9f7a40e1ca1b2 |
afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0 |
src.hash |
sha256-Z8qvzwSTpri9M05xZ07PJi9xSYIgBOos9bDh0NijSZg= |
sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ= |
cargoHash |
sha256-FbtY6K+0tG7JymhG/PnK+SU7SW/IFjG8Wswt+EnWPhg= |
sha256-Xw9OT8HXVlnZ0XqIMnnFwQ/y9xKxOtmcwomJsRxUx5E= |
afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0 = main HEAD at probe time ("feat: isolate git
worktrees per task, plan merge steps, and commit as Marmel Coder (#46)", committer date
2026-11-07T05:55:53Z). Re-check before bumping — upstream advances daily.
src.hash was derived three independent ways, all agreeing (§4.2); cargoHash came from a
real nix-build hash-mismatch of the exact derivation nixpkgs uses for cargoHash (§4.3).
Fallback one-liner (no nix-update)
SHA=$(curl -s https://api.github.com/repos/Na1w/marmel/commits/main \
| sed -n 's/.*"sha": "\([0-9a-f]\{40\}\)".*/\1/p' | head -1)
nix-prefetch-url --unpack "https://github.com/Na1w/marmel/archive/$SHA.tar.gz" \
| tail -1 | xargs -I{} nix hash convert --hash-algo sha256 --to sri {}
# then edit version/rev/src.hash by hand and let the build report cargoHash (§6.2)
Full fallback detail in §6.
1. nix — installed, flakes + nix-command enabled
| item | value |
|---|---|
| binary | /run/current-system/sw/bin/nix |
| version | nix (Nix) 2.34.9 |
nix show-config → experimental-features |
fetch-tree flakes nix-command |
/etc/nix/nix.conf → experimental-features |
nix-command flakes |
user nix.conf |
none (~/.config/nix/nix.conf does not exist); no nix.conf.d |
| env vars | no NIX_CONFIG, no NIX_FEATURES. NIX_PATH=nixpkgs=flake:nixpkgs:... is set, so with import <nixpkgs> {}; works (nix-update relies on this) |
| store / remote | nix store ping → Store URL: daemon, Version: 2.34.9, Trusted: 0 |
| daemon | nix-daemon --daemon running; builds run as nixbld1 |
| substituters | https://mirror.yandex.ru/nixos, https://cache.numtide.com, https://cache.nixos.org/ (all reachable) |
No --extra-experimental-features flag is needed — nix-command + flakes are already
enabled system-wide.
Cosmetic noise: nix.conf carries a bogus
sandbox_extra_readonly_paths = /home/minde/.beads (typo'd home dir), so every nix
invocation prints warning: ignoring sandbox_extra_readonly_paths entry "/home/minde/.beads": does not exist.
2. Tool availability
| tool | on PATH? |
notes |
|---|---|---|
nix |
yes | 2.34.9 |
nix-update |
NO | Not installed. Installable from cache: nix shell nixpkgs#nix-update → 1.15.1 (verified → /nix/store/sxspafgpl5d4h4ipd945a6q4l7gsjvyw-nix-update-1.15.1). Also already in store at /nix/store/v5rgl0pm2qd5mwra66gfri6j1cc6v5fm-nix-update-1.15.1/bin/nix-update. |
nix-prefetch-git |
NO | nix shell nixpkgs#nix-prefetch-git → 26.05 (verified working). Not needed for this package (§2.1). |
nix-prefetch-github |
NO | nix shell nixpkgs#nix-prefetch-github → 7.1.0 (verified working). |
prefetch-git |
no | not an attribute in current nixpkgs. |
nix-prefetch |
no | not a real command. |
nix-prefetch-url |
yes | /run/current-system/sw/bin/nix-prefetch-url (ships with nix) — use it for the src hash (§4.2). |
nix-build, nix-shell, nix-instantiate, nix-env |
yes | /run/current-system/sw/bin (nix-update needs the first three). |
git |
yes | /etc/profiles/per-user/minder/bin/git (nix-update needs it). |
treefmt / nixfmt |
no | not on PATH; use nix fmt (§7). |
nom |
no | nix-update falls back to plain nix. |
nix-update --version is not a usable flag in 1.15.1 (--version is the "version to
update to" option; bare --version prints usage). Get the version from
nix eval nixpkgs#nix-update.version or the store path name.
2.1 nix-update's real external requirements
Grepped from
/nix/store/v5rgl0pm2qd5mwra66gfri6j1cc6v5fm-nix-update-1.15.1/lib/python3.13/site-packages/nix_update/:
git, nix-build, nix-instantiate, nix-shell, nix (nix-command flakes), and
nix-prefetch-git only in git.py::git_prefetch, used for git+ entries in a Cargo.lock
that the package declares via cargoLock.lockFile.
For marmel: Cargo.lock at the new rev has 621 packages and 0 git+ sources, and
package.nix declares no cargoLock, so nix-prefetch-git is never invoked. nix-update
has zero references to nix-prefetch-github — it computes hashes itself (§5.3).
3. Network access — yes, including from inside the build sandbox
curl -I https://api.github.com -> HTTP 200 (0.53 s)
curl https://api.github.com/rate_limit -> core limit 60/h, 59 remaining (unauthenticated)
curl -I https://codeload.github.com/Na1w/marmel/tar.gz/refs/heads/main -> HTTP 200
curl -I https://cache.nixos.org/nix-cache-info -> HTTP 200
curl -I https://static.crates.io/ -> HTTP 403 (bare bucket root; crate fetches work)
curl https://github.com/Na1w/marmel/commits/main.atom -> Atom feed OK (nix-update's branch source)
GitHub unauthenticated API limit is 60 req/h. nix-prefetch-github and nix-update's
release lookups consume it; the commits/main.atom feed used by --version=branch=main
is not API-rate-limited.
Fixed-output derivations get network inside the sandbox — confirmed empirically:
$ nix build --impure --expr 'let p = import <nixpkgs> {}; in p.fetchurl { url = "https://api.github.com/zen"; hash = ""; }'
error: hash mismatch in fixed-output derivation '/nix/store/9njz7kig2zzgv4h98381l3fv33nsv3db-zen.drv':
specified: sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
got: sha256-pMlQmrUEDYRs2ap8pjC+ug40eC3aL1feTGB4DJBIFCU=
That got: <hash> line is exactly what nix-update parses, so hash computation works here.
4. Attribute exposure, and how to obtain the hashes
4.1 The exact attribute name
nix eval --impure --expr 'builtins.attrNames (builtins.getFlake "git+file:.").packages'
# -> [ "aarch64-darwin" "aarch64-linux" "x86_64-darwin" "x86_64-linux" ]
nix eval --impure --raw --expr 'builtins.concatStringsSep "\n" (builtins.attrNames (builtins.getFlake "git+file:.").packages.x86_64-linux)'
# -> agnix aionui awg-tool awgen codeaf container-use default desloppify ds4 flake-inputs
# freebuff freetoken g3 graphify haivemind hipengine kubernetes-mcp-server kyojin loop
# **marmel** mcp-gateway memdoor nftables-analyzer nftablesbuilder omniroute
# open-code-review pdfcraft pilotdeck radar relay-free-llm shardr skillsmcp stakpak traycer
builtins.elem "marmel" (builtins.attrNames packages.<sys>):
| system | packages.<sys>.marmel |
|---|---|
x86_64-linux |
✅ true (this machine's builtins.currentSystem — use it) |
aarch64-linux |
✅ true |
aarch64-darwin |
✅ true |
x86_64-darwin |
❌ eval errors — pre-existing, unrelated: error: Nixpkgs 26.11 has dropped support for x86_64-darwin. (locked nixpkgs rev eaad089433ca, lib.version = 26.11pre-git). Never pass --system x86_64-darwin. |
The attribute name to give nix-update --flake is the bare marmel — the comment in
package.nix is correct. Mechanism: Options.get_package() (nix_update/options.py) builds
(let flake = builtins.getFlake <path>; in flake.packages.${builtins.currentSystem}.marmel or flake.marmel)
and parse_attribute_path raises AttributePathError on a leading dot, so .#marmel fails.
nix flake show renders it as checks.<sys>.pkgs-marmel: derivation 'marmel-0-unstable-2026-10-23';
blueprint also emits packages.<sys>.marmel and a packages.<sys>.default launcher.
4.2 src.hash — three agreeing methods (all executed)
For rev afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0 →
sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ=
-
Empty-hash fixed-output build (no installs needed):
nix build --impure --no-write-lock-file --no-link --expr ' let pkgs = import <nixpkgs> {}; in pkgs.fetchFromGitHub { owner = "Na1w"; repo = "marmel"; rev = "afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0"; hash = ""; }' # error: hash mismatch ... got: sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ= -
nix-prefetch-url --unpack https://github.com/Na1w/marmel/archive/<sha>.tar.gz→013fw4rsisl9h2yqx15fzcrps4iw3ripv1vxblp57lrcrqnpc89s, thennix hash convert --hash-algo sha256 --to sri <hex>→ same SRI. -
nix-prefetch-github Na1w marmel --rev <sha>(afternix shell nixpkgs#nix-prefetch-github) →{"owner":"Na1w","repo":"marmel","rev":"afcc1dc…","hash":"sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ="}(7.1.0 already emits SRI — nonix hash convertneeded).nix-prefetch-git https://github.com/Na1w/marmel <sha>also agrees ("sha256": "013fw4rsisl9…","hash": "sha256-OiF2…").
4.3 cargoHash — it is cargoDeps.vendorStaging, not cargoDeps
The locked nixpkgs (26.11pre-git) no longer uses fetchCargoTarball:
pkgs/build-support/rust/build-rust-package/default.nix:114-132mapscargoHash→fetchCargoVendor (… { hash = args.cargoHash; }).pkgs/build-support/rust/fetch-cargo-vendor.nix:74-107putsoutputHash = hashon an innervendorStagingderivation (outputHashMode = "recursive",outputHashAlgo = "sha256"whenhash == "").
So cargoHash == cargoDeps.vendorStaging.outputHash — exactly what nix-update 1.15.1
targets (eval.nix: cargo_vendor_deps = pkg.cargoDeps.vendorStaging.outputHash or null;,
dependency_hashes.py: "cargo_vendor_deps" → update_hash_with_prefetch("cargoDeps.vendorStaging")).
Verified recipe (~12 min for 621 crates; read-only, does not touch the repo):
cat > /tmp/cargohash.nix <<'EOF'
let
flake = builtins.getFlake "/home/minder/GIT/millerson.name/nix-overlay";
pkgs = import flake.inputs.nixpkgs { };
pkg = flake.packages.x86_64-linux.marmel.overrideAttrs (final: prev: {
src = pkgs.fetchFromGitHub {
owner = "Na1w"; repo = "marmel";
rev = "afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0";
hash = "sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ=";
};
});
vs = pkg.cargoDeps.vendorStaging or pkg.cargoDeps;
in vs.overrideAttrs (_: { outputHash = ""; outputHashAlgo = "sha256"; })
EOF
nix build --impure --no-write-lock-file --no-link --file /tmp/cargohash.nix
# error: hash mismatch in fixed-output derivation '…-marmel-0-unstable-…-vendor-staging.drv':
# got: sha256-Xw9OT8HXVlnZ0XqIMnnFwQ/y9xKxOtmcwomJsRxUx5E=
Two traps: overrideSrc does not exist in this nixpkgs (removed — error: attribute 'overrideSrc' missing), so use overrideAttrs; and cargoDeps is derived from
finalAttrs.src, so overriding src correctly recomputes the vendor derivation.
4.4 End-to-end nix-update verification (performed)
Run in a copy of the repo (git archive HEAD → /tmp/marmel-bump-test), leaving the real
repo untouched:
PATH=/nix/store/v5rgl0pm2qd5mwra66gfri6j1cc6v5fm-nix-update-1.15.1/bin:$PATH \
nix-update --flake --version=branch=main marmel
Produced diff (only these 4 lines changed):
- version = "0-unstable-2026-10-23";
+ version = "0-unstable-2026-11-07";
src = fetchFromGitHub {
owner = "Na1w";
repo = "marmel";
- rev = "de3e99c89b18bf43fbb471930bd9f7a40e1ca1b2";
- hash = "sha256-Z8qvzwSTpri9M05xZ07PJi9xSYIgBOos9bDh0NijSZg=";
+ rev = "afcc1dc971ae4acd59b157f031d4bdbc9d52a7d0";
+ hash = "sha256-OiF2Lc4s01MuXX2HfWMePBJ9M/uuhI69gInqqDPhbgQ=";
};
- cargoHash = "sha256-FbtY6K+0tG7JymhG/PnK+SU7SW/IFjG8Wswt+EnWPhg=";
+ cargoHash = "sha256-Xw9OT8HXVlnZ0XqIMnnFwQ/y9xKxOtmcwomJsRxUx5E=";
Comments, nativeCheckInputs, preCheck, cargoTestFlags, postInstall, passthru and
meta were left untouched. Reference copy kept at /tmp/marmel-bump-test.
The only error in that run was an artifact of the copy not being a git repo
(git -C /tmp/marmel-bump-test/.. diff → exit 129 in git_has_diff), raised after the file
was written. In the real repo it does not happen — but it means nix-update must be run
inside the git working tree (validate_git_dir).
5. nix-update deep-dive (1.15.1)
5.1 Version scheme
--version=branch=main → VersionPreference.BRANCH with branch main
(version/version.py::from_str accepts branch and branch=<name>). The fetcher is
fetch_github_snapshots (version/github.py:144-199), which reads
https://github.com/Na1w/marmel/commits/main.atom, takes the newest entry and emits
Version(f"{version}-unstable-{date}", rev=commit) where
version_numbers = <release tag numbers> + ["0"]. marmel publishes no tags and no
releases (GET /repos/Na1w/marmel/tags → []), so the result is always
0-unstable-YYYY-MM-DD — exactly the existing convention. date is the Atom <updated>
of the head commit (2026-11-07T05:55:53Z → 2026-11-07).
5.2 Which file it edits
eval.nix uses builtins.unsafeGetAttrPos "src" pkg and maps the store path back onto the
working tree (sanitizePosition, flakeImportPath from nix flake metadata --json). Verified:
it edited packages/marmel/package.nix, not the thin packages/marmel/default.nix
(pkgs.callPackage ./package.nix { }). No --override-filename needed.
5.3 How it computes hashes (no prefetch tools required)
dependency_hashes.py::nix_prefetch runs
nix-build --expr 'let src = <pkg>.src; in (src.overrideAttrs or (f: src // f src)) (_: { outputHash = ""; outputHashAlgo = "sha256"; })'
and regex-extracts got: <hash> from stderr (extract_hash_from_nix_error), then
nix hash to-sri. The identical trick is used for cargoDeps.vendorStaging. Hence no
nix-prefetch-* is required — but fixed-output builds with network must work, which §3 confirms.
5.4 Gotchas
- Must run inside a git working tree (post-update
git diffingit_has_diff). - The working tree is dirty (
.serena/project.ymlmodified;.marmel/untracked). nix-update copies the flake vianix flake metadata --json, so dirty tracked content is used and nix printswarning: Git tree … is dirty. Harmless. --use-update-scriptwill fail as written.run_update_script(update.py:136-191) executespassthru.updateScriptinsidenix develop --impure --expr 'with import <nixpkgs> {}; pkgs.mkShell { inputsFrom = [ <pkg> ]; }'.inputsFromsupplies the package's build inputs (rustPlatform, cargo, cacert) — notnix-update— andnix-updateis not on the host PATH, sonix-update --flake marmel --use-update-script(the command suggested by the comment inpackage.nix) dies withnix-update: command not found. If you insist on the update-script path, prefix it:nix shell nixpkgs#nix-update --command nix-update --flake marmel --use-update-script. Prefer the direct form in §0 (one lessnix developlayer, and it avoids buildinginputsFrom).--formatshells out to a barenixfmt(not on PATH) — usenix fmtafterwards instead.--build/--test/--reviewpull in extra tooling and a full compile; omit them.--commitwould auto-commit; the repo's AGENTS.md wants conventional commits, so either use it deliberately or commit manually (§8).
6. Fallback procedure (nix-update unavailable, or branch scheme unresolved)
6.1 Manual bump — three edits in packages/marmel/package.nix
version = "0-unstable-YYYY-MM-DD";— date = committer date ofmainHEAD:curl -s https://api.github.com/repos/Na1w/marmel/commits/main \ | python3 -c 'import json,sys;d=json.load(sys.stdin);print(d["sha"]);print(d["commit"]["committer"]["date"])'rev= full 40-char SHA;hash= §4.2 method 1, 2 or 3.cargoHash= §6.2.
6.2 Getting cargoHash without nix-update
Both routes work on this box:
- Let the build report it (the flow AGENTS.md documents): write the new
rev/src.hash, thennix build .#marmel. The…-marmel-…-vendor-stagingfixed-output derivation fails before any rustc work withgot: sha256-…; paste that intocargoHashand rebuild. - Read-only probe (no file edit): the
/tmp/cargohash.nixrecipe in §4.3.
prefetchCargoHash / prefetch-cargo-hash are not commands on this system (nor in
nixpkgs) — don't look for them. Note that in this nixpkgs the mismatching derivation is
<pname>-<version>-vendor-staging, not cargo-deps; grepping build output for
vendor-staging locates it fast.
6.3 Sandbox / daemon constraints
sandbox = true,sandbox-fallback = false, and this user is not trusted (nix store ping→Trusted: 0;trusted-users = root).__noChrootderivations are therefore rejected — verified:error: derivation '…' has '__noChroot' set, but that's not allowed when 'sandbox' is 'true'. Good news: neitherfetchFromGitHubnorfetchCargoVendor/vendorStagingsets__noChroot(grepped in the locked nixpkgs), so no sandbox bypass is needed for this bump.--option sandbox falseis silently ignored:warning: ignoring the client-specified setting 'sandbox', because it is a restricted setting and you are not a trusted user. Do not plan aroundnix build --option sandbox false; it does nothing here.- Plain sandboxed builds work (
nix build nixpkgs#hellosubstituted fromcache.numtide.com; a hand-made sandboxed derivation built successfully).
7. Repo conventions that matter for the edit
- Formatter:
nix fmt <paths>is the right command.flake.formatter.x86_64-linux=/nix/store/b6mf3mzvln2igb244baas9vi6pywa05x-nixfmt-tree-2.6.0— a treefmt wrapper whose generated config is[formatter.nixfmt] command = "nixfmt",includes = ["*.nix"], wrapping nixfmt 1.5.0. Verified:nix fmt packages/marmel/package.nix→traversed 1 files / emitted 1 files / formatted 1 files (0 changed), and nix-update's output is already format-clean. Currentpackages/marmel/package.nixis alsonixfmt --check-clean as-is. - The repo's
treefmt.tomlis effectively dead config.nix fmtis handed the generated config (--config-file /nix/store/…-treefmt.toml, formatter idnixfmt), so the repo's[formatter.nix]section is never consulted. There is no.pre-commit-config.yamland notreefmt.nix;treefmt-nixis only an input feeding blueprint's formatter. README already labels treefmt "(optional)". nix flake checkdoes NOT check formatting.checks.x86_64-linuxcontains onlypkgs-agnix … pkgs-marmel … pkgs-traycer(one derivation per package → it builds everything). Blueprint'sformat-checkderivation is not wired intochecks.devShellsis empty →nix develop(suggested in AGENTS.md) does not work in this repo.- CI (
.github/workflows/ci.yml):nix flake check, thennix build .#packages || true. - Formatting scope: run
nix fmt packages/marmel/package.nix, not barenix fmt(bare invocation formats the wholegit ls-filestree). - README row for
marmel(README.md:29) carries description + category only — no version string, so a version bump needs no README edit. overlays/andmodules/contain nomarmelliteral (blueprint auto-generates the overlay), sopackages/marmel/package.nixis the only file to touch.- AGENTS.md §"Updating a Package Version" (~lines 209-215) and §"Updating Packages"
(~lines 284-307) already document this flow, including
nix-update <package-name> --version=branch=main.
8. Copy-paste runbook
cd /home/minder/GIT/millerson.name/nix-overlay
# 0. sanity: current state + who is upstream now
git status --short
curl -s https://api.github.com/repos/Na1w/marmel/commits/main \
| python3 -c 'import json,sys;d=json.load(sys.stdin);print(d["sha"], d["commit"]["committer"]["date"])'
# 1. bump (nix-update is not installed; pull it from the binary cache)
nix shell nixpkgs#nix-update --command nix-update --flake --version=branch=main marmel
# 2. inspect — expect exactly 4 changed lines (version, rev, src hash, cargoHash)
git diff -- packages/marmel/package.nix
# 3. format (expect "0 changed")
nix fmt packages/marmel/package.nix
# 4. build + run the package's own checks (long: full rust build)
nix build .#marmel
nix build .#checks.x86_64-linux.pkgs-marmel # same derivation via blueprint's check
# 5. commit (conventional commits, per AGENTS.md)
git add packages/marmel/package.nix
git commit -m "chore(marmel): bump 0-unstable-2026-10-23 -> 0-unstable-2026-11-07"
If step 1 is impossible, use §6.1 + §6.2 verbatim.
Things to re-check after the bump
nativeCheckInputs = [ cacert ], thepreCheckSSL_CERT_FILEexport andcargoTestFlags(--test-threads=1, skipharness::sandbox::tests::test_internal_sandbox_exec_dev_null_and_dns) exist for reasons documented inpackage.nixcomments. Re-read those comments against the new rev: they claim the lib suite passes 1055 tests with that single skip at the old rev; a new upstream rev can change the test count, rename the skipped test, or re-introduce flakiness. If a skip filter stops matching, cargo prints0 filtered outand the suite silently under-tests.meta.license = lib.licenses.mitwas asserted from the README because no LICENSE file shipped;Cargo.tomlatafcc1dcnow haslicense = "MIT", so the claim is better supported.Cargo.tomlstill saysversion = "1.0.0"(so the0-unstable-*scheme stays mandatory) andrust-version = "1.98". Confirm the locked nixpkgs toolchain still satisfies it; if upstream ever needs a newer rustc, copy thenixpkgs-rust195input pattern already used forpdfcraft(see theflake.nixheader comments).
9. Pre-existing issues found (not blockers)
packages.x86_64-darwinevaluates to an error:error: Nixpkgs 26.11 has dropped support for x86_64-darwin.Consequentlynix flake show --all-systemsandnix flake check-style whole-system traversals can fail on that system. Unrelated to this bump; affects every package in the repo.nix.conftyposandbox_extra_readonly_paths = /home/minde/.beadsemits a warning on every nix invocation.devShellsis empty, so AGENTS.md'snix developinstruction is stale.treefmt.tomlis unused bynix fmt(§7).nix flake show/nix evalongit+file:.printswarning: Fetching Git repository 'file:.', which uses a path relative to the current directory. This is not supported and will stop working in a future release.(nix issue 12281) — use an absolute path (git+file:///home/minder/GIT/millerson.name/nix-overlay) to silence it.
10. One-line answers
| question | answer |
|---|---|
| nix installed + flakes? | Yes — nix 2.34.9, experimental-features = nix-command flakes (system nix.conf); no flag needed |
| nix-update? | Not on PATH; nix shell nixpkgs#nix-update → 1.15.1 (works, verified end-to-end) |
| nix-prefetch-git / -github / prefetch-git / nix-prefetch? | All missing; first two installable from cache; nix-prefetch-url is present; prefetch-git/nix-prefetch don't exist |
| network? | Yes — GitHub API/atom/codeload and nix caches reachable; fixed-output sandbox builds get network (proven) |
| attribute name | marmel (i.e. packages.x86_64-linux.marmel); also on aarch64-linux + aarch64-darwin; x86_64-darwin is broken upstream |
| recommended command | nix shell nixpkgs#nix-update --command nix-update --flake --version=branch=main marmel |
| fallback | manual rev + nix-prefetch-url --unpack/fetchFromGitHub hash="" for src.hash, then nix build .#marmel's vendor-staging hash-mismatch for cargoHash (§6) |
| sandbox permits it? | Yes — no __noChroot needed and none used; --option sandbox false is a no-op for this untrusted user |
| formatting | nix fmt packages/marmel/package.nix (treefmt wrapper → nixfmt 1.5.0); nix-update's output is already clean |