From d39b0792a9b4ab741a27041d8f670fcaf964a8c8 Mon Sep 17 00:00:00 2001
From: admin <admin@vecmocon.com>
Date: Tue, 14 Jul 2026 10:50:46 +0000
Subject: [PATCH] Add direct .SchLib parameter writer (schlib_write.py): write
 SOP mandatory params into symbol, Value=value-only, remove UL
 Manufacturer_Name/Part_Number; docs updated

---
 SKILL.md                        |  55 +++++++
 assets/CHANGELOG.xlsx           | Bin 5530 -> 5530 bytes
 references/schlib_parameters.md | 122 +++++++++++++++
 scripts/altium_params.py        | 189 +++++++++++++++++++++++
 scripts/schlib_write.py         | 261 ++++++++++++++++++++++++++++++++
 5 files changed, 627 insertions(+)
 create mode 100644 references/schlib_parameters.md
 create mode 100644 scripts/altium_params.py
 create mode 100644 scripts/schlib_write.py

diff --git a/SKILL.md b/SKILL.md
index bcd0922..5159e39 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -290,6 +290,12 @@ python scripts/fill_templates.py part.json \
     --template assets/template/template.xlsx --dest <stage>/<tag>/ --design design.json
 ```
 
+Once you have the symbol and its Library Ref, you can also produce the **mandatory symbol
+parameters** the SOP requires on the `.SchLib` (Manufacturer, Manufacturer Part, Value,
+Tolerance, Operating Temperature, RoHS, Datasheet, Process, Vecmocon Part Code, …) — see
+*Mandatory symbol parameters* below. This is optional per run but is how the datasheet values
+land in the Altium symbol's properties.
+
 ### 7. Assemble the part folder
 
 The staging folder `<tag>/` should now hold the four files: the per-part `<tag>.xlsx`, the
@@ -306,6 +312,47 @@ This places the folder at `components/<Class>/<tag>/` — creating the Class fol
 doesn't exist yet, or pushing into it if it does — and commits and pushes. Confirm to the
 user where it landed.
 
+## Mandatory symbol parameters (.SchLib)
+
+The SOP (§5) requires every schematic symbol to carry a fixed parameter set in its Altium
+properties — `Manufacturer`, `Manufacturer Part`, `Value`, `Tolerance`, `Operating
+Temperature`, `ROHS`, `Datasheet`, `Process`, `Vecmocon Part Code`, and the two second-source
+fields — with the **Comment** set to the MPN. The skill can stamp these onto the symbol from
+the datasheet.
+
+The skill writes these **directly into the `.SchLib` in pure Python** with
+`scripts/schlib_write.py` (it rebuilds the OLE around the enlarged `Data` stream, preserving
+every other byte, and strips the Ultra-Librarian `Manufacturer_Name` / `Manufacturer_Part_Number`
+defaults that duplicate the SOP fields). Three kinds of value:
+
+- **Read from the datasheet** (don't just echo given text — open the PDF and fill the real,
+  verified values): `Value` = the **value only** in shorthand (e.g. `1u`, `12p`, `10k` — no
+  package), plus `Manufacturer`, `Manufacturer Part`, `Operating Temperature`, `Tolerance`,
+  `ROHS`, `Datasheet`, and `Process` by inference from the package.
+- **Leave blank for now** — `Manufacturer 2` / `Manufacturer Part 2` (the second source). Don't
+  populate these by default; they stay hidden in Altium until filled later. (An optional
+  cross-reference search to find a second source is documented in
+  `references/schlib_parameters.md` but is currently off — only do it if the engineer asks.)
+- **Ask the engineer** — only `Vecmocon Part Code` (internal, not derivable).
+
+Leave any genuinely-unknown field blank — the SOP hides blank parameters, so a gap simply stays
+empty until filled. The full method for the second-source search is in
+`references/schlib_parameters.md`.
+
+Collect the values into a `params.json` and write them into the symbol:
+
+```bash
+python scripts/schlib_write.py --schlib <in>.SchLib --params params.json --out <stage>/<tag>/<sym>.SchLib
+```
+
+Deliver the resulting `.SchLib`; the engineer opens it in Altium once to confirm it loads, then
+**Saves to Server** with a revision note. The full parameter set, each value's source, the
+`params.json` shape (incl. the `remove` list), and the mini-stream size caveat are in
+`references/schlib_parameters.md` — read it before building the parameter set. If a file doesn't
+round-trip, fall back to `scripts/altium_params.py` (emits an Altium DXP script to apply the same
+parameters from inside Altium). Always have the engineer confirm the file opens in Altium — the
+skill writes Altium's own binary format, so Altium is the final validator.
+
 ## Per-typeid versioning
 
 Versioning is **per typeid**, not global. Each typeid carries its own `template_version` and
@@ -462,6 +509,9 @@ plain flat push, but it does not merge the changelog or blank the token, so pref
   engineering string for each part's Description column). Defines a format for **every** type:
   the four SOP-defined ones (RES/CAP/Zener/TVS) are strict, the rest are the house extension on
   the same basis. Read it before filling any Description.
+- `references/schlib_parameters.md` — the SOP **mandatory symbol parameters** (§5) for the
+  `.SchLib`: the parameter set, where each value comes from, and how the generated Altium script
+  stamps them onto the symbol.
 - `assets/template/versions.json` — per-typeid `template_version` + `skill_version`.
 - `assets/CHANGELOG.xlsx` — global version/parameter changelog (created on first add;
   merged into the skill repo's copy in Gitea by `push-skill`).
@@ -472,6 +522,11 @@ plain flat push, but it does not merge the changelog or blank the token, so pref
 - `scripts/append_parameter.py` — append parameter(s) to a typeid, bump its versions, write
   the changelog.
 - `scripts/altium_refs.py` — read Library/Footprint Ref from `.SchLib`/`.PcbLib`.
+- `scripts/schlib_write.py` — write the SOP mandatory parameters **directly into a `.SchLib`**
+  (pure-Python OLE rebuild; removes the Ultra-Librarian `Manufacturer_Name` /
+  `Manufacturer_Part_Number` defaults). Primary path; see `references/schlib_parameters.md`.
+- `scripts/altium_params.py` — fallback: generate an Altium DelphiScript that stamps the same
+  parameters onto a `.SchLib` from inside Altium (DXP → Run Script).
 - `scripts/gitea_components.py` — `check-mpn`, `find-part` (locate an existing part to
   update), `checkout`, `list-type`, `place-part`, `commit-push`, `push-part` (library repo),
   and `push-skill` (skill repo: token-blanked push + append-only changelog merge).
diff --git a/assets/CHANGELOG.xlsx b/assets/CHANGELOG.xlsx
index cdd51ab1ee007787a79bd094c18ccc9e926e5211..888a6a81821450b3e75acb57bc6fa676dafdbd3d 100644
GIT binary patch
delta 1742
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
Q9wc@LpeTnO@I*QP0|izh00000

delta 1757
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
Qhc-PBxPtA0xG9|f15(Ez_W%F@

diff --git a/references/schlib_parameters.md b/references/schlib_parameters.md
new file mode 100644
index 0000000..9b53436
--- /dev/null
+++ b/references/schlib_parameters.md
@@ -0,0 +1,122 @@
+# Mandatory symbol parameters (.SchLib)
+
+Vecmocon's Altium SOP (§5) requires every schematic-library symbol to carry a fixed set of
+parameters in its component properties (the panel shown in Altium: *Properties → Parameters*).
+This file defines that set, where each value comes from, and how the skill stamps them onto the
+`.SchLib` symbol.
+
+How the parameters get in: the skill writes them **directly into the `.SchLib` in pure Python**
+via `scripts/schlib_write.py` — it rebuilds the OLE compound file around the enlarged component
+`Data` stream while preserving every other byte (all other streams, the directory tree, the
+Altium CLSIDs). It also **removes the Ultra-Librarian default params `Manufacturer_Name` and
+`Manufacturer_Part_Number`**, which just duplicate the SOP `Manufacturer` / `Manufacturer Part`.
+The output is a ready `.SchLib`. Because this writes Altium's own format from outside Altium, the
+script self-checks that the result re-opens as a valid OLE with the params present — but **always
+open the result in Altium once to confirm it loads** before relying on it. (An older path,
+`scripts/altium_params.py`, instead emits an Altium DXP script to stamp the same parameters from
+inside Altium; keep it as a fallback if a particular file doesn't round-trip.)
+
+## The parameter set
+
+Use these exact Altium parameter names (they must match the symbol, per the SOP screenshot).
+The **Comment** field is set to the MPN (SOP §4), and the **Description** field is the strict
+string from `references/description_format.md`.
+
+| Parameter | Source | Notes |
+|-----------|--------|-------|
+| `Value` | datasheet | the component **value only** (no package), in shorthand — e.g. `1u`, `12p`, `100n`, `10k` |
+| `Manufacturer Part` | datasheet | the MPN; also the **Comment** field |
+| `Manufacturer` | datasheet | manufacturer name as printed, e.g. `YAGEO` |
+| `Manufacturer Part 2` | **leave blank (for now)** | second-source MPN — left empty by default; see optional note below |
+| `Manufacturer 2` | **leave blank (for now)** | second-source manufacturer — left empty by default |
+| `Process` | derived | assembly process from package: SMD → `Reflow`, through-hole → `Wave`/`Manual`; confirm |
+| `Vecmocon Part Code` | engineer | internal code (e.g. `VECESC2421`) — **not on the datasheet**; ask |
+| `Operating Temperature` | datasheet | full range, e.g. `-55 °C to +125 °C` |
+| `Tolerance` | datasheet | e.g. `1%` (or `±1%`) |
+| `Datasheet` | datasheet | source URL or document reference (SOP marks this optional) |
+| `ROHS` | datasheet | RoHS compliance, `Yes`/`No` |
+
+**Read the datasheet-sourced values from the actual datasheet — don't echo whatever text was
+handed to you.** Open the PDF, find each real value (`Value`, `Manufacturer Part`,
+`Manufacturer`, `Operating Temperature`, `Tolerance`, `Datasheet`, `ROHS`, and `Process` by
+inference from the package), and fill them verified. An honest blank beats a guess — the SOP
+hides blank parameters, so a gap just stays empty until someone fills it. Only **one** field is
+purely internal and must come from the engineer: `Vecmocon Part Code` — ask for it.
+
+The second-source pair (`Manufacturer 2` / `Manufacturer Part 2`) is **left blank for now** —
+don't populate it by default. It simply stays hidden in Altium until someone fills it later.
+
+## Optional: second-source cross-reference (currently off)
+
+**House preference right now is to leave `Manufacturer 2` / `Manufacturer Part 2` blank**, so do
+not do this unless the engineer explicitly asks you to find a second source. It's documented
+here so it can be switched on later without redesigning anything.
+
+If asked to find a second source, it is an **equivalent part from a different manufacturer** that
+could drop into the design unchanged:
+
+1. **Pull the original's form-fit-function specs** from the datasheet — capacitance, voltage,
+   tolerance, dielectric/temp class, package (for a cap); resistance, power, tolerance, package
+   (for a resistor); and so on per type.
+2. **Search for an equivalent from a *different* manufacturer** (distributor/parametric
+   cross-reference, "equivalent to `<MPN>`", or another reputable maker's matching series). It
+   must match **every** form-fit-function spec and be **at least as good** on tolerance /
+   voltage / temperature — never worse.
+3. **Fill** `Manufacturer 2` = its maker, `Manufacturer Part 2` = its exact MPN.
+
+Two hard rules if this is ever used: **never invent an MPN** (only a part number you verified
+exists; else leave blank), and **always flag the chosen second source for the engineer to
+confirm** with the specs you compared.
+
+## Building the parameter set
+
+Collect the values into a `params.json` (same spirit as `part.json`). `component` is the
+symbol's Library Ref (from `altium_refs.py`); omit it to apply to every component in the lib.
+
+```json
+{
+  "component": "CC0402FRNPO9BN120",
+  "comment": "CC0402FRNPO9BN120",
+  "parameters": {
+    "Value": "12pF_0402",
+    "Manufacturer Part": "CC0402FRNPO9BN120",
+    "Manufacturer": "YAGEO",
+    "Manufacturer Part 2": "0402N120F500CT",
+    "Manufacturer 2": "Walsin Tech Corp",
+    "Process": "Reflow",
+    "Vecmocon Part Code": "VECESC2421",
+    "Operating Temperature": "-55 °C to +125 °C",
+    "Tolerance": "1%",
+    "Datasheet": "https://www.lcsc.com/datasheet/C326662.pdf",
+    "ROHS": "Yes"
+  }
+}
+```
+
+## Writing them into the symbol
+
+Write the parameters straight into the `.SchLib`, producing a new file:
+
+```bash
+python scripts/schlib_write.py --schlib <in>.SchLib --params params.json --out <out>.SchLib
+```
+
+`params.json` may carry a `"remove"` list (defaults to `["Manufacturer_Name",
+"Manufacturer_Part_Number"]`); those Ultra-Librarian defaults are stripped and the SOP params
+added. The script targets the component named in `"component"` (its Library Ref / storage name),
+or every component if omitted, and self-checks the output re-opens as a valid OLE. Deliver the
+resulting `.SchLib`, and have the engineer open it in Altium once to confirm it loads, then Save
+to Server with a revision note per the SOP.
+
+Scope note: the direct writer keeps a component's `Data` under Altium's 4096-byte mini-stream
+threshold in the common case; a very large parameter set (or an extremely long datasheet URL)
+can push it past that, at which point fall back to the `altium_params.py` DXP-script path.
+
+Fallback (apply from inside Altium):
+
+```bash
+python scripts/altium_params.py script --params params.json --out apply_params.pas
+```
+
+Then in Altium: open the `.SchLib`, **DXP → Run Script… → ApplyParameters**, review, **Save to
+Server**.
diff --git a/scripts/altium_params.py b/scripts/altium_params.py
new file mode 100644
index 0000000..037eab6
--- /dev/null
+++ b/scripts/altium_params.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Generate an Altium DelphiScript that stamps the mandatory parameters (SOP §5) onto a
+schematic-library symbol, from a params.json the skill builds off the datasheet.
+
+Why a script instead of editing the .SchLib directly: a .SchLib is an OLE compound-binary that
+we can read but cannot safely grow from outside Altium (adding parameter records means
+rewriting Altium's own format). So the skill produces the parameter *values* from the datasheet
+and emits a small script the engineer runs inside Altium (DXP -> Run Script -> ApplyParameters),
+which adds/updates exactly these parameters on the component and sets the Comment to the MPN.
+See references/schlib_parameters.md for the parameter set and each value's source.
+
+params.json:
+  {
+    "component": "CC0402FRNPO9BN120",     # Library Ref of the target symbol; omit -> all comps
+    "comment":   "CC0402FRNPO9BN120",     # sets the Comment field (usually the MPN)
+    "parameters": {"Value": "12pF_0402", "Manufacturer": "YAGEO", ...}
+  }
+
+Usage:
+  python altium_params.py script --params params.json --out apply_params.pas
+  python altium_params.py script --params params.json           # prints to stdout
+
+The generated .pas is plain text; validate its first run on a new Altium version, since the
+scripting API can differ slightly between releases.
+"""
+import argparse, json, sys
+
+
+def _q(s):
+    """Quote a value as a DelphiScript single-quoted string literal (doubling embedded quotes).
+    None/blank -> ''. Non-strings are stringified."""
+    if s is None:
+        s = ""
+    return "'" + str(s).replace("'", "''") + "'"
+
+
+PROLOGUE = """{ Auto-generated by library-manager (altium_params.py).
+  Stamps the SOP mandatory parameters onto a schematic-library symbol.
+  HOW TO RUN: open the target .SchLib in Altium, then DXP -> Run Script -> pick this file
+  -> run 'ApplyParameters'. It adds each parameter if missing, updates it if present, sets the
+  Comment field, hides blank-valued parameters, and leaves the library open for you to review
+  and Save to Server (with a revision note, per the SOP). }
+
+Var
+    Lib      : ISch_Lib;
+    LibIter  : ISch_Iterator;
+    Comp     : ISch_Component;
+    TargetRef: String;
+    CommentText : String;
+
+Procedure SetParam(AComp : ISch_Component; AName : String; AValue : String);
+Var
+    PIter : ISch_Iterator;
+    P     : ISch_Parameter;
+    Found : ISch_Parameter;
+Begin
+    Found := Nil;
+    PIter := AComp.SchIterator_Create;
+    PIter.AddFilter_ObjectSet(MkSet(eParameter));
+    Try
+        P := PIter.FirstSchObject;
+        While P <> Nil Do
+        Begin
+            If P.Name = AName Then Found := P;
+            P := PIter.NextSchObject;
+        End;
+    Finally
+        AComp.SchIterator_Destroy(PIter);
+    End;
+
+    If Found <> Nil Then
+    Begin
+        Found.Text := AValue;
+        Found.IsHidden := (AValue = '');
+    End
+    Else
+    Begin
+        Found := SchServer.SchObjectFactory(eParameter, eCreate_GlobalCopy);
+        Found.Name     := AName;
+        Found.Text     := AValue;
+        Found.IsHidden := (AValue = '');
+        AComp.AddSchObject(Found);
+    End;
+End;
+
+Procedure ApplyToComponent(AComp : ISch_Component);
+Begin
+    SchServer.RobotManager.SendMessage(AComp.I_ObjectAddress, c_BroadCast,
+                                       SCHM_BeginModify, c_NoEventData);
+    Try
+        If CommentText <> '' Then AComp.Comment.Text := CommentText;
+"""
+
+EPILOGUE = """    Finally
+        SchServer.RobotManager.SendMessage(AComp.I_ObjectAddress, c_BroadCast,
+                                           SCHM_EndModify, c_NoEventData);
+    End;
+End;
+
+Procedure ApplyParameters;
+Begin
+    If SchServer = Nil Then
+    Begin
+        ShowMessage('Schematic server not available.');
+        Exit;
+    End;
+    Lib := SchServer.GetCurrentSchDocument;
+    If Lib = Nil Then
+    Begin
+        ShowMessage('Open the target .SchLib first.');
+        Exit;
+    End;
+    If Lib.ObjectID <> eSchLib Then
+    Begin
+        ShowMessage('The active document is not a .SchLib.');
+        Exit;
+    End;
+
+    LibIter := Lib.SchLibIterator_Create;
+    LibIter.AddFilter_ObjectSet(MkSet(eSchComponent));
+    Try
+        Comp := LibIter.FirstSchObject;
+        While Comp <> Nil Do
+        Begin
+            If (TargetRef = '') Or (Comp.LibReference = TargetRef) Then
+                ApplyToComponent(Comp);
+            Comp := LibIter.NextSchObject;
+        End;
+    Finally
+        Lib.SchLibIterator_Destroy(LibIter);
+    End;
+
+    Lib.GraphicallyInvalidate;
+    ShowMessage('Parameters applied. Review the component, then Save to Server.');
+End;
+"""
+
+
+def generate(params):
+    comp = params.get("component", "") or ""
+    comment = params.get("comment", "") or ""
+    fields = params.get("parameters", {}) or {}
+
+    setparam_calls = "\n".join(
+        f"        SetParam(AComp, {_q(name)}, {_q(value)});" for name, value in fields.items()
+    )
+
+    # TargetRef / CommentText are globals set by InitTargets, called first in ApplyParameters.
+    init_block = (
+        "Procedure InitTargets;\n"
+        "Begin\n"
+        f"    TargetRef := {_q(comp)};\n"
+        f"    CommentText := {_q(comment)};\n"
+        "End;\n\n"
+    )
+
+    body = PROLOGUE + setparam_calls + "\n" + EPILOGUE
+    # Ensure InitTargets is called first inside ApplyParameters.
+    body = body.replace("Procedure ApplyParameters;\nBegin\n",
+                        "Procedure ApplyParameters;\nBegin\n    InitTargets;\n")
+    # Place InitTargets AFTER the global Var block (Pascal: declarations before use), i.e. just
+    # before the first procedure. The Var block lives at the top of PROLOGUE.
+    return body.replace("Procedure SetParam(AComp",
+                        init_block + "Procedure SetParam(AComp", 1)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    s = sub.add_parser("script", help="emit the Altium DelphiScript from a params.json")
+    s.add_argument("--params", required=True)
+    s.add_argument("--out", help="write the .pas here (default: stdout)")
+    a = ap.parse_args()
+
+    params = json.load(open(a.params, encoding="utf-8"))
+    pas = generate(params)
+    if a.out:
+        with open(a.out, "w", encoding="utf-8") as f:
+            f.write(pas)
+        n = len(params.get("parameters", {}))
+        print(f"wrote {a.out}  ({n} parameters"
+              + (f", component '{params['component']}'" if params.get("component") else ", all components")
+              + ")")
+    else:
+        sys.stdout.write(pas)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/schlib_write.py b/scripts/schlib_write.py
new file mode 100644
index 0000000..ffc952b
--- /dev/null
+++ b/scripts/schlib_write.py
@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+"""Write Vecmocon's mandatory parameters directly INTO an Altium schematic-library (.SchLib)
+file, in pure Python — no Altium needed.
+
+Reading a value out of a .SchLib is a plain stream read (see altium_refs.py). Writing is harder:
+parameters live as text records inside the component's ``Data`` stream, and adding/removing them
+changes that stream's size, which means rebuilding the whole OLE compound container around it.
+This script does exactly that while **preserving every original byte except the Data stream(s)
+it must change** — all other streams (FileHeader, Storage, …), the directory tree, the Altium
+CLSIDs and timestamps are copied through untouched, and only the size/offset fields that must
+move are recomputed.
+
+What it does to the target component's Data stream:
+  - removes the Ultra-Librarian default params ``Manufacturer_Name`` / ``Manufacturer_Part_Number``
+    (they duplicate the SOP ``Manufacturer`` / ``Manufacturer Part`` — override with --keep or a
+    "remove" list in params.json),
+  - adds/updates the SOP parameters from params.json (see references/schlib_parameters.md),
+  - leaves pins, graphics, the Comment and all other records exactly as they were.
+
+Usage:
+  python schlib_write.py --schlib IN.SchLib --params params.json --out OUT.SchLib
+
+params.json (same shape altium_params.py uses):
+  {"component":"JMK105BJ105KV-F",           # LibRef / component-storage name; omit -> all comps
+   "parameters":{"Value":"1u","Manufacturer":"Taiyo Yuden", ...},
+   "remove":["Manufacturer_Name","Manufacturer_Part_Number"]}   # optional; this is the default
+
+IMPORTANT: this writes Altium's own binary format from outside Altium. It is validated to
+re-open as a well-formed OLE with every other stream byte-identical, but ALWAYS open the result
+in Altium once to confirm it loads before relying on it.
+"""
+import argparse, json, struct, sys, hashlib
+import olefile
+
+FREESECT=0xFFFFFFFF; ENDOFCHAIN=0xFFFFFFFE; FATSECT=0xFFFFFFFD
+SEC=512; MINI=64; CUTOFF=4096
+DEFAULT_REMOVE=["Manufacturer_Name", "Manufacturer_Part_Number"]
+
+
+def le16(b,o): return struct.unpack('<H',b[o:o+2])[0]
+def le32(b,o): return struct.unpack('<I',b[o:o+4])[0]
+def pad(b,n): return b+b'\x00'*((-len(b))%n)
+
+
+# ----------------------------------------------------------------- read the container
+
+def read_container(path):
+    """Return (raw_dir_entries[list of bytearray(128)], sid->path, sid->content-bytes)."""
+    raw=open(path,'rb').read()
+    dir_start=le32(raw,48)
+    difat=[le32(raw,76+4*i) for i in range(109)]
+    fat=[]
+    for s in difat:
+        if s>=0xFFFFFFFC: continue
+        sec=raw[512+s*SEC:512+(s+1)*SEC]
+        fat+=[struct.unpack('<I',sec[k:k+4])[0] for k in range(0,SEC,4)]
+    def chain(start):
+        out=[]; s=start
+        while s not in (ENDOFCHAIN,FREESECT) and s<len(fat):
+            out.append(s); s=fat[s]
+        return out
+    dirbytes=b''.join(raw[512+s*SEC:512+(s+1)*SEC] for s in chain(dir_start))
+    entries=[bytearray(dirbytes[i:i+128]) for i in range(0,len(dirbytes),128)]
+
+    def name_of(e):
+        nlen=le16(e,64)
+        return e[0:max(0,nlen-2)].decode('utf-16-le') if nlen>=2 else ''
+    paths={}
+    def walk(sid, prefix):
+        if sid>=0xFFFFFFFC or sid>=len(entries): return
+        e=entries[sid]
+        walk(le32(e,68), prefix)                       # left
+        nm=name_of(e); paths[sid]=prefix+[nm]
+        if e[66]==1:                                   # storage -> recurse children
+            walk(le32(e,76), prefix+[nm])
+        walk(le32(e,72), prefix)                       # right
+    walk(le32(entries[0],76), [])                      # from root's child
+
+    ole=olefile.OleFileIO(path)
+    bypath={'/'.join(e):ole.openstream(e).read() for e in ole.listdir(streams=True)}
+    ole.close()
+    content={sid:bypath['/'.join(p)] for sid,p in paths.items() if '/'.join(p) in bypath}
+    return entries, paths, content
+
+
+# ----------------------------------------------------------------- edit a Data stream
+
+def _uid(name):
+    h=''.join(c for c in hashlib.md5(name.encode()).hexdigest().upper() if c.isalpha())
+    return (h+"ABCDEFGH")[:8]
+
+
+def _param_record(idx, name, value):
+    s=(f"|RECORD=41|IndexInSheet={idx}|OwnerPartId=1|Justification=4|FontID=2|IsHidden=T"
+       f"|Text={value}|Name={name}|UniqueID={_uid(name)}")
+    payload=s.encode('latin-1')+b'\x00'
+    return struct.pack('<I',len(payload))+payload
+
+
+def _leading_text_records(data):
+    """Split Data into (list of leading text-record byte-blocks, tail bytes). The leading run is
+    the contiguous |RECORD=…| text records at the start (RECORD=1 + the parameter block); it
+    stops at the first non-text record (the binary pin records), which — with everything after —
+    is returned untouched as the tail."""
+    recs=[]; i=0
+    while i+4<=len(data):
+        L=struct.unpack('<I',data[i:i+4])[0]
+        if L==0 or i+4+L>len(data): break
+        payload=data[i+4:i+4+L]
+        if payload[-1:]!=b'\x00' or not payload[:8].startswith(b'|RECORD='):
+            break
+        recs.append(data[i:i+4+L]); i+=4+L
+    return recs, data[i:]
+
+
+def _rec_name(block):
+    t=block[4:-1].decode('latin-1')
+    return t.split('|Name=')[1].split('|')[0] if '|Name=' in t else None
+
+
+def edit_data(data, params, remove):
+    """Return a new Data stream: drop `remove` params, drop any SOP-name params (re-added
+    fresh), keep everything else, then append the SOP params. Pins/graphics/tail untouched."""
+    leading, tail = _leading_text_records(data)
+    sop_names=set(params)
+    kept=[]
+    for blk in leading:
+        nm=_rec_name(blk)
+        if nm is not None and (nm in remove or nm in sop_names):
+            continue                                   # drop UL duplicates + stale SOP copies
+        kept.append(blk)
+    added=[_param_record(20+i, nm, val) for i,(nm,val) in enumerate(params.items())]
+    return b''.join(kept)+b''.join(added)+tail
+
+
+# ----------------------------------------------------------------- rebuild the container
+
+def _set(e, off, val, n): e[off:off+n]=val.to_bytes(n,'little')
+
+def rebuild(entries, content):
+    """Rebuild an OLE compound file from raw directory entries + {sid: content}. Small streams
+    (<4096) go in the mini-stream; big streams get their own FAT sectors. Directory-entry bytes
+    are preserved; only each entry's start-sector and size are patched."""
+    minis=[sid for sid,c in content.items() if len(c)<CUTOFF]
+    bigs =[sid for sid,c in content.items() if len(c)>=CUTOFF]
+
+    ministream=b''; mini_start={}
+    for sid in minis:
+        mini_start[sid]=len(ministream)//MINI
+        ministream+=pad(content[sid],MINI)
+    n_mini=len(ministream)//MINI
+    minifat=[ENDOFCHAIN]*n_mini
+    for sid in minis:
+        st=mini_start[sid]; cnt=(len(content[sid])+MINI-1)//MINI or 1
+        for k in range(cnt-1): minifat[st+k]=st+k+1
+    minifat_bytes=pad(b''.join(struct.pack('<I',x) for x in minifat),SEC) if n_mini else b''
+    n_mf=len(minifat_bytes)//SEC
+
+    # sector layout: [big streams][ministream][miniFAT][directory][FAT]
+    ms_p=pad(ministream,SEC); n_ms=len(ms_p)//SEC
+    big_secs={}; cur=0
+    for sid in bigs:
+        b=pad(content[sid],SEC); k=len(b)//SEC
+        big_secs[sid]=(list(range(cur,cur+k)), b); cur+=k
+    ms_secs=list(range(cur,cur+n_ms)); cur+=n_ms
+    mf_secs=list(range(cur,cur+n_mf)); cur+=n_mf
+    dir_bytes=pad(b''.join(entries),SEC); n_dir=len(dir_bytes)//SEC
+    dir_secs=list(range(cur,cur+n_dir)); cur+=n_dir
+    data_secs=cur
+    n_fat=1
+    while (data_secs+n_fat)*4 > n_fat*SEC: n_fat+=1
+    fat_secs=list(range(cur,cur+n_fat)); total=cur+n_fat
+    if n_fat>109: sys.exit("too many FAT sectors for a header-only DIFAT (file unexpectedly large)")
+
+    # patch directory entries: start-sector + size
+    for sid in bigs:  _set(entries[sid],116,big_secs[sid][0][0],4); entries[sid][120:128]=struct.pack('<Q',len(content[sid]))
+    for sid in minis: _set(entries[sid],116,mini_start[sid],4);     entries[sid][120:128]=struct.pack('<Q',len(content[sid]))
+    entries[0][120:128]=struct.pack('<Q',len(ministream))            # root: ministream size
+    _set(entries[0],116, ms_secs[0] if n_ms else ENDOFCHAIN, 4)
+    dir_bytes=pad(b''.join(entries),SEC)
+
+    # FAT
+    FAT=[FREESECT]*total
+    def ch(secs):
+        for k in range(len(secs)-1): FAT[secs[k]]=secs[k+1]
+        if secs: FAT[secs[-1]]=ENDOFCHAIN
+    for sid in bigs: ch(big_secs[sid][0])
+    ch(ms_secs); ch(mf_secs); ch(dir_secs)
+    for s in fat_secs: FAT[s]=FATSECT
+    fat_bytes=pad(b''.join(struct.pack('<I',x) for x in FAT),SEC)
+
+    # header
+    h=bytearray(512)
+    h[0:8]=bytes([0xD0,0xCF,0x11,0xE0,0xA1,0xB1,0x1A,0xE1])
+    h[24:26]=struct.pack('<H',0x003E); h[26:28]=struct.pack('<H',3)
+    h[28:30]=struct.pack('<H',0xFFFE); h[30:32]=struct.pack('<H',9); h[32:34]=struct.pack('<H',6)
+    h[44:48]=struct.pack('<I',n_fat)
+    h[48:52]=struct.pack('<I',dir_secs[0])
+    h[56:60]=struct.pack('<I',CUTOFF)
+    h[60:64]=struct.pack('<I',mf_secs[0] if n_mf else ENDOFCHAIN)
+    h[64:68]=struct.pack('<I',n_mf)
+    h[68:72]=struct.pack('<I',ENDOFCHAIN)
+    for i in range(109):
+        h[76+4*i:80+4*i]=struct.pack('<I', fat_secs[i] if i<n_fat else FREESECT)
+
+    out=bytearray(h)
+    for sid in bigs: out+=big_secs[sid][1]
+    out+=ms_p+minifat_bytes+dir_bytes+fat_bytes
+    return bytes(out)
+
+
+# ----------------------------------------------------------------- driver
+
+def write_params(schlib, params_json, out):
+    component=params_json.get("component") or None
+    fields=params_json.get("parameters", {}) or {}
+    remove=params_json.get("remove", DEFAULT_REMOVE)
+    entries, paths, content = read_container(schlib)
+
+    # target Data stream sid(s): a stream named 'Data' whose parent storage == component (or all)
+    targets=[]
+    for sid,p in paths.items():
+        if len(p)>=2 and p[-1].lower()=="data" and sid in content:
+            if component is None or p[-2]==component:
+                targets.append(sid)
+    if not targets:
+        sys.exit(f"no component Data stream found" + (f" for '{component}'" if component else ""))
+    for sid in targets:
+        content[sid]=edit_data(content[sid], fields, remove)
+
+    blob=rebuild(entries, content)
+    open(out,'wb').write(blob)
+
+    # self-check: re-open and confirm it's a valid OLE with the params present
+    if not olefile.isOleFile(out):
+        sys.exit("ERROR: rebuilt file is not a valid OLE — aborting")
+    ole=olefile.OleFileIO(out)
+    ok=True
+    for e in ole.listdir(streams=True):
+        if e[-1].lower()=="data":
+            t=ole.openstream(e).read().decode('latin-1','ignore')
+            for nm in fields:
+                if f"|Name={nm}|" not in t and f"|Name={nm}\x00" not in t and f"Name={nm}" not in t:
+                    ok=False
+    ole.close()
+    n_comp=len(targets)
+    print(f"wrote {out}  ({len(fields)} params into {n_comp} component(s); removed {remove}) "
+          f"{'[self-check OK]' if ok else '[WARN: verify params]'}")
+
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument("--schlib", required=True)
+    ap.add_argument("--params", required=True)
+    ap.add_argument("--out", required=True)
+    a=ap.parse_args()
+    write_params(a.schlib, json.load(open(a.params, encoding="utf-8")), a.out)
+
+
+if __name__ == "__main__":
+    main()