From 3500a1e588fb3618ec1393f094310f181709d4ee Mon Sep 17 00:00:00 2001
From: SoftFever <softfeverever@gmail.com>
Date: Mon, 7 Sep 2026 10:46:59 +0800
Subject: [PATCH] unify id generation scripts

---
 .github/pull_request_template.md              |    2 +-
 docs/HLSD/filament_id.md                      |   86 +-
 scripts/assign_vendor_setting_ids.py          |  258 -----
 scripts/orca_extra_profile_check.py           |   20 +-
 ...assign_filament_ids.py => orca_id_tool.py} | 1009 +++++++++++------
 scripts/tests/test_filament_id.py             |  696 ++++++++++--
 scripts/tests/test_setting_id.py              |  902 +++++++++++++++
 scripts/update_bambu_filament_ids.py          |    4 +-
 src/libslic3r/Preset.cpp                      |    2 +-
 src/libslic3r/Preset.hpp                      |    4 +-
 src/libslic3r/PresetBundle.cpp                |    4 +-
 tests/libslic3r/test_preset_setting_id.cpp    |    6 +-
 12 files changed, 2230 insertions(+), 763 deletions(-)
 delete mode 100644 scripts/assign_vendor_setting_ids.py
 rename scripts/{assign_filament_ids.py => orca_id_tool.py} (54%)
 create mode 100644 scripts/tests/test_setting_id.py

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 8b82f51730..cf9799df19 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -20,7 +20,7 @@
 > Please describe the tests that you have conducted to verify the changes made in this PR.
 -->
 
-- [ ] New filament/material profiles: I wrote **no** `filament_id` key by hand — I ran `python scripts/assign_filament_ids.py` and `--update-snapshot` and committed both diffs (see `doc/developer-reference/filament_id.md`)
+- [ ] New filament/material profiles: I wrote **no** `filament_id` key by hand — I ran `python scripts/orca_id_tool.py --generate` and `--update-snapshot` and committed both diffs (see [docs/HLSD/filament_id.md](docs/HLSD/filament_id.md))
 
 <!--
 > A guide for users on how to download the artifacts from this PR.
diff --git a/docs/HLSD/filament_id.md b/docs/HLSD/filament_id.md
index eaf9de4a6c..92d75ca8ca 100644
--- a/docs/HLSD/filament_id.md
+++ b/docs/HLSD/filament_id.md
@@ -9,7 +9,7 @@ OrcaFilamentLibrary (OFL), Qidi, or Snapmaker bundle. The granularity is the nam
 not the brand behind it: `AAA PLA Lite` and `AAA PLA Pro` are two filaments with two ids, not
 variants of one.
 
-**How it is generated:** an id is computed, never invented. `scripts/assign_filament_ids.py`
+**How it is generated:** an id is computed, never invented. `scripts/orca_id_tool.py`
 mints it as a deterministic hash of the product's identity — the triple
 `(filament_vendor, filament_type, filament name)`, where the filament name is the preset name
 with its `@...` variant suffix stripped — producing an 8-character `OF*` code that is the
@@ -34,7 +34,7 @@ This page is the rule for authoring `filament_id` in system profiles
 
 > [!IMPORTANT]
 > **Never write a `filament_id` value by hand.** A new filament gets its id from
-> `python scripts/assign_filament_ids.py`; one already in the tree has one — inherit it.
+> `python scripts/orca_id_tool.py --generate`; one already in the tree has one — inherit it.
 
 ## The design, in two pieces
 
@@ -158,7 +158,8 @@ key needed). Tuning a generic material → **join the OrcaFilamentLibrary filame
    different product by rule 5, so it then needs its own id.
 5. **Ids follow the product identity.** The id is a pure function of the product triple
    `(filament_vendor, filament_type, filament name)`, so correcting any of them re-mints the id
-   **by design** (via `--remint <Vendor>`; the exact sequence is in the FAQ). Nothing forwards
+   **by design**, applied by `--generate` (preview with `--dry-run`, confine with `--vendor`) and
+   gated by the `--update-snapshot` diff; the exact sequence is in the FAQ. Nothing forwards
    the old value, so anything outside the tree that stored it — a device tray, a calibration
    record, a saved project — falls back to matching by filament type until the user re-selects
    the filament. Re-mint deliberately, and only to fix a genuinely wrong identity.
@@ -167,7 +168,7 @@ key needed). Tuning a generic material → **join the OrcaFilamentLibrary filame
 ## Minting — nobody invents ids
 
 New ids are deterministic, computed exactly like the `setting_id` precedent
-(`scripts/assign_vendor_setting_ids.py`):
+(the `setting_id` half of `scripts/orca_id_tool.py`):
 
 ```text
 FILAMENT_ID_NAMESPACE = uuid5(setting-id NAMESPACE, "filament_id")
@@ -204,36 +205,49 @@ Workflow for a new filament:
 
 ```bash
 # 1. Author the filament with NO filament_id key anywhere.
-python scripts/assign_filament_ids.py                    # 2. mint + insert ids into the root preset(s)
-python scripts/assign_filament_ids.py --update-snapshot  # 3. record the new claims in the snapshot
-python scripts/assign_filament_ids.py --check            # 4. verify — the same checks CI runs
-# 5. Commit the profile edits together with scripts/filament_id_snapshot.json.
+python scripts/orca_id_tool.py --dry-run          # 2. preview the ids — writes nothing
+python scripts/orca_id_tool.py --generate         # 3. apply them to the profile file(s)
+python scripts/orca_id_tool.py --update-snapshot  # 4. record the new claims in the snapshot
+python scripts/orca_id_tool.py --check            # 5. validate the filament_id state
+python scripts/orca_extra_profile_check.py        # 6. ...and everything else CI checks
+# 7. Commit the profile edits together with scripts/filament_id_snapshot.json, for review.
 ```
 
-The default run mints ids for id-less filaments and replaces any declaration that is not in
-`OF` format; it never rewrites a valid `OF` id, so it is idempotent and a no-op once every
-filament has one. It edits profile files byte-preservingly (indentation, BOM, and line endings
-intact) and re-parses them to fail loudly.
-`--mint "filament_vendor/filament_type/filament_name"` prints the id a **new** mint of that
-triple would get, without touching anything — note that for a triple whose id already exists
-it prints the next *free* salt iteration, not the live id (asking for
-`Polymaker/PLA/PolyLite PLA` today prints the salt-1 id, because `OF5CgdDq` is taken).
+`--generate` makes every filament's id equal the mint of its own
+`(filament_vendor, filament_type, filament name)` triple: it inserts one where an instantiated
+filament resolves none, and re-derives one that does not match. A preset that *inherits* a
+mismatching id is the one case left to the author — check 3b names it, and the fix is to inherit
+a preset of the same filament or to give the preset its own key. It converges on an id the same
+product already holds and salts only past ids *other* products hold, so an id already equal to a
+salt iteration of its own triple is left alone and deliberate salt splits survive. The same run
+assigns `generate_preset_setting_id(vendor, type, name)` to every instantiated filament, process
+and machine preset of every vendor except BBL, which keeps its authoritative `G*` ids, strips
+`setting_id` from base profiles, and fixes the misspelled `settings_id` key — dropped, or, for
+BBL, whose ids have no formula to fall back on, restored under the correct name. It is idempotent and
+byte-preserving (indentation, BOM, and line endings intact, every edited file re-parsed to fail
+loudly), and a no-op on a tree that already passes `scripts/orca_extra_profile_check.py` — the
+check CI runs over both id kinds, of which `--check` is the `filament_id` half.
 
-Maintenance modes (`--remint` is also the step for identity fixes — see the FAQ; the rest are
-normally only used by id migrations):
-
-- `--remint VENDOR` re-derives a vendor's declared ids from their triples — any vendor, BBL
-  included, since no bundle is exempt from the mint rule. A declaration already equal to a
-  salt iteration of its own triple is conformant and left alone, so deliberate salt splits
-  survive; convergence onto an id another bundle already uses for the *same* triple is legal
-  by design — that is the point.
-- `--drop-redundant-ids VENDOR` deletes declarations that merely re-declare an inherited
-  OrcaFilamentLibrary id.
+- `--filament-id` limits the run to `filament_id`.
+- `--setting-id` limits the run to `setting_id`. The two exclude each other; pass neither to
+  write both.
+- `--vendor VENDOR` confines the run to that bundle; repeatable. The ids are still derived
+  tree-wide, so a narrowed run writes exactly what a full one would — and reports any duplicate
+  it was not allowed to clear, since only a run covering both bundles can.
+- `--dry-run` reports what `--generate` would do and writes nothing; with no mode of its own it
+  implies `--generate`, so `--dry-run --vendor <Vendor>` previews just that bundle.
 - `--profiles DIR` points the tooling at a different profile tree (default
-  `resources/profiles`).
+  `resources/profiles`). `--check` and `--update-snapshot` read and write the sanctioned state of
+  the tree they are given, so pointing them elsewhere needs `--snapshot PATH` for that tree too —
+  `scripts/filament_id_snapshot.json` describes `resources/profiles` and no other tree.
+
+**Identity fixes need no separate mode.** `--generate` re-derives an id that no longer matches its
+triple exactly the way it fills in a missing one, so a rename or a `filament_vendor` /
+`filament_type` correction is just: fix the config, run `--generate` (confine it with `--vendor`,
+preview it with `--dry-run`), then `--update-snapshot` and review the diff.
 
 If you skip the tooling, CI fails and prints the remedy: the expected id for your filament and
-the instruction to run `python scripts/assign_filament_ids.py`; once the id is minted, the
+the instruction to run `python scripts/orca_id_tool.py --generate`; once the id is minted, the
 snapshot checks likewise point at `--update-snapshot` and tell you to commit the resulting
 diff.
 
@@ -466,18 +480,20 @@ ambiguity check behind structure rule 3.
   `Generic PLA` base name, set `compatible_printers`; no id key needed.
 - **A branded filament that borrows a generic's settings?** Fine — inherit `Generic X @System`
   (or any real filament) for the settings and declare the id of your own filament; run
-  `python scripts/assign_filament_ids.py` to mint it. Inheritance never changes the id.
+  `python scripts/orca_id_tool.py --generate` to mint it. Inheritance never changes the id.
 - **I need to fix a filament's `filament_vendor` or `filament_type`.** Fix the config, run
-  `--remint <Vendor>` then `--update-snapshot`, and commit the profile and snapshot diffs
-  together. The id re-derives from the corrected identity, and nothing forwards the old
-  value, so a tray or record still holding it falls back to matching by filament type.
+  `--generate --vendor <Vendor>` (preview with `--dry-run`), then `--update-snapshot`, and commit
+  the profile and snapshot diffs together. The id re-derives from the corrected identity, and
+  nothing forwards the old value, so a tray or record still holding it falls back to matching by
+  filament type.
 - **I need to rename a filament.** Rename the presets (adding `renamed_from`, which keeps the
-  preset *name* resolving), then `--remint <Vendor>`, then `--update-snapshot`. The id follows
-  the new filament name; as with any identity fix, the old id is not forwarded.
+  preset *name* resolving), then `--generate --vendor <Vendor>` (preview with `--dry-run`), then
+  `--update-snapshot`. The id follows the new filament name; as with any identity fix, the old id
+  is not forwarded.
 - **Can I reuse a `QD_*` id for a Qidi profile?** No — nobody can. It is the device protocol's
   own id space: the box composes those values at runtime and no preset carries one. Author
   Qidi filaments like any other vendor's.
-- **CI says my filament needs an id.** Run `python scripts/assign_filament_ids.py`, then
+- **CI says my filament needs an id.** Run `python scripts/orca_id_tool.py --generate`, then
   `--update-snapshot`, and commit both diffs. Do not type an id by hand.
 
 For general profile authoring, see the profile development guide on the
diff --git a/scripts/assign_vendor_setting_ids.py b/scripts/assign_vendor_setting_ids.py
deleted file mode 100644
index 8ed607f591..0000000000
--- a/scripts/assign_vendor_setting_ids.py
+++ /dev/null
@@ -1,258 +0,0 @@
-#!/usr/bin/env python3
-"""
-Assign deterministic, globally-unique setting_id to OrcaSlicer system profiles.
-
-Policy (see AGENTS.md "Critical Constraints"):
-  * A preset's setting_id is a pure function of its identity:
-        setting_id = base62_16( uuid5(NAMESPACE, "<vendor>/<type>/<name>") )
-    The same value is recomputed on the fly by the C++ app
-    (Slic3r::generate_preset_setting_id); the two MUST stay byte-identical. The rule
-    (generate_preset_setting_id, below) is also imported by the validator
-    (orca_extra_profile_check.py). Uniqueness is therefore automatic: two presets
-    collide only if they share vendor + type + name, which the validator flags.
-  * Bambu (BBL) owns the authoritative "G*" id space and is the only reserved vendor:
-    its ids are never rewritten (preserves backward-compat with Bambu-synced presets).
-    Every other vendor - including OrcaFilamentLibrary and Custom - follows the
-    deterministic rule.
-  * Only instantiated presets (instantiation == "true") carry a setting_id; base /
-    template profiles do not.
-
-Only setting_id is rewritten. filament_id is deliberately left untouched: it is a
-per-material id, shared across a filament's nozzle variants and inherited from base
-templates, so it must not be made per-file unique.
-
-Run from anywhere:  python3 scripts/assign_vendor_setting_ids.py
-The script is idempotent: a second run over an unchanged tree produces no diff.
-"""
-
-import json
-import os
-import re
-import sys
-import uuid
-
-
-# Deterministic preset setting_id rule. Imported by the validator
-# (orca_extra_profile_check.py) and kept byte-identical to the C++
-# Slic3r::generate_preset_setting_id. Dedicated namespace, distinct from the cloud
-# namespace (f47ac10b-...) so the two id spaces never coincide; this constant is baked
-# into both languages - never change it.
-NAMESPACE = uuid.UUID("c1f4d9e2-7a3b-5c8d-9e0f-1a2b3c4d5e6f")
-ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-ID_LENGTH = 16
-
-
-def generate_preset_setting_id(vendor, type_name, name):
-    """Deterministic 16-char base62 setting_id for a preset.
-
-    input = f"{vendor}/{type_name}/{name}"; u = uuid5(NAMESPACE, input);
-    id = the low ID_LENGTH base62 digits of int(u.bytes, "big"), most-significant first.
-    """
-    u = uuid.uuid5(NAMESPACE, f"{vendor}/{type_name}/{name}")
-    n = int.from_bytes(u.bytes, "big")
-    digits = []
-    for _ in range(ID_LENGTH):
-        digits.append(ALPHABET[n % 62])
-        n //= 62
-    return "".join(reversed(digits))
-
-
-PROFILES_DIR = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "resources", "profiles"))
-
-# Bambu (BBL) is the only reserved vendor: it keeps its authoritative "G*" cloud ids.
-RESERVED_VENDORS = {"BBL"}
-
-PROFILE_SUBDIRS = ("filament", "process", "machine")
-
-
-def iter_profile_files(vendor_dir):
-    """Yield (json path, type) under a vendor, in a deterministic order.
-
-    type is the subdir name ("filament"/"process"/"machine"), which matches
-    Preset::get_type_string() on the C++ side.
-    """
-    for sub in PROFILE_SUBDIRS:
-        base = os.path.join(vendor_dir, sub)
-        if not os.path.isdir(base):
-            continue
-        for root, dirs, files in os.walk(base):
-            dirs.sort()  # deterministic traversal across filesystems
-            for name in sorted(files):
-                if name.endswith(".json"):
-                    yield os.path.join(root, name), sub
-
-
-def read_profile(path):
-    """Return (setting_id, instantiation, name) as present (or None)."""
-    try:
-        with open(path, "rb") as f:
-            data = json.loads(f.read())
-    except (ValueError, OSError):
-        return None, None, None
-    if not isinstance(data, dict):
-        return None, None, None
-    return data.get("setting_id"), data.get("instantiation"), data.get("name")
-
-
-def list_vendors():
-    return sorted(
-        d for d in os.listdir(PROFILES_DIR)
-        if os.path.isdir(os.path.join(PROFILES_DIR, d))
-    )
-
-
-_JSON_STR = r'"(?:[^"\\]|\\.)*"'
-
-
-def remove_key_line(text, key):
-    """Remove a top-level `"key": "..."` member, preserving formatting.
-
-    Handles both the common case (member has a trailing comma) and the member
-    being the LAST in its object (consume the preceding comma instead, so no
-    dangling comma is left). Returns (new_text, count).
-    """
-    # Member followed by a comma (not the last in the object).
-    trailing = re.compile(
-        r'[ \t]*"' + re.escape(key) + r'"[ \t]*:[ \t]*' + _JSON_STR + r'[ \t]*,[ \t]*\r?\n'
-    )
-    new, n = trailing.subn("", text, count=1)
-    if n:
-        return new, n
-    # Member is the last one: drop the preceding comma and the member itself.
-    leading = re.compile(
-        r',[ \t]*\r?\n[ \t]*"' + re.escape(key) + r'"[ \t]*:[ \t]*' + _JSON_STR
-    )
-    return leading.subn("", text, count=1)
-
-
-def _remove_key_in_tree(key, should_remove):
-    """Remove `key` from files where should_remove(sid, inst, text) is True."""
-    removed = 0
-    for vendor in list_vendors():
-        for path, _type in iter_profile_files(os.path.join(PROFILES_DIR, vendor)):
-            with open(path, "rb") as f:
-                text = f.read().decode("utf-8")
-            sid, inst, _name = read_profile(path)
-            if not should_remove(sid, inst, text):
-                continue
-            new_text, n = remove_key_line(text, key)
-            if n == 0:
-                raise RuntimeError(f"Could not locate {key} line to remove: {path}")
-            json.loads(new_text)  # fail loudly if removal broke the JSON
-            with open(path, "wb") as f:
-                f.write(new_text.encode("utf-8"))
-            removed += 1
-    return removed
-
-
-def remove_misspelled_settings_id():
-    """Delete the misspelled "settings_id" key (extra "s") wherever it appears.
-
-    The app never reads that key, so those presets effectively had no setting_id
-    and get a correct one assigned by the normal pass; here we drop the junk key.
-    """
-    return _remove_key_in_tree(
-        "settings_id", lambda sid, inst, text: '"settings_id"' in text
-    )
-
-
-def strip_base_setting_ids():
-    """Remove setting_id from every base profile (instantiation != "true").
-
-    Convention: only instantiated, user-selectable presets carry a setting_id;
-    base/template profiles do not. Applied across all vendors.
-    """
-    return _remove_key_in_tree(
-        "setting_id", lambda sid, inst, text: bool(sid) and inst != "true"
-    )
-
-
-def replace_id_value(text, key, new_value):
-    """Replace the first top-level `"key": "..."` value, preserving all formatting."""
-    pattern = re.compile(r'("' + re.escape(key) + r'"\s*:\s*)"(?:[^"\\]|\\.)*"')
-    repl = lambda m: m.group(1) + json.dumps(new_value, ensure_ascii=False)
-    new_text, n = pattern.subn(repl, text, count=1)
-    return new_text, n
-
-
-def insert_setting_id(text, new_id):
-    """Insert a `"setting_id"` line into a preset that lacks one.
-
-    Placed just before `filament_id` (or, failing that, `instantiation`) so it
-    matches the canonical key order, reusing that anchor line's indentation and
-    line ending. Only setting_id is added; filament_id is left untouched.
-    """
-    for key in ("filament_id", "instantiation"):
-        m = re.search(r'^([ \t]*)"' + key + r'"[ \t]*:.*?(\r?\n)', text, re.MULTILINE)
-        if m:
-            line = f'{m.group(1)}"setting_id": {json.dumps(new_id, ensure_ascii=False)},{m.group(2)}'
-            return text[:m.start()] + line + text[m.start():], 1
-    return text, 0
-
-
-def rewrite_file(path, new_id, has_setting_id):
-    """Set the preset's setting_id to new_id (replacing or inserting as needed).
-
-    filament_id is intentionally left untouched. Uses binary IO so the file's
-    original line endings (LF or CRLF) and exact formatting are preserved
-    byte-for-byte apart from the changed/added line. The result is re-parsed to
-    guarantee it is still valid JSON.
-    """
-    with open(path, "rb") as f:
-        text = f.read().decode("utf-8")
-    if has_setting_id:
-        text, n = replace_id_value(text, "setting_id", new_id)
-    else:
-        text, n = insert_setting_id(text, new_id)
-    if n == 0:
-        raise RuntimeError(f"Could not set setting_id on {path}")
-    json.loads(text)  # fail loudly if the edit broke the JSON
-    with open(path, "wb") as f:
-        f.write(text.encode("utf-8"))
-    return True
-
-
-def main():
-    # 0. Drop the misspelled "settings_id" key wherever it appears.
-    typos = remove_misspelled_settings_id()
-
-    # 1. Strip setting_id from base profiles everywhere (only instantiated presets keep one).
-    stripped = strip_base_setting_ids()
-
-    # 2. Assign the deterministic setting_id to every instantiated preset of every
-    #    non-reserved vendor.
-    changed = added = 0
-    vendors_touched = []
-    for vendor in list_vendors():
-        if vendor in RESERVED_VENDORS:
-            continue
-        vendor_changed = 0
-        for path, type_name in iter_profile_files(os.path.join(PROFILES_DIR, vendor)):
-            sid, inst, name = read_profile(path)
-            if inst != "true":
-                continue
-            if not name:
-                raise RuntimeError(f"instantiated preset has no \"name\": {path}")
-            new_id = generate_preset_setting_id(vendor, type_name, name)
-            if sid == new_id:
-                continue  # already correct - idempotent
-            rewrite_file(path, new_id, has_setting_id=sid is not None)
-            changed += 1
-            vendor_changed += 1
-            if sid is None:
-                added += 1
-        if vendor_changed:
-            vendors_touched.append((vendor, vendor_changed))
-
-    print(f"Misspelled settings_id removed : {typos}")
-    print(f"Base setting_ids stripped : {stripped}")
-    print(f"Reserved vendors : {sorted(RESERVED_VENDORS)}")
-    print(f"Vendors updated  : {len(vendors_touched)}")
-    for v, n in vendors_touched:
-        print(f"    {v}  ({n} files)")
-    print(f"Files rewritten  : {changed}  (of which newly assigned: {added})")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/scripts/orca_extra_profile_check.py b/scripts/orca_extra_profile_check.py
index 285b2fbf64..e95e2c29e8 100644
--- a/scripts/orca_extra_profile_check.py
+++ b/scripts/orca_extra_profile_check.py
@@ -3,8 +3,7 @@ import json
 import argparse
 from pathlib import Path
 
-from assign_vendor_setting_ids import generate_preset_setting_id
-from assign_filament_ids import check_filament_ids
+from orca_id_tool import generate_preset_setting_id, check_filament_ids
 
 OBSOLETE_KEYS = {
     "acceleration", "scale", "rotate", "duplicate", "duplicate_grid",
@@ -488,10 +487,11 @@ PROFILE_SUBDIRS = ("filament", "process", "machine")
 
 def check_setting_id_uniqueness(profiles_dir):
     """
-    Validate setting_id across every vendor (see scripts/assign_vendor_setting_ids.py):
+    Validate setting_id across every vendor (see scripts/orca_id_tool.py):
       1. Every instantiated preset must HAVE a setting_id.            (all vendors)
       2. A stored setting_id must equal generate_preset_setting_id(vendor, type, name); a stale
-         value means the JSON was edited without rerunning assign_vendor_setting_ids.py.
+         value means the JSON was edited without rerunning
+         "python scripts/orca_id_tool.py --generate --setting-id".
          (all vendors EXCEPT the formula-exempt ones, e.g. BBL)
       3. Base profiles (instantiation != "true") must not carry a setting_id.  (all vendors)
       4. setting_id must be globally unique - no two files may share one.       (all vendors)
@@ -523,7 +523,8 @@ def check_setting_id_uniqueness(profiles_dir):
                     errors += 1
                     print_error(
                         f'profile {rel} uses the misspelled key "settings_id" '
-                        f'(should be "setting_id"); run assign_vendor_setting_ids.py'
+                        f'(should be "setting_id"); run '
+                        f'"python scripts/orca_id_tool.py --generate --setting-id"'
                     )
                 sid = data.get("setting_id")
                 instantiated = data.get("instantiation") == "true"
@@ -533,7 +534,8 @@ def check_setting_id_uniqueness(profiles_dir):
                         errors += 1
                         print_error(
                             f'base profile {rel} (instantiation != "true") must not have a '
-                            f'setting_id ("{sid}"); run assign_vendor_setting_ids.py'
+                            f'setting_id ("{sid}"); run '
+                            f'"python scripts/orca_id_tool.py --generate --setting-id"'
                         )
                     continue
                 # Rule 1: every instantiated preset must have a setting_id.
@@ -541,7 +543,7 @@ def check_setting_id_uniqueness(profiles_dir):
                     errors += 1
                     print_error(
                         f"instantiated preset {rel} is missing a setting_id; "
-                        f"run assign_vendor_setting_ids.py"
+                        f'run "python scripts/orca_id_tool.py --generate --setting-id"'
                     )
                     continue
                 # Rule 2: the stored id must match the deterministic rule. BBL keeps its
@@ -553,7 +555,7 @@ def check_setting_id_uniqueness(profiles_dir):
                         print_error(
                             f'setting_id "{sid}" in {rel} does not match the expected '
                             f'"{expected}" for {vendor}/{sub}/{data.get("name", "")}; '
-                            f"run assign_vendor_setting_ids.py"
+                            f'run "python scripts/orca_id_tool.py --generate --setting-id"'
                         )
                         continue
                 # Rule 4: collect for the global-uniqueness check below.
@@ -631,7 +633,7 @@ def main():
     # Runs once over the whole tree regardless of the --vendor filter.
     errors_found += check_setting_id_uniqueness(profiles_dir)
 
-    # Global filament_id check (see scripts/assign_filament_ids.py): effective ids
+    # Global filament_id check (see scripts/orca_id_tool.py): effective ids
     # are resolved loader-faithfully and validated against the sanctioned snapshot
     # (scripts/filament_id_snapshot.json). Runs once over the whole tree.
     errors_found += check_filament_ids(profiles_dir)
diff --git a/scripts/assign_filament_ids.py b/scripts/orca_id_tool.py
similarity index 54%
rename from scripts/assign_filament_ids.py
rename to scripts/orca_id_tool.py
index e10dbe138e..8d08bde4ab 100755
--- a/scripts/assign_filament_ids.py
+++ b/scripts/orca_id_tool.py
@@ -1,9 +1,13 @@
 #!/usr/bin/env python3
 """
-Mint deterministic filament_id values for OrcaSlicer system filament products and
-validate the tree against the sanctioned-state snapshot.
+Assign and validate the deterministic ids of OrcaSlicer system profiles: the
+per-product filament_id and the per-preset setting_id.
 
-Policy (companion to assign_vendor_setting_ids.py; see docs/HLSD/filament_id.md):
+Both ids are pure functions of the thing they name, so nothing here is ever
+invented: the tool only writes the id the rules below already imply, and a tree
+that already satisfies them is left untouched.
+
+filament_id policy (see docs/HLSD/filament_id.md):
   * filament_id is a PRODUCT id: one named spool product = one id, shared by all
     of that product's per-printer/per-nozzle variants in every bundle. The
     granularity is the name on the spool, not the brand: "AAA PLA Lite" and
@@ -20,8 +24,8 @@ Policy (companion to assign_vendor_setting_ids.py; see docs/HLSD/filament_id.md)
         filament_id = "OF" + base62_6( uuid5(FILAMENT_ID_NAMESPACE,
             "filament_product/<filament_vendor>/<filament_type>/<filament_name>") )
     8 chars total, which satisfies the AMS length limit. Nobody invents ids by
-    hand; on the astronomically rare collision with an existing id the input
-    is salted ("/1", "/2", ...) until free and the result is frozen in file.
+    hand; on the astronomically rare collision with another product's id the
+    input is salted ("/1", "/2", ...) until free and the result is frozen in file.
     Identity changes (a filament rename, a filament_vendor/filament_type fix)
     change the id BY DESIGN.
   * Reserved id spaces that are never minted into or altered:
@@ -41,25 +45,34 @@ Policy (companion to assign_vendor_setting_ids.py; see docs/HLSD/filament_id.md)
     diff to that file (the maintainer gate). It sanctions state, never
     exceptions: no check consults it to excuse a preset from the rules above.
 
+setting_id policy (see AGENTS.md "Critical Constraints"):
+  * setting_id is a PRESET id, a pure function of the preset's identity:
+        setting_id = base62_16( uuid5(NAMESPACE, "<vendor>/<type>/<name>") )
+    The same value is recomputed on the fly by the C++ app
+    (Slic3r::generate_preset_setting_id); the two MUST stay byte-identical, and
+    the validator (orca_extra_profile_check.py) imports the rule from here.
+    Uniqueness is therefore automatic: two presets collide only if they share
+    vendor + type + name, which the validator flags.
+  * Only instantiated presets (instantiation == "true") carry a setting_id;
+    base / template profiles do not.
+  * Bambu (BBL) owns the authoritative "G*" setting_id space and is the only
+    reserved vendor: its setting_ids are never rewritten, which keeps
+    Bambu-synced presets backward compatible. filament_id has no such exemption
+    — the GF* catalog space is frozen and ownerless, so BBL's filament_ids are
+    minted like every other vendor's.
+
 The effective-id resolution below is loader-faithful (PresetBundle.cpp
 load_vendor_configs_from_json): own filament_id key, else walk `inherits` within
 the vendor map, with OrcaFilamentLibrary base-bundle fallback; once a chain enters
 OFL it stays in OFL; a vendor chain that dead-ends id-less retries its direct
 parent in the OFL map. filament_vendor / filament_type resolve the same way.
 
-Run from anywhere:  python3 scripts/assign_filament_ids.py
-  (default)          mint + insert ids for id-less filaments, mint + replace
-                     non-OF-format declarations; idempotent, never rewrites a
-                     valid OF-format id; a no-op once every filament has one
-  --mint "Vendor/Type/Filament"
-                     print the id that triple would mint; touches nothing
-  --update-snapshot  regenerate the snapshot from the tree
-  --remint VENDOR    re-derive VENDOR's declared ids from their triples and
-                     rewrite mismatches in place (repeatable)
-  --drop-redundant-ids VENDOR
-                     delete declarations that re-declare an inherited OFL id
-  --check            run the validation checks (also run by CI through
-                     orca_extra_profile_check.py); exit nonzero on errors
+Run from anywhere:
+  python scripts/orca_id_tool.py --generate         write the ids every profile should carry
+  python scripts/orca_id_tool.py --dry-run          preview that; writes nothing
+  python scripts/orca_id_tool.py --check            validate filament_id state (what CI runs)
+  python scripts/orca_id_tool.py --update-snapshot  re-record the sanctioned filament_id state
+Narrow --generate with --filament-id / --setting-id and --vendor VENDOR (repeatable).
 """
 
 import argparse
@@ -69,11 +82,15 @@ import re
 import sys
 import uuid
 
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from assign_vendor_setting_ids import ALPHABET, NAMESPACE  # noqa: E402
+# The id namespace baked into both Python and C++ (Slic3r::generate_preset_setting_id).
+# Dedicated, distinct from the cloud namespace (f47ac10b-...) so the two id spaces never
+# coincide; it is the root of BOTH id rules below — never change it.
+NAMESPACE = uuid.UUID("c1f4d9e2-7a3b-5c8d-9e0f-1a2b3c4d5e6f")
+ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+SETTING_ID_LENGTH = 16
 
-# Dedicated namespace for filament_id, derived from the setting_id namespace baked
-# into both Python and C++ (assign_vendor_setting_ids.NAMESPACE). Never change it.
+# Dedicated namespace for filament_id, derived from the setting_id namespace above.
+# Never change it.
 # FILAMENT_ID_NAMESPACE == UUID("c4d3ff49-4c32-5534-a3e3-00894157ab97")
 FILAMENT_ID_NAMESPACE = uuid.uuid5(NAMESPACE, "filament_id")
 FILAMENT_ID_LENGTH = 6  # base62 digits after the "OF" prefix -> 8 chars total
@@ -88,6 +105,14 @@ BAMBU_MAP_PATH = os.path.normpath(
 
 OFL = "OrcaFilamentLibrary"
 
+# Bambu (BBL) is the only vendor exempt from the setting_id rule: it keeps its
+# authoritative "G*" cloud ids. No vendor is exempt from the filament_id rule.
+RESERVED_VENDORS = {"BBL"}
+
+# The profile types that carry a setting_id; the subdir name is also the type
+# name, matching Preset::get_type_string() on the C++ side.
+PROFILE_SUBDIRS = ("filament", "process", "machine")
+
 OF_ID_RE = re.compile(r"^OF[0-9A-Za-z]{6}$")
 # User-custom id space minted by CreatePresetsDialog.cpp ("P" + md5(name)[0:7]);
 # reserved case-insensitively, together with its "null" sentinel.
@@ -97,8 +122,11 @@ USER_CUSTOM_ID_RE = re.compile(r"^P[0-9A-Fa-f]{7}$", re.IGNORECASE)
 BASE_NAME_RE = re.compile(r"\s?@.*$")
 # Salt iterations accepted by the identity check (check 3).
 MAX_CHECK_SALT = 8
+# A JSON string literal, for the byte-preserving key edits.
+_JSON_STR = r'"(?:[^"\\]|\\.)*"'
 
-UPDATE_HINT = 'run "python scripts/assign_filament_ids.py --update-snapshot" and commit the diff for maintainer review'
+GENERATE_CMD = "python scripts/orca_id_tool.py --generate"
+UPDATE_HINT = 'run "python scripts/orca_id_tool.py --update-snapshot" and commit the diff for maintainer review'
 BAMBU_MAP_HINT = 'regenerate the map with "python scripts/update_bambu_filament_ids.py" and commit the diff for maintainer review'
 
 
@@ -131,6 +159,32 @@ def _utf8_console():
 # Minting
 # ---------------------------------------------------------------------------
 
+def _base62_tail(n, length):
+    """The low `length` base62 digits of n, most-significant first.
+
+    The shared tail of both id rules. Its output bytes are pinned by the C++
+    golden vectors (tests/libslic3r/test_preset_setting_id.cpp) and by the
+    filament_id snapshot — never change it.
+    """
+    digits = []
+    for _ in range(length):
+        digits.append(ALPHABET[n % 62])
+        n //= 62
+    return "".join(reversed(digits))
+
+
+def generate_preset_setting_id(vendor, type_name, name):
+    """Deterministic 16-char base62 setting_id for a preset.
+
+    input = f"{vendor}/{type_name}/{name}"; u = uuid5(NAMESPACE, input);
+    id = the low SETTING_ID_LENGTH base62 digits of int(u.bytes, "big"),
+    most-significant first. Kept byte-identical to the C++
+    Slic3r::generate_preset_setting_id.
+    """
+    u = uuid.uuid5(NAMESPACE, f"{vendor}/{type_name}/{name}")
+    return _base62_tail(int.from_bytes(u.bytes, "big"), SETTING_ID_LENGTH)
+
+
 def base_name(name):
     """Filament name of a preset: name with the first "@..." suffix stripped."""
     return BASE_NAME_RE.sub("", name, count=1)
@@ -148,22 +202,24 @@ def generate_filament_id(filament_vendor, filament_type, filament_name, salt=0):
     if salt:
         key = f"{key}/{salt}"
     u = uuid.uuid5(FILAMENT_ID_NAMESPACE, key)
-    n = int.from_bytes(u.bytes, "big")
-    digits = []
-    for _ in range(FILAMENT_ID_LENGTH):
-        digits.append(ALPHABET[n % 62])
-        n //= 62
-    return "OF" + "".join(reversed(digits))
+    return "OF" + _base62_tail(int.from_bytes(u.bytes, "big"), FILAMENT_ID_LENGTH)
 
 
 def mint_filament_id(filament_vendor, filament_type, filament_name, taken):
-    """Mint the product's id, salting past any id in `taken`."""
-    for salt in range(10000):
+    """Mint the product's id: the first salt iteration not in `taken`.
+
+    Bounded by MAX_CHECK_SALT, the last iteration the identity check accepts, so
+    the tool can never write an id its own --check would reject. Exhausting it
+    would take nine base62 collisions on one triple; it means something is wrong
+    with `taken`, not that a tenth salt is needed.
+    """
+    for salt in range(MAX_CHECK_SALT + 1):
         candidate = generate_filament_id(filament_vendor, filament_type, filament_name, salt)
         if candidate not in taken:
             return candidate
     raise RuntimeError(
-        f"could not mint a free filament_id for {filament_vendor}/{filament_type}/{filament_name}")
+        f"could not mint a free filament_id for {filament_vendor}/{filament_type}/"
+        f"{filament_name}: salts 0..{MAX_CHECK_SALT} are all taken")
 
 
 def mint_iterations(triple):
@@ -194,6 +250,33 @@ def list_vendor_names(profiles_dir):
     )
 
 
+def list_profile_dirs(profiles_dir):
+    """Every vendor directory under the tree, index or not.
+
+    What the setting_id pass walks, and what orca_extra_profile_check.py walks:
+    setting_id is a per-file property, so a bundle whose index has not landed yet
+    must still be assignable — otherwise the validator flags files the tool
+    refuses to touch. (filament_id is driven by each bundle's filament_list
+    instead, hence list_vendor_names above.)
+    """
+    profiles_dir = str(profiles_dir)
+    return sorted(d for d in os.listdir(profiles_dir)
+                  if os.path.isdir(os.path.join(profiles_dir, d)))
+
+
+def iter_profile_files(vendor_dir):
+    """Yield (json path, type) under a vendor bundle, in a deterministic order."""
+    for sub in PROFILE_SUBDIRS:
+        base = os.path.join(vendor_dir, sub)
+        if not os.path.isdir(base):
+            continue
+        for root, dirs, files in os.walk(base):
+            dirs.sort()  # deterministic traversal across filesystems
+            for name in sorted(files):
+                if name.endswith(".json"):
+                    yield os.path.join(root, name), sub
+
+
 def load_vendor_filaments(profiles_dir, vendor):
     """Load a vendor's filament presets from its index's filament_list.
 
@@ -230,7 +313,7 @@ def load_vendor_filaments(profiles_dir, vendor):
     return presets, errors
 
 
-def resolve_filament_id(name, filaments, ofl_filaments, seen=None, in_ofl=False, skip_own=False):
+def resolve_filament_id(name, filaments, ofl_filaments, seen=None, in_ofl=False):
     """Walk the inherits chain for the effective filament_id, loader-faithfully.
 
     Mirrors PresetBundle.cpp load_vendor_configs_from_json: a hop resolves in the
@@ -240,10 +323,6 @@ def resolve_filament_id(name, filaments, ofl_filaments, seen=None, in_ofl=False,
     hops). Additionally, a vendor preset that never resolves an id inside the
     vendor is re-tried against the OFL map keyed by its direct parent name.
 
-    skip_own ignores the first preset's own filament_id key (used to compute the
-    id its inherits chain would resolve WITHOUT the declaration — the
-    --drop-redundant-ids redundancy test).
-
     Returns (filament_id or None, source, ofl_entry) where source is one of
     "own"/"inherited"/"missing"/"dangling"/"cycle" and ofl_entry is the name of
     the OFL preset through which a vendor chain entered OFL (None when the id was
@@ -263,7 +342,7 @@ def resolve_filament_id(name, filaments, ofl_filaments, seen=None, in_ofl=False,
             rec, in_ofl, entry = ofl_filaments[name], True, name
     if rec is None:
         return None, "dangling", None
-    if rec.get("filament_id") and not skip_own:
+    if rec.get("filament_id"):
         return rec["filament_id"], "own" if len(seen) == 1 else "inherited", entry
     parent = rec.get("inherits")
     if parent:
@@ -541,8 +620,7 @@ def check_filament_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH,
                 continue
             print_error(
                 f'filament_id "{fid}" ({vendor}) is not a minted "OF" id; new '
-                f'filament ids must come from "python scripts/assign_filament_ids.py" '
-                f'(see --mint)')
+                f'filament ids must come from "{GENERATE_CMD}"')
             errors += 1
 
     # -- 2. snapshot equality (both directions) -----------------------------
@@ -594,7 +672,8 @@ def check_filament_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH,
             f'filament_id "{fid}" declared by "{rec["name"]}" ({rec["file"]}) does '
             f'not match the mint of its triple "{"/".join(triple)}": expected '
             f'"{generate_filament_id(*triple)}" (or a salted iteration); paste the '
-            f"expected id, or fix the triple and --remint the vendor")
+            f'expected id, or fix the triple and run "{GENERATE_CMD} --vendor {vendor}" '
+            f"(preview with --dry-run), then --update-snapshot")
         errors += 1
     for vendor, rec, eff, triple in sorted(
             analysis["id_mismatches"], key=lambda x: (x[0], x[1]["file"])):
@@ -611,7 +690,7 @@ def check_filament_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH,
         print_error(
             f'instantiated filament "{name}" ({file}) resolves no filament_id anywhere '
             f"in its inherits chain — this is a hard load error in the C++ loader; "
-            f'run "python scripts/assign_filament_ids.py" (expected id for filament '
+            f'run "{GENERATE_CMD}" (expected id for filament '
             f'"{vendor}/{base_name(name)}": "{expected}", salted if taken)')
         errors += 1
 
@@ -722,20 +801,24 @@ def check_filament_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH,
 # --update-snapshot
 # ---------------------------------------------------------------------------
 
-def update_snapshot(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
+def update_snapshot(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH, dry_run=False):
     """Regenerate the snapshot from the tree.
 
-    Refuses to sanction a reserved-namespace id (or a claim on one) and an id
-    declared under more than one triple: neither can ever pass --check, so
-    writing it into the snapshot would only hide the mistake until CI.
+    Refuses to sanction a tree it could not read whole, a reserved-namespace id
+    (or a claim on one) and an id declared under more than one triple: none of
+    them can ever pass --check, so writing them into the snapshot would only
+    hide the mistake until CI.
     Idempotent: a second run over an unchanged tree changes nothing. Returns 0
     on success.
     """
     analysis = analyze_tree(profiles_dir)
+    # A tree that could not be read whole cannot be sanctioned: the snapshot
+    # would silently drop the unreadable bundle's ids and claims, and the diff
+    # would read as a deliberate removal.
+    refusals = len(analysis["read_errors"])
     for msg in analysis["read_errors"]:
         print_error(msg)
 
-    refusals = 0
     for vendor in sorted(analysis["vendor_ids"]):
         for fid in sorted(analysis["vendor_ids"][vendor]):
             is_reserved, owner = reserved_space_owner(fid)
@@ -769,13 +852,15 @@ def update_snapshot(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
         for fid, entry in old_ids.items())
     changed = new_snap != (old_snap or {"ids": {}})
 
-    if changed:
+    if changed and not dry_run:
         write_snapshot(snapshot_path, new_snap)
 
     print_info(f"snapshot ids      : {len(new_snap['ids'])} (+{len(added_ids)} / -{len(removed_ids)})")
     print_info(f"claims added      : {added_claims}")
     print_info(f"claims removed    : {removed_claims}")
-    if changed:
+    if changed and dry_run:
+        print_success(f"dry run: {snapshot_path} would be rewritten; nothing written")
+    elif changed:
         print_success(f"snapshot written to {snapshot_path}")
     else:
         print_success("snapshot already up to date; nothing changed")
@@ -785,61 +870,92 @@ def update_snapshot(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
 # ---------------------------------------------------------------------------
 # Byte-preserving profile edits
 # ---------------------------------------------------------------------------
+# Binary IO throughout: a profile keeps its original line endings (LF or CRLF),
+# its BOM and its exact formatting apart from the one line being touched.
+
+def insert_key_line(text, key, value, before=(), after=()):
+    """Insert a `"key": value` line into a preset that lacks one.
+
+    Placed just before the first `before` anchor the file has (matching the
+    canonical key order), else just after the first `after` anchor, reusing that
+    anchor line's indentation and line ending. Returns (text, insertions made).
+    """
+    def line(m):
+        return (f'{m.group(1)}"{key}": {json.dumps(value, ensure_ascii=False)},'
+                f'{m.group(2)}')
+
+    for anchors, at_start in ((before, True), (after, False)):
+        for anchor in anchors:
+            m = re.search(r'^([ \t]*)"' + re.escape(anchor) + r'"[ \t]*:.*?(\r?\n)',
+                          text, re.MULTILINE)
+            if m:
+                cut = m.start() if at_start else m.end()
+                return text[:cut] + line(m) + text[cut:], 1
+    return text, 0
+
+
+def replace_key_value(text, key, new_value, old_value=None):
+    """Swap the JSON string VALUE on the `"key"` line, byte-preserving the rest.
+
+    When old_value is given the line must carry exactly that value, so a stale
+    rewrite fails loudly instead of clobbering an unexpected id.
+    Returns (text, replacements made).
+    """
+    value = (re.escape(json.dumps(old_value, ensure_ascii=False))
+             if old_value is not None else _JSON_STR)
+    pattern = re.compile(
+        r'(^[ \t]*"' + re.escape(key) + r'"[ \t]*:[ \t]*)' + value, re.MULTILINE)
+    return pattern.subn(
+        lambda m: m.group(1) + json.dumps(new_value, ensure_ascii=False), text, count=1)
+
+
+def delete_key_line(text, key, old_value=None):
+    """Delete the `"key"` line, byte-preserving the rest.
+
+    Handles both the canonical layout (trailing comma) and a last-property
+    layout (comma on the preceding line, consumed so no dangling comma is left).
+    Returns (text, deletions made).
+    """
+    value = (re.escape(json.dumps(old_value, ensure_ascii=False))
+             if old_value is not None else _JSON_STR)
+    member = r'"' + re.escape(key) + r'"[ \t]*:[ \t]*' + value
+    m = re.search(r'^[ \t]*' + member + r'[ \t]*,[ \t]*\r?\n', text, re.MULTILINE)
+    if m:
+        return text[:m.start()] + text[m.end():], 1
+    m = re.search(r',[ \t]*\r?\n[ \t]*' + member + r'[ \t]*(?=\r?\n)', text)
+    if m:
+        return text[:m.start()] + text[m.end():], 1
+    return text, 0
+
 
 def insert_filament_id(text, new_id):
-    """Insert a `"filament_id"` line into a preset that lacks one.
-
-    Placed just before `instantiation` (or, failing that, after the `name` line)
-    so it matches the canonical key order, reusing that anchor line's indentation
-    and line ending. Same byte-preserving approach as assign_vendor_setting_ids.
-    """
-    m = re.search(r'^([ \t]*)"instantiation"[ \t]*:.*?(\r?\n)', text, re.MULTILINE)
-    if m:
-        line = f'{m.group(1)}"filament_id": {json.dumps(new_id, ensure_ascii=False)},{m.group(2)}'
-        return text[:m.start()] + line + text[m.start():], 1
-    m = re.search(r'^([ \t]*)"name"[ \t]*:.*?(\r?\n)', text, re.MULTILINE)
-    if m:
-        line = f'{m.group(1)}"filament_id": {json.dumps(new_id, ensure_ascii=False)},{m.group(2)}'
-        return text[:m.end()] + line + text[m.end():], 1
-    return text, 0
+    """Insert a `"filament_id"` line before `instantiation`, else after `name`."""
+    return insert_key_line(text, "filament_id", new_id,
+                           before=("instantiation",), after=("name",))
 
 
 def replace_filament_id_value(text, old_id, new_id):
-    """Swap the JSON string VALUE on the `"filament_id"` line, byte-preserving
-    everything else. Returns (text, replacements made).
+    """Swap the value on the `"filament_id"` line; it must carry old_id."""
+    return replace_key_value(text, "filament_id", new_id, old_value=old_id)
+
+
+def insert_setting_id(text, new_id):
+    """Insert a `"setting_id"` line before `filament_id`, else `instantiation`.
+
+    Falls back to `name` — the one key every preset has — so the anchor does not
+    depend on whether filament_id has been written yet: a dry run, which does not
+    write it, must reach the same verdict as the real run that does.
     """
-    pattern = re.compile(
-        r'(^[ \t]*"filament_id"[ \t]*:[ \t]*)'
-        + re.escape(json.dumps(old_id, ensure_ascii=False)),
-        re.MULTILINE)
-    return pattern.subn(
-        lambda m: m.group(1) + json.dumps(new_id, ensure_ascii=False), text, count=1)
+    return insert_key_line(text, "setting_id", new_id,
+                           before=("filament_id", "instantiation"), after=("name",))
 
 
-def delete_filament_id_line(text, old_id):
-    """Delete the `"filament_id"` line, byte-preserving the rest.
-
-    Handles both the canonical layout (trailing comma) and a last-property
-    layout (comma on the preceding line). Returns (text, deletions made).
-    """
-    val = re.escape(json.dumps(old_id, ensure_ascii=False))
-    m = re.search(r'^[ \t]*"filament_id"[ \t]*:[ \t]*' + val + r'[ \t]*,[ \t]*\r?\n',
-                  text, re.MULTILINE)
-    if m:
-        return text[:m.start()] + text[m.end():], 1
-    m = re.search(r',[ \t]*\r?\n[ \t]*"filament_id"[ \t]*:[ \t]*' + val + r'[ \t]*(?=\r?\n)',
-                  text)
-    if m:
-        return text[:m.start()] + text[m.end():], 1
-    return text, 0
-
-
-def _edit_profile(path, edit):
+def _edit_profile(path, edit, dry_run=False, what="edit"):
     """Apply `edit(text) -> (text, n)` to the profile at path, byte-preserving.
 
-    Binary IO keeps the file's original line endings (LF or CRLF), BOM and exact
-    formatting apart from the edit; the result is re-parsed and returned so the
-    caller can verify the outcome. Raises when the edit found no anchor.
+    The result is re-parsed and returned so the caller can verify the outcome —
+    in a dry run too, where only the write itself is skipped. Raises when the
+    edit found no anchor or produced invalid JSON.
     """
     with open(path, "rb") as f:
         raw = f.read()
@@ -847,69 +963,177 @@ def _edit_profile(path, edit):
     text = raw.decode("utf-8-sig")
     text, n = edit(text)
     if n == 0:
-        raise RuntimeError(f"could not apply filament_id edit to {path}")
-    data = json.loads(text)  # fail loudly if the edit broke the JSON
-    with open(path, "wb") as f:
-        f.write((b"\xef\xbb\xbf" if bom else b"") + text.encode("utf-8"))
+        raise RuntimeError(f"could not apply {what} to {path}")
+    try:
+        data = json.loads(text)  # fail loudly if the edit broke the JSON
+    except ValueError as e:
+        raise RuntimeError(f"{what} broke the JSON in {path}: {e}") from None
+    if not dry_run:
+        with open(path, "wb") as f:
+            f.write((b"\xef\xbb\xbf" if bom else b"") + text.encode("utf-8"))
     return data
 
 
-def write_filament_id(path, new_id):
+def write_filament_id(path, new_id, dry_run=False):
     """Insert new_id into the profile at path, byte-preserving everything else."""
-    _edit_profile(path, lambda text: insert_filament_id(text, new_id))
+    _edit_profile(path, lambda text: insert_filament_id(text, new_id),
+                  dry_run, "filament_id insert")
 
 
-def rewrite_filament_id(path, old_id, new_id):
+def rewrite_filament_id(path, old_id, new_id, dry_run=False):
     """Replace the filament_id value old_id -> new_id; re-parses to verify."""
-    data = _edit_profile(path, lambda text: replace_filament_id_value(text, old_id, new_id))
+    data = _edit_profile(path, lambda text: replace_filament_id_value(text, old_id, new_id),
+                         dry_run, "filament_id rewrite")
     if data.get("filament_id") != new_id:
         raise RuntimeError(f'rewrite of filament_id "{old_id}" -> "{new_id}" in {path} '
                            f"did not take effect")
 
 
-def remove_filament_id(path, old_id):
-    """Delete the filament_id declaration line; re-parses to verify."""
-    data = _edit_profile(path, lambda text: delete_filament_id_line(text, old_id))
-    if "filament_id" in data:
-        raise RuntimeError(f'deletion of filament_id "{old_id}" from {path} did not take effect')
-
-
 # ---------------------------------------------------------------------------
-# Default run: mint + insert ids for id-less filaments
+# --generate
 # ---------------------------------------------------------------------------
 
-def assign_missing_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
-    """Mint + insert ids for id-less filaments; mint + replace non-OF-format
-    declarations. Never rewrites a valid (OF-format) existing id.
+def make_want_id(analysis, snapshot=None):
+    """Build the id policy: want_id(triple) -> the id that triple must carry.
 
-    A filament = (vendor, base name) group over instantiated presets with no
-    effective id. The minted id is a pure function of the filament's triple —
-    (filament_vendor, filament_type) resolved on the root(s), filament name —
-    and is inserted into the filament's root(s): the id-less presets of the
-    SAME filament its members inherit, or the member itself otherwise (a parent
-    of another filament cannot carry this filament's id — check 3).
+    A triple's id is its first mint iteration that no OTHER product holds. An id
+    is blocked when the tree or the snapshot records it under a triple set other
+    than exactly {triple}, or when this run already handed it to a different
+    triple. Same-triple reuse is therefore convergence — one product, one id in
+    every bundle — and salting only ever steps past another product's id.
 
-    A declaration whose value is not OF-format (e.g. a vendor bundle synced
-    from an upstream source that ships its own catalog ids, such as BBL's GF*)
-    is treated the same as a missing filament: a fresh id is minted for the
-    declarer's triple and the value is replaced in place (declarers that share
-    one triple across several per-printer roots converge on the same id, same
-    as the multi-root filaments above). This is what makes a future BBL sync
-    self-healing: upstream files arrive with GF ids, this pass replaces them,
-    and the generated Bambu catalog map (keyed by the ids this mints) already
-    knows the resulting rows.
-
-    Returns (files_changed, errors).
+    Only a CONFORMANT record holds an id: a declaration whose value is not a mint
+    iteration of its own triple is transient — this run rewrites it — so it must
+    not block the product that legitimately mints the id it is squatting on. That
+    also makes the policy independent of which vendors a run writes, so a
+    --vendor-narrowed run picks the same ids as a full one.
     """
+    holders = {}  # id -> the set of triples that legitimately hold it
+    for fid, ts in analysis["triple_sets"].items():
+        conformant = {t for t in ts if fid in mint_iterations(t)}
+        if conformant:
+            holders[fid] = conformant
+    for fid, entry in (snapshot or {}).get("ids", {}).items():
+        triple = tuple(snapshot_triple(entry))
+        if fid in mint_iterations(triple):
+            holders.setdefault(fid, set()).add(triple)
+
+    assigned = {}   # triple -> the id chosen for it this run
+    run_taken = {}  # id -> the triple this run gave it to
+
+    def want_id(triple):
+        if triple not in assigned:
+            blocked = {fid for fid, ts in holders.items() if ts != {triple}}
+            blocked |= {fid for fid, t in run_taken.items() if t != triple}
+            cand = mint_filament_id(*triple, taken=blocked)
+            assigned[triple] = cand
+            run_taken[cand] = triple
+        return assigned[triple]
+
+    return want_id
+
+
+def _incomplete_triple(triple):
+    """The name(s) of the empty mint-key fields, or "" when both are present."""
+    return " and ".join(k for k, v in (("filament_vendor", triple[0]),
+                                       ("filament_type", triple[1])) if not v)
+
+
+def generate_filament_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH,
+                          vendors=None, dry_run=False, changed_paths=None):
+    """Make every filament carry the id its own triple mints.
+
+    One rule, applied to declarations and to id-less filaments alike:
+      * a declared id that is not a mint iteration of the declarer's own triple —
+        a wrong OF id, or a foreign one such as a Bambu "GF*" arriving with an
+        upstream sync — is replaced in place;
+      * an instantiated filament that resolves no id at all gets one inserted
+        into its root(s): the id-less presets of the SAME filament its members
+        inherit, or the member itself (a parent of another filament cannot carry
+        this filament's id — check 3).
+    An id already equal to ANY salt iteration of its own triple is conformant
+    (check 3) and left alone, so deliberate salt splits — distinct presets of one
+    product kept apart for per-printer AMS matching — survive.
+
+    `vendors` restricts what is WRITTEN; the analysis and the id policy always
+    span the whole tree, so a narrowed run mints exactly what a full one would.
+    `changed_paths`, when a set is passed, collects the files that changed. A
+    file whose layout offers no anchor for the edit is reported and counted as an
+    error, so one odd profile cannot abort the pass over all the others.
+    Never touches the snapshot — run --update-snapshot afterwards and review the
+    diff. Returns (files_changed, errors).
+    """
+    _utf8_console()
     analysis = analyze_tree(profiles_dir)
     errors = 0
     for msg in analysis["read_errors"]:
         print_error(msg)
         errors += 1
+    wanted = None
+    if vendors is not None:
+        wanted = set(vendors)
+        # A vendor directory without a bundle index simply has no filaments to
+        # process; only a name that is no directory at all is an error.
+        unknown = sorted(wanted - set(list_profile_dirs(profiles_dir)))
+        if unknown:
+            for v in unknown:
+                print_error(f'unknown vendor "{v}" in {profiles_dir}')
+            return 0, errors + len(unknown)
 
-    # Group id-less instantiated presets by filament.
-    filaments = {}  # (vendor, filament_name) -> [rec]
+    want_id = make_want_id(analysis, load_snapshot(snapshot_path))
+    verb = "would " if dry_run else ""
+    files_changed = 0
+    reminted = 0
+    inserted = 0
+    held_here = set()   # ids the filaments this run may write legitimately hold
+    left_standing = {}  # id -> files still declaring one non-conformantly
+
+    # 1. Declarations that are not the mint of their own triple.
+    for vendor, rec, fid, triple in sorted(
+            analysis["declarer_triples"], key=lambda x: (x[0], x[1]["file"])):
+        in_scope = wanted is None or vendor in wanted
+        if fid in mint_iterations(triple):
+            if in_scope:
+                held_here.add(fid)
+            continue
+        if not in_scope:
+            left_standing.setdefault(fid, []).append(rec["file"])
+            continue
+        missing = _incomplete_triple(triple)
+        if missing:
+            print_error(
+                f'cannot re-mint "{rec["file"]}" (filament_id "{fid}"): resolves empty '
+                f'{missing}; the mint key needs both (generic materials use '
+                f'filament_vendor "Generic")')
+            errors += 1
+            left_standing.setdefault(fid, []).append(rec["file"])
+            continue
+        want = want_id(triple)
+        if fid == want:
+            continue
+        try:
+            rewrite_filament_id(rec["path"], fid, want, dry_run)
+        except (OSError, RuntimeError, ValueError) as e:
+            print_error(str(e))
+            errors += 1
+            left_standing.setdefault(fid, []).append(rec["file"])
+            continue
+        files_changed += 1
+        reminted += 1
+        held_here.add(want)
+        if changed_paths is not None:
+            # Index sub_paths are "/"-joined even on Windows, where the
+            # setting_id pass reaches the same file through os.walk: normalize
+            # or one file touched by both passes counts as two.
+            changed_paths.add(os.path.normpath(rec["path"]))
+        print_info(f'{verb}rewrite {rec["file"]}: "{fid}" -> "{want}" '
+                   f'(triple "{"/".join(triple)}")')
+
+    # 2. Instantiated filaments that resolve no id at all, grouped by filament.
+    filaments = {}  # (vendor, filament name) -> [rec]
     for vendor, name, _file in analysis["missing_effective"]:
+        if wanted is not None and vendor not in wanted:
+            continue
         rec = analysis["vendors"][vendor][name]
         if rec["id_source"] in ("cycle", "dangling"):
             print_error(f'cannot mint for "{vendor}/{name}": broken inherits chain '
@@ -918,50 +1142,22 @@ def assign_missing_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
             continue
         filaments.setdefault((vendor, base_name(name)), []).append(rec)
 
-    # Declarations whose value is not OF-format: treated as missing too (see
-    # docstring). Grouped by triple, not by (vendor, filament), so declarers
-    # that legitimately share one triple across several files converge on one
-    # freshly minted id instead of each getting their own.
-    non_of_declarers = [
-        (vendor, rec, fid, triple) for vendor, rec, fid, triple in analysis["declarer_triples"]
-        if not OF_ID_RE.match(fid)]
-
-    if not filaments and not non_of_declarers:
-        print_success("every instantiated filament already resolves an OF-format "
-                      "filament_id; nothing to do (0 files changed)")
-        return 0, errors
-
-    # Ids already spoken for: the whole tree (declared or effective) + snapshot.
-    snapshot = load_snapshot(snapshot_path) or {"ids": {}}
-    taken = set(snapshot["ids"])
-    for occurring in analysis["vendor_ids"].values():
-        taken |= occurring
-
-    # Root preset(s): the direct vendor-side parents of the members (id-less by
-    # construction) that belong to the same filament, or the member itself.
-    roots = {}  # (vendor, filament_name) -> {preset name: rec}
-    for key, members in sorted(filaments.items()):
-        vendor, filament_name = key
+    ofl_map = analysis["vendors"].get(OFL, {})
+    for (vendor, filament_name), members in sorted(filaments.items()):
         vendor_map = analysis["vendors"][vendor]
-        filament_roots = {}
+        # Root preset(s): the direct vendor-side parents of the members (id-less
+        # by construction) that belong to the same filament, or the member itself.
+        roots = {}
         for rec in members:
             parent = rec.get("inherits")
             root = vendor_map.get(parent) if parent else None
             if (root is None or root.get("filament_id")
                     or base_name(root["name"]) != filament_name):
                 root = rec  # root-less member carries the id itself
-            filament_roots[root["name"]] = root
-        roots[key] = filament_roots
-
-    ofl_map = analysis["vendors"].get(OFL, {})
-    files_changed = 0
-    filaments_minted = 0
-    for key, filament_roots in sorted(roots.items()):
-        vendor, filament_name = key
-        vendor_map = analysis["vendors"][vendor]
+            roots[root["name"]] = root
         fields = {(resolve_filament_field(n, "filament_vendor", vendor_map, ofl_map),
                    resolve_filament_field(n, "filament_type", vendor_map, ofl_map))
-                  for n in filament_roots}
+                  for n in roots}
         if len(fields) > 1:
             print_error(
                 f'cannot mint for filament "{vendor}/{filament_name}": its roots resolve '
@@ -969,252 +1165,321 @@ def assign_missing_ids(profiles_dir=PROFILES_DIR, snapshot_path=SNAPSHOT_PATH):
                 f"align the fields first")
             errors += 1
             continue
-        fvendor, ftype = next(iter(fields))
-        if not fvendor or not ftype:
-            missing = " and ".join(
-                k for k, v in (("filament_vendor", fvendor),
-                               ("filament_type", ftype)) if not v)
+        triple = (*next(iter(fields)), filament_name)
+        missing = _incomplete_triple(triple)
+        if missing:
             print_error(
                 f'cannot mint for filament "{vendor}/{filament_name}": it resolves empty '
                 f'{missing}; the mint key needs both (generic materials use '
                 f'filament_vendor "Generic")')
             errors += 1
             continue
-        new_id = mint_filament_id(fvendor, ftype, filament_name, taken)
-        taken.add(new_id)
-        filaments_minted += 1
-        for name in sorted(filament_roots):
-            root = filament_roots[name]
-            write_filament_id(root["path"], new_id)
+        new_id = want_id(triple)
+        for name in sorted(roots):
+            root = roots[name]
+            try:
+                write_filament_id(root["path"], new_id, dry_run)
+            except (OSError, RuntimeError, ValueError) as e:
+                print_error(str(e))
+                errors += 1
+                continue
             files_changed += 1
-            print_info(f'filament "{vendor}/{filament_name}": filament_id "{new_id}" '
-                       f'-> {root["file"]}')
+            inserted += 1
+            held_here.add(new_id)
+            if changed_paths is not None:
+                changed_paths.add(os.path.normpath(root["path"]))
+            print_info(f'{verb}insert filament "{vendor}/{filament_name}": filament_id '
+                       f'"{new_id}" -> {root["file"]}')
 
-    # Non-OF-format declarations: mint once per triple, rewrite every declarer
-    # that shares it (see docstring).
-    declarations_reminted = 0
-    assigned = {}  # triple -> id chosen this run
-    for vendor, rec, fid, triple in sorted(non_of_declarers, key=lambda x: (x[0], x[1]["file"])):
-        fvendor, ftype, filament_name = triple
-        if not fvendor or not ftype:
-            missing = " and ".join(
-                k for k, v in (("filament_vendor", fvendor),
-                               ("filament_type", ftype)) if not v)
-            print_error(
-                f'cannot re-mint "{rec["file"]}" (non-OF filament_id "{fid}"): resolves '
-                f'empty {missing}; the mint key needs both (generic materials use '
-                f'filament_vendor "Generic")')
-            errors += 1
-            continue
-        if triple not in assigned:
-            assigned[triple] = mint_filament_id(fvendor, ftype, filament_name, taken)
-            taken.add(assigned[triple])
-        new_id = assigned[triple]
-        rewrite_filament_id(rec["path"], fid, new_id)
-        files_changed += 1
-        declarations_reminted += 1
-        print_info(f'filament "{vendor}/{filament_name}": non-OF filament_id "{fid}" '
-                   f'-> "{new_id}" ({rec["file"]})')
+    # A declaration that is not the mint of its own triple holds no id, so it
+    # never blocks the product the id belongs to — that is what makes a narrowed
+    # run mint exactly what a full one would. When the run is not allowed to
+    # rewrite that declaration, though, it stays behind on an id just handed to
+    # its rightful owner, and only a run that covers both can clear it.
+    for fid in sorted(held_here & set(left_standing)):
+        print_error(
+            f'filament_id "{fid}" belongs to a filament this run covers but is also '
+            f'declared by {", ".join(sorted(left_standing[fid]))}, which it did not '
+            f'rewrite; run "{GENERATE_CMD}" over both to clear the duplicate')
+        errors += 1
 
-    print_info(f"filaments minted : {filaments_minted}")
-    print_info(f"non-OF reminted  : {declarations_reminted}")
-    print_info(f"files changed    : {files_changed}")
-    if files_changed:
-        print_warning(f"now {UPDATE_HINT}")
+    print_info(f"filament_ids inserted  : {inserted}")
+    print_info(f"filament_ids re-minted : {reminted}")
     return files_changed, errors
 
 
-# ---------------------------------------------------------------------------
-# --remint / --drop-redundant-ids (v3.1/v3.2 migration modes)
-# ---------------------------------------------------------------------------
+def generate_setting_ids(profiles_dir=PROFILES_DIR, vendors=None, dry_run=False,
+                         changed_paths=None):
+    """Make every preset carry the setting_id its identity mints.
 
-def remint_vendors(vendor_list, profiles_dir=PROFILES_DIR):
-    """Re-derive every declared id in the given vendors from its triple;
-    rewrite mismatching declarations in place (byte-preserving). Never touches
-    the snapshot — run --update-snapshot afterwards and review the diff.
-    Accepts BBL like any other vendor: the GF* catalog is reserved and
-    ownerless, so BBL's own declarations mint OF ids the same as everyone
-    else's.
-
-    A declaration already equal to ANY salt iteration of its own triple is
-    mint-conformant (check 3) and left alone — deliberate salt splits (distinct
-    presets of one product kept apart for per-printer AMS matching) survive.
-    A candidate id is blocked when it occurs in the tree with any triple set
-    other than exactly {T}. Equal-triple reuse
-    is convergence: the same product must end up under the same id everywhere.
-    Returns (rewritten, errors).
+    One walk over filament/, process/ and machine/ of every vendor bundle, and
+    one composite edit per file: drop the misspelled "settings_id" key (the app
+    never reads it), strip setting_id from base profiles (only instantiated
+    presets carry one), and set generate_preset_setting_id(vendor, type, name) on
+    instantiated presets — except BBL's, which keep their authoritative "G*"
+    cloud ids. `changed_paths`, when a set is passed, collects the files that
+    changed. Returns (files_changed, errors).
     """
     _utf8_console()
-    analysis = analyze_tree(profiles_dir)
+    profiles_dir = str(profiles_dir)
     errors = 0
-    for msg in analysis["read_errors"]:
-        print_error(msg)
-        errors += 1
-    unknown = sorted(set(vendor_list) - set(analysis["vendors"]))
-    if unknown:
-        for v in unknown:
-            print_error(f"--remint: unknown vendor {v!r}")
-        return 0, errors + len(unknown)
+    names = list_profile_dirs(profiles_dir)
+    if vendors is not None:
+        wanted = set(vendors)
+        unknown = sorted(wanted - set(names))
+        if unknown:
+            for v in unknown:
+                print_error(f'unknown vendor "{v}" in {profiles_dir}')
+            return 0, len(unknown)
+        names = [v for v in names if v in wanted]
+        for v in sorted(wanted & RESERVED_VENDORS):
+            print_info(f'{v} keeps its authoritative "G*" setting_ids; only its base '
+                       f"declarations are stripped")
 
-    occurring = set()
-    for vids in analysis["vendor_ids"].values():
-        occurring |= vids
-    triple_sets = analysis["triple_sets"]
-
-    assigned = {}       # triple -> id chosen this run (all declarers converge)
-    run_taken = {}      # id -> triple (a run-local mint may not collide either)
-
-    def want_id(triple):
-        if triple in assigned:
-            return assigned[triple]
-        for salt in range(10000):
-            cand = generate_filament_id(*triple, salt=salt)
-            if cand in occurring and triple_sets.get(cand, set()) != {triple}:
+    verb = "would " if dry_run else ""
+    files_changed = 0
+    counts = {"typos": 0, "stripped": 0, "assigned": 0}
+    for vendor in names:
+        for path, type_name in iter_profile_files(os.path.join(profiles_dir, vendor)):
+            try:
+                with open(path, "rb") as f:
+                    data = json.loads(f.read().decode("utf-8-sig"))
+                if not isinstance(data, dict):
+                    raise ValueError("top level is not a JSON object")
+            except (OSError, ValueError) as e:
+                print_error(f"unreadable profile {path}: {e}")
+                errors += 1
                 continue
-            if run_taken.get(cand, triple) != triple:
+
+            sid = data.get("setting_id")
+            # Strictly "true", exactly as orca_extra_profile_check.py tests it:
+            # a preset the validator calls a base profile must not be given an id
+            # here, or the two would fight over it forever.
+            instantiated = data.get("instantiation") == "true"
+            edits = []  # (counter key, description, edit function)
+            if "settings_id" in data:
+                edits.append(("typos", 'drop the misspelled "settings_id"',
+                              lambda text: delete_key_line(text, "settings_id")))
+                typo = data["settings_id"]
+                if (vendor in RESERVED_VENDORS and instantiated and sid is None
+                        and isinstance(typo, str) and typo):
+                    # A reserved vendor's ids are authoritative, so there is no
+                    # formula to fall back on: correct the key and keep the
+                    # value, or the drop would leave an instantiated preset with
+                    # no setting_id and nothing able to give it one.
+                    edits.append(("assigned", 'restore its value as "setting_id"',
+                                  lambda text, new=typo: insert_setting_id(text, new)))
+            if not instantiated:
+                if sid is not None:
+                    edits.append(("stripped", "strip the base profile's setting_id",
+                                  lambda text, old=sid: delete_key_line(
+                                      text, "setting_id", old)))
+            elif vendor not in RESERVED_VENDORS:
+                name = data.get("name")
+                if not name:
+                    # Report and carry on: an edit already queued for this file
+                    # (a misspelled key) is still worth applying.
+                    print_error(f'instantiated preset has no "name": {path}')
+                    errors += 1
+                else:
+                    new_id = generate_preset_setting_id(vendor, type_name, name)
+                    if sid is None:
+                        edits.append(("assigned", "insert the setting_id",
+                                      lambda text, new=new_id: insert_setting_id(text, new)))
+                    elif sid != new_id:
+                        edits.append(("assigned", "replace the setting_id",
+                                      lambda text, new=new_id, old=sid: replace_key_value(
+                                          text, "setting_id", new, old)))
+            if not edits:
                 continue
-            assigned[triple] = cand
-            run_taken[cand] = triple
-            return cand
-        raise RuntimeError(f"could not mint a free filament_id for triple {triple}")
 
-    scanned = 0
-    rewritten = 0
-    for vendor in sorted(set(vendor_list)):
-        recs = sorted(
-            (rec for rec in analysis["vendors"][vendor].values() if rec.get("filament_id")),
-            key=lambda r: r["file"])
-        for rec in recs:
-            fid = rec["filament_id"]
-            scanned += 1
-            # Any salt iteration of the declarer's own triple is already
-            # mint-conformant (check 3) — leave it. This keeps deliberate salt
-            # splits (two presets of one product that must stay distinct for
-            # per-printer AMS matching, validator -f) stable across re-mints.
-            if fid in mint_iterations(rec["triple"]):
+            def apply(text, _edits=edits, _path=path):
+                for _key, what, edit in _edits:
+                    text, n = edit(text)
+                    if n == 0:
+                        raise RuntimeError(f"could not {what} in {_path}")
+                return text, len(_edits)
+
+            try:
+                _edit_profile(path, apply, dry_run)
+            except (OSError, RuntimeError, ValueError) as e:
+                print_error(str(e))
+                errors += 1
                 continue
-            want = want_id(rec["triple"])
-            if fid == want:
-                continue
-            rewrite_filament_id(rec["path"], fid, want)
-            rewritten += 1
-            print_info(f'{rec["file"]}: "{fid}" -> "{want}" '
-                       f'(triple "{"/".join(rec["triple"])}")')
-    print_info(f"declarations scanned : {scanned}")
-    print_info(f"declarations reminted: {rewritten}")
-    if rewritten:
-        print_warning(f"now {UPDATE_HINT}")
-    return rewritten, errors
+            files_changed += 1
+            if changed_paths is not None:
+                changed_paths.add(os.path.normpath(path))
+            for key, _what, _edit in edits:
+                counts[key] += 1
+            rel = os.path.relpath(path, profiles_dir).replace(os.sep, "/")
+            print_info(f"{verb}update {rel}: "
+                       f"{', '.join(what for _key, what, _edit in edits)}")
 
-
-def drop_redundant_ids(vendor, profiles_dir=PROFILES_DIR):
-    """Delete filament_id declarations in `vendor` that merely re-declare an OFL
-    filament's id path: ignoring its own key, the preset's inherits chain enters
-    OFL and resolves an OFL-declared id, and the preset keeps the OFL filament's
-    base name. Such a preset is a specialization and rides the OFL id (v3.2(b)).
-    Never touches the snapshot. Returns (dropped, errors).
-    """
-    _utf8_console()
-    analysis = analyze_tree(profiles_dir)
-    errors = 0
-    for msg in analysis["read_errors"]:
-        print_error(msg)
-        errors += 1
-    if vendor == "BBL":
-        print_error("--drop-redundant-ids BBL is forbidden (the GF* catalog is frozen)")
-        return 0, errors + 1
-    if vendor not in analysis["vendors"]:
-        print_error(f"--drop-redundant-ids: unknown vendor {vendor!r}")
-        return 0, errors + 1
-
-    vendor_map = analysis["vendors"][vendor]
-    ofl_map = analysis["vendors"].get(OFL, {})
-    ofl_declared = {r["filament_id"] for r in ofl_map.values() if r.get("filament_id")}
-    dropped = 0
-    for rec in sorted(vendor_map.values(), key=lambda r: r["file"]):
-        fid = rec.get("filament_id")
-        if not fid or not rec.get("inherits"):
-            continue
-        resolved, _src, entry = resolve_filament_id(
-            rec["name"], vendor_map, ofl_map, skip_own=True)
-        if not (entry and resolved and resolved in ofl_declared):
-            continue
-        if base_name(rec["name"]) != base_name(entry):
-            continue
-        remove_filament_id(rec["path"], fid)
-        dropped += 1
-        print_info(f'{rec["file"]}: dropped filament_id "{fid}" '
-                   f'(rides OFL "{entry}", id "{resolved}")')
-    print_info(f"declarations dropped : {dropped}")
-    if dropped:
-        print_warning(f"now {UPDATE_HINT}")
-    return dropped, errors
+    print_info(f'misspelled "settings_id" dropped : {counts["typos"]}')
+    print_info(f'base setting_ids stripped        : {counts["stripped"]}')
+    print_info(f'setting_ids assigned             : {counts["assigned"]}')
+    return files_changed, errors
 
 
 # ---------------------------------------------------------------------------
 # CLI
 # ---------------------------------------------------------------------------
 
-def main(argv=None):
-    _utf8_console()
+EXAMPLES = """\
+examples:
+  orca_id_tool.py --generate
+      give every profile the id its identity mints, in every vendor bundle
+  orca_id_tool.py --dry-run
+      preview exactly that; writes nothing
+  orca_id_tool.py --generate --setting-id
+      setting_id only (filament, process and machine presets)
+  orca_id_tool.py --generate --filament-id --vendor Creality --vendor Elegoo
+      filament_id only, and only in those two bundles
+  orca_id_tool.py --check
+      validate filament_id state against the snapshot (the filament_id half
+      of scripts/orca_extra_profile_check.py, which is what CI runs)
+  orca_id_tool.py --update-snapshot
+      re-record the sanctioned filament_id state after a --generate run
+
+a maintenance round:
+  --dry-run  ->  --generate  ->  --update-snapshot  ->  --check  ->  commit the diff
+"""
+
+
+def build_parser():
     parser = argparse.ArgumentParser(
-        description="Mint deterministic filament_id values for id-less filaments "
-                    "and validate the tree against the sanctioned snapshot.")
-    parser.add_argument("--mint", metavar='"Vendor/Type/Filament"',
-                        help="print the id the (filament_vendor, filament_type, "
-                             "filament name) triple would mint; touches nothing")
-    parser.add_argument("--update-snapshot", action="store_true",
-                        help="regenerate scripts/filament_id_snapshot.json from "
-                             "the tree")
-    parser.add_argument("--check", action="store_true",
-                        help="run the filament_id checks; exit nonzero on errors")
-    parser.add_argument("--remint", metavar="VENDOR", action="append",
-                        help="re-derive VENDOR's declared filament_ids from their "
-                             "triples and rewrite mismatches in place; repeatable")
-    parser.add_argument("--drop-redundant-ids", metavar="VENDOR",
-                        help="delete filament_id declarations in VENDOR that "
-                             "re-declare the OFL filament id they already resolve "
-                             "through inherits")
+        prog="orca_id_tool.py", allow_abbrev=False,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="Assign and validate the deterministic ids of OrcaSlicer system\n"
+                    "profiles: the per-product filament_id and the per-preset setting_id.\n"
+                    "\n"
+                    "Both are pure functions of the profile's own identity, so this tool\n"
+                    "never invents an id: it writes the one the rules already imply, and\n"
+                    "leaves a conforming tree alone.",
+        epilog=EXAMPLES)
+    modes = parser.add_argument_group("modes (pick one; no mode prints this help)")
+    modes.add_argument("--generate", action="store_true",
+                       help="write the id every profile should carry: filament_id from "
+                            "each filament's (filament_vendor, filament_type, name) "
+                            "triple, setting_id from each preset's (vendor, type, name). "
+                            "Idempotent and byte-preserving")
+    modes.add_argument("--check", action="store_true",
+                       help="validate filament_id state against "
+                            "scripts/filament_id_snapshot.json; exit nonzero on errors")
+    modes.add_argument("--update-snapshot", action="store_true",
+                       help="re-record the sanctioned filament_id state in "
+                            "scripts/filament_id_snapshot.json; commit the diff for "
+                            "maintainer review")
+    narrow = parser.add_argument_group("narrowing --generate")
+    narrow.add_argument("--filament-id", action="store_true",
+                        help="write filament_id only, skipping setting_id")
+    narrow.add_argument("--setting-id", action="store_true",
+                        help="write setting_id only, skipping filament_id")
+    narrow.add_argument("--vendor", metavar="VENDOR", action="append", default=[],
+                        help="write only in this vendor bundle; repeatable. The ids are "
+                             "still derived tree-wide, so a narrowed run writes exactly "
+                             "what a full one would, and reports what it was not allowed "
+                             "to fix")
+    parser.add_argument("--dry-run", "--dryrun", dest="dry_run", action="store_true",
+                        help="report what would change and write nothing; with no mode of "
+                             "its own it previews --generate")
     parser.add_argument("--profiles", default=PROFILES_DIR,
                         help="profiles directory (default: resources/profiles)")
+    parser.add_argument("--snapshot", default=None, metavar="PATH",
+                        help="the sanctioned filament_id state of that tree (default: "
+                             "scripts/filament_id_snapshot.json, which describes "
+                             "resources/profiles and no other tree)")
+    return parser
+
+
+def main(argv=None):
+    _utf8_console()
+    argv = sys.argv[1:] if argv is None else list(argv)
+    parser = build_parser()
+    if not argv:
+        parser.print_help()
+        return 0
     args = parser.parse_args(argv)
 
+    modes = [flag for flag, on in (("--generate", args.generate),
+                                   ("--check", args.check),
+                                   ("--update-snapshot", args.update_snapshot)) if on]
+    if len(modes) > 1:
+        parser.error(f"{' and '.join(modes)} cannot be combined; pick one mode")
+    if args.filament_id and args.setting_id:
+        parser.error("--filament-id and --setting-id each exclude the other; "
+                     "pass neither to write both")
+    narrowing = [flag for flag, on in (("--filament-id", args.filament_id),
+                                       ("--setting-id", args.setting_id),
+                                       ("--vendor", bool(args.vendor))) if on]
+    if not modes:
+        if args.dry_run:
+            mode = "--generate"  # --dry-run previews the writing mode
+        elif narrowing:
+            parser.error(f"{', '.join(narrowing)} narrows --generate; "
+                         f"add --generate (or --dry-run to preview it)")
+        else:
+            parser.print_help()
+            return 0
+    else:
+        mode = modes[0]
+        if narrowing and mode != "--generate":
+            parser.error(f"{', '.join(narrowing)} applies to --generate, not {mode}")
 
-    if args.mint:
-        parts = args.mint.split("/", 2)
-        if len(parts) != 3 or not all(parts):
-            parser.error('--mint expects "filament_vendor/filament_type/filament_name" '
-                         "with all three components non-empty (check 5 rejects empty "
-                         "vendor/type in the tree)")
-        snapshot = load_snapshot(SNAPSHOT_PATH) or {"ids": {}}
-        taken = set(snapshot["ids"])
-        print(mint_filament_id(parts[0], parts[1], parts[2], taken))
-        return 0
+    snapshot_path = args.snapshot or SNAPSHOT_PATH
+    if (args.snapshot is None and mode in ("--check", "--update-snapshot")
+            and os.path.abspath(args.profiles) != os.path.abspath(PROFILES_DIR)):
+        # The repo snapshot is the sanctioned state of resources/profiles alone:
+        # checking another tree against it is meaningless, and re-recording one
+        # into it would overwrite the tracked file with a foreign tree's state.
+        parser.error(f"{mode} reads and writes the sanctioned state of the tree it is "
+                     f"given, so --profiles needs --snapshot PATH for that tree too")
 
-    if args.remint:
-        if args.update_snapshot or args.check or args.drop_redundant_ids:
-            parser.error("--remint cannot be combined with other modes")
-        _changed, errors = remint_vendors(args.remint, args.profiles)
-        return 1 if errors else 0
-
-    if args.drop_redundant_ids:
-        if args.update_snapshot or args.check:
-            parser.error("--drop-redundant-ids cannot be combined with other modes")
-        _changed, errors = drop_redundant_ids(args.drop_redundant_ids, args.profiles)
-        return 1 if errors else 0
-
-    if args.update_snapshot:
-        return update_snapshot(args.profiles, SNAPSHOT_PATH)
-
-    if args.check:
-        errors = check_filament_ids(args.profiles, SNAPSHOT_PATH)
+    if mode == "--check":
+        errors = check_filament_ids(args.profiles, snapshot_path)
         if errors:
             print_error(f"filament_id check: {errors} error(s)")
             return 1
         print_success("filament_id check: no errors")
         return 0
 
-    _changed, errors = assign_missing_ids(args.profiles, SNAPSHOT_PATH)
+    if mode == "--update-snapshot":
+        return update_snapshot(args.profiles, snapshot_path, dry_run=args.dry_run)
+
+    vendors = sorted(set(args.vendor)) or None
+    if vendors:
+        unknown = sorted(set(vendors) - set(list_profile_dirs(args.profiles)))
+        if unknown:
+            for v in unknown:
+                print_error(f'unknown vendor "{v}" in {args.profiles}')
+            return 1
+
+    # Both by default. filament_id runs first so its keys are in place before the
+    # setting_id pass reads the files back.
+    do_filament = args.filament_id or not args.setting_id
+    do_setting = args.setting_id or not args.filament_id
+    changed = set()  # one file the two passes both touch is still one file
+    filament_files = errors = 0
+    if do_filament:
+        filament_files, e = generate_filament_ids(
+            args.profiles, snapshot_path, vendors, args.dry_run, changed)
+        errors += e
+    if do_setting:
+        _n, e = generate_setting_ids(args.profiles, vendors, args.dry_run, changed)
+        errors += e
+
+    summary = (f"dry run: {len(changed)} file(s) would change; nothing written"
+               if args.dry_run else f"{len(changed)} file(s) changed")
+    if errors:
+        print_error(f"{summary}; {errors} error(s)")
+    else:
+        print_success(summary)
+    if filament_files and not args.dry_run:
+        # A filament_id write may or may not move the sanctioned state (an id
+        # repaired back to the value the snapshot already records does not), so
+        # regenerate and let the diff — empty or not — say.
+        print_warning('now run "python scripts/orca_id_tool.py --update-snapshot" '
+                      "and commit any resulting diff for maintainer review")
     return 1 if errors else 0
 
 
diff --git a/scripts/tests/test_filament_id.py b/scripts/tests/test_filament_id.py
index 37c7d16772..b7646c4b64 100644
--- a/scripts/tests/test_filament_id.py
+++ b/scripts/tests/test_filament_id.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Tests for scripts/assign_filament_ids.py (stdlib unittest, no external deps).
+"""Tests for scripts/orca_id_tool.py (stdlib unittest, no external deps).
 
 Run from the repo root:  python -m unittest discover -s scripts/tests -v
 """
@@ -17,7 +17,7 @@ import uuid
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
-import assign_filament_ids as afi  # noqa: E402
+import orca_id_tool as afi  # noqa: E402
 import update_bambu_filament_ids as ubfi  # noqa: E402
 
 REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
@@ -99,6 +99,17 @@ class SyntheticTree:
         if register:
             self.add_to_index(vendor, data["name"])
 
+    def set_sub_path(self, vendor, name, sub_path):
+        """Rewrite one index entry's sub_path (the file itself does not move)."""
+        idx_path = os.path.join(self.profiles, vendor + ".json")
+        with open(idx_path, encoding="utf-8") as f:
+            index = json.load(f)
+        for entry in index["filament_list"]:
+            if entry["name"] == name:
+                entry["sub_path"] = sub_path
+        with open(idx_path, "w", encoding="utf-8") as f:
+            json.dump(index, f, indent=4, ensure_ascii=False)
+
     def remove_preset(self, vendor, name):
         os.remove(self.preset_path(vendor, name))
         idx_path = os.path.join(self.profiles, vendor + ".json")
@@ -109,12 +120,25 @@ class SyntheticTree:
         with open(idx_path, "w", encoding="utf-8") as f:
             json.dump(index, f, indent=4, ensure_ascii=False)
 
+    def bytes_map(self):
+        """{relative path -> file bytes} over every .json in the tree."""
+        raw = {}
+        for root, dirs, files in os.walk(self.profiles):
+            dirs.sort()
+            for name in sorted(files):
+                if not name.endswith(".json"):
+                    continue
+                path = os.path.join(root, name)
+                with open(path, "rb") as f:
+                    raw[os.path.relpath(path, self.profiles)] = f.read()
+        return raw
+
     # -- pipeline wrappers ---------------------------------------------------
 
-    def update_snapshot(self):
+    def update_snapshot(self, dry_run=False):
         buf = io.StringIO()
         with contextlib.redirect_stdout(buf):
-            rc = afi.update_snapshot(self.profiles, self.snapshot)
+            rc = afi.update_snapshot(self.profiles, self.snapshot, dry_run)
         return rc, buf.getvalue()
 
     def check(self, map_path=None):
@@ -124,23 +148,32 @@ class SyntheticTree:
             errors = afi.check_filament_ids(self.profiles, self.snapshot, **kwargs)
         return errors, buf.getvalue()
 
-    def assign(self):
+    # assign() and remint() are the same one pass over the tree — every filament
+    # ends up with the id its own triple mints, whether that means inserting a
+    # missing key or rewriting a non-conformant one. Both names are kept because
+    # they read differently at the call sites.
+    def assign(self, vendors=None, dry_run=False):
         buf = io.StringIO()
         with contextlib.redirect_stdout(buf):
-            changed, errors = afi.assign_missing_ids(self.profiles, self.snapshot)
+            changed, errors = afi.generate_filament_ids(
+                self.profiles, self.snapshot, vendors, dry_run)
         return changed, errors, buf.getvalue()
 
-    def remint(self, vendors):
+    def remint(self, vendors, dry_run=False):
         buf = io.StringIO()
         with contextlib.redirect_stdout(buf):
-            changed, errors = afi.remint_vendors(vendors, self.profiles)
+            changed, errors = afi.generate_filament_ids(
+                self.profiles, self.snapshot, vendors, dry_run)
         return changed, errors, buf.getvalue()
 
-    def drop_redundant(self, vendor):
+    def cli(self, *flags):
+        """Run main() against this tree, capturing stdout."""
         buf = io.StringIO()
         with contextlib.redirect_stdout(buf):
-            dropped, errors = afi.drop_redundant_ids(vendor, self.profiles)
-        return dropped, errors, buf.getvalue()
+            rc = afi.main([*flags, "--profiles", self.profiles,
+                           "--snapshot", self.snapshot])
+        return rc, buf.getvalue()
+
 
 def make_clean_tree(apla_id="AX01", generic_id="OGFL99"):
     """Baseline tree: OFL base+generic, a vendor filament, a clean tuned generic.
@@ -182,8 +215,8 @@ class OfCleanTreeCase(unittest.TestCase):
     real OF-format ids (check 1 now rejects "AX01"/"OGFL99" unconditionally,
     with no snapshot exemption), so an otherwise-untouched tree still passes
     check_filament_ids. Tests that specifically need a non-OF baseline to
-    remint or drop (TestRemint, TestDropRedundantIds, TestUpdateSnapshot) keep
-    using SyntheticTreeCase instead.
+    remint (TestRemint, TestUpdateSnapshot) keep using SyntheticTreeCase
+    instead.
     """
     def setUp(self):
         self.t = make_clean_tree(
@@ -243,6 +276,81 @@ class TestMint(unittest.TestCase):
         self.assertEqual(afi.mint_filament_id(*triple, set()),
                          afi.generate_filament_id(*triple))
 
+    def test_mint_never_returns_a_salt_the_identity_check_rejects(self):
+        # mint_filament_id stops at MAX_CHECK_SALT, the last iteration check 3
+        # accepts, so the tool can never write an id its own --check rejects.
+        triple = ("Polymaker", "PLA", "PolyLite PLA")
+        all_taken = afi.mint_iterations(triple)
+        self.assertEqual(len(all_taken), afi.MAX_CHECK_SALT + 1)
+        last = afi.mint_filament_id(*triple, all_taken - {afi.generate_filament_id(
+            *triple, salt=afi.MAX_CHECK_SALT)})
+        self.assertIn(last, afi.mint_iterations(triple))
+        with self.assertRaises(RuntimeError):
+            afi.mint_filament_id(*triple, all_taken)
+
+    def test_want_id_policy(self):
+        # The whole id policy: a triple's id is its first mint iteration that no
+        # OTHER product holds, in the tree or in the snapshot.
+        triple = ("Polymaker", "PLA", "PolyLite PLA")
+        other = ("Elegoo", "PETG", "Rapid PETG")
+        salt0 = afi.generate_filament_id(*triple)
+        salt1 = afi.generate_filament_id(*triple, salt=1)
+
+        def snapshot(**entries):
+            return {"ids": {fid: {"filaments": [], "name": t[2],
+                                  "filament_type": t[1], "filament_vendor": t[0]}
+                            for fid, t in entries.items()}}
+
+        # nobody holds it: salt 0
+        self.assertEqual(afi.make_want_id({"triple_sets": {}})(triple), salt0)
+        # the tree holds it under this very triple: reuse is convergence
+        self.assertEqual(
+            afi.make_want_id({"triple_sets": {salt0: {triple}}})(triple), salt0)
+        # Another triple "holds" it, but salt0 is not a mint iteration of THAT
+        # triple, so the holder is a wrong declaration this very run rewrites.
+        # A transient squatter must not push a product off its own id.
+        self.assertEqual(
+            afi.make_want_id({"triple_sets": {salt0: {other}}})(triple), salt0)
+        self.assertEqual(
+            afi.make_want_id({"triple_sets": {salt0: {triple, other}}})(triple), salt0)
+        # The snapshot is read the same way: only a conformant record holds.
+        self.assertEqual(
+            afi.make_want_id({"triple_sets": {}}, snapshot(**{salt0: other}))(triple),
+            salt0)
+        # ... and the snapshot's own triple reuses it
+        self.assertEqual(
+            afi.make_want_id({"triple_sets": {}}, snapshot(**{salt0: triple}))(triple),
+            salt0)
+        # Unused here, but salting must still be reachable: see
+        # test_want_id_salts_past_a_genuine_collision.
+        self.assertNotEqual(salt0, salt1)
+        # memoized: one triple keeps one id for the whole run
+        want_id = afi.make_want_id({"triple_sets": {}})
+        self.assertEqual(want_id(triple), want_id(triple))
+        # ... and a second triple never gets the id this run already handed out
+        self.assertNotEqual(want_id(triple), want_id(other))
+
+    def test_want_id_salts_past_a_genuine_collision(self):
+        # Salting exists for one case only: two products whose triples mint the
+        # same id. That needs a base62 collision, so force one — salt 0 of every
+        # triple collapses to a single value while the salted iterations stay
+        # distinct. `other` then CONFORMANTLY holds the shared salt-0 id, and
+        # `triple` must step past it instead of stealing it.
+        triple = ("V", "PLA", "X")
+        other = ("W", "ABS", "Y")
+        real = afi.generate_filament_id
+
+        def colliding(vendor, ftype, name, salt=0):
+            return "OFcolid" if salt == 0 else real(vendor, ftype, name, salt)
+
+        afi.generate_filament_id = colliding
+        try:
+            self.assertIn("OFcolid", afi.mint_iterations(other))  # holder conforms
+            got = afi.make_want_id({"triple_sets": {"OFcolid": {other}}})(triple)
+        finally:
+            afi.generate_filament_id = real
+        self.assertEqual(got, real(*triple, salt=1))
+
 
 class TestBaseName(unittest.TestCase):
     def test_filament_name_derivation(self):
@@ -258,6 +366,27 @@ class TestBaseName(unittest.TestCase):
             self.assertEqual(afi.base_name(name), filament_name, msg=name)
 
 
+# ---------------------------------------------------------------------------
+# vendor discovery
+# ---------------------------------------------------------------------------
+
+class TestVendorDiscovery(unittest.TestCase):
+    def test_a_bundle_is_a_subdir_with_a_matching_index(self):
+        # Neither half alone makes a bundle: resources/profiles tracks a "user"
+        # directory with no user.json, and an index without its directory is a
+        # leftover. Both are skipped, tree-wide.
+        t = SyntheticTree()
+        self.addCleanup(t.cleanup)
+        t.add_vendor("VendorA", [])
+        os.makedirs(os.path.join(t.profiles, "user", "filament"))
+        with open(os.path.join(t.profiles, "Orphan.json"), "w",
+                  encoding="utf-8") as f:
+            json.dump({"name": "Orphan", "filament_list": []}, f)
+        self.assertEqual(afi.list_vendor_names(t.profiles), ["VendorA"])
+        self.assertEqual(sorted(afi.analyze_tree(t.profiles)["vendors"]),
+                         ["VendorA"])
+
+
 # ---------------------------------------------------------------------------
 # resolver (loader-faithful semantics)
 # ---------------------------------------------------------------------------
@@ -323,12 +452,6 @@ class TestResolver(unittest.TestCase):
         fid, src, _e = self.resolve("A", [self.rec("A")], [])
         self.assertEqual((fid, src), (None, "missing"))
 
-    def test_skip_own_resolves_inherited(self):
-        fid, _src, _e = self.resolve(
-            "A", [self.rec("A", "OWN", inherits="B"), self.rec("B", "PARENT")], [],
-            skip_own=True)
-        self.assertEqual(fid, "PARENT")
-
 
 class TestTripleResolution(unittest.TestCase):
     @staticmethod
@@ -692,6 +815,16 @@ class TestCheck6(OfCleanTreeCase):
         self.assertGreater(errors, 0)
         self.assertIn("regenerate the map", out)
 
+    def test_non_of_map_key_is_an_error(self):
+        # The map is keyed by OUR ids; a Bambu id in the key column means the
+        # map was generated or hand-edited the wrong way round.
+        map_path = self._write_map({
+            "GFB00": {"bambu_id": "GFB00", "vendor": "V", "type": "PLA",
+                      "name": "Foo"}})
+        errors, out = self.t.check(map_path)
+        self.assertEqual(errors, 1, out)
+        self.assertIn('"GFB00" is not a minted "OF" id', out)
+
     def test_duplicate_bambu_id_is_an_error(self):
         map_path = self._write_map({
             "OFaaaaaa": {"bambu_id": "GFZ00", "vendor": "V", "type": "PLA", "name": "Foo"},
@@ -786,6 +919,21 @@ class TestUpdateSnapshot(SyntheticTreeCase):
         self.assertEqual(list(snap["ids"]["AX01"]),
                          ["filaments", "name", "filament_type", "filament_vendor"])
 
+    def test_refuses_a_tree_it_could_not_read(self):
+        # A bundle that does not parse contributes no ids, so sanctioning the
+        # rest would record the loss as a deliberate removal.
+        with open(self.t.snapshot, "rb") as f:
+            before = f.read()
+        with open(os.path.join(self.t.profiles, "VendorA",
+                               "filament", "APLA @base.json"), "w",
+                  encoding="utf-8") as f:
+            f.write("{ not json")
+        rc, out = self.t.update_snapshot()
+        self.assertEqual(rc, 1, out)
+        self.assertIn("unreadable filament profile", out)
+        with open(self.t.snapshot, "rb") as f:
+            self.assertEqual(f.read(), before)
+
     def test_refuses_an_id_declared_under_two_triples(self):
         # VendorB re-declares APLA's id for a different product: one id, two
         # triples. No single entry can describe it, and check 3 rejects it anyway.
@@ -818,16 +966,36 @@ class TestUpdateSnapshot(SyntheticTreeCase):
         with open(self.t.snapshot, "rb") as f:
             self.assertEqual(f.read(), before)  # nothing written on refusal
 
+    def test_dry_run_reports_without_writing(self):
+        self.t.write_preset("VendorA", preset("ANEW @P2", inherits="APLA @base",
+                                              compatible_printers=["P2"]))
+        with open(self.t.snapshot, "rb") as f:
+            before = f.read()
+        rc, out = self.t.update_snapshot(dry_run=True)
+        self.assertEqual(rc, 0)
+        self.assertIn("would be rewritten", out)
+        self.assertIn("claims added      : 1", out)
+        with open(self.t.snapshot, "rb") as f:
+            self.assertEqual(f.read(), before)
+        # the real run writes exactly what the dry run reported
+        rc, out = self.t.update_snapshot()
+        self.assertEqual(rc, 0)
+        self.assertIn("snapshot written", out)
+        snap = load_json_file(self.t.snapshot)
+        self.assertEqual(snap["ids"]["AX01"]["filaments"],
+                         ["VendorA/ANEW", "VendorA/APLA"])
+
 
 # ---------------------------------------------------------------------------
-# default run: mint + insert
+# --generate: one rule for inserts and rewrites alike
 # ---------------------------------------------------------------------------
 
 class TestAssign(OfCleanTreeCase):
     def test_noop_on_fully_idded_tree(self):
         changed, errors, out = self.t.assign()
         self.assertEqual((changed, errors), (0, 0))
-        self.assertIn("nothing to do (0 files changed)", out)
+        self.assertIn("filament_ids inserted  : 0", out)
+        self.assertIn("filament_ids re-minted : 0", out)
 
     def test_mints_into_filament_root_and_rootless_member(self):
         self.t.write_preset("VendorA", preset("FNEW @base", instantiation=False,
@@ -855,7 +1023,7 @@ class TestAssign(OfCleanTreeCase):
         # idempotent: second run is a no-op
         changed, errors, out = self.t.assign()
         self.assertEqual((changed, errors), (0, 0))
-        self.assertIn("nothing to do", out)
+        self.assertIn("filament_ids inserted  : 0", out)
 
     def test_refuses_filament_with_incomplete_triple(self):
         self.t.write_preset("VendorA", preset("ENEW @base", instantiation=False))
@@ -867,6 +1035,21 @@ class TestAssign(OfCleanTreeCase):
         self.assertIn("resolves empty filament_vendor and filament_type", out)
         self.assertIn("mint key needs both", out)
 
+    def test_refuses_to_re_mint_a_declaration_with_an_incomplete_triple(self):
+        # The rewrite half of the same guard: a declared id that is not its
+        # triple's mint still cannot be re-derived without a filament_vendor.
+        self.t.write_preset("VendorA", preset("QNEW @base", filament_id="OFZZZZZZ",
+                                              instantiation=False,
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("QNEW @P1", inherits="QNEW @base",
+                                              compatible_printers=["P1"]))
+        before = self.t.bytes_map()
+        changed, errors, out = self.t.assign()
+        self.assertEqual((changed, errors), (0, 1), out)
+        self.assertIn("resolves empty filament_vendor", out)
+        self.assertIn("mint key needs both", out)
+        self.assertEqual(self.t.bytes_map(), before)
+
     def test_refuses_filament_with_divergent_root_fields(self):
         self.t.write_preset("VendorA", preset("HNEW @base1", instantiation=False,
                                               filament_vendor="HV",
@@ -909,10 +1092,10 @@ class TestAssign(OfCleanTreeCase):
         errors, out = self.t.check()
         self.assertEqual(errors, 0, out)
 
-    def test_non_of_declaration_is_treated_as_missing(self):
+    def test_non_of_declaration_is_re_minted(self):
         # A declaration that isn't OF-format (e.g. a vendor bundle synced from
-        # an upstream catalog, like BBL's GF ids) is reminted like a missing
-        # filament, not left alone.
+        # an upstream catalog, like BBL's GF ids) is not the mint of its own
+        # triple, so the same pass rewrites it in place.
         self.t.write_preset("VendorA", preset("Synced PLA @base", filament_id="GFZZ00",
                                               instantiation=False,
                                               filament_vendor="ZV", filament_type="PLA"))
@@ -927,9 +1110,10 @@ class TestAssign(OfCleanTreeCase):
         want = afi.generate_filament_id("ZV", "PLA", "Synced PLA")
         self.assertEqual(root["filament_id"], want)
         # the value was replaced in place, not appended as a second key
-        raw = open(path, encoding="utf-8").read()
+        with open(path, encoding="utf-8") as f:
+            raw = f.read()
         self.assertEqual(raw.count('"filament_id"'), 1)
-        # idempotent: the id is OF-format now, so a second run is a no-op
+        # idempotent: the id is its triple's mint now, so a second run is a no-op
         changed, errors, _out = self.t.assign()
         self.assertEqual((changed, errors), (0, 0))
 
@@ -959,6 +1143,148 @@ class TestAssign(OfCleanTreeCase):
         self.assertEqual(b1["filament_id"], want)
         self.assertEqual(b2["filament_id"], want)
 
+    def test_converges_on_an_existing_tree_id_for_the_same_triple(self):
+        # BEHAVIOUR CHANGE: an id-less filament whose product is already shipped
+        # (with its conforming id) in another bundle converges on that id
+        # instead of salting past it. One product, one id, in every bundle.
+        want = afi.generate_filament_id("CV", "PLA", "CPLA")
+        self.t.add_vendor("VendorB", [
+            preset("CPLA @base", filament_id=want, instantiation=False,
+                   filament_vendor="CV", filament_type="PLA"),
+            preset("CPLA @PB", inherits="CPLA @base",
+                   compatible_printers=["PB 0.4 nozzle"]),
+        ])
+        self.t.write_preset("VendorA", preset("CPLA @base", instantiation=False,
+                                              filament_vendor="CV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("CPLA @P1", inherits="CPLA @base",
+                                              compatible_printers=["P1"]))
+        changed, errors, out = self.t.assign()
+        self.assertEqual((changed, errors), (1, 0), out)
+        root = load_json_file(self.t.preset_path("VendorA", "CPLA @base"))
+        self.assertEqual(root["filament_id"], want)
+
+    def test_a_squatted_id_is_still_minted_for_its_own_product(self):
+        # VendorB's "Other" declares the id that belongs to VendorA's "DPLA" —
+        # a copy-paste, not a real claim, since it is not the mint of Other's
+        # own triple. That declaration is transient (--generate rewrites it), so
+        # it must NOT push DPLA onto a salted id: DPLA gets its canonical one.
+        want0 = afi.generate_filament_id("DV", "PLA", "DPLA")
+        self.t.add_vendor("VendorB", [
+            preset("Other @base", filament_id=want0, instantiation=False,
+                   filament_vendor="OV", filament_type="ABS"),
+        ])
+        self.t.write_preset("VendorA", preset("DPLA @base", instantiation=False,
+                                              filament_vendor="DV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("DPLA @P1", inherits="DPLA @base",
+                                              compatible_printers=["P1"]))
+        changed, errors, out = self.t.assign(["VendorA"])
+        # VendorB is outside the write set, so the id DPLA just took is still
+        # declared there: the run says so rather than leaving a silent duplicate.
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("declared by VendorB/filament/Other @base.json", out)
+        # ...and keeps saying so until a run that covers VendorB clears it.
+        self.assertEqual(self.t.assign(["VendorA"])[:2], (0, 1))
+        root = load_json_file(self.t.preset_path("VendorA", "DPLA @base"))
+        self.assertEqual(root["filament_id"], want0)
+        # A full run re-mints Other to its own triple and the duplicate is gone.
+        other = load_json_file(self.t.preset_path("VendorB", "Other @base"))
+        self.assertEqual(other["filament_id"], want0)
+        changed, errors, out = self.t.assign()
+        self.assertEqual((changed, errors), (1, 0), out)
+        other = load_json_file(self.t.preset_path("VendorB", "Other @base"))
+        self.assertEqual(other["filament_id"],
+                         afi.generate_filament_id("OV", "ABS", "Other"))
+
+    def test_mismatching_of_declaration_is_re_derived(self):
+        # BEHAVIOUR CHANGE: the default run used to leave an OF-format id alone
+        # and needed a separate mode to fix it. One rule now: an id that is not
+        # a mint iteration of its own triple is rewritten.
+        self.t.write_preset("VendorA", preset("KNEW @base", filament_id="OFZZZZZZ",
+                                              instantiation=False,
+                                              filament_vendor="KV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("KNEW @P1", inherits="KNEW @base",
+                                              compatible_printers=["P1"]))
+        want = afi.generate_filament_id("KV", "PLA", "KNEW")
+        changed, errors, out = self.t.assign()
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertIn('"OFZZZZZZ" -> "%s"' % want, out)
+        root = load_json_file(self.t.preset_path("VendorA", "KNEW @base"))
+        self.assertEqual(root["filament_id"], want)
+        changed, errors, _out = self.t.assign()
+        self.assertEqual((changed, errors), (0, 0))
+
+    def test_vendor_filter_limits_rewrites_and_inserts_alike(self):
+        # A mismatching declarer in VendorA and an id-less filament in VendorB;
+        # only VendorA is written, and VendorB's bytes are untouched.
+        self.t.write_preset("VendorA", preset("LNEW @base", filament_id="OFZZZZZZ",
+                                              instantiation=False,
+                                              filament_vendor="LV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("LNEW @P1", inherits="LNEW @base",
+                                              compatible_printers=["P1"]))
+        self.t.add_vendor("VendorB", [
+            preset("MNEW @base", instantiation=False,
+                   filament_vendor="MV", filament_type="PLA"),
+            preset("MNEW @PB", inherits="MNEW @base",
+                   compatible_printers=["PB 0.4 nozzle"]),
+        ])
+        before = self.t.bytes_map()
+        changed, errors, out = self.t.assign(["VendorA"])
+        self.assertEqual((changed, errors), (1, 0), out)
+        root = load_json_file(self.t.preset_path("VendorA", "LNEW @base"))
+        self.assertEqual(root["filament_id"],
+                         afi.generate_filament_id("LV", "PLA", "LNEW"))
+        after = self.t.bytes_map()
+        for rel, raw in before.items():
+            if rel.split(os.sep)[0].startswith("VendorB"):
+                self.assertEqual(after[rel], raw, rel)
+        # ... and the deferred half is exactly what a VendorB run then writes
+        changed, errors, out = self.t.assign(["VendorB"])
+        self.assertEqual((changed, errors), (1, 0), out)
+        b_root = load_json_file(self.t.preset_path("VendorB", "MNEW @base"))
+        self.assertEqual(b_root["filament_id"],
+                         afi.generate_filament_id("MV", "PLA", "MNEW"))
+
+    def test_unknown_vendor_reports_and_writes_nothing(self):
+        # A real insert is pending, so "wrote nothing" means the unknown vendor
+        # aborted the run before any write — not that the tree was already done.
+        self.t.write_preset("VendorA", preset("PNEW @base", instantiation=False,
+                                              filament_vendor="PV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("PNEW @P1", inherits="PNEW @base",
+                                              compatible_printers=["P1"]))
+        before = self.t.bytes_map()
+        changed, errors, out = self.t.assign(["Nope"])
+        self.assertEqual((changed, errors), (0, 1))
+        self.assertIn("unknown vendor", out)
+        self.assertEqual(self.t.bytes_map(), before)
+        # ... and that pending insert is real: a known-vendor run makes it.
+        changed, errors, out = self.t.assign(["VendorA"])
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(
+            load_json_file(self.t.preset_path("VendorA", "PNEW @base"))["filament_id"],
+            afi.generate_filament_id("PV", "PLA", "PNEW"))
+
+    def test_dry_run_reports_the_real_run_and_writes_nothing(self):
+        self.t.write_preset("VendorA", preset("NNEW @base", instantiation=False,
+                                              filament_vendor="NV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset("NNEW @P1", inherits="NNEW @base",
+                                              compatible_printers=["P1"]))
+        before = self.t.bytes_map()
+        dry_changed, errors, out = self.t.assign(dry_run=True)
+        self.assertEqual((dry_changed, errors), (1, 0), out)
+        self.assertIn("would insert", out)
+        self.assertEqual(self.t.bytes_map(), before)
+        changed, errors, out = self.t.assign()
+        self.assertEqual((changed, errors), (dry_changed, 0), out)
+        root = load_json_file(self.t.preset_path("VendorA", "NNEW @base"))
+        self.assertEqual(root["filament_id"],
+                         afi.generate_filament_id("NV", "PLA", "NNEW"))
+
 
 # ---------------------------------------------------------------------------
 # byte-preserving profile edits
@@ -1056,7 +1382,7 @@ class TestInsertEditing(unittest.TestCase):
             afi.rewrite_filament_id(path, "OFold123", "OFxxx999")  # stale old id
 
     def test_delete_line_with_trailing_comma(self):
-        text, n = afi.delete_filament_id_line(self.CRLF_WITH_ID, "OFold123")
+        text, n = afi.delete_key_line(self.CRLF_WITH_ID, "filament_id", "OFold123")
         self.assertEqual(n, 1)
         self.assertNotIn("filament_id", json.loads(text))
         self.assertEqual(text, self.CRLF_WITH_ID.replace(
@@ -1065,15 +1391,40 @@ class TestInsertEditing(unittest.TestCase):
     def test_delete_last_property_line(self):
         lf_text = ('{\n    "name": "K @base",\n    "instantiation": "false",\n'
                    '    "filament_id": "OFold123"\n}\n')
-        text, n = afi.delete_filament_id_line(lf_text, "OFold123")
+        text, n = afi.delete_key_line(lf_text, "filament_id", "OFold123")
         self.assertEqual(n, 1)
         data = json.loads(text)
         self.assertNotIn("filament_id", data)
         self.assertEqual(data["instantiation"], "false")
+        # the preceding comma goes with it, and nothing else moves
+        self.assertEqual(text, '{\n    "name": "K @base",\n'
+                               '    "instantiation": "false"\n}\n')
+
+    def test_dry_run_edits_verify_but_write_nothing(self):
+        t = SyntheticTree()
+        self.addCleanup(t.cleanup)
+        t.add_vendor("VendorA", [])
+        fresh = t.preset_path("VendorA", "JNEW @base")
+        with open(fresh, "wb") as f:
+            f.write(self.CRLF_TEXT.encode("utf-8"))
+        idded = t.preset_path("VendorA", "JOLD @base")
+        with open(idded, "wb") as f:
+            f.write(self.CRLF_WITH_ID.encode("utf-8"))
+
+        afi.write_filament_id(fresh, "OFabc123", dry_run=True)
+        afi.rewrite_filament_id(idded, "OFold123", "OFnew456", dry_run=True)
+        with open(fresh, "rb") as f:
+            self.assertEqual(f.read(), self.CRLF_TEXT.encode("utf-8"))
+        with open(idded, "rb") as f:
+            self.assertEqual(f.read(), self.CRLF_WITH_ID.encode("utf-8"))
+        # the edit is still applied and verified in memory: only the write is
+        # skipped, so a stale old id fails just as loudly
+        with self.assertRaises(RuntimeError):
+            afi.rewrite_filament_id(idded, "OFstale1", "OFnew456", dry_run=True)
 
 
 # ---------------------------------------------------------------------------
-# --remint
+# --generate: re-minting non-conformant declarations
 # ---------------------------------------------------------------------------
 
 class TestRemint(SyntheticTreeCase):
@@ -1138,17 +1489,23 @@ class TestRemint(SyntheticTreeCase):
         a = load_json_file(self.t.preset_path("VendorA", "APLA @base"))
         self.assertEqual(a["filament_id"], want)
 
-    def test_blocked_by_other_triple_occurrence(self):
+    def test_not_blocked_by_a_non_conformant_occurrence(self):
+        # VendorB carries APLA's id under a PETG triple of its own, so that
+        # declaration is wrong and this run's job is to rewrite it. It must not
+        # cost VendorA's APLA the id its triple actually mints.
         want0 = afi.generate_filament_id(*self.TRIPLE)
         self.t.add_vendor("VendorB", [
             preset("BPLA @base", filament_id=want0, instantiation=False,
                    filament_vendor="BV", filament_type="PETG"),
         ])
-        changed, errors, _out = self.t.remint(["VendorA"])
-        self.assertEqual((changed, errors), (1, 0))
+        changed, errors, out = self.t.remint(["VendorA"])
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("declared by VendorB/filament/BPLA @base.json", out)
         root = load_json_file(self.t.preset_path("VendorA", "APLA @base"))
-        self.assertEqual(root["filament_id"],
-                         afi.generate_filament_id(*self.TRIPLE, salt=1))
+        self.assertEqual(root["filament_id"], want0)
+        # Widening the run to both bundles clears it.
+        changed, errors, out = self.t.remint(["VendorA", "VendorB"])
+        self.assertEqual((changed, errors), (1, 0), out)
 
     def test_bbl_is_reminted_like_any_vendor(self):
         self.t.add_vendor("BBL", [
@@ -1164,59 +1521,195 @@ class TestRemint(SyntheticTreeCase):
         self.assertEqual(root["filament_id"],
                          afi.generate_filament_id("Bambu Lab", "ABS", "Bambu ABS"))
 
-
-# ---------------------------------------------------------------------------
-# --drop-redundant-ids
-# ---------------------------------------------------------------------------
-
-class TestDropRedundantIds(SyntheticTreeCase):
-    def test_drops_only_ofl_riding_same_base_name_declarations(self):
-        # Redundant: same base name, rides the OFL generic, re-declares its id.
-        self.t.write_preset("VendorA", preset("Generic PLA @P2",
-                                              inherits="Generic PLA @System",
-                                              compatible_printers=["P2"],
-                                              filament_id="OGFL99"))
-        # Renamed rider: not dropped (a repoint worksheet decision, not a drop).
-        self.t.write_preset("VendorA", preset("Tuned PLA @P3",
-                                              inherits="Generic PLA @System",
-                                              compatible_printers=["P3"],
-                                              filament_id="OGFL99"))
-        dropped, errors, out = self.t.drop_redundant("VendorA")
-        self.assertEqual(errors, 0, out)
-        self.assertEqual(dropped, 1)
-        self.assertIn('dropped filament_id "OGFL99"', out)
-        self.assertIn('rides OFL "Generic PLA @System"', out)
-        gone = load_json_file(self.t.preset_path("VendorA", "Generic PLA @P2"))
-        self.assertNotIn("filament_id", gone)
-        kept = load_json_file(self.t.preset_path("VendorA", "Tuned PLA @P3"))
-        self.assertEqual(kept["filament_id"], "OGFL99")
-        # vendor-rooted filaments are untouched
+    def test_dry_run_leaves_every_file_untouched(self):
+        before = self.t.bytes_map()
+        changed, errors, out = self.t.remint(["VendorA"], dry_run=True)
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertIn("would rewrite", out)
+        self.assertEqual(self.t.bytes_map(), before)
+        # the real run then makes exactly that one change
+        changed, errors, _out = self.t.remint(["VendorA"])
+        self.assertEqual((changed, errors), (1, 0))
         root = load_json_file(self.t.preset_path("VendorA", "APLA @base"))
-        self.assertEqual(root["filament_id"], "AX01")
-
-    def test_bbl_is_forbidden(self):
-        dropped, errors, out = self.t.drop_redundant("BBL")
-        self.assertEqual(dropped, 0)
-        self.assertGreater(errors, 0)
-        self.assertIn("forbidden", out)
+        self.assertEqual(root["filament_id"],
+                         afi.generate_filament_id(*self.TRIPLE))
 
 
 # ---------------------------------------------------------------------------
-# --mint CLI
+# CLI
 # ---------------------------------------------------------------------------
 
-class TestMintCli(unittest.TestCase):
-    def test_prints_an_of_id(self):
+class TestCli(unittest.TestCase):
+    """main(argv) over a synthetic tree. The clean tree's baseline ids are
+    deliberately non-conformant ("AX01"/"OGFL99"), so a --generate run always
+    has both a filament_id rewrite and setting_id inserts to do."""
+
+    def setUp(self):
+        self.t = make_clean_tree()
+        self.addCleanup(self.t.cleanup)
+
+    def test_bare_invocation_prints_help(self):
         buf = io.StringIO()
         with contextlib.redirect_stdout(buf):
-            rc = afi.main(["--mint", "Polymaker/PLA/PolyLite PLA"])
+            rc = afi.main([])
         self.assertEqual(rc, 0)
-        self.assertRegex(buf.getvalue().strip(), r"^OF[0-9A-Za-z]{6}$")
+        self.assertIn("usage:", buf.getvalue())
+        self.assertIn("--generate", buf.getvalue())
+        # ... and so does any invocation naming no mode: help, and no work
+        before = self.t.bytes_map()
+        rc, out = self.t.cli()
+        self.assertEqual(rc, 0)
+        self.assertIn("usage:", out)
+        self.assertEqual(self.t.bytes_map(), before)
 
-    def test_requires_exactly_three_parts(self):
-        with self.assertRaises(SystemExit), \
-                contextlib.redirect_stderr(io.StringIO()):
-            afi.main(["--mint", "Vendor/Filament"])
+    def test_another_tree_needs_its_own_snapshot(self):
+        # --profiles retargets the tree, but the sanctioned state of that tree
+        # is not the repo snapshot: checking against it is meaningless and
+        # re-recording into it would overwrite the tracked file.
+        with open(afi.SNAPSHOT_PATH, "rb") as f:
+            repo_snapshot = f.read()
+        for mode in ("--check", "--update-snapshot"):
+            with self.assertRaises(SystemExit) as caught:
+                with contextlib.redirect_stderr(io.StringIO()):
+                    afi.main([mode, "--profiles", self.t.profiles])
+            self.assertEqual(caught.exception.code, 2, mode)
+        with open(afi.SNAPSHOT_PATH, "rb") as f:
+            self.assertEqual(f.read(), repo_snapshot)
+        # Named explicitly, both modes run against that tree.
+        rc, out = self.t.cli("--update-snapshot")
+        self.assertEqual(rc, 0, out)
+        # --generate only reads the snapshot as a list of ids not to reuse, so
+        # it keeps working without one.
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            rc = afi.main(["--dry-run", "--profiles", self.t.profiles])
+        self.assertEqual(rc, 0, buf.getvalue())
+
+    def test_filament_id_and_setting_id_together_are_rejected(self):
+        # Each flag's help promises it skips the other kind, so the pair cannot
+        # quietly mean "both".
+        with self.assertRaises(SystemExit) as caught:
+            with contextlib.redirect_stderr(io.StringIO()):
+                afi.main(["--generate", "--filament-id", "--setting-id",
+                          "--profiles", self.t.profiles])
+        self.assertEqual(caught.exception.code, 2)
+
+    def test_a_run_with_errors_does_not_report_success(self):
+        # An unreadable profile must not be buried under a green summary line.
+        path = self.t.preset_path("VendorA", "APLA @base")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("{ not json")
+        rc, out = self.t.cli("--generate")
+        self.assertEqual(rc, 1, out)
+        self.assertIn("error(s)", out)
+        self.assertNotIn("SUCCESS", out)
+
+    def test_dry_run_alone_previews_generate(self):
+        before = self.t.bytes_map()
+        rc, out = self.t.cli("--dry-run")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("would ", out)
+        self.assertIn("nothing written", out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+    def test_the_reported_count_is_files_not_edits(self):
+        # A file both passes touch is still one file. "SoloPLA @P1" needs a
+        # filament_id rewrite AND a setting_id insert, so an edit-counting
+        # summary would over-report the tree.
+        self.t.write_preset("VendorA", preset(
+            "SoloPLA @P1", filament_id="AX01", filament_vendor="AVendor",
+            filament_type="PLA", compatible_printers=["P1"]))
+        before = self.t.bytes_map()
+
+        rc, out = self.t.cli("--generate")
+
+        self.assertEqual(rc, 0, out)
+        after = self.t.bytes_map()
+        touched = {p for p in after if after[p] != before.get(p)}
+        self.assertIn("VendorA/filament/SoloPLA @P1.json".replace("/", os.sep), touched)
+        self.assertIn("rewrite VendorA/filament/SoloPLA @P1.json", out)
+        self.assertIn("update VendorA/filament/SoloPLA @P1.json", out)
+        summary = [l for l in out.splitlines() if "file(s) changed" in l]
+        self.assertEqual(len(summary), 1, out)
+        self.assertIn(f"{len(touched)} file(s) changed", summary[0])
+
+    def test_dryrun_is_the_same_flag(self):
+        before = self.t.bytes_map()
+        rc, out = self.t.cli("--dryrun")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("would ", out)  # the same preview, not a silent no-op
+        self.assertIn("nothing written", out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+    def test_generate_vendor_writes_only_in_that_bundle(self):
+        before = self.t.bytes_map()
+        rc, out = self.t.cli("--generate", "--vendor", "VendorA")
+        self.assertEqual(rc, 0, out)
+        after = self.t.bytes_map()
+        changed = sorted(rel for rel in before if after[rel] != before[rel])
+        self.assertTrue(changed, out)
+        for rel in changed:
+            self.assertTrue(rel.startswith("VendorA" + os.sep), rel)
+        # The bundles it spared were not simply already conformant: the
+        # un-narrowed run goes on to write in them too.
+        rc, out = self.t.cli("--generate")
+        self.assertEqual(rc, 0, out)
+        final = self.t.bytes_map()
+        self.assertTrue(any(final[rel] != after[rel] for rel in after
+                            if not rel.startswith("VendorA" + os.sep)), out)
+
+    def test_generate_unknown_vendor_returns_1(self):
+        before = self.t.bytes_map()
+        rc, out = self.t.cli("--generate", "--vendor", "Nope")
+        self.assertEqual(rc, 1)
+        self.assertIn("unknown vendor", out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+    def test_setting_id_only_leaves_filament_ids_alone(self):
+        rc, out = self.t.cli("--generate", "--setting-id")
+        self.assertEqual(rc, 0, out)
+        root = load_json_file(self.t.preset_path("VendorA", "APLA @base"))
+        self.assertEqual(root["filament_id"], "AX01")  # not re-minted
+        member = load_json_file(self.t.preset_path("VendorA", "APLA @P1"))
+        self.assertNotIn("filament_id", member)
+        self.assertEqual(member["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament",
+                                                        "APLA @P1"))
+
+    def test_filament_id_only_inserts_no_setting_id(self):
+        rc, out = self.t.cli("--generate", "--filament-id")
+        self.assertEqual(rc, 0, out)
+        root = load_json_file(self.t.preset_path("VendorA", "APLA @base"))
+        self.assertEqual(root["filament_id"],
+                         afi.generate_filament_id("AVendor", "PLA", "APLA"))
+        for name in ("APLA @base", "APLA @P1"):
+            self.assertNotIn(
+                "setting_id", load_json_file(self.t.preset_path("VendorA", name)))
+
+    def test_check_mode_returns_1_on_errors(self):
+        # What CI keys off: --check exits nonzero when the tree does not match
+        # the snapshot it is validated against.
+        before = self.t.bytes_map()
+        rc, out = self.t.cli("--check")
+        self.assertEqual(rc, 1)
+        self.assertIn("error(s)", out)
+        self.assertEqual(self.t.bytes_map(), before)  # --check never writes
+
+    def test_removed_and_conflicting_flags_are_rejected(self):
+        for argv in (["--remint", "VendorA"],          # removed mode
+                     ["--mint", "A/B/C"],              # removed mode
+                     ["--drop-redundant-ids", "VendorA"],  # removed mode
+                     ["--assign"],                     # removed mode
+                     ["--generate", "--check"],        # two modes
+                     ["--vendor", "VendorA"],          # narrowing without a mode
+                     ["--filament-id"],                # narrowing without a mode
+                     ["--check", "--vendor", "VendorA"]):  # narrowing on --check
+            with self.subTest(argv=argv):
+                with self.assertRaises(SystemExit) as cm, \
+                        contextlib.redirect_stdout(io.StringIO()), \
+                        contextlib.redirect_stderr(io.StringIO()):
+                    afi.main([*argv, "--profiles", self.t.profiles])
+                self.assertEqual(cm.exception.code, 2)
 
 
 # ---------------------------------------------------------------------------
@@ -1231,6 +1724,13 @@ class TestRealTree(unittest.TestCase):
             errors = afi.check_filament_ids(REAL_PROFILES)
         self.assertEqual(errors, 0, buf.getvalue())
 
+    def test_check_cli_returns_0(self):
+        # The exact CI invocation, return code included.
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            rc = afi.main(["--check"])
+        self.assertEqual(rc, 0, buf.getvalue())
+
     def test_every_instantiated_filament_resolves_an_id(self):
         analysis = afi.analyze_tree(REAL_PROFILES)
         self.assertEqual(analysis["missing_effective"], [])
@@ -1241,6 +1741,46 @@ class TestRealTree(unittest.TestCase):
 # ---------------------------------------------------------------------------
 
 class TestReviewFixes(OfCleanTreeCase):
+    def test_one_file_reached_by_two_spellings_counts_once(self):
+        # The filament pass reaches a file through its index sub_path, the
+        # setting_id pass through os.walk. Those two spellings differ whenever
+        # the sub_path is not already normalized - always, on Windows, where
+        # every sub_path keeps the "/" the index stores. One file is one file.
+        # One preset per write path: SoloPLA has no id (inserted), WrongPLA
+        # declares one that is not its own mint (rewritten). Both are
+        # instantiated, so the setting_id pass reaches them too.
+        self.t.write_preset("VendorA", preset("SoloPLA @P1",
+                                              compatible_printers=["P1 0.4 nozzle"],
+                                              filament_vendor="SV",
+                                              filament_type="PLA"))
+        self.t.write_preset("VendorA", preset(
+            "WrongPLA @P1", filament_id=afi.generate_filament_id("WV", "PLA", "Nope"),
+            compatible_printers=["P1 0.4 nozzle"],
+            filament_vendor="WV", filament_type="PLA"))
+        for name in ("SoloPLA @P1", "WrongPLA @P1"):
+            self.t.set_sub_path("VendorA", name, f"filament/./{name}.json")
+        touched = set()
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            afi.generate_filament_ids(self.t.profiles, self.t.snapshot,
+                                      None, False, touched)
+            afi.generate_setting_ids(self.t.profiles, None, False, touched)
+        for name in ("SoloPLA @P1", "WrongPLA @P1"):
+            self.assertEqual([t for t in touched if t.endswith(name + ".json")],
+                             [self.t.preset_path("VendorA", name)], sorted(touched))
+        self.assertEqual(sorted(touched),
+                         sorted(os.path.normpath(t) for t in touched))
+
+    def test_a_broken_edit_names_the_file(self):
+        # An edit that produces invalid JSON is refused, and the message has to
+        # say which of ~12,000 files it was: a bare JSONDecodeError does not.
+        path = self.t.preset_path("VendorA", "APLA @base")
+        with self.assertRaises(RuntimeError) as caught:
+            afi._edit_profile(path, lambda text: (text.replace("{", "{,", 1), 1),
+                              what="test edit")
+        self.assertIn(path, str(caught.exception))
+        self.assertIn("test edit", str(caught.exception))
+
     def test_check3_skips_of_id_inherited_from_other_vendor(self):
         # An OFL filament carries its own minted OF id and a vendor tunes it
         # correctly (same base name, non-empty printers). The new claim must
diff --git a/scripts/tests/test_setting_id.py b/scripts/tests/test_setting_id.py
new file mode 100644
index 0000000000..ad9d06a2f0
--- /dev/null
+++ b/scripts/tests/test_setting_id.py
@@ -0,0 +1,902 @@
+#!/usr/bin/env python3
+"""Tests for the setting_id half of scripts/orca_id_tool.py (stdlib unittest, no
+external deps).
+
+Run from the repo root:  python -m unittest discover -s scripts/tests -v
+"""
+
+import contextlib
+import io
+import json
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+import uuid
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import orca_id_tool as afi  # noqa: E402
+
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+REAL_PROFILES = os.path.join(REPO_ROOT, "resources", "profiles")
+
+
+# ---------------------------------------------------------------------------
+# helpers: synthetic profile trees
+# ---------------------------------------------------------------------------
+
+def preset(name, instantiation=True, setting_id=None, settings_id=None,
+           filament_id=None, type_name="filament", **extra):
+    """A preset in the canonical key order the shipped profiles use."""
+    data = {"type": type_name, "name": name, "from": "system"}
+    if setting_id is not None:
+        data["setting_id"] = setting_id
+    if settings_id is not None:
+        data["settings_id"] = settings_id
+    if filament_id is not None:
+        data["filament_id"] = filament_id
+    data["instantiation"] = "true" if instantiation else "false"
+    data.update(extra)
+    return data
+
+
+class SettingTree:
+    """A throwaway resources/profiles-shaped directory of setting_id-bearing bundles.
+
+    A bundle is a `<vendor>/` directory plus the sibling `<vendor>.json` index
+    that makes list_vendor_names() see it; presets live under filament/,
+    process/ and machine/, the three subdirs generate_setting_ids walks.
+
+    write() also registers filament presets in the index's filament_list, the
+    way a shipped bundle does. generate_setting_ids never reads that list, but
+    generate_filament_ids does: without it the filament half of the tool is a
+    no-op on this tree, and the tests that assert --setting-id leaves
+    filament_ids alone would hold for the wrong reason.
+    """
+
+    def __init__(self):
+        self.dir = tempfile.mkdtemp(prefix="setting_id_test_")
+        self.profiles = os.path.join(self.dir, "profiles")
+        os.makedirs(self.profiles)
+
+    def cleanup(self):
+        shutil.rmtree(self.dir, ignore_errors=True)
+
+    def index_path(self, vendor):
+        return os.path.join(self.profiles, vendor + ".json")
+
+    def add_vendor(self, vendor):
+        """Create the bundle dir and its index; idempotent, keeps the list."""
+        for sub in afi.PROFILE_SUBDIRS:
+            os.makedirs(os.path.join(self.profiles, vendor, sub), exist_ok=True)
+        if not os.path.exists(self.index_path(vendor)):
+            self._write_index(vendor, {"name": vendor, "version": "01.00.00.00",
+                                       "filament_list": []})
+
+    def _write_index(self, vendor, index):
+        with open(self.index_path(vendor), "w", encoding="utf-8",
+                  newline="\n") as f:
+            json.dump(index, f, indent=4, ensure_ascii=False)
+
+    def register(self, vendor, subdir, name):
+        """Add a filament preset to the bundle index's filament_list."""
+        with open(self.index_path(vendor), encoding="utf-8") as f:
+            index = json.load(f)
+        sub_path = os.path.join(subdir, name + ".json").replace(os.sep, "/")
+        index["filament_list"].append({"name": name, "sub_path": sub_path})
+        self._write_index(vendor, index)
+
+    def path(self, vendor, subdir, name):
+        return os.path.join(self.profiles, vendor, subdir, name + ".json")
+
+    def write(self, vendor, subdir, data, name=None):
+        """Write a preset as indented LF JSON; returns its path."""
+        self.add_vendor(vendor)
+        file_name = name if name is not None else data["name"]
+        path = self.path(vendor, subdir, file_name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="\n") as f:
+            json.dump(data, f, indent=4, ensure_ascii=False)
+            f.write("\n")
+        if subdir.split(os.sep)[0] == "filament" and data.get("name"):
+            self.register(vendor, subdir, file_name)
+        return path
+
+    def write_raw(self, vendor, subdir, name, raw):
+        """Write exact bytes (BOM, CRLF, tabs, broken JSON); returns its path."""
+        self.add_vendor(vendor)
+        path = self.path(vendor, subdir, name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as f:
+            f.write(raw)
+        return path
+
+    def read(self, vendor, subdir, name):
+        with open(self.path(vendor, subdir, name), encoding="utf-8-sig") as f:
+            return json.load(f)
+
+    def raw(self, vendor, subdir, name):
+        with open(self.path(vendor, subdir, name), "rb") as f:
+            return f.read()
+
+    def bytes_map(self):
+        """relative path -> bytes, for every file in the tree."""
+        out = {}
+        for root, dirs, files in os.walk(self.profiles):
+            dirs.sort()
+            for name in sorted(files):
+                path = os.path.join(root, name)
+                with open(path, "rb") as f:
+                    out[os.path.relpath(path, self.profiles)] = f.read()
+        return out
+
+    # -- pipeline wrappers ---------------------------------------------------
+
+    def run(self, vendors=None, dry_run=False):
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            changed, errors = afi.generate_setting_ids(self.profiles, vendors, dry_run)
+        return changed, errors, buf.getvalue()
+
+    def run_filament_ids(self, vendors=None, dry_run=False):
+        """The OTHER half of --generate, against this tree's own (absent)
+        snapshot, so the id policy never consults the repo's real one."""
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            changed, errors = afi.generate_filament_ids(
+                self.profiles, os.path.join(self.dir, "filament_id_snapshot.json"),
+                vendors, dry_run)
+        return changed, errors, buf.getvalue()
+
+
+class SettingTreeCase(unittest.TestCase):
+    def setUp(self):
+        self.t = SettingTree()
+        self.addCleanup(self.t.cleanup)
+
+
+# ---------------------------------------------------------------------------
+# mint: the C++/Python byte-identity contract
+# ---------------------------------------------------------------------------
+
+class TestSettingIdMint(unittest.TestCase):
+    # Copied verbatim from tests/libslic3r/test_preset_setting_id.cpp: the C++
+    # generate_preset_setting_id() recomputes these ids on the fly, so the two
+    # implementations must stay byte-identical.
+    GOLDEN = [
+        ("Afinia",   "filament", "Afinia ABS @Afinia H400",             "TL34qSVkppBvMvgH"),
+        ("Afinia",   "process",  "0.20mm Standard @Afinia H400",        "FzmtNsy7XQvpd7w0"),
+        ("Afinia",   "machine",  "Afinia H400 0.4 nozzle",              "r4FZagW0S8uoaJPd"),
+        ("Anycubic", "filament", "Generic PLA @Anycubic Kobra 2",       "YIWGGLQ8Oepd30Fv"),
+        ("Creality", "process",  "0.16mm Optimal @Creality Ender-3 V3", "2Nrbq8PxssUPBLza"),
+        ("Elegoo",   "machine",  "Elegoo Neptune 4 0.4 nozzle",         "69QdWuRQwAZk9rFu"),
+    ]
+
+    def test_golden_vectors(self):
+        for vendor, type_name, name, expected in self.GOLDEN:
+            with self.subTest(name=name):
+                self.assertEqual(
+                    afi.generate_preset_setting_id(vendor, type_name, name), expected)
+
+    def test_namespace_and_length_are_frozen(self):
+        # Baked into the C++ side and into every shipped profile; never change it.
+        self.assertEqual(afi.NAMESPACE,
+                         uuid.UUID("c1f4d9e2-7a3b-5c8d-9e0f-1a2b3c4d5e6f"))
+        self.assertEqual(afi.SETTING_ID_LENGTH, 16)
+        self.assertEqual(
+            afi.ALPHABET,
+            "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+        self.assertEqual(len(afi.ALPHABET), 62)
+
+    def test_format_is_sixteen_alphabet_chars(self):
+        for vendor, type_name, name in [("Creality", "filament", "CR PLA @Ender"),
+                                        ("Elegoo", "machine", "Elegoo Neptune 4"),
+                                        ("拓竹", "filament", "拓竹 PLA @P1")]:
+            with self.subTest(name=name):
+                sid = afi.generate_preset_setting_id(vendor, type_name, name)
+                self.assertEqual(len(sid), afi.SETTING_ID_LENGTH)
+                self.assertTrue(set(sid) <= set(afi.ALPHABET), sid)
+
+    def test_is_the_low_base62_digits_of_the_uuid5(self):
+        # Independent re-implementation of the whole rule, key layout included.
+        for vendor, type_name, name, _expected in self.GOLDEN:
+            u = uuid.uuid5(afi.NAMESPACE, f"{vendor}/{type_name}/{name}")
+            n = int.from_bytes(u.bytes, "big")
+            digits = ""
+            for _ in range(afi.SETTING_ID_LENGTH):
+                digits = afi.ALPHABET[n % 62] + digits
+                n //= 62
+            self.assertEqual(afi.generate_preset_setting_id(vendor, type_name, name),
+                             digits)
+
+    def test_deterministic(self):
+        a = afi.generate_preset_setting_id("VendorX", "filament", "My PLA")
+        self.assertEqual(a, afi.generate_preset_setting_id("VendorX", "filament", "My PLA"))
+
+    def test_every_identity_component_changes_the_id(self):
+        base = afi.generate_preset_setting_id("VendorX", "filament", "My PLA")
+        self.assertNotEqual(base, afi.generate_preset_setting_id("VendorY", "filament", "My PLA"))
+        self.assertNotEqual(base, afi.generate_preset_setting_id("VendorX", "process", "My PLA"))
+        self.assertNotEqual(base, afi.generate_preset_setting_id("VendorX", "filament", "My PETG"))
+
+    def test_key_is_a_flat_slash_join(self):
+        # The mint key is "<vendor>/<type>/<name>" with no escaping, so a "/" in
+        # a component shifts the split — harmless in practice (vendor is a
+        # directory name and type is one of PROFILE_SUBDIRS), but it is what the
+        # C++ side does too and the two must agree byte for byte.
+        self.assertEqual(afi.generate_preset_setting_id("A/B", "filament", "C"),
+                         afi.generate_preset_setting_id("A", "B/filament", "C"))
+
+
+class TestBase62Tail(unittest.TestCase):
+    def test_hand_computed_digits(self):
+        self.assertEqual(afi._base62_tail(0, 4), "0000")
+        self.assertEqual(afi._base62_tail(61, 1), "z")           # last alphabet char
+        self.assertEqual(afi._base62_tail(62, 2), "10")          # 1*62 + 0
+        self.assertEqual(afi._base62_tail(3843, 2), "zz")        # 61*62 + 61
+        self.assertEqual(afi._base62_tail(3907, 3), "111")       # 62^2 + 62 + 1
+
+    def test_keeps_only_the_low_digits(self):
+        self.assertEqual(afi._base62_tail(62, 1), "0")           # high digit dropped
+        self.assertEqual(afi._base62_tail(3907, 2), "11")
+
+
+# ---------------------------------------------------------------------------
+# assignment
+# ---------------------------------------------------------------------------
+
+class TestAssignment(SettingTreeCase):
+    def test_instantiation_is_read_exactly_as_the_validator_reads_it(self):
+        # orca_extra_profile_check.py tests `instantiation == "true"` strictly.
+        # Anything looser here would hand an id to a preset the validator calls
+        # a base profile, and the two would fight over it on every run.
+        for name, value in [("Boolean", True), ("Capitalised", "True"),
+                            ("Numeric", 1), ("Absent", None)]:
+            with self.subTest(instantiation=value):
+                data = {"type": "filament", "name": name, "from": "system"}
+                if value is not None:
+                    data["instantiation"] = value
+                self.t.write("VendorA", "filament", data)
+        before = self.t.bytes_map()
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (0, 0), out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+    def test_a_bundle_without_an_index_is_still_assigned(self):
+        # setting_id is a per-file property, and the validator walks every
+        # directory. A bundle whose index has not landed yet must be fixable,
+        # or the validator flags files this tool refuses to touch.
+        path = os.path.join(self.t.profiles, "Noindex", "process", "Q.json")
+        os.makedirs(os.path.dirname(path))
+        with open(path, "w", encoding="utf-8", newline="\n") as f:
+            json.dump(preset("Q", type_name="process"), f, indent=4)
+        self.assertFalse(os.path.exists(self.t.index_path("Noindex")))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        with open(path, encoding="utf-8") as f:
+            self.assertEqual(json.load(f)["setting_id"],
+                             afi.generate_preset_setting_id("Noindex", "process", "Q"))
+
+    def test_assigns_across_every_profile_subdir(self):
+        self.t.write("VendorA", "filament", preset("A PLA @P1"))
+        self.t.write("VendorA", "process",
+                     preset("0.20mm Standard @P1", type_name="process"))
+        self.t.write("VendorA", "machine",
+                     preset("P1 0.4 nozzle", type_name="machine"))
+        # os.walk recursion: a preset in a nested directory is walked too.
+        self.t.write("VendorA", os.path.join("filament", "nested"),
+                     preset("A PETG @P1"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (4, 0), out)
+        for subdir, type_name, name in [
+                ("filament", "filament", "A PLA @P1"),
+                ("process", "process", "0.20mm Standard @P1"),
+                ("machine", "machine", "P1 0.4 nozzle"),
+                (os.path.join("filament", "nested"), "filament", "A PETG @P1")]:
+            self.assertEqual(
+                self.t.read("VendorA", subdir, name)["setting_id"],
+                afi.generate_preset_setting_id("VendorA", type_name, name),
+                msg=name)
+
+    def test_type_comes_from_the_subdirectory_not_the_type_field(self):
+        # The subdir name is the type name (Preset::get_type_string()); a stale
+        # "type" field inside the file does not enter the id.
+        self.t.write("VendorA", "process", preset("Odd @P1", type_name="filament"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(self.t.read("VendorA", "process", "Odd @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "process", "Odd @P1"))
+
+    def test_idempotent(self):
+        self.t.write("VendorA", "filament", preset("A PLA @P1"))
+        self.t.write("VendorA", "process",
+                     preset("0.20mm Standard @P1", type_name="process"))
+        self.t.write("VendorA", "filament", preset("A PLA @base", instantiation=False,
+                                                   setting_id="LEFTOVER00000000"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (3, 0), out)
+
+        after_first = self.t.bytes_map()
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (0, 0), out)
+        self.assertEqual(self.t.bytes_map(), after_first)
+
+    def test_stale_value_is_replaced_in_place(self):
+        path = self.t.write("VendorA", "filament",
+                            preset("A PLA @P1", setting_id="0000000000000000",
+                                   filament_id="OFabc123"))
+        before = self.t.raw("VendorA", "filament", "A PLA @P1")
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        want = afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1")
+        self.assertEqual(self.t.read("VendorA", "filament", "A PLA @P1")["setting_id"],
+                         want)
+        raw = self.t.raw("VendorA", "filament", "A PLA @P1")
+        self.assertEqual(raw.count(b'"setting_id"'), 1)  # replaced, not appended
+        self.assertEqual(raw, before.replace(b'"0000000000000000"',
+                                             b'"%s"' % want.encode()))
+        self.assertTrue(os.path.isfile(path))
+
+    def test_missing_value_is_inserted_before_filament_id(self):
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @P1", filament_id="OFabc123"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        text = self.t.raw("VendorA", "filament", "A PLA @P1").decode("utf-8")
+        want = afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1")
+        self.assertIn(f'"setting_id": "{want}"', text)
+        self.assertLess(text.index('"setting_id"'), text.index('"filament_id"'))
+
+    def test_base_profiles_are_stripped(self):
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @base", instantiation=False,
+                            setting_id="0000000000000000", filament_id="OFabc123"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        data = self.t.read("VendorA", "filament", "A PLA @base")
+        self.assertNotIn("setting_id", data)
+        self.assertEqual(data["filament_id"], "OFabc123")   # nothing else touched
+        self.assertEqual(data["instantiation"], "false")
+
+    def test_base_profile_without_instantiation_key_is_stripped(self):
+        # No "instantiation" key at all == not instantiated (str(None) != "true").
+        data = {"type": "filament", "name": "A PLA @root", "from": "system",
+                "setting_id": "0000000000000000"}
+        self.t.write("VendorA", "filament", data)
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertNotIn("setting_id", self.t.read("VendorA", "filament", "A PLA @root"))
+
+    def test_misspelled_settings_id_is_dropped(self):
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @base", instantiation=False,
+                            settings_id="0000000000000000"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        data = self.t.read("VendorA", "filament", "A PLA @base")
+        self.assertNotIn("settings_id", data)
+        self.assertNotIn("setting_id", data)
+
+    def test_typo_drop_and_assignment_are_one_file_change(self):
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @P1", settings_id="0000000000000000",
+                            filament_id="OFabc123"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)   # ONE counted file change
+        data = self.t.read("VendorA", "filament", "A PLA @P1")
+        self.assertNotIn("settings_id", data)
+        self.assertEqual(data["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1"))
+
+    def test_reserved_vendor_keeps_instantiated_ids_and_loses_base_ones(self):
+        # BBL owns the authoritative "G*" cloud id space: its instantiated
+        # presets are never rewritten, its base declarations still are stripped.
+        self.t.write("BBL", "filament",
+                     preset("Bambu ABS @BBL A1", setting_id="GFSB00_07"))
+        self.t.write("BBL", "filament", preset("Bambu ABS @P1 no id"))
+        self.t.write("BBL", "filament",
+                     preset("Bambu ABS @base", instantiation=False,
+                            setting_id="GFSB00_00"))
+        kept = self.t.raw("BBL", "filament", "Bambu ABS @BBL A1")
+        kept_idless = self.t.raw("BBL", "filament", "Bambu ABS @P1 no id")
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)   # only the base profile
+        self.assertEqual(self.t.raw("BBL", "filament", "Bambu ABS @BBL A1"), kept)
+        self.assertEqual(self.t.raw("BBL", "filament", "Bambu ABS @P1 no id"),
+                         kept_idless)
+        self.assertNotIn("setting_id",
+                         self.t.read("BBL", "filament", "Bambu ABS @base"))
+
+    def test_reserved_vendors_misspelled_key_is_corrected_not_dropped(self):
+        # A reserved vendor's id is authoritative, so there is no formula to
+        # fall back on. Dropping the typo and stopping there would leave the
+        # preset with no setting_id at all and no way for the tool to give it
+        # one - a validator error nothing can clear. Fix the key, keep the value.
+        self.t.write("BBL", "filament",
+                     preset("Bambu PLA @P1", settings_id="GFSA00_01"))
+        # A base profile still just loses the key; it may not carry an id.
+        self.t.write("BBL", "filament",
+                     preset("Bambu PLA @base", instantiation=False,
+                            settings_id="GFSA00_00"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (2, 0), out)
+        fixed = self.t.read("BBL", "filament", "Bambu PLA @P1")
+        self.assertNotIn("settings_id", fixed)
+        self.assertEqual(fixed["setting_id"], "GFSA00_01")
+        base = self.t.read("BBL", "filament", "Bambu PLA @base")
+        self.assertNotIn("settings_id", base)
+        self.assertNotIn("setting_id", base)
+        # Idempotent: the corrected file is what the next run expects to see.
+        self.assertEqual(self.t.run()[:2], (0, 0))
+
+    def test_a_managed_vendors_misspelled_key_is_still_replaced_by_the_mint(self):
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @P1", settings_id="whatever"))
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        data = self.t.read("VendorA", "filament", "A PLA @P1")
+        self.assertNotIn("settings_id", data)
+        self.assertEqual(data["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1"))
+
+    def test_reserved_vendors_constant(self):
+        self.assertEqual(afi.RESERVED_VENDORS, {"BBL"})
+        self.assertEqual(afi.PROFILE_SUBDIRS, ("filament", "process", "machine"))
+
+
+# ---------------------------------------------------------------------------
+# --vendor narrowing
+# ---------------------------------------------------------------------------
+
+class TestVendorNarrowing(SettingTreeCase):
+    def setUp(self):
+        super().setUp()
+        self.t.write("VendorA", "filament", preset("A PLA @P1"))
+        self.t.write("VendorB", "filament", preset("B PLA @P1"))
+
+    def test_restricts_writes_to_the_named_vendor(self):
+        before = self.t.bytes_map()
+
+        changed, errors, out = self.t.run(vendors=["VendorA"])
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(self.t.read("VendorA", "filament", "A PLA @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1"))
+        self.assertEqual(self.t.raw("VendorB", "filament", "B PLA @P1"),
+                         before[os.path.join("VendorB", "filament", "B PLA @P1.json")])
+        # ... and the vendor left out is written by a later run, unchanged in kind.
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(self.t.read("VendorB", "filament", "B PLA @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorB", "filament", "B PLA @P1"))
+
+    def test_unknown_vendor_reports_and_writes_nothing(self):
+        before = self.t.bytes_map()
+
+        changed, errors, out = self.t.run(vendors=["Nope"])
+
+        self.assertEqual((changed, errors), (0, 1))
+        self.assertIn("Nope", out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+    def test_unknown_vendor_blocks_the_known_ones_too(self):
+        before = self.t.bytes_map()
+        changed, errors, _out = self.t.run(vendors=["VendorA", "Nope"])
+        self.assertEqual((changed, errors), (0, 1))
+        self.assertEqual(self.t.bytes_map(), before)
+
+
+# ---------------------------------------------------------------------------
+# --dry-run
+# ---------------------------------------------------------------------------
+
+class TestDryRun(SettingTreeCase):
+    def test_writes_nothing_and_previews_the_real_run(self):
+        self.t.write("VendorA", "filament", preset("A PLA @P1"))
+        self.t.write("VendorA", "process",
+                     preset("0.20mm Standard @P1", type_name="process"))
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @base", instantiation=False,
+                            setting_id="0000000000000000"))
+        before = self.t.bytes_map()
+
+        dry_changed, dry_errors, out = self.t.run(dry_run=True)
+
+        self.assertEqual((dry_changed, dry_errors), (3, 0), out)
+        self.assertIn("would", out)
+        self.assertEqual(self.t.bytes_map(), before)   # nothing written
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (dry_changed, dry_errors), out)
+        self.assertNotEqual(self.t.bytes_map(), before)
+
+
+# ---------------------------------------------------------------------------
+# byte preservation
+# ---------------------------------------------------------------------------
+
+class TestBytePreservation(SettingTreeCase):
+    CRLF_TEXT = (
+        '{\r\n'
+        '\t"type": "filament",\r\n'
+        '\t"name": "CRLF PLA @P1",\r\n'
+        '\t"from": "system",\r\n'
+        '\t"filament_id": "OFabc123",\r\n'
+        '\t"instantiation": "true",\r\n'
+        '\t"filament_type": [\r\n'
+        '\t\t"PLA"\r\n'
+        '\t]\r\n'
+        '}\r\n'
+    )
+
+    def test_crlf_and_tab_indentation_survive(self):
+        self.t.write_raw("VendorA", "filament", "CRLF PLA @P1",
+                         self.CRLF_TEXT.encode("utf-8"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        raw = self.t.raw("VendorA", "filament", "CRLF PLA @P1")
+        self.assertEqual(raw.count(b"\n"), raw.count(b"\r\n"))   # still CRLF-only
+        want = afi.generate_preset_setting_id("VendorA", "filament", "CRLF PLA @P1")
+        inserted = ('\t"setting_id": "%s",\r\n' % want).encode("utf-8")
+        # Every original byte survives: dropping the inserted line restores the file.
+        self.assertEqual(raw.replace(inserted, b"", 1),
+                         self.CRLF_TEXT.encode("utf-8"))
+
+    def test_bom_survives(self):
+        raw_in = b"\xef\xbb\xbf" + json.dumps(
+            preset("BOM PLA @P1", filament_id="OFabc123"),
+            indent=4, ensure_ascii=False).encode("utf-8") + b"\n"
+        self.t.write_raw("VendorA", "filament", "BOM PLA @P1", raw_in)
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        raw = self.t.raw("VendorA", "filament", "BOM PLA @P1")
+        self.assertTrue(raw.startswith(b"\xef\xbb\xbf"))
+        self.assertEqual(raw.count(b"\xef\xbb\xbf"), 1)
+        want = afi.generate_preset_setting_id("VendorA", "filament", "BOM PLA @P1")
+        self.assertEqual(self.t.read("VendorA", "filament", "BOM PLA @P1")["setting_id"],
+                         want)
+        self.assertEqual(
+            raw.replace(('    "setting_id": "%s",\n' % want).encode("utf-8"), b"", 1),
+            raw_in)
+
+    def test_non_ascii_name_round_trips(self):
+        name = "拓竹 PLA @P1 0.4 nozzle"
+        raw_in = (json.dumps(preset(name, filament_id="OFabc123"), indent=4,
+                             ensure_ascii=False).encode("utf-8") + b"\n")
+        self.t.write_raw("VendorA", "filament", name, raw_in)
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        raw = self.t.raw("VendorA", "filament", name)
+        self.assertIn(name.encode("utf-8"), raw)         # not escaped to \uXXXX
+        data = self.t.read("VendorA", "filament", name)
+        self.assertEqual(data["name"], name)
+        self.assertEqual(data["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", name))
+
+    def test_surrounding_formatting_is_untouched_on_a_strip(self):
+        text = ('{\r\n'
+                '\t"type": "filament",\r\n'
+                '\t"name": "Odd @base",\r\n'
+                '\t"setting_id": "0000000000000000",\r\n'
+                '\t"instantiation": "false",\r\n'
+                '\t"compatible_printers": []\r\n'
+                '}\r\n')
+        self.t.write_raw("VendorA", "filament", "Odd @base", text.encode("utf-8"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(
+            self.t.raw("VendorA", "filament", "Odd @base").decode("utf-8"),
+            text.replace('\t"setting_id": "0000000000000000",\r\n', "", 1))
+
+
+# ---------------------------------------------------------------------------
+# byte-preserving key edits
+# ---------------------------------------------------------------------------
+
+class TestInsertAnchor(unittest.TestCase):
+    WITH_BOTH = ('{\n    "name": "K @P1",\n    "filament_id": "OFabc123",\n'
+                 '    "instantiation": "true"\n}\n')
+    WITH_INSTANTIATION = ('{\n    "name": "K @P1",\n'
+                          '    "instantiation": "true"\n}\n')
+
+    def test_inserts_before_filament_id(self):
+        text, n = afi.insert_setting_id(self.WITH_BOTH, "0123456789abcdef")
+        self.assertEqual(n, 1)
+        json.loads(text)
+        self.assertEqual(text, self.WITH_BOTH.replace(
+            '    "filament_id"',
+            '    "setting_id": "0123456789abcdef",\n    "filament_id"', 1))
+
+    def test_falls_back_to_instantiation(self):
+        text, n = afi.insert_setting_id(self.WITH_INSTANTIATION, "0123456789abcdef")
+        self.assertEqual(n, 1)
+        json.loads(text)
+        self.assertIn('"setting_id": "0123456789abcdef",\n    "instantiation"', text)
+
+    def test_falls_back_to_name(self):
+        # Last-resort anchor: every preset has a name, so the insert does not
+        # depend on filament_id having been written first — a dry run, which
+        # writes none, must reach the same verdict as the real run.
+        text, n = afi.insert_setting_id('{\n    "name": "K",\n    "x": 1\n}\n',
+                                        "0123456789abcdef")
+        self.assertEqual(n, 1)
+        json.loads(text)
+        self.assertIn('"name": "K",\n    "setting_id": "0123456789abcdef",', text)
+
+    def test_no_anchor_returns_zero(self):
+        src = '{\n    "type": "filament"\n}\n'
+        text, n = afi.insert_setting_id(src, "0123456789abcdef")
+        self.assertEqual(n, 0)
+        self.assertEqual(text, src)
+
+
+class TestKeyLineHelpers(unittest.TestCase):
+    def test_delete_trailing_comma_form(self):
+        text = ('{\n    "name": "K",\n    "setting_id": "OLD0000000000000",\n'
+                '    "instantiation": "false"\n}\n')
+        out, n = afi.delete_key_line(text, "setting_id")
+        self.assertEqual(n, 1)
+        self.assertEqual(json.loads(out), {"name": "K", "instantiation": "false"})
+        self.assertEqual(out, text.replace(
+            '    "setting_id": "OLD0000000000000",\n', "", 1))
+
+    def test_delete_last_property_form_consumes_the_preceding_comma(self):
+        text = ('{\n    "name": "K",\n    "instantiation": "false",\n'
+                '    "setting_id": "OLD0000000000000"\n}\n')
+        out, n = afi.delete_key_line(text, "setting_id")
+        self.assertEqual(n, 1)
+        self.assertEqual(json.loads(out), {"name": "K", "instantiation": "false"})
+        self.assertEqual(out, '{\n    "name": "K",\n    "instantiation": "false"\n}\n')
+
+    def test_delete_requires_the_exact_old_value(self):
+        text = ('{\n    "name": "K",\n    "setting_id": "OLD0000000000000",\n'
+                '    "instantiation": "false"\n}\n')
+        out, n = afi.delete_key_line(text, "setting_id", old_value="OTHER")
+        self.assertEqual((out, n), (text, 0))
+        _out, n = afi.delete_key_line(text, "setting_id",
+                                      old_value="OLD0000000000000")
+        self.assertEqual(n, 1)
+
+    def test_delete_missing_key_returns_zero(self):
+        text = '{\n    "name": "K"\n}\n'
+        self.assertEqual(afi.delete_key_line(text, "setting_id"), (text, 0))
+
+    def test_delete_does_not_confuse_the_two_spellings(self):
+        text = ('{\n    "name": "K",\n    "settings_id": "TYPO000000000000",\n'
+                '    "setting_id": "REAL000000000000",\n'
+                '    "instantiation": "true"\n}\n')
+        out, n = afi.delete_key_line(text, "settings_id")
+        self.assertEqual(n, 1)
+        self.assertEqual(json.loads(out)["setting_id"], "REAL000000000000")
+
+    def test_replace_refuses_a_stale_old_value(self):
+        text = '{\n    "setting_id": "OLD0000000000000"\n}\n'
+        out, n = afi.replace_key_value(text, "setting_id", "NEW0000000000000",
+                                       old_value="NOTTHIS000000000")
+        self.assertEqual((out, n), (text, 0))
+        out, n = afi.replace_key_value(text, "setting_id", "NEW0000000000000",
+                                       old_value="OLD0000000000000")
+        self.assertEqual(n, 1)
+        self.assertEqual(json.loads(out)["setting_id"], "NEW0000000000000")
+
+    def test_insert_key_line_prefers_before_over_after(self):
+        text = ('{\n    "name": "K",\n    "filament_id": "OFabc123",\n'
+                '    "instantiation": "true"\n}\n')
+        out, n = afi.insert_key_line(text, "setting_id", "V",
+                                     before=("filament_id", "instantiation"),
+                                     after=("name",))
+        self.assertEqual(n, 1)
+        self.assertLess(out.index('"setting_id"'), out.index('"filament_id"'))
+        self.assertGreater(out.index('"setting_id"'), out.index('"name"'))
+        # The `before` tuple's own order decides, not the order in the file.
+        out, _n = afi.insert_key_line(text, "setting_id", "V",
+                                      before=("instantiation", "filament_id"))
+        self.assertGreater(out.index('"setting_id"'), out.index('"filament_id"'))
+
+    def test_insert_key_line_falls_back_to_after(self):
+        text = '{\n    "name": "K",\n    "from": "system"\n}\n'
+        out, n = afi.insert_key_line(text, "setting_id", "V",
+                                     before=("filament_id",), after=("name",))
+        self.assertEqual(n, 1)
+        self.assertEqual(out, '{\n    "name": "K",\n    "setting_id": "V",\n'
+                              '    "from": "system"\n}\n')
+
+    def test_insert_key_line_without_any_anchor(self):
+        text = '{\n    "from": "system"\n}\n'
+        self.assertEqual(
+            afi.insert_key_line(text, "setting_id", "V", before=("filament_id",),
+                                after=("name",)),
+            (text, 0))
+
+
+# ---------------------------------------------------------------------------
+# error paths: reported and counted, never raised
+# ---------------------------------------------------------------------------
+
+class TestErrorPaths(SettingTreeCase):
+    def test_unparsable_profile_is_reported_and_the_run_continues(self):
+        broken = b'{\n    "name": "Broken @P1",\n    oops\n}\n'
+        self.t.write_raw("VendorA", "filament", "Broken @P1", broken)
+        self.t.write("VendorA", "filament", preset("Good @P1"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("Broken @P1", out)
+        self.assertEqual(self.t.raw("VendorA", "filament", "Broken @P1"), broken)
+        self.assertEqual(self.t.read("VendorA", "filament", "Good @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "Good @P1"))
+
+    def test_non_object_top_level_is_reported(self):
+        raw = b'[\n    {"name": "K"}\n]\n'
+        self.t.write_raw("VendorA", "filament", "List @P1", raw)
+        self.t.write("VendorA", "filament", preset("Good @P1"))
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("List @P1", out)
+        self.assertEqual(self.t.raw("VendorA", "filament", "List @P1"), raw)
+
+    def test_nameless_instantiated_preset_is_reported(self):
+        nameless = {"type": "filament", "from": "system", "instantiation": "true"}
+        self.t.write("VendorA", "filament", nameless, name="Nameless")
+        self.t.write("VendorA", "filament", preset("Good @P1"))
+        before = self.t.raw("VendorA", "filament", "Nameless")
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("Nameless", out)
+        self.assertEqual(self.t.raw("VendorA", "filament", "Nameless"), before)
+        self.assertEqual(self.t.read("VendorA", "filament", "Good @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "Good @P1"))
+
+    def test_a_nameless_preset_still_gets_its_misspelled_key_dropped(self):
+        # The nameless-preset error must not abandon an edit already queued for
+        # the same file: leaving "settings_id" behind would keep the validator
+        # red with no way for this tool to clear it.
+        nameless = {"type": "filament", "from": "system", "settings_id": "JUNK123",
+                    "instantiation": "true"}
+        self.t.write("VendorA", "filament", nameless, name="Nameless")
+
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertNotIn("settings_id", self.t.read("VendorA", "filament", "Nameless"))
+        self.assertNotIn("setting_id", self.t.read("VendorA", "filament", "Nameless"))
+        self.assertIn('misspelled "settings_id" dropped : 1', out)
+
+    def test_an_unanchorable_file_is_reported_not_raised(self):
+        # One oddly formatted profile must not abort the pass over all the
+        # others, and it must fail the same way in a dry run as in a real one.
+        raw = b'{ "type":"filament", "name":"Flat @P1", "instantiation":"true" }\n'
+        self.t.write_raw("VendorA", "filament", "Flat @P1", raw)
+        self.t.write("VendorA", "filament", preset("Good @P1"))
+
+        dry_changed, dry_errors, dry_out = self.t.run(dry_run=True)
+        changed, errors, out = self.t.run()
+
+        self.assertEqual((dry_changed, dry_errors), (changed, errors), dry_out)
+        self.assertEqual((changed, errors), (1, 1), out)
+        self.assertIn("Flat @P1", out)
+        self.assertEqual(self.t.raw("VendorA", "filament", "Flat @P1"), raw)
+        self.assertEqual(self.t.read("VendorA", "filament", "Good @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "Good @P1"))
+
+    def test_nameless_base_preset_is_fine(self):
+        # Only instantiated presets need an identity; a nameless base profile is
+        # simply left alone.
+        nameless = {"type": "filament", "from": "system", "instantiation": "false"}
+        self.t.write("VendorA", "filament", nameless, name="Nameless base")
+        before = self.t.bytes_map()
+        changed, errors, out = self.t.run()
+        self.assertEqual((changed, errors), (0, 0), out)
+        self.assertEqual(self.t.bytes_map(), before)
+
+
+# ---------------------------------------------------------------------------
+# the real tree
+# ---------------------------------------------------------------------------
+
+@unittest.skipUnless(os.path.isdir(REAL_PROFILES), "resources/profiles not present")
+class TestRealTree(unittest.TestCase):
+    def test_shipped_tree_needs_no_setting_id_change(self):
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            changed, errors = afi.generate_setting_ids(REAL_PROFILES, dry_run=True)
+        self.assertEqual((changed, errors), (0, 0), buf.getvalue())
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+class TestCli(SettingTreeCase):
+    def main(self, argv):
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            rc = afi.main(argv)
+        return rc, buf.getvalue()
+
+    def test_setting_id_only_run_touches_no_filament_id(self):
+        # "OFZZZZZZ" is not the mint of the preset's own triple, so the filament
+        # half of --generate has real work waiting on this tree (proven at the
+        # end): leaving the id alone is the narrowing's doing, not an idle tree.
+        self.t.write("VendorA", "filament",
+                     preset("A PLA @P1", filament_id="OFZZZZZZ",
+                            filament_vendor=["AV"], filament_type=["PLA"]))
+        self.t.write("VendorA", "machine",
+                     preset("P1 0.4 nozzle", type_name="machine"))
+
+        rc, out = self.main(["--generate", "--setting-id",
+                             "--profiles", self.t.profiles])
+
+        self.assertEqual(rc, 0, out)
+        filament = self.t.read("VendorA", "filament", "A PLA @P1")
+        self.assertEqual(filament["filament_id"], "OFZZZZZZ")
+        self.assertEqual(filament["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament", "A PLA @P1"))
+        machine = self.t.read("VendorA", "machine", "P1 0.4 nozzle")
+        self.assertNotIn("filament_id", machine)
+        self.assertEqual(machine["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "machine", "P1 0.4 nozzle"))
+        # ... and the skipped half does re-mint that id when it is allowed to run.
+        changed, errors, out = self.t.run_filament_ids()
+        self.assertEqual((changed, errors), (1, 0), out)
+        self.assertEqual(
+            self.t.read("VendorA", "filament", "A PLA @P1")["filament_id"],
+            afi.generate_filament_id("AV", "PLA", "A PLA"))
+
+    def test_dry_run_setting_id_writes_nothing(self):
+        self.t.write("VendorA", "filament", preset("A PLA @P1"))
+        before = self.t.bytes_map()
+        rc, out = self.main(["--generate", "--setting-id", "--dry-run",
+                             "--profiles", self.t.profiles])
+        self.assertEqual(rc, 0, out)
+        self.assertIn("1 file(s) would change", out)   # there WAS one to write
+        self.assertEqual(self.t.bytes_map(), before)
+        # the real run then writes exactly it
+        rc, out = self.main(["--generate", "--setting-id",
+                             "--profiles", self.t.profiles])
+        self.assertEqual(rc, 0, out)
+        self.assertIn("1 file(s) changed", out)
+        self.assertEqual(self.t.read("VendorA", "filament", "A PLA @P1")["setting_id"],
+                         afi.generate_preset_setting_id("VendorA", "filament",
+                                                        "A PLA @P1"))
+
+    def test_setting_id_without_generate_is_a_usage_error(self):
+        with contextlib.redirect_stderr(io.StringIO()), \
+                self.assertRaises(SystemExit) as cm:
+            afi.main(["--setting-id", "--profiles", self.t.profiles])
+        self.assertEqual(cm.exception.code, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/update_bambu_filament_ids.py b/scripts/update_bambu_filament_ids.py
index 7a4a67d2a3..93047895e1 100644
--- a/scripts/update_bambu_filament_ids.py
+++ b/scripts/update_bambu_filament_ids.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Generate resources/printers/bambu_filament_ids.json: the map from Orca's
-content-addressed filament_id ("OF" + 6 base62 chars, see assign_filament_ids.py)
+content-addressed filament_id ("OF" + 6 base62 chars, see orca_id_tool.py)
 to Bambu Lab's own AMS/RFID catalog id ("GF..." etc.) for the subset of filament
 products Bambu ships.
 
@@ -54,7 +54,7 @@ import tempfile
 import datetime
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from assign_filament_ids import (  # noqa: E402
+from orca_id_tool import (  # noqa: E402
     BAMBU_MAP_PATH,
     OFL,
     OF_ID_RE,
diff --git a/src/libslic3r/Preset.cpp b/src/libslic3r/Preset.cpp
index 235ea66ad2..de17a678ce 100644
--- a/src/libslic3r/Preset.cpp
+++ b/src/libslic3r/Preset.cpp
@@ -545,7 +545,7 @@ std::string generate_preset_setting_id(const std::string& vendor, const std::str
         return "";
 
     // Dedicated namespace for preset setting_ids, distinct from the cloud per-user
-    // namespace (OrcaCloudServiceAgent). Keep in sync with scripts/assign_vendor_setting_ids.py;
+    // namespace (OrcaCloudServiceAgent). Keep in sync with scripts/orca_id_tool.py;
     // never change this constant.
     static const boost::uuids::uuid vendor_namespace =
         boost::uuids::string_generator()("c1f4d9e2-7a3b-5c8d-9e0f-1a2b3c4d5e6f");
diff --git a/src/libslic3r/Preset.hpp b/src/libslic3r/Preset.hpp
index 22089be0b6..e0728d7fa2 100644
--- a/src/libslic3r/Preset.hpp
+++ b/src/libslic3r/Preset.hpp
@@ -93,8 +93,8 @@ class PresetBundle;
 
 // Deterministic preset setting_id: uuid5(vendor/type/name) -> 16 base62 chars.
 // Pure function of a system preset's identity, so the value can be assigned by
-// scripts/assign_vendor_setting_ids.py and recomputed here when a profile ships
-// without it. MUST stay byte-identical to scripts/assign_vendor_setting_ids.py.
+// scripts/orca_id_tool.py and recomputed here when a profile ships without it.
+// MUST stay byte-identical to scripts/orca_id_tool.py.
 // This is NOT the per-user cloud-sync setting_id
 // (OrcaCloudServiceAgent::generate_uuid_for_setting_id) - do not conflate them.
 std::string generate_preset_setting_id(const std::string& vendor,
diff --git a/src/libslic3r/PresetBundle.cpp b/src/libslic3r/PresetBundle.cpp
index 42ae7b6216..29bccf0966 100644
--- a/src/libslic3r/PresetBundle.cpp
+++ b/src/libslic3r/PresetBundle.cpp
@@ -5293,8 +5293,8 @@ std::string PresetBundle::load_vendor_preset(
         loaded.description = entry.description;
         loaded.setting_id = entry.setting_id;
         // Derive the preset setting_id on the fly when a profile ships without one,
-        // matching scripts/assign_vendor_setting_ids.py. Only instantiated presets
-        // carry an id; non-instantiated base profiles return earlier above. This never
+        // matching scripts/orca_id_tool.py. Only instantiated presets carry an id;
+        // non-instantiated base profiles return earlier above. This never
         // touches the per-user cloud-sync setting_id written into user .info files.
         if (loaded.setting_id.empty() && entry.instantiation == "true")
             loaded.setting_id = generate_preset_setting_id(
diff --git a/tests/libslic3r/test_preset_setting_id.cpp b/tests/libslic3r/test_preset_setting_id.cpp
index b0e340ead5..8347fa7089 100644
--- a/tests/libslic3r/test_preset_setting_id.cpp
+++ b/tests/libslic3r/test_preset_setting_id.cpp
@@ -5,10 +5,10 @@
 using namespace Slic3r;
 
 // Golden vectors from the Python reference generate_preset_setting_id (defined in
-// scripts/assign_vendor_setting_ids.py). The C++ generate_preset_setting_id() MUST stay
-// byte-identical to it, otherwise app-side on-the-fly ids would diverge from the
+// scripts/orca_id_tool.py). The C++ generate_preset_setting_id() MUST stay byte-identical
+// to it, otherwise app-side on-the-fly ids would diverge from the
 // script-assigned ones in the profiles. Regenerate a vector with:
-//   python3 -c "from assign_vendor_setting_ids import generate_preset_setting_id as g; print(g('Afinia','filament','Afinia ABS @Afinia H400'))"
+//   python3 -c "import sys; sys.path.insert(0, 'scripts'); from orca_id_tool import generate_preset_setting_id as g; print(g('Afinia','filament','Afinia ABS @Afinia H400'))"
 TEST_CASE("preset setting_id matches the Python reference", "[Preset][setting_id]") {
     struct Vec { const char* vendor; const char* type; const char* name; const char* expected; };
     const Vec vectors[] = {