docs/reference/plumbing.md · gabriel/muse

**Exit codes:** 0 done · 1 commit not in store (with `--verify`), invalid branch or commit ID, or `--delete` on non-existent ref · 3 file write failure

410

411

---

412

413

### `commit-graph` — emit the commit DAG

414

415

```

416

muse plumbing commit-graph [--tip <id>] [--stop-at <id>] [-n <max>] [-c] [-1] [-a] [-f json|text]

417

```

418

419

Performs a BFS walk from a tip commit (defaulting to HEAD), following both

420

`parent_commit_id` and `parent2_commit_id` pointers. Returns every reachable

421

commit as a JSON array. Useful for building visualisations, computing

422

reachability sets, or finding the commits on a branch since it diverged from

another.

**Flags**

|---|---|---|---|

| `--tip` | — | HEAD | Commit to start from |

430

| `--stop-at` | — | — | Stop BFS at this commit (exclusive) |

431

| `--max` | `-n` | 10 000 | Maximum commits to traverse |

432

| `--count` | `-c` | off | Emit only the integer count, not the full node list |

433

| `--first-parent` | `-1` | off | Follow only first-parent links — linear history, no merge parents |

434

| `--ancestry-path` | `-a` | off | With `--stop-at`: restrict to commits on the direct path between tip and stop-at (capped at 100 000 visited commits to guard against unbounded BFS) |

**Output — JSON**

```json

{

"tip": "a3f2...c8d1",

"count": 42,

"truncated": false,

"commits": [

{

"commit_id": "a3f2...c8d1",

447

"parent_commit_id": "ff01...23ab",

448

"parent2_commit_id": null,

449

"message": "Add verse melody",

450

"branch": "main",

451

"committed_at": "2026-03-18T12:00:00+00:00",

452

"snapshot_id": "b7e4...f912",

"author": "gabriel"

}

]

}

```

`truncated` is `true` when the graph was cut off by `--max`.

460

461

**Output — `--count`**

462

463

```json

464

{"tip": "a3f2...c8d1", "count": 42}

465

```

466

467

`--count` suppresses the `commits` array entirely, making it suitable for fast

468

cardinality checks without loading commit metadata.

**Examples**

Commits on a feature branch since it diverged from `main`:

473

474

```sh

475

BASE=$(muse plumbing merge-base feat/x main -f text)

476

muse plumbing commit-graph --tip feat/x --stop-at "$BASE" -f text

477

```

478

479

Count commits in a feature branch:

480

481

```sh

482

muse plumbing commit-graph \

483

--tip $(muse plumbing rev-parse feat/x -f text) \

484

--stop-at $(muse plumbing merge-base feat/x dev -f text) \

--count

```

Linear history only (skip merge parents):

489

490

```sh

491

muse plumbing commit-graph --first-parent -f text

492

```

493

494

**Exit codes:** 0 graph emitted · 1 tip commit not found, `--ancestry-path` without `--stop-at`, or bad `--format`

---

### `pack-objects` — bundle commits for transport

499

500

```

501

muse plumbing pack-objects <want>... [--have <id>...]

502

```

503

504

Collects a set of commits — and all their referenced snapshots and objects —

505

into a single JSON `PackBundle` written to `stdout`. Pass `--have` to tell

506

the packer which commits the receiver already has; objects reachable only from

507

`--have` ancestors are excluded, minimising transfer size.

508

509

`<want>` may be a full commit ID or `HEAD`.

**Flags**

| Flag | Short | Description |

514

|---|---|---|

515

| `--have` | — | Commits the receiver already has (repeat for multiple) |

516

517

**Output** — a JSON `PackBundle` object (pipe to a file or `unpack-objects`)

```json

{

"commits": [...],

"snapshots": [...],

"objects": [{"object_id": "...", "content_b64": "..."}],

524

"branch_heads": {"main": "a3f2...c8d1"}

}

```

`objects` entries are base64-encoded so the bundle is safe for any JSON-capable

529

transport (HTTP body, agent message, file).

530

531

**Exit codes:** 0 pack written · 1 a wanted commit not found or HEAD has no commits · 3 I/O error reading from the local store

---

### `unpack-objects` — apply a bundle to the local store

536

537

```

538

cat pack.json | muse plumbing unpack-objects [-f json|text]

539

muse plumbing pack-objects HEAD | muse plumbing unpack-objects

540

```

541

542

Reads a `PackBundle` JSON document from `stdin` and writes its commits,

543

snapshots, and objects into `.muse/`. Idempotent: objects already present in

544

the store are silently skipped. Partial packs from interrupted transfers are

safe to re-apply.

**Flags**

|---|---|---|---|

**Output — JSON (default)**

```json

{

"commits_written": 12,

558

"snapshots_written": 12,

559

"objects_written": 47,

"objects_skipped": 3

}

```

**Output — `--format text`**

565

566

```

567

Wrote 12 commits, 12 snapshots, 47 objects (3 skipped).

568

```

569

570

**Exit codes:** 0 unpacked (all objects stored) · 1 invalid JSON from stdin or bad `--format` · 3 write failure

---

### `ls-remote` — list refs on a remote

575

576

```

577

muse plumbing ls-remote [<remote-or-url>] [-f json|text]

578

```

579

580

Contacts a remote and lists every branch HEAD without altering local state.

581

The `<remote-or-url>` argument is either a remote name configured with

582

`muse remote add` (defaults to `origin`) or a full `https://` URL.

**Flags**

|---|---|---|---|

**Output — `--format text` (default)**

591

592

One line per branch, tab-separated. The default branch is marked with ` *`.

```

a3f2...c8d1 main *

b7e4...f912 feat/experiment

597

```

598

599

**Output — `--format json`**

```json

{

"repo_id": "550e8400-e29b-41d4-a716-446655440000",

604

"domain": "midi",

605

"default_branch": "main",

606

"branches": {

607

"main": "a3f2...c8d1",

608

"feat/experiment": "b7e4...f912"

}

}

```

**Exit codes:** 0 remote contacted · 1 remote not configured, URL invalid, or bad `--format` · 3 transport error (network, HTTP error)

---

## Composability Patterns

618

619

### Export a history range

620

621

```sh

622

# All commits on feat/x that are not on main

623

BASE=$(muse plumbing rev-parse main -f text)

624

TIP=$(muse plumbing rev-parse feat/x -f text)

625

muse plumbing commit-graph --tip "$TIP" --stop-at "$BASE" -f text

626

```

627

628

### Ship commits between two machines

629

630

```sh

631

# On the sender — pack everything the receiver doesn't have

632

HAVE=$(muse plumbing ls-remote origin --format text | awk '{print "--have " $1}' | tr '\n' ' ')

633

muse plumbing pack-objects HEAD $HAVE > bundle.json

634

635

# On the receiver

636

cat bundle.json | muse plumbing unpack-objects

637

muse plumbing update-ref main <commit-id>

638

```

639

640

### Verify a stored object

641

642

```sh

643

ID=$(muse plumbing hash-object tracks/drums.mid -f text)

644

muse plumbing cat-object "$ID" -f info

645

```

646

647

### Inspect what changed in the last commit

648

649

```sh

650

muse plumbing read-commit $(muse plumbing rev-parse HEAD -f text) | \

651

python3 -c "import sys, json; d=json.load(sys.stdin); print(d['message'])"

652

```

653

654

### Script a bare commit (advanced)

655

656

```sh

657

# 1. Hash and store the files

658

OID=$(muse plumbing hash-object -w tracks/drums.mid -f text)

659

660

# 2. Build a snapshot manifest and write it (via muse commit is easier,

661

# but for full control use commit-tree after writing the snapshot)

662

SNAP=$(muse plumbing rev-parse HEAD -f text | \

663

xargs -I{} muse plumbing read-commit {} | \

664

python3 -c "import sys,json; print(json.load(sys.stdin)['snapshot_id'])")

665

666

# 3. Create a commit on top of HEAD

667

PARENT=$(muse plumbing rev-parse HEAD -f text)

668

NEW=$(muse plumbing commit-tree -s "$SNAP" -p "$PARENT" -m "scripted commit" | \

669

python3 -c "import sys,json; print(json.load(sys.stdin)['commit_id'])")

670

671

# 4. Advance the branch

672

muse plumbing update-ref main "$NEW"

```

---

### `merge-base` — find the common ancestor of two commits

678

679

Find the lowest common ancestor of two commits — the point at which two

branches diverged.

```sh

muse plumbing merge-base <commit-a> <commit-b> [-f json|text]

```

|---|---|---|---|

Arguments accept full SHA-256 commit IDs, branch names, or `HEAD`.

**JSON output:**

```json

{

"commit_a": "<sha256>",

697

"commit_b": "<sha256>",

698

"merge_base": "<sha256>"

}

```

When no common ancestor exists, `merge_base` is `null` and `error` is set.

| Exit | Meaning |

|---|---|

| 0 | Result computed (check `merge_base` for null vs. found) |

707

| 1 | Ref cannot be resolved; bad `--format` |

708

| 3 | DAG walk failed |

---

### `snapshot-diff` — diff two snapshot manifests

713

714

Compare two snapshots and categorise every changed path as added, modified,

or deleted.

```sh

muse plumbing snapshot-diff <ref-a> <ref-b> [-f json|text] [-s]

```

|---|---|---|---|

Arguments accept snapshot IDs, commit IDs, branch names, or `HEAD`.

**JSON output:**

```json

{

"snapshot_a": "<sha256>",

733

"snapshot_b": "<sha256>",

734

"added": [{"path": "new.mid", "object_id": "<sha256>"}],

735

"modified": [{"path": "main.mid", "object_id_a": "<sha256>", "object_id_b": "<sha256>"}],

736

"deleted": [{"path": "old.mid", "object_id": "<sha256>"}],

"total_changes": 3

}

```

**Text output:**

```

A new.mid

M main.mid

D old.mid

```

| Exit | Meaning |

|---|---|

| 0 | Diff computed (zero changes is a valid result) |

752

| 1 | Ref cannot be resolved; bad `--format` |

753

| 3 | I/O error reading snapshot records |

---

### `domain-info` — inspect the active domain plugin

758

759

Inspect the domain plugin active for this repository — its name, class,

760

optional protocol capabilities, and full structural schema.

761

762

```sh

763

muse plumbing domain-info [-f json|text] [-a]

```

|---|---|---|---|

**JSON output:**

```json

{

"domain": "midi",

"plugin_class": "MidiPlugin",

777

"capabilities": {

778

"structured_merge": true,

"crdt": false,

"rerere": false

},

"schema": {

"domain": "midi", "merge_mode": "three_way",

784

"dimensions": [...], "top_level": {...}

785

},

786

"registered_domains": ["bitcoin", "code", "midi", "scaffold"]

}

```

| Exit | Meaning |

|---|---|

| 0 | Domain resolved and schema emitted |

793

| 1 | Domain not registered; bad `--format` |

794

| 3 | Plugin raised an error computing its schema |

---

### `show-ref` — list all branch refs

799

800

List all branch refs and the commit IDs they point to.

801

802

```sh

803

muse plumbing show-ref [-f json|text] [-p PATTERN] [-H] [-v REF]

```

|---|---|---|---|

| `--pattern` | `-p` | `""` | fnmatch glob to filter ref names |

810

811

| `--verify` | `-v` | `""` | Silent existence check — exit 0 if found, 1 if not |

**JSON output:**

```json

{

"refs": [

{"ref": "refs/heads/dev", "commit_id": "<sha256>"},

819

{"ref": "refs/heads/main", "commit_id": "<sha256>"}

820

],

821

"head": {"ref": "refs/heads/main", "branch": "main", "commit_id": "<sha256>"},

"count": 2

}

```

Use `--verify` in shell conditionals:

827

828

```sh

829

muse plumbing show-ref --verify refs/heads/my-branch && echo "branch exists"

```

| Exit | Meaning |

|---|---|

| 0 | Refs enumerated (or `--verify` ref exists) |

835

| 1 | `--verify` ref absent; bad `--format` |

836

| 3 | I/O error reading refs directory |

---

### `check-ignore` — test whether paths are excluded by `.museignore`

841

842

Test whether workspace paths are excluded by `.museignore` rules.

843

844

```sh

845

muse plumbing check-ignore <path>... [-f json|text] [-q] [-V]

```

|---|---|---|---|

**JSON output:**

```json

{

"domain": "midi",

"patterns_loaded": 4,

860

"results": [

861

{"path": "build/out.bin", "ignored": true, "matching_pattern": "build/"},

862

{"path": "tracks/dr.mid", "ignored": false, "matching_pattern": null}

]

}

```

Last-match-wins: a negation rule (`!important.mid`) can un-ignore a path

868

matched by an earlier rule.

| Exit | Meaning |

|---|---|

| 0 | Results emitted (or `--quiet` with all ignored) |

873

| 1 | `--quiet` with any non-ignored path; missing args |

874

| 3 | TOML parse error in `.museignore` |

---

### `check-attr` — query merge-strategy attributes for paths

879

880

Query merge-strategy attributes for workspace paths from `.museattributes`.

881

882

```sh

883

muse plumbing check-attr <path>... [-f json|text] [-d DIMENSION] [-A]

```

|---|---|---|---|

| `--dimension` | `-d` | `*` | Domain axis to query (e.g. `notes`, `tempo`) |

890

891

892

**JSON output (default: first-match):**

```json

{

"domain": "midi",

"rules_loaded": 3,

"dimension": "*",

"results": [

{

"path": "drums/kit.mid",

902

"dimension": "*",

903

"strategy": "ours",

904

"rule": {"path_pattern": "drums/*", "strategy": "ours", "priority": 10, ...}

}

]

}

```

When no rule matches, `strategy` is `"auto"` and `rule` is `null`.

| Exit | Meaning |

|---|---|

| 0 | Attributes resolved and emitted |

915

| 1 | Missing args; bad `--format` |

916

| 3 | TOML parse error in `.museattributes` |

---

### `verify-object` — re-hash stored objects to detect corruption

921

922

Re-hash stored objects to detect silent data corruption.

923

924

```sh

925

muse plumbing verify-object <object-id>... [-f json|text] [-q]

```

|---|---|---|---|

Objects are streamed in 64 KiB chunks — safe for very large blobs.

**JSON output:**

```json

{

"results": [

{"object_id": "<sha256>", "ok": true, "size_bytes": 4096, "error": null},

941

{"object_id": "<sha256>", "ok": false, "size_bytes": null,

942

"error": "object not found in store"}

],

"all_ok": false,

"checked": 2,

"failed": 1

}

```

Compose with `show-ref` to verify every commit in a repo:

951

952

```sh

953

muse plumbing show-ref -f json \

954

| jq -r '.refs[].commit_id' \

955

| xargs muse plumbing verify-object

```

| Exit | Meaning |

|---|---|

| 0 | All objects verified successfully |

961

| 1 | One or more objects failed; object not found; bad args |

962

| 3 | Unexpected I/O error (disk read failure) |

---

### `symbolic-ref` — read or write HEAD's symbolic reference

967

968

In Muse, HEAD is always a symbolic reference — it always points to a branch,

969

never directly to a commit. `symbolic-ref` reads which branch HEAD tracks or,

970

with `--set`, points HEAD at a different branch.

```sh

# Read mode

muse plumbing symbolic-ref HEAD [-f json|text] [--short]

975

976

# Write mode

977

muse plumbing symbolic-ref HEAD --set <branch> [-f json|text]

```

|---|---|---|---|

| `--set` | `-s` | `""` | Branch name to point HEAD at |

**JSON output (read mode):**

```json

{

"ref": "HEAD",

"symbolic_target": "refs/heads/main",

992

"branch": "main",

993

"commit_id": "<sha256>"

}

```

`commit_id` is `null` when the branch has no commits yet.

998

999

**Text output:** `refs/heads/main` (or just `main` with `--short`)

| Exit | Meaning |

|---|---|

| 0 | Ref read or written |

1004

| 1 | `--set` target branch does not exist; bad `--format` |

1005

| 3 | I/O error reading or writing HEAD |

---

### `for-each-ref` — iterate all refs with rich commit metadata

1010

1011

Enumerates every branch ref together with the full commit metadata it points to.

1012

Supports sorting by any commit field and glob-pattern filtering, making it

1013

ideal for agent pipelines that need to slice the ref list without post-processing.

1014

1015

```sh

1016

muse plumbing for-each-ref [-p <pattern>] [-s <field>] [-d] [-n <count>] [-f json|text]

```

|---|---|---|---|

| `--pattern` | `-p` | `""` | fnmatch glob on the full ref name, e.g. `refs/heads/feat/*` |

1022

| `--sort` | `-s` | `ref` | Sort field: `ref`, `branch`, `commit_id`, `author`, `committed_at`, `message` |

1023

1024

| `--count` | `-n` | `0` | Limit to first N refs after sorting (0 = unlimited) |

**JSON output:**

```json

{

"refs": [

{

"ref": "refs/heads/dev",

1034

"branch": "dev",

1035

"commit_id": "<sha256>",

1036

"author": "gabriel",

1037

"message": "Add verse melody",

1038

"committed_at": "2026-01-01T00:00:00+00:00",

1039

"snapshot_id": "<sha256>"

}

],

"count": 1

}

```

**Text output:** `<commit_id> <ref> <committed_at> <author>`

1047

1048

**Example — three most recently committed branches:**

1049

1050

```sh

1051

muse plumbing for-each-ref --sort committed_at --desc --count 3

```

| Exit | Meaning |

|---|---|

| 0 | Refs emitted (list may be empty) |

1057

| 1 | Bad `--sort` field; bad `--format` |

1058

| 3 | I/O error reading refs or commit records |

---

### `name-rev` — map commit IDs to branch-relative names

1063

1064

For each supplied commit ID, performs a single multi-source BFS from all branch

1065

tips and reports the closest branch and hop distance. Results are expressed as

1066

`<branch>~N` — where N is the number of parent hops from the tip. When N is 0

1067

(the commit is the exact branch tip) the name is the bare branch name with no

`~0` suffix.

```sh

muse plumbing name-rev <commit-id>... [-n] [-u <string>] [-f json|text]

```

|---|---|---|---|

**JSON output:**

```json

{

"results": [

{

"commit_id": "<sha256>",

"name": "main~3",

"branch": "main",

"distance": 3,

"undefined": false

},

{

"commit_id": "<sha256>",

"name": null,

"branch": null,

"distance": null,

"undefined": true

}

]

}

```

**Text output:** `<sha256> main~3` (or `main~3` with `--name-only`)

1104

1105

**Performance:** A single O(total-commits) BFS from all branch tips simultaneously.

1106

Every commit is visited at most once regardless of how many input IDs are supplied.

| Exit | Meaning |

|---|---|

| 0 | All results computed (some may be `undefined`) |

1111

| 1 | Bad `--format`; no commit IDs supplied |

1112

| 3 | I/O error reading commit records |

---

### `check-ref-format` — validate branch and ref names

1117

1118

Tests one or more names against Muse's branch-naming rules — the same

1119

validation used by `muse branch` and `muse plumbing update-ref`. Use in

1120

scripts to pre-validate names before attempting to create a branch.

1121

1122

```sh

1123

muse plumbing check-ref-format <name>... [-q] [-f json|text]

```

|---|---|---|---|

**Rules enforced:** 1–255 chars; no backslash, null bytes, CR, LF, or tab;

1132

no leading/trailing dot; no consecutive dots (`..`); no leading/trailing or

consecutive slashes.

**JSON output:**

```json

{

"results": [

{"name": "feat/my-branch", "valid": true, "error": null},

1141

{"name": "bad..name", "valid": false, "error": "..."}

],

"all_valid": false

}

```

**Text output:**

```

ok feat/my-branch

FAIL bad..name → Branch name 'bad..name' contains forbidden characters

1151

```

1152

1153

**Shell conditional:**

1154

1155

```sh

1156

muse plumbing check-ref-format -q "$BRANCH" && git checkout -b "$BRANCH"

```

| Exit | Meaning |

|---|---|

| 0 | All names are valid |

1162

| 1 | One or more names are invalid; no names supplied |

---

### `verify-pack` — verify PackBundle integrity

1167

1168

Reads a PackBundle JSON from stdin or `--file` and performs three-tier integrity

1169

checking:

1170

1171

1. **Object integrity** — every object payload is base64-decoded and its SHA-256

1172

is recomputed. The digest must match the declared `object_id`.

1173

2. **Snapshot consistency** — every snapshot's manifest entries reference objects

1174

present in the bundle or already in the local store.

1175

3. **Commit consistency** — every commit's `snapshot_id` is present in the bundle

1176

or already in the local store.

1177

1178

```sh

1179

muse plumbing pack-objects main | muse plumbing verify-pack

1180

muse plumbing verify-pack --file bundle.json

```

|---|---|---|---|

| `--file` | `-i` | `""` | Path to bundle file (reads stdin when omitted) |

**JSON output:**

```json

{

"objects_checked": 42,

1195

"snapshots_checked": 5,

1196

"commits_checked": 5,

"all_ok": true,

"failures": []

}

```

**With failures:**

```json

{

"all_ok": false,

"failures": [

{"kind": "object", "id": "<sha256>", "error": "hash mismatch"},

1209

{"kind": "snapshot", "id": "<sha256>", "error": "missing object: ..."}

]

}

```

**Validate before upload:**

1215

1216

```sh

1217

muse plumbing pack-objects main | muse plumbing verify-pack -q \

1218

&& echo "bundle is clean — safe to push"

```

| Exit | Meaning |

|---|---|

| 0 | Bundle is fully intact |

1224

| 1 | One or more integrity failures; malformed JSON; bad args |

1225

| 3 | I/O error reading stdin or the bundle file |

---

---

## Composability Patterns — Advanced

1232

1233

### Name every commit reachable from a branch

1234

1235

```sh

1236

# Get all commit IDs on feat/x since it diverged from dev

1237

BASE=$(muse plumbing merge-base feat/x dev -f text)

1238

muse plumbing commit-graph --tip feat/x --stop-at "$BASE" -f text \

1239

| xargs muse plumbing name-rev --name-only

1240

```

1241

1242

### Audit all refs with full metadata and filter by recency

1243

1244

```sh

1245

# List all branches modified in 2026, sorted newest-first

1246

muse plumbing for-each-ref --sort committed_at --desc \

1247

| jq '.refs[] | select(.committed_at | startswith("2026"))'

1248

```

1249

1250

### Validate a branch name before creating it

1251

1252

```sh

1253

BRANCH="feat/my-feature"

1254

muse plumbing check-ref-format -q "$BRANCH" \

1255

&& echo "Name is valid — safe to branch" \

1256

|| echo "Invalid branch name"

1257

```

1258

1259

### Verify a bundle before shipping

1260

1261

```sh

1262

muse plumbing pack-objects main | tee bundle.json | muse plumbing verify-pack -q \

1263

&& echo "bundle is clean — safe to push" \

1264

|| echo "bundle has integrity failures — do not push"

1265

```

1266

1267

### Switch active branch via plumbing

1268

1269

```sh

1270

# Check where HEAD is now

1271

muse plumbing symbolic-ref HEAD -f text # → refs/heads/main

1272

# Redirect HEAD to dev

1273

muse plumbing symbolic-ref HEAD --set dev

1274

muse plumbing rev-parse HEAD -f text # → tip of dev

1275

```

1276

1277

### Find stale branches (no commits in the last 30 days)

1278

1279

```sh

1280

# Requires `date` and `jq`

1281

CUTOFF=$(date -u -v-30d +%Y-%m-%dT%H:%M:%SZ 2>/dev/null \

1282

|| date -u --date="30 days ago" +%Y-%m-%dT%H:%M:%SZ)

1283

muse plumbing for-each-ref -f json \

1284

| jq --arg c "$CUTOFF" '.refs[] | select(.committed_at < $c) | .branch'

1285

```

1286

1287

### Check which files changed between two branches

1288

1289

```sh

1290

BASE=$(muse plumbing merge-base main feat/x -f text)

1291

muse plumbing snapshot-diff "$BASE" feat/x --format text --stat

```

---

## Object ID Quick Reference

1297

1298

All IDs in Muse are 64-character lowercase hex SHA-256 digests. There are

1299

three kinds:

1300

1301

| Kind | Computed from | Used by |

1302

|---|---|---|

1303

| **Object ID** | File bytes | `hash-object`, `cat-object`, snapshot manifests |

1304

| **Snapshot ID** | Sorted `path:object_id` pairs | `read-snapshot`, `commit-tree` |

1305

| **Commit ID** | Parent IDs + snapshot ID + message + timestamp | `read-commit`, `rev-parse`, `update-ref` |

1306

1307

Every ID is deterministic and content-addressed. The same input always

1308

produces the same ID; two different inputs never produce the same ID in

practice.

---

## Exit Code Summary

| Code | Constant | Meaning |

1316

|---|---|---|

1317

| 0 | `SUCCESS` | Command completed successfully |

1318

| 1 | `USER_ERROR` | Bad input, ref not found, invalid format |

1319

| 3 | `INTERNAL_ERROR` | I/O failure, integrity check, transport error |