diff --git "a/reference-catalog.json" "b/reference-catalog.json"
--- "a/reference-catalog.json"
+++ "b/reference-catalog.json"
@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "updated_at": "2026-10-08T15:33:59.615978+00:00",
+  "updated_at": "2026-10-08T16:01:55.749706+00:00",
   "methods": [
     {
       "family": "ALP",
@@ -763,254 +763,1524 @@
   "operators": [
     {
       "id": "eraser",
-      "name": "eraser",
+      "family_number": "01",
+      "name": "Eraser / 擦除",
       "group": "Bit processing",
       "description": "Preprocesses floating-point bit patterns by clearing selected mantissa suffix bits and encoding the information needed to reconstruct them. Whether a concrete pipeline is lossless depends on its erasure rule and stored metadata.",
       "reference_ids": [
         "O01"
+      ],
+      "implementations": [
+        {
+          "id": "A001",
+          "name": "Fixed Low-4-bit Split Proxy",
+          "layer": "configuration",
+          "description": "对每个int64 x计算high=x>>4和low4=x&15；逆向按64位位型计算(high<<4)|low4。它固定拆4位，不检查浮点指数、尾数或十进制可逆性。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流high:int64[N]、low4:uint8语义[N]；low_bits固定4，可参数化为通用低位拆分。",
+          "example": "输入 [33,34,-1]，得到 high=[2,2,-1]、low4=[1,2,15]。例如 (2<<4)|1=33；-1 按64位原位恢复。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A002",
+          "name": "Pongo Shortest-decimal Mantissa Recoding",
+          "layer": "mechanism",
+          "description": "对有限非零double求最短十进制小数，提取前导零数与后续十进制整数；若其位数能放入当前指数留下的尾数字段，则反转低位写入该字段并逐位验证恢复，否则保留原字。",
+          "inputs": "1流64位原字bytes:uint8[8N]，逻辑可为int64或float64",
+          "outputs": "3流first:uint64[0/1]、eraser_flags:uint8[N-1]、targets:uint64[N-1]；无外部参数。",
+          "example": "输入原字序列 [+0.0,+0.0]：首字为0，后续零值不做十进制改写，target仍为0，擦除标记表示原字保留。此时后接相邻XOR得到0残差。非零值仅在逆十进制重编码逐位相等时采用改写。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A003",
+          "name": "Elf Decimal Significant-digit Mantissa Erasure",
+          "layer": "mechanism",
+          "description": "从浮点十进制有效位推导alpha与beta，据指数计算可擦除的低尾数位；仅当掩码后的原字配合beta能逐位恢复且收益达到阈值时输出擦除字，否则发literal，并按块重置beta状态。",
+          "inputs": "float64[N]原位；P003要求可精确窄化为float32，P005处理binary64。",
+          "outputs": "3流tag:uint8[N]、beta:uint8[N]、erased_bits:uint32或uint64[N]；word_bits、block_size、threshold为profile参数。",
+          "example": "输入 [-0.0,+0.0] 走 literal 分支，输出对应 tag/beta 与 erased_bits=[0x8000000000000000,0x0000000000000000]（64位profile）。解码恢复两种符号零；beta没有被用来近似替代原位。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A004",
+          "name": "Camel Integer-plus-short-decimal Decomposition",
+          "layer": "mechanism",
+          "description": "每1000项首值直接保存；其余有限值截取int64整数部分，检测十进制位数并最多保留3位小数及符号，按Java式round重建并逐位核验；失败则保存literal原字。",
+          "inputs": "1流float64[N]或可精确转float64的int64[N]",
+          "outputs": "6流tag:uint8[N]、raw_bits:uint64[R]、integer:int64[D]、signal:uint8[D]、decimal_count:uint8[D]、decimal_value:uint32[D]；chunk=1000、max_decimal_digits=3。",
+          "example": "一块中先存首值100.0；下一值100.25可表示为 integer=100、decimal_count=2、decimal_value=25及正号。解码以100+25/100恢复，并逐位检查；无法精确恢复的记录改用literal。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "scaling",
-      "name": "scaling",
+      "family_number": "02",
+      "name": "Scaling / 数值缩放",
       "group": "Numeric representation",
       "description": "Maps decimal-valued floating-point data to integers by multiplying by a power of ten and applying a rounding rule. Exact restoration requires the scale and a conversion rule that preserves every source value used by the pipeline.",
       "reference_ids": [
         "O02"
+      ],
+      "implementations": [
+        {
+          "id": "A006",
+          "name": "Decimal Scaling with Delta-chain Constraint",
+          "layer": "mechanism",
+          "description": "选择阶段从max_point向下取s，使用double乘积与llround生成候选整数，直到相邻差满足int64范围；停止后再逐位检查逆缩放。当前convert在乘积越界时另有退回llround(x)/原位解释的兼容行为，不能笼统说仅“越界拒绝”。",
+          "inputs": "1流values:float64[N]及max_point:int32[0…18]",
+          "outputs": "2流scale:uint32[1]、values:int64[N]；selector=delta_chain_fit、rounding=llround。",
+          "example": "max_point=2，输入 [1.25,1.50,1.75]：候选code=[125,150,175]，相邻差25可装入int64，逆缩放精确，因此输出scale=2与该整数流。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A007",
+          "name": "Fixed Exact Decimal Scale",
+          "layer": "mechanism",
+          "description": "s=max_point直接作为输入；用long double乘积计算llround(x×10^s)，再用double(code)/10^s逐位验证；非有限、越界或不精确拒绝。TS_2DIFF与Simple8b的执行一致。",
+          "inputs": "1流values:float64[N]及s=max_point:int32[0…18]",
+          "outputs": "1流values:int64[N]，s作为输入参数/packet恢复字段而非新增活动流；rounding=llround。",
+          "example": "给定s=2，输入 [1.25,-2.50]，输出 [125,-250]；解码除以100得到原值。s必须作为恢复参数保存。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A008",
+          "name": "Largest-fitting Decimal Scale Selector",
+          "layer": "mechanism",
+          "description": "从max_point向0搜索首个使所有x×10^s落入int64的s，按llround生成整数；找到首个fit尺度后才做逐位逆检查，若不精确则立即拒绝，不继续尝试更小s。",
+          "inputs": "1流values:float64[N]及max_point:int32[0…18]",
+          "outputs": "2流effective_scale:int32[1]、values:int64[N]；selector=largest_fitting_then_exact_check。",
+          "example": "max_point=2，输入 [1.25,2.50]，最高候选不越界且逆变换精确，输出scale=2、codes=[125,250]；若该候选逆变换不精确，当前profile拒绝输入。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A009",
+          "name": "Recipe: Required Precision → Decimal Scale",
+          "layer": "mechanism",
+          "description": "逐值从0至15找最少可逆小数位，取整组最大值s，再按共同s重新量化并逐位复核。选择阶段乘积为double，量化阶段为long double；P010分1024项，P011整列。失败整块/整列保存raw，含负零也可触发raw。",
+          "inputs": "values:float64[N]；block_size=1024 或 whole。",
+          "outputs": "scaled 路径输出 precision:uint8 与 scaled_int:int64；raw 路径输出 raw_bits:uint64。P010 可混合 3 流，P011 整列为 scaled 2 流或 raw 1 流。",
+          "example": "输入 [1.2,1.23,1.234]，最少所需小数位为[1,2,3]，整组取s=3，得到[1200,1230,1234]。块mode区分scaled与整块raw。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A010",
+          "name": "Code-equivalent Decimal Scale Search",
+          "layer": "mechanism",
+          "description": "float64先从max_point下降选择一组能装入int64的codes，再从max(18,max_point)下降，找可产生同一codes且按wire尺度逐位恢复原输入的s。C++显式实现Python ties-to-even语义；int64直接透传。",
+          "inputs": "1流int64[N]或float64[N]原字及kind:string；float需max_point",
+          "outputs": "effective_scale:int32[1]+codes:int64[N]共2流，int64仅codes 1流；rounding=ties_to_even。",
+          "example": "整数profile输入 [10,11,12]，仅输出同一code流；浮点profile输入[1.25,2.5]，候选s=2可得到[125,250]，另保存实际恢复scale，解码逐位校验。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A011",
+          "name": "Recipe: ALP Selector → Ordered Scale → Exception Split",
+          "layer": "mechanism",
+          "description": "每1024项枚举exp=10..0、fac=min(exp,9)..0，用估计位宽与异常成本选参数。数值执行x×10^exp→×10^-fac→magic舍入；再按逐位恢复是否相同分离异常，正常code保留，异常另存位置及原位，无可用参数则整块raw。",
+          "inputs": "float64 values；selector 产生的 fac/exp:int32[2B]；当前入口仍整体执行，未暴露独立活动端口。",
+          "outputs": "Scaling 生成 codes:int64 及可逆性结果；异常分离生成带占位正常 codes、exception_index:uint32、exception_bits:uint64。scaled 块最终 4 个语义角色（含 fac/exp），raw 块 1 个角色；mode/count 为恢复信息。",
+          "example": "给定候选exp=2、fac=0，输入[1.25,2.50]，有序乘法及magic舍入得到[125,250]，两个位置都可恢复，无异常。若另有不能恢复的原字，该位置及原字进入异常表。参数选择仍比较全部候选成本。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A012",
+          "name": "Recipe: Mean/Sigma Estimate → Normalize → XOR Repair",
+          "layer": "mechanism",
+          "description": "先用有限值估计mean/sigma，再输出z=(x-mean)/sigma；异常z置0。由z逆预测原字，生成repair=original_bits XOR predicted_bits。解码依靠z、mean/sigma与repair才能逐位恢复。",
+          "inputs": "原始int64/float64位流。参数估计",
+          "outputs": "mean_sigma:float64[2]；Normalize输出z:float64[N]；Repair读取原始bits:uint64[N]与逆预测bits:uint64[N]，输出repair:uint64[N]。完整配方共3语义流mean_sigma、z、repair；原类型及N保留用于逆预测。",
+          "example": "输入[1.0,2.0,3.0]，均值为2，标准差按实现规则计算为sigma；输出z=[-1/sigma,0,1/sigma]与mean/sigma。每项还输出original_bits XOR inverse_prediction_bits；解码必须应用这条repair流。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "frame_of_reference",
-      "name": "for",
+      "family_number": "03",
+      "name": "Frame of Reference (FOR) / 基准帧",
       "group": "Numeric representation",
       "description": "Stores a block reference value, commonly the minimum or another base, and represents each value as a smaller offset from that reference.",
       "reference_ids": [
         "O03"
+      ],
+      "implementations": [
+        {
+          "id": "A013",
+          "name": "Minimum Frame of Reference",
+          "layer": "mechanism",
+          "description": "求minimum=min(values)，逐项以同宽无符号算术计算offset=unsigned(value)-unsigned(minimum)。逆向将minimum加回并恢复原位。空输入以minimum=0配合N=0表示。",
+          "inputs": "values:T[N]，T为int32/uint32/int64/uint64。",
+          "outputs": "minimum:T[1]和offsets:unsigned(T)[N]。参数：字宽、块边界。首值、scale、排列、异常字段为旁路恢复元数据；本步不做Bit Packing。",
+          "example": "输入int64 [100,103,101]，输出minimum=100、offsets:uint64=[0,3,1]。逆向100+[0,3,1]恢复原序列。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "value_reorder",
-      "name": "value reorder",
+      "family_number": "04",
+      "name": "Value Reorder / 数值重排",
       "group": "Reordering and symbol recoding",
       "description": "Reorders values, or timestamp-value pairs, within a block to expose stronger local correlation and reduce later residual widths. A reversible pipeline must preserve enough ordering information to restore the original sequence.",
       "reference_ids": [
         "O04"
+      ],
+      "implementations": [
+        {
+          "id": "A014",
+          "name": "Stable Sort with Inverse Permutation",
+          "layer": "mechanism",
+          "description": "建立order=[0…N-1]，按values[order[j]]的signed int64值stable_sort；依order输出sorted_values并保存原位置，逆向把第j个排序值写回original_index[j]。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流sorted_values:int64[N]、original_index:int64[N]或uint32[N]；参数block_size=whole或64、index_dtype/index_scope为I/O配置。",
+          "example": "输入[30,10,30,20]，稳定排序后values=[10,20,30,30]，original_index=[1,3,0,2]。按索引散写恢复[30,10,30,20]。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "regression_predictor",
-      "name": "regression",
+      "family_number": "05",
+      "name": "Regression Predictor / 回归预测",
       "group": "Residual formation",
       "description": "Predicts values or timestamp-value pairs from a fitted regression relation, then passes prediction residuals to later integer or bit-level coding stages.",
       "reference_ids": [
         "O04"
+      ],
+      "implementations": [
+        {
+          "id": "A015",
+          "name": "First-order Autoregression by OLS",
+          "layer": "mechanism",
+          "description": "以x_i=value[i]、y_i=value[i+1]对整列做OLS，求theta0、theta1；从首值开始用round(theta0+theta1×previous_value)预测下一值，保存模2^64有符号残差。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "3流first:int64[0/1]、coefficients:float64[2]、residuals:int64[N-1]；无外部参数，rounding=nearbyint。",
+          "example": "输入[10,20,30,40]，相邻样本满足next=10+previous，OLS得到theta0=10、theta1=1；首值10单存，后三个残差全为0。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A016",
+          "name": "Blockwise Linear Regression against Position",
+          "layer": "mechanism",
+          "description": "每个512值块以块内位置i为自变量拟合intercept+slope×i；预测经llround并限制在int64域，逐值输出有符号残差。输出有符号残差，ZigZag由A046执行。",
+          "inputs": "1流values:int64[N]，参数block_size（当前LECO profile为512）。",
+          "outputs": "2流coefficients:float64[blocks,2]、residuals:int64[N]；块长度和原值个数是恢复元数据。",
+          "example": "一块[10,12,14,16]以位置[0,1,2,3]拟合得到intercept=10、slope=2，signed残差[0,0,0,0]；系数和块长随包保存，残差可再接A046。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "outlier_separation",
-      "name": "outlier separation",
+      "family_number": "06",
+      "name": "Outlier Separation / 异常分离",
       "group": "Numeric representation",
       "description": "Splits exceptional values from a regular block so the common values can use a narrow bit width, while positions and payloads for outliers are encoded separately.",
       "reference_ids": [
         "O05"
+      ],
+      "implementations": [
+        {
+          "id": "A018",
+          "name": "IQR Clipping（四分位距裁剪）",
+          "layer": "mechanism",
+          "description": "计算Q1、Q3，令IQR=max(Q3-Q1,1)，边界为floor(Q1-1.5IQR)与ceil(Q3+1.5IQR)。越界值在主体中替换为边界，同时保存原位置与原值，解码再覆盖恢复。",
+          "inputs": "values:int64[N]",
+          "outputs": "3流clipped_values:int64[N]、outlier_index:int64[E]、outlier_original:int64[E]。倍率1.5和IQR下限1当前固定；无公开参数。",
+          "example": "在Q1=10、Q3=12的状态下，IQR=2，裁剪区间[7,15]；输入末项100会在主体变为15，并保存其位置与100。解码覆盖该位置恢复100。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A019",
+          "name": "BOS Cost-based Range Split（按成本选区间）",
+          "layer": "mechanism",
+          "description": "对上游FOR码排序，枚举宽度b和跨度不超过2^b-1的连续值域，比较K×b+96×E位的代价，选常规区间；按原序标注异常并保留原数值，本步尚不减区间基准。",
+          "inputs": "BF11 packet:uint8[L]，核心codes:uint64[N-1]",
+          "outputs": "7流normal_values:uint64、outlier_values:uint64、tags:uint8、range_base:uint64、bit_width:uint8及透传first:uint64、source_base:int64。",
+          "example": "上游码为[0,1,2,1000]。常规域[0,3]取b=2，成本3×2+96=102位；全域b=10成本40位，因此该小例选择全域、不拆异常。大规模常规值才可能摊薄96位异常开销。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A111",
+          "name": "Given-width Exception Separation",
+          "layer": "mechanism",
+          "description": "调用方给定b，对每个uint32值提取low=x & mask(b)，仅当high=x>>b非零时记录pos和high。b=32时low保留全值且异常为空。逆向严格验证位置、流长和有效位范围，按low[pos] OR (high<<b)恢复。",
+          "inputs": "values:uint32[N]及b∈[0,32]，N≤UINT32_MAX。",
+          "outputs": "low:uint32[N]、pos:uint32[E]、high:uint32[E]，以及b/N/E和流边界。C++ Parts与bridge to_ports/from_ports提供三条独立流；EHS1为13字节头加三流，EHP1为15字节头加A020分别打包的三支。不是原FastPFor自动选宽/异常桶码流。",
+          "example": "给定b=2，输入[1,2,3,1025]，输出low=[1,2,3,1]、exception_pos=[3]、high=[256]；逆向将256<<2合入第3项得到1025，其他项保持low。独立C++ API/CLI与三流bridge可调用；另有A111→A020的EHP1配方。",
+          "status": "独立C++ API/CLI及三流bridge已接入；另有A111→A020配方。原FastPFor融合入口与图策略动作没有因此改写。",
+          "reference_ids": [
+            "M09",
+            "O05"
+          ]
+        }
       ]
     },
     {
       "id": "bitpack_int",
-      "name": "bit-packing",
+      "family_number": "07",
+      "name": "Bit Packing / 位打包",
       "group": "Bit processing",
       "description": "Packs unsigned integers into fixed-width fields chosen for a block, avoiding the unused high bits of a machine-word representation.",
       "reference_ids": [
         "O06"
+      ],
+      "implementations": [
+        {
+          "id": "A020",
+          "name": "Parameterized Fixed-width Bit Packing",
+          "layer": "mechanism",
+          "description": "maximum_width返回最大值所需位宽；allowed_width按minimum_width和wide_cutoff确定允许位宽。pack_fixed只消费values与给定b，逐值按b位写出，超宽值拒绝。unpack依据N/b/位序恢复，并拒绝非零填充。",
+          "inputs": "values:uint64[N]与b∈[0,64]。",
+          "outputs": "packed:uint8[ceil(N*b/8)]及恢复所需N、b、位序和对齐。可选宽度选择策略：最大位宽，或至少1位且57-64位统一取64。MSB-first用于常规流；LSB-first的32/64位profile表达小端异常字段。",
+          "example": "输入uint64 [0,3,1]，b=2，MSB位串00|11|01补零为0x34；另存N=3、b=2。BOS64的[0,0]以minimum_width=1输出两位0；需要57位的值在wide_cutoff=56时按64位打包。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A021",
+          "name": "Recipe: Simple8b Mode Selection → Fixed Width Pack",
+          "layer": "mechanism",
+          "description": "先按 Simple8b 表依次尝试，选择首个容纳当前前缀的 (k,b,selector)；再把 k 个值各写 b 位到60-bit区域，最后将4-bit selector写入64-bit字。两个 b=0 模式用 selector 表示240或120个零，无需主体位。",
+          "inputs": "当前 int64 源先拆 low/high uint32 肢。模式选择器输入 uint32[]",
+          "outputs": "selector:uint8[W]，由固定表推出各组 k/b；Fixed Width Pack 输入分组值与 k/b，输出各组payload。最终两个语义角色为 selector 与 packed_fields；有效N、双肢与scale属于恢复/旁路。",
+          "example": "输入240个0，选择240×0-bit模式，64-bit字只需selector描述；输入混合非零值时选择可容纳当前前缀的(k,b)模式，在60位区域写k个b位整数。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A022",
+          "name": "Sprintz Block Packing with Tail（分块打包与尾部）",
+          "layer": "composition",
+          "description": "读取上游SZI1/SZF1，每9个原字是一组anchor加8个已ZigZag的残差；对8码取至少1位的最大宽度打包。剩余不足9项尾部，整数交URL1 RLE，浮点交Gorilla。",
+          "inputs": "SZI1/SZF1 packet:uint8[12+8N]",
+          "outputs": "4流anchors:int64原字、bit_width:uint8、packed_residuals:bytes、tail_encoded:bytes。B=floor(N/9)，8残差/组；当前无公开参数。",
+          "example": "一个9值组包含anchor=100及8个残差码[0,1,0,1,0,1,0,1]，b=1，主体位串01010101=0x55；anchor及组头另存。不足一组的尾部走相应RLE/Gorilla后端。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A023",
+          "name": "Unsigned ULEB128（无符号Base-128变长码）",
+          "layer": "mechanism",
+          "description": "对每个uint32/uint64反复取低7位；非末字节置continuation bit=1，末字节置0。核心可编码整列、DBP已ZigZag残差位置或Snappy的单个raw_size。",
+          "inputs": "核心输入values:uint32[N]或uint64[N]，参数word_bits=32/64与I/O profile；A023新生成1流encoded:bytes。DBP adapter完整",
+          "outputs": "2种语义：first:int64[0/1]与encoded residuals:bytes；scaled profile另带scale:int32旁路恢复字段。",
+          "example": "输入[0,127,128,300]，ULEB128字节依次为00、7f、80 01、ac 02。解码去掉continuation位并按7位组拼接；signed输入先接A046。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A027",
+          "name": "BUFF Plane Reframing（已有字节平面重封装）",
+          "layer": "adapter",
+          "description": "读取BSF1中上游已经生成的base、width、scale和byte planes，按BUFF公开格式序列化这些字段；本步不重新求minimum、位宽，也不重新逐值取位。",
+          "inputs": "BSF1 packet:uint8[L]",
+          "outputs": "4流minimum:int64、precision:uint8、bit_width:uint8、byte_planes:bytes，均为既有语义字段。当前无参数。",
+          "example": "输入base=100、b=2、offsets产生的单平面[00,c0,40]及N=3；输出公开BUFF头和同一平面字节。解码恢复相同字段，A048逆向给出[0,3,1]，A013再恢复原值。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        }
       ]
     },
     {
       "id": "delta",
-      "name": "delta",
+      "family_number": "08",
+      "name": "Delta / 差分",
       "group": "Residual formation",
       "description": "Stores the first value or another anchor and replaces later values with differences from their predecessors, making smooth sequences easier to encode compactly.",
       "reference_ids": [
         "O07"
+      ],
+      "implementations": [
+        {
+          "id": "A028",
+          "name": "Parameterized Lagged Difference（带滞后参数的差分）",
+          "layer": "mechanism",
+          "description": "每条语义流独立计算r[i]=x[i]-history[lag]，逆向按同一历史加回。32/64位模运算、lag=1/2、首值或零历史、分块重置及REGER/BOS carrier都是同一差分核心的参数或I/O profile。",
+          "inputs": "int64或uint32/uint64语义流，参数lane width、lag、reset extent与anchor profile。首值模式",
+          "outputs": "anchor与residual两种语义；零历史模式由残差自身携带起始信息。REGER/BOS输出residuals:int64，下一阶段A046单独映为uint64。",
+          "example": "lag=1，输入[100,103,108]，首值100单存，残差[3,5]；解码100+3=103、103+5=108。零历史的lag=2输入[1,2,4,8]得到[1,2,3,6]。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A029",
+          "name": "Sprintz FIRE Predictor（在线FIRE预测）",
+          "layer": "mechanism",
+          "description": "每组保存accumulator与上次delta，预测为previous加由(accumulator>>2)×delta右移16位得到的校正；以预测误差符号更新accumulator，再更新delta。每9值组重置。",
+          "inputs": "int64[N]或float64原位字",
+          "outputs": "3流anchors:int64原字[B]、residuals:int64模残差[8B]、raw_tail:int64原字[T]，B=floor(N/9)，T=N%9。当前移位/学习规则固定。",
+          "example": "组起点previous=100、delta=0、accumulator=0，下一值103的预测为100、误差为3；观察误差符号更新accumulator，再令delta=3。后续预测使用更新后的状态。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A030",
+          "name": "FPZIP Mapped Float Residual（浮点映射残差）",
+          "layer": "mechanism",
+          "description": "把double原位映射为可逆的单调uint64码；按固定FPZIP一维浮点表达式从previous产生预测，再做mapped_current-mapped_prediction。初始预测为+0，解码加回并逆映射。",
+          "inputs": "float64[N]的8N字节原位，N≤UINT32_MAX",
+          "outputs": "1流mapped_residuals:uint64[N]。无公开参数；须保留运算顺序与初始+0。源码未拒绝NaN/Inf，但因预测执行double运算，特殊值位级可逆性需单独round-trip验证。",
+          "example": "若当前位置的原位与预测原位相同，则两者经同一单调映射得到同一码，mapped residual=0。解码把0加回预测码并逆映射，恢复相同float64位型。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "xor",
-      "name": "xor",
+      "family_number": "09",
+      "name": "XOR / 异或残差",
       "group": "Numeric representation",
       "description": "XORs adjacent fixed-width values or floating-point bit patterns so shared bits become zeros and only changing bit regions need further coding.",
       "reference_ids": [
         "O08"
+      ],
+      "implementations": [
+        {
+          "id": "A031",
+          "name": "Adjacent Previous-word XOR",
+          "layer": "mechanism",
+          "description": "对每个32/64位原字计算residual=current XOR previous；首值作为anchor保留。逆操作同样是residual XOR previous。状态由调用方按原始记录顺序和chunk边界更新，不做浮点数值转换。",
+          "inputs": "current:uint32/uint64[N]，previous来自lag=1历史或显式前字。",
+          "outputs": "anchor与同宽residual流；标签、beta及块计数旁路。Camel的literal路径与decimal路径共用原记录前值状态，不能先分类型过滤再计算相邻关系。",
+          "example": "原字[0x3ff0000000000000,0x3ff0000000000001,0x3ff0000000000001]，首字单存，残差[1,0]。逐项与前一恢复字异或，得到完全相同的原位。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A032",
+          "name": "Chimp128 History-reference XOR（历史引用异或）",
+          "layer": "mechanism",
+          "description": "用当前字低14位查最近同key的位置；若该候选仍在128项历史内且候选XOR尾零数>13，使用该历史槽，否则用前一字。输出所选引用及XOR，再更新环形历史和索引。",
+          "inputs": "int64/float64原字；纯参考",
+          "outputs": "first、references:int64、xor_residuals:uint64共3流；实际Chimp128包还存trailing_zeros:uint8共4流。128槽、14位key、阈值13当前固定。",
+          "example": "历史槽7存A，当前值再次为A且低14位key命中槽7，XOR=0、尾零数64，满足引用条件。输出reference=7和residual=0；解码用槽7原字恢复A，再更新环形历史。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A033",
+          "name": "FCM/DFCM Predictor Selection（双预测器选择）",
+          "layer": "mechanism",
+          "description": "FCM按值历史hash预测原字，DFCM按差分历史hash预测stride，再加last得到第二候选；比较两种XOR残差的无符号大小，记录较小者和selector，随后同时更新两个表。",
+          "inputs": "非空8字节对齐原字bytes:uint8[8N]",
+          "outputs": "2流predictor_selector:uint8[N]、xor_residuals:uint64[N]。公开lg2固定16；pFPC每2^20值重置，底层其他lg2不是已开放图参数。",
+          "example": "假定本步FCM预测0x1000、DFCM预测0x1010，真实原字0x1011；候选残差为0x11与0x01，选择DFCM并记录selector和0x01。解码先预测，再用selector选预测并XOR残差。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "trailing_zero_pack",
-      "name": "trailing-zero packing",
+      "family_number": "10",
+      "name": "Trailing-zero Packing / 零位与残差打包",
       "group": "Bit processing",
       "description": "Represents an XOR result using its significant bits plus leading/trailing-zero metadata, allowing zero suffixes and other unchanged regions to be omitted from the payload.",
       "reference_ids": [
         "O09"
+      ],
+      "implementations": [
+        {
+          "id": "A035",
+          "name": "Elf+ Residual Window Packing",
+          "layer": "mechanism",
+          "description": "消费已有残差。零残差写01；若分桶leading与已保存leading相等且trailing≥已保存trailing，则写00与已保存窗口宽度的载荷；否则写10/11短长窗口头，包含3位leading桶和有效位数，载荷省去已知为1的最低有效位。逆向重建窗口及残差，不隐含XOR。",
+          "inputs": "residual:uint32/uint64[N]及窗口状态。",
+          "outputs": "控制/窗口头与有效位组成的bitstream，恢复N/profile/有效长度。32位桶[0,6,10,12,14,16,18,20]，短长长度字段3/5位；64位桶[0,8,12,16,18,20,22,24]，短长字段4/6位。方法适配器单独处理首字、EOS、eraser元数据和A031。",
+          "example": "64位profile，残差1的leading桶=24、trailing=0，significant=40：写长头11、leading码111、长度101000，以及省略最低1后的39位0。随后残差3可复用窗口，写00及40位载荷；零残差写01。",
+          "status": "共享C++内核与独立residual_window_pack_cli可用；原方法适配器复用该内核。独立图窗口动作尚未注册。"
+        },
+        {
+          "id": "A037",
+          "name": "Common Trailing-zero Shift（共同尾零移位）",
+          "layer": "mechanism",
+          "description": "对所有非零int64取最小尾零数，再与16取小得到shift；每项算术右移shift。空列或全零列shift=0，逆向利用同一个shift恢复各原字。",
+          "inputs": "values:int64[N]",
+          "outputs": "2流values:int64[N]与shift:int64[1]。上限16当前固定，可作参数；并非float数值缩放。",
+          "example": "输入[16,48,80]，共同尾零最小值4，输出shift=4、values=[1,3,5]。逆向同宽左移4位恢复。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A038",
+          "name": "Zero/Reuse/New Window Packing（零值/复用/新窗口）",
+          "layer": "mechanism",
+          "description": "读取已生成XOR：零残差只写zero标记；非零的leading和trailing都不少于已保存窗口时复用已保存窗口，否则写新leading、有效位宽与有效位，并更新窗口。",
+          "inputs": "GXI1/GXF1或PXR1 packet；Gorilla",
+          "outputs": "4流first:uint64、window_tags:uint8、window_parameters:uint8、significant_payload:bytes；Pongo多eraser_flags:uint8共5流。",
+          "example": "已有窗口leading=30、trailing=30，残差0xc0000000的真实leading=32、trailing=30，满足复用条件；只需复用标记及保存窗口宽4位中的0011。残差0只写zero标记。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A039",
+          "name": "Parameterized Chimp Residual Window Packing",
+          "layer": "mechanism",
+          "description": "消费已有XOR与可选reference。四分支：00零残差，01省略尾零并写leading/有效位数，10复用leading，11写新leading。00/01按profile保存引用槽。零值或省尾零分支使leading复用状态失效；逆向读控制字段恢复原残差。",
+          "inputs": "residual:uint32/uint64[N]，可选reference:uint8[N]，trailing及leading桶信息。",
+          "outputs": "控制位、可选历史索引、窗口字段与有效位流。word_bits=32/64，history_index_bits=0/7，长度字段5/6位，leading桶和尾零阈值固定在profile中。独立CLI用N终止；方法适配器负责首字及EOS。",
+          "example": "64位、history_index_bits=0、threshold=6，残差1：leading桶24，新头11|111后写40位载荷1；下一残差3复用leading，写10与40位载荷3。零残差写00。索引位数7的profile在需要时另写7位历史槽。",
+          "status": "共享C++内核与独立residual_window_pack_cli可用；原方法适配器复用该内核。独立图窗口动作尚未注册。"
+        },
+        {
+          "id": "A040",
+          "name": "FPC Nibble/Byte Packing（半字控制与整字节残差）",
+          "layer": "mechanism",
+          "description": "按XOR残差落入的字节范围编码为0…7，实际字节数为[0,1,2,3,5,6,7,8]；把此3-bit码与预测器selector合为nibble，每两项合一控制字节，再写低位残差字节。",
+          "inputs": "FPR1/PFR1预测包，记录(selector:uint8,residual:uint64)",
+          "outputs": "2流control_nibbles:bytes、residual_payload:bytes。预测器选择来自上游，本步不重新预测。",
+          "example": "残差0用byte-count码0；残差0x1234需2字节，用码2。若selector分别为0和1，两个nibble分别为0和10，合成control=0x0a，再写第二项两字节残差（顺序按profile）。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "dictionary",
-      "name": "dictionary",
+      "family_number": "11",
+      "name": "Dictionary / 字典编码",
       "group": "Match and repetition",
       "description": "Builds a set of distinct values or symbols and replaces repeated occurrences with compact dictionary identifiers; the dictionary is retained for decoding.",
       "reference_ids": [
         "O10"
+      ],
+      "implementations": [
+        {
+          "id": "A041",
+          "name": "Value-sorted Integer Dictionary Recoding",
+          "layer": "configuration",
+          "description": "统计int64唯一值，但字典直接保留std::map的数值升序；令dictionary[j]为第j小值，再逐项输出ids[i]=dictionary中values[i]的下标，解码按下标查表。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无参数。",
+          "example": "输入[30,10,30,20]，字典按值升序为[10,20,30]，ID=[2,0,2,1]；查表逐项恢复原值。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A042",
+          "name": "First-seen 64-bit-word Dictionary Recoding",
+          "layer": "mechanism",
+          "description": "把每个8字节原字读成uint64；从左到右遇到新原字即追加到dictionary并记录下标，重复原字复用既有下标，解码用uint64下标恢复原始64位字。",
+          "inputs": "1流64位原字，可标为int64[N]或float64[N]",
+          "outputs": "2流dictionary:同输入原字[D]、ids:uint64[N]；无算法参数。",
+          "example": "输入原字[A,B,A,C]，首次出现字典[A,B,C]，ID=[0,1,0,2]。即使两个NaN的payload不同，也作为不同原字处理。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A043",
+          "name": "First-seen Dictionary plus Fixed-width ID Packing",
+          "layer": "composition",
+          "description": "先按A042相同的首次出现规则建立float64原位字典和ID；再取b=bit_width(D-1)，把每个ID恰用b位连续写入位流，逆向按相同b读ID并查字典。",
+          "inputs": "1流values:float64[N]原位",
+          "outputs": "3流dictionary:float64[D]、id_bit_width:uint8[1]、packed_ids:bytes[ceil(Nb/8)]；b由D生成。",
+          "example": "输入[A,B,A,C]，字典[A,B,C]、D=3，b=2；ID位串00|01|00|10，连同字典和N保存。解码按2位读ID并查表。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A044",
+          "name": "Fixed 12-word Greedy Substitution",
+          "layer": "mechanism",
+          "description": "从左到右扫描bytes，在固定12词表中按表序寻找当前位置可匹配的首个词；命中则写tag=1和词ID并前进词长，否则写tag=0和一个literal字节。",
+          "inputs": "1流payload:uint8[N]",
+          "outputs": "3流kind:uint8[T]、literals:uint8[L]、dictionary_ids:uint8[M]；当前词表固定，无需输出。",
+          "example": "对于不匹配词表的单字节0xff，输出literal tag=0及0xff；若当前位置匹配词表第j项，则输出tag=1和j，解码展开该固定词条。词表及顺序是算法参数的一部分。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A045",
+          "name": "CORAD Tricklet XOR Atom Selection",
+          "layer": "mechanism",
+          "description": "将64位字按40-lane块组织，最多取4个40-lane atom作字典；每块对每个atom计算各lane异或残差位宽之和，选代价最小atom，输出selector与逐lane XOR残差。",
+          "inputs": "CNM2 packet:uint8[L]，含float64归一化字及repair",
+          "outputs": "5流parameters:float64[2]、dictionary:float64[40A]、selectors:uint8[B]、xor_residuals:uint64[N]、repair:uint64[N]；当前width=40、A≤4。",
+          "example": "当前40-lane块与候选atom0逐lane完全相同，则40个XOR残差均为0，成本0；选择atom0并保存selector。解码从atom0逐lane异或0恢复该块。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "zigzag",
-      "name": "zigzag",
+      "family_number": "12",
+      "name": "ZigZag / 之字形映射",
       "group": "Numeric representation",
       "description": "Maps signed integers to unsigned integers by interleaving nonnegative and negative values, keeping small magnitudes small before varint or bit-packed coding.",
       "reference_ids": [
         "O11"
+      ],
+      "implementations": [
+        {
+          "id": "A046",
+          "name": "Signed64 ZigZag Mapping（有符号到无符号映射）",
+          "layer": "mechanism",
+          "description": "对选中的int64残差逐值计算ZigZag双射，输出uint64码；逆向恢复原signed64位型。reference、Sprintz、DBP、LECO、REGER与BOS64只选择不同位置并旁路各自元数据。",
+          "inputs": "输入selected residuals:int64[N]，参数selected positions/I/O profile；A046新生成1流codes:uint64[N]。anchors、coefficients、indices、scale等输入流原样旁路。",
+          "outputs": "输入selected residuals:int64[N]，参数selected positions/I/O profile；A046新生成1流codes:uint64[N]。anchors、coefficients、indices、scale等输入流原样旁路。",
+          "example": "输入signed [-2,-1,0,1,2]，输出unsigned [3,1,0,2,4]；负数映为奇数，非负数映为偶数。INT64_MIN对应UINT64_MAX。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "block_transform",
-      "name": "block transform",
+      "family_number": "13",
+      "name": "Block Transform / 块变换",
       "group": "Reordering and symbol recoding",
       "description": "Applies a reversible block permutation such as the Burrows-Wheeler transform to group similar symbol contexts before recoding and entropy coding.",
       "reference_ids": [
         "O12"
+      ],
+      "implementations": [
+        {
+          "id": "A014",
+          "name": "Stable Sort with Inverse Permutation",
+          "layer": "mechanism",
+          "description": "建立order=[0…N-1]，按values[order[j]]的signed int64值stable_sort；依order输出sorted_values并保存原位置，逆向把第j个排序值写回original_index[j]。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流sorted_values:int64[N]、original_index:int64[N]或uint32[N]；参数block_size=whole或64、index_dtype/index_scope为I/O配置。",
+          "example": "输入[30,10,30,20]，稳定排序后values=[10,20,30,30]，original_index=[1,3,0,2]。按索引散写恢复[30,10,30,20]。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A047",
+          "name": "SPDP Byte-plane Transpose plus Cross-plane Delta",
+          "layer": "composition",
+          "description": "把每个64位lag-2残差的第0至7字节依次组成8个平面；按该平面串接顺序维护单个previous状态，输出d=(current-previous) mod256，previous随后更新为current。",
+          "inputs": "S2D1 packet:uint8[12+8N]，语义为lag2_deltas:uint64[N]",
+          "outputs": "8流plane0_deltas…plane7_deltas:uint8[N]；word_width固定8，previous初值0。",
+          "example": "两个uint64值[1,2]的小端字节列化后为[1,2,0,0,...]；以previous=0做连续字节Delta，前四字节变为[1,1,254,0]。逆向先前缀加，再逆转置。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A048",
+          "name": "Byte-plane Split",
+          "layer": "mechanism",
+          "description": "输入已有uint64值和有效位宽b，令S=ceil(b/8)，将有效位左对齐到S字节，按从高到低字节位置输出S条平面。逆向拼接平面并去除低位padding，仅还原输入值。",
+          "inputs": "values:uint64[N]，b∈[0,64]，每值须可由b位表示。",
+          "outputs": "S条uint8[N]平面；N、b以及高低顺序用于恢复，空/零宽情况也保留N。minimum和scale由上游旁路保存，本步骤不计算minimum、不做减法。",
+          "example": "输入offsets=[0,3,1]、b=2，S=1，左移6位后输出uint8平面[0x00,0xc0,0x40]。逆向右移6位恢复[0,3,1]；base不参与本步。b=0时没有平面，但N仍保留。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A050",
+          "name": "Cyclic Burrows-Wheeler Transform",
+          "layer": "mechanism",
+          "description": "把整个字节串的N个循环旋转按字典序排序，输出每行旋转的末字节last_column，并记录原串所在行primary_index；逆向用字节计数和LF映射恢复原串。",
+          "inputs": "1流payload:uint8[N]",
+          "outputs": "2流last_column:uint8[N]、primary_index:uint64[1]；当前整个输入为单块，无算法参数。",
+          "example": "输入ASCII BANANA，排序循环旋转后last_column=NNBAAA、primary_index=3（0起点）。保留两者，LF映射可还原BANANA。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A051",
+          "name": "Low/High 32-bit Limb Decomposition",
+          "layer": "configuration",
+          "description": "对每个64位code计算low=uint32(code&0xffffffff)、high=uint32(code>>32)，分别按小端写入两条等长limb流；逆向按code=low|(uint64(high)<<32)逐项合成。",
+          "inputs": "codes:int64[N]或其LNS1块",
+          "outputs": "2流low32:uint32[N]、high32:uint32[N]；scaled/ALP仅增加scale、factor/exponent、exception等透传流。",
+          "example": "输入uint64 0x1122334455667788，low32=0x55667788、high32=0x11223344；两条limb流分别保存，逆向high<<32|low恢复原字。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A052",
+          "name": "Swap 32-bit Halves within Each 64-bit Word",
+          "layer": "mechanism",
+          "description": "对每个8字节原字交换前4字节与后4字节，半字内部小端顺序不变；该变换自逆，等价于先取得high32、low32，再按high32后low32写回单一路载荷。",
+          "inputs": "1流64位原字bytes:uint8[8N]，逻辑可为int64或float64",
+          "outputs": "1流reordered_words:uint8[8N]；layout=interleaved-high-low，无数值参数。",
+          "example": "输入字节88 77 66 55 44 33 22 11，输出44 33 22 11 88 77 66 55；再执行一次即恢复。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "symbol_recode",
-      "name": "symbol recoding",
+      "family_number": "14",
+      "name": "Symbol Recoding / 符号重编码",
       "group": "Reordering and symbol recoding",
       "description": "Re-expresses symbols after a transform, for example as move-to-front ranks, so recent or repeated symbols become small values and longer runs.",
       "reference_ids": [
         "O13"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A054",
+          "name": "Move-to-Front Recoding",
+          "layer": "mechanism",
+          "description": "初始化table=[0,1,…,255]；对每个byte输出它在当前table中的rank，再把命中符号移到table[0]并保持其他符号相对次序；解码同步执行同一更新。",
+          "inputs": "1流symbols:uint8[N]",
+          "outputs": "1流ranks:uint8[N]；alphabet固定0…255，无输出表和算法参数。",
+          "example": "初始表[0,1,2,...]，输入[2,2,1]，rank依次为[2,0,2]；第一步表变为[2,0,1,...]，第���步取rank2得到1。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "run_length",
-      "name": "run length",
+      "family_number": "15",
+      "name": "Run Length / 游程编码",
       "group": "Match and repetition",
       "description": "Replaces consecutive equal values or symbols with a value-and-count representation, reducing long runs while adding overhead to rapidly changing data.",
       "reference_ids": [
         "O14"
+      ],
+      "implementations": [
+        {
+          "id": "A055",
+          "name": "Size-optimal Hybrid RLE/Bitpack/Raw Selection",
+          "layer": "mechanism",
+          "description": "在raw、constant、全流bitpack与hybrid中按精确编码字节数选最小；hybrid用DP在最长128项literal-bitpack段和任意等值repeat段间切分，同成本优先repeat再优先更早起点。",
+          "inputs": "C++核心输入bytes:uint8[N×symbol_width]，按unsigned固定宽原字比较，symbol_width=1…8；当前公开profile实际用1或8字节。",
+          "outputs": "按模式为1流raw、2流constant、2流bitpack或5流hybrid；scaled传64位raw codes，RLBE先生成位宽序列并旁路delta_bits。",
+          "example": "输入100个7，constant候选只需保存常量及长度；与raw、bitpack、hybrid的完整候选字节数比较，选择最短表示。解码由count=100重复该常量。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "lz_match",
-      "name": "lz matching",
+      "family_number": "16",
+      "name": "LZ Match / LZ匹配",
       "group": "Match and repetition",
       "description": "Searches previously decoded data for repeated byte strings and emits distance-length copy commands in place of duplicate literals, following the LZ77 family model.",
       "reference_ids": [
         "O15"
+      ],
+      "implementations": [
+        {
+          "id": "A056",
+          "name": "Threshold-four int64 RLE Compatibility Proxy",
+          "layer": "adapter",
+          "description": "从左到右寻找相邻相等int64的最大游程；长度至少4时输出repeat标记、run length和一个值，较短游程输出literal标记、长度和全部原值，不产生向后距离。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "3流tag:int64[R]、count:int64[R]、values:int64[K]；repeat_threshold固定4，无offset。",
+          "example": "输入[5,5,5,5,2]，形成repeat(value=5,length=4)与literal([2],length=1)。解码按长度展开，未出现任何向后距离字段。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A057",
+          "name": "Attach Native-LZ Minimum/Maximum Configuration",
+          "layer": "configuration",
+          "description": "读取已有NLS1 role=1上下文，验证body仍等于raw_size，仅把role改为2并写入minimum与maximum；载荷逐字节不变，既不建立索引也不查找匹配。",
+          "inputs": "NLS1 packet:uint8[25+N]及minimum:uint32、maximum:uint32",
+          "outputs": "仍1流raw_body:uint8[N]并更新头字段，新增算法语义流0。",
+          "example": "输入NLS1上下文(window=32768,raw_size=8,body=ABCDEFGH)，设min=4、max=130后body仍为ABCDEFGH；输出只增加/更新约束字段，后续A060才查找匹配。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A058",
+          "name": "Reference Lazy Hash-chain LZ Search",
+          "layer": "mechanism",
+          "description": "以3字节key维护历史位置链，每处从最近位置反查至多64个候选，选window内最长匹配；若下一位置的最佳长度大于当前长度加1，则放弃当前match并先输出literal。",
+          "inputs": "1流payload:uint8[N]及window/min_match/max_match:uint32",
+          "outputs": "4流tag:uint8[T]、literal:uint8[L]、offset:uint32[M]、length:uint32[M]；search_policy=lazy。",
+          "example": "位置i最佳match长4，而i+1最佳match长7时，7>4+1，lazy规则先发出i处literal；随后再处理更长候选。保存literal/match序列及raw_size以供逆向复制。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A059",
+          "name": "Reference Greedy Hash-chain LZ Search",
+          "layer": "configuration",
+          "description": "使用与A058相同的3字节历史链和最多64候选最长匹配，但当前位置一旦找到长度达到min_match的最佳match便立即发出，不计算下一位置候选，也不执行lazy lookahead。",
+          "inputs": "1流payload:uint8[N]及window/min/max",
+          "outputs": "同A058的4条LZS1语义流；search_policy=greedy。",
+          "example": "同一候选状态中，位置i已有满足min_match的长4匹配，立即发出(distance,4)，不比较i+1的长7候选；逆向按距离从已恢复前缀复制4字节。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A060",
+          "name": "Native Aligned-8 Greedy Last-occurrence LZ Search",
+          "layer": "mechanism",
+          "description": "以8字节key只保存最近一次位置；match长度先逐字节扩展，再向下取8的倍数，并受有效min/max约束；有match立即贪心发出，否则首位失败时批量发8个literal。",
+          "inputs": "P074输入LNS1双肢bytes，核心参数window=32768、min=5、max=175；每肢",
+          "outputs": "kind:uint8[T]、literal:uint8[L]、offset:uint32[M]、length:uint32[M]，外围scale/exception透传。",
+          "example": "输入ABCDEFGHABCDEFGH（16字节），前8字节作为literal，位置8命中key ABCDEFGH，发出offset=8、length=8。解码复制已恢复的前8字节。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A061",
+          "name": "Snappy snap-1.1.1 Hash-table Match Generation",
+          "layer": "mechanism",
+          "description": "按64KiB块建立乘法hash表，使用skip增量探测寻找4字节候选，命中后逐字节延长；长copy按64或60切片，当前位置附近hash表按Snappy规则更新。",
+          "inputs": "1流payload:uint8[N]",
+          "outputs": "5流tag:uint8[R]、literal_bytes:uint8[L]、literal_length:uint32[J]、copy_offset:uint32[M]、copy_length:uint32[M]；规则固定。",
+          "example": "输入中已存在ABCD且当前位置4字节hash命中它，匹配扩展到长度70时，copy按Snappy规则切成多段（每段最多64），再交A068形成tag。此例说明匹配记录，不指定未经运行的完整压缩字节。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "match_parse_policy",
-      "name": "match policy",
+      "family_number": "17",
+      "name": "Match Parse Policy / 匹配解析策略",
       "group": "LZ decisions and format",
       "description": "Chooses among candidate matches and literals using policies such as greedy, lazy, optimal, or repeat-offset parsing, trading search cost against encoded size.",
       "reference_ids": [
         "O16"
+      ],
+      "implementations": [
+        {
+          "id": "A060",
+          "name": "Native Aligned-8 Greedy Last-occurrence LZ Search",
+          "layer": "mechanism",
+          "description": "以8字节key只保存最近一次位置；match长度先逐字节扩展，再向下取8的倍数，并受有效min/max约束；有match立即贪心发出，否则首位失败时批量发8个literal。",
+          "inputs": "P074输入LNS1双肢bytes，核心参数window=32768、min=5、max=175；每肢",
+          "outputs": "kind:uint8[T]、literal:uint8[L]、offset:uint32[M]、length:uint32[M]，外围scale/exception透传。",
+          "example": "输入ABCDEFGHABCDEFGH（16字节），前8字节作为literal，位置8命中key ABCDEFGH，发出offset=8、length=8。解码复制已恢复的前8字节。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A062",
+          "name": "Position-dependent Multiply/Add Proxy",
+          "layer": "adapter",
+          "description": "对第i个int64原位按模2^64计算y=3×uint64(x)+(i mod251)，再把同一64位型放回int64载体；逆向用3在模2^64下的乘法逆元恢复。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "1流transformed_values:int64[N]；位置i隐式，乘数3和模项251固定。",
+          "example": "输入[10,10,10]，位置i=0,1,2时输出[30,31,32]；解码减去i mod251，再乘3的模2^64逆元，恢复三个10。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A063",
+          "name": "Validated Identity Wrapper for Generic LZ Packet",
+          "layer": "adapter",
+          "description": "解析并验证输入LZS1的raw_size与literal/match token合法性，然后在外层增加ZPP1 wrapper；逆向去掉wrapper并再次验证，token次序和字段值完全不变。",
+          "inputs": "4条已有语义流tag:uint8[T]、literal:uint8[L]、offset:uint32[M]、length:uint32[M]的LZS1 packet",
+          "outputs": "同4流透传；无参数。",
+          "example": "输入已有LZS1的literal A及match(offset=1,length=3)，验证可恢复AAAA后加ZPP1包头；内部两个token值与顺序保持一致���解码去头并验证。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        }
       ]
     },
     {
       "id": "match_window_model",
-      "name": "window model",
+      "family_number": "18",
+      "name": "Match Window Model / 匹配窗口模型",
       "group": "LZ decisions and format",
       "description": "Defines how far back matches may refer and how candidates are indexed, bounded, or reset; larger windows can capture distant repetition at additional memory and search cost.",
       "reference_ids": [
         "O15"
+      ],
+      "implementations": [
+        {
+          "id": "A064",
+          "name": "Position-dependent XOR Proxy",
+          "layer": "adapter",
+          "description": "对第i个int64的64位原字计算y=uint64(x) XOR (uint64(i)×131)，逆向再次异或同一位置常量；每项独立，不维护任何跨位置历史状态。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "1流transformed_values:int64[N]；位置i隐式，常数131固定；兼容block_state profile只改变入口名。",
+          "example": "输入[10,10,10]，位置常量为[0,131,262]，输出[10,137,268]；再次异或相同常量恢复[10,10,10]。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A065",
+          "name": "Attach Native-LZ Window Configuration",
+          "layer": "configuration",
+          "description": "把原始bytes装入NLS1 role=1 envelope并在头部记录window_bytes与raw_size；body逐字节不变，逆向只核对window及长度后取回body，不建立窗口数据结构。",
+          "inputs": "1流raw_body:uint8[N]及window_bytes:uint32",
+          "outputs": "1个NLS1 packet，语义payload仍1流且新增算法流0；min/max可在同一配置接口补齐。",
+          "example": "raw=ABCDEFGH、window_bytes=32768，输出NLS1(role=1,window=32768,raw_size=8,body=ABCDEFGH)。逆向取回8字节body。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        }
       ]
     },
     {
       "id": "match_token_format",
-      "name": "match tokens",
+      "family_number": "19",
+      "name": "Match Token Format / 匹配令牌格式",
       "group": "LZ decisions and format",
       "description": "Serializes literal lengths, literal bytes, match offsets, and match lengths into codec-specific commands, such as the nibble-split token and extensions used by an LZ4 block.",
       "reference_ids": [
         "O17"
+      ],
+      "implementations": [
+        {
+          "id": "A066",
+          "name": "Nibble Split and Pack",
+          "layer": "composition",
+          "description": "对每个int64输出high=value>>4；每两个值取低4位，按(low_even<<4)|low_odd组成一个uint8，奇数尾项的低半字节补0；逆向结合high与低4位恢复。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流low_pairs:uint8[ceil(N/2)]、highs:int64[N]；low_width固定4，跨类历史入口不增加参数。",
+          "example": "输入[0x21,0x32,0x43]，high=[2,3,4]，低半字节打包为[0x12,0x30]，N=3指明最后0是padding。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A067",
+          "name": "Native ctrl8 Literal/Offset16/Length8 Packing",
+          "layer": "mechanism",
+          "description": "每8个有序token先留一个control byte，第b位为1表示match；literal写1字节，match写offset:uint16和(length-bias):uint8，逆向按control逐token读取并同步展开校验。",
+          "inputs": "literal/match token；参数offset_bits=16、length_bits=8、length_bias∈{3,4,5}",
+          "outputs": "4流control:uint8[ceil(T/8)]、literal:uint8[L]、offset:uint16[M]、length_bias:uint8[M]。",
+          "example": "token序列为literal A、match(offset=1,length=4)，bias=4：control最低两位为10（二进制），写literal 0x41、offset16=1、length8=0。其余control位对应不存在的token，不增加数据。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A068",
+          "name": "Snappy Literal/COPY Tag Formation",
+          "layer": "mechanism",
+          "description": "按Snappy语法为literal长度选择1至5字节头，为copy按offset和length选择COPY_1、COPY_2或COPY_4 tag；部分长度与offset位嵌入tag，长copy已由matcher切片。",
+          "inputs": "5条Snappy语义流tag、literal_bytes、literal_length、copy_offset、copy_length",
+          "outputs": "物理tag body:bytes，文档仍按5个语义角色展示；规则固定。",
+          "example": "literal ABC长度3，用tag=(3-1)<<2=0x08，后接41 42 43；COPY_2(offset=3,length=4)用tag=((4-1)<<2)|2=0x0e，后接小端offset 03 00。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A069",
+          "name": "LZ4 Token Nibbles and Offset Formation",
+          "layer": "mechanism",
+          "description": "每个sequence以一字节token保存literal_length的高nibble和match_length-4的低nibble；达到15时追加扩展长度，随后写literal bytes、offset:uint16及match扩展。",
+          "inputs": "LZ4 sequence",
+          "outputs": "7个语义角色token:uint8[S]、literal_extension:uint32[S]、literal_length:uint32[S]、literal_bytes:uint8[L]、has_match:bool[S]、offset:uint16[M]、match_extension:uint32[M]；match bias=4。",
+          "example": "一个sequence有3字节literal ABC、match长度8和offset=3；token高半字节3、低半字节8-4=4，即0x34，后接ABC及offset小端03 00。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A070",
+          "name": "Generic ctrl8 Literal/Offset32/Length32 Packing",
+          "layer": "mechanism",
+          "description": "同样每8个token写一个control byte，第b位区分literal和match；literal写uint8，match依次写未偏置offset:uint32和length:uint32，逆向依control恢复原token序列。",
+          "inputs": "literal/match token；参数offset_bits=32、length_bits=32、length_bias=0",
+          "outputs": "4流control:uint8[ceil(T/8)]、literal:uint8[L]、offset:uint32[M]、length:uint32[M]。",
+          "example": "literal A、match(offset=1,length=4)同样用control最低位0、下一位1，但match字段为offset32=1与length32=4，均不使用length-bias。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "integer_code",
-      "name": "integer coding",
+      "family_number": "20",
+      "name": "Integer Code / 整数编码",
       "group": "Bit processing",
       "description": "Uses variable-length or byte-oriented codes for nonnegative integers such as residuals, lengths, offsets, and metadata, giving small integers shorter representations.",
       "reference_ids": [
         "O18"
+      ],
+      "implementations": [
+        {
+          "id": "A023",
+          "name": "Unsigned ULEB128（无符号Base-128变长码）",
+          "layer": "mechanism",
+          "description": "对每个uint32/uint64反复取低7位；非末字节置continuation bit=1，末字节置0。核心可编码整列、DBP已ZigZag残差位置或Snappy的单个raw_size。",
+          "inputs": "核心输入values:uint32[N]或uint64[N]，参数word_bits=32/64与I/O profile；A023新生成1流encoded:bytes。DBP adapter完整",
+          "outputs": "2种语义：first:int64[0/1]与encoded residuals:bytes；scaled profile另带scale:int32旁路恢复字段。",
+          "example": "输入[0,127,128,300]，ULEB128字节依次为00、7f、80 01、ac 02。解码去掉continuation位并按7位组拼接；signed输入先接A046。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A072",
+          "name": "Stream VByte Coding of uint32 Limbs",
+          "layer": "mechanism",
+          "description": "解析SVD1中的low_deltas与high_deltas两条uint32流；每4值用一个control byte的四个2-bit字段记录1至4字节长度，低位数据紧密写入各自data区。",
+          "inputs": "1个SVD1 packet:uint8[12+8N]，字段scale:int32、count:uint32、low_deltas/high_deltas:uint32[N]",
+          "outputs": "4流low/high_control:uint8[ceil(N/4)]与low/high_data:bytes，scaled另透传scale共5流；无新增参数。",
+          "example": "四个uint32 [1,255,256,65536]需字节数[1,1,2,3]，2-bit长度码[0,0,1,2]合成control=0x90，数据小端为01 ff 00 01 00 00 01。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A073",
+          "name": "VariableByte Tail Coding after FastPFor Prefix",
+          "layer": "mechanism",
+          "description": "解析PFS1中已经编码好的low/high pfor_words与raw_tail；每肢原样复制pfor_words，只把raw_tail:uint32[T]交给VariableByte，再把两段拼成公开word序列。",
+          "inputs": "1个PFS1 packet，含kind:uint8、scale:int32、count:uint64及每肢pfor_words:uint32[P]、raw_tail:uint32[T]；完整",
+          "outputs": "每肢4条PFor前缀语义流加1条tail_bytes，整数源至多10流，scaled再加scale；无新增参数。",
+          "example": "已有pfor_words=[W0,W1]与raw_tail=[1,128]：保留W0/W1不变，仅把尾部交VariableByte编码并追加；两肢各自记录长度，逆向分别恢复前缀和两个尾值。",
+          "status": "源码机���与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A075",
+          "name": "LZ4 Extension-length Base-255 Coding",
+          "layer": "mechanism",
+          "description": "解析P086产生的LZT1 sequence；literal或match的长度nibble达到15时写对应extension，包括extra=0时必需的零终止字节。extension反复写255并减255，最后写0..254余数；token、literal字节和offset保持原语义。",
+          "inputs": "LZT1 packet，含token、literal_extra/literal_length、literal_bytes、has_match、offset、match_extra；完整",
+          "outputs": "压缩块5流tokens、literal_extension_bytes、literal_bytes、offset、match_extension_bytes，raw块1流raw_bytes，混合共6流；无参数。",
+          "example": "LZ4扩展长度为510，输出ff ff 00；长度17输出11。255重复字节后必须有一个小于255的终止余数。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "bitstream_pack",
-      "name": "bitstream packing",
+      "family_number": "21",
+      "name": "Bitstream Write / 位流写入",
       "group": "Bit processing",
       "description": "Writes flags, codewords, and variable-width fields into a contiguous bitstream so sub-byte fields do not consume whole bytes; DEFLATE is a canonical bit-packed format.",
       "reference_ids": [
         "O19"
+      ],
+      "implementations": [
+        {
+          "id": "A066",
+          "name": "Nibble Split and Pack",
+          "layer": "composition",
+          "description": "对每个int64输出high=value>>4；每两个值取低4位，按(low_even<<4)|low_odd组成一个uint8，奇数尾项的低半字节补0；逆向结合high与低4位恢复。",
+          "inputs": "1流values:int64[N]",
+          "outputs": "2流low_pairs:uint8[ceil(N/2)]、highs:int64[N]；low_width固定4，跨类历史入口不增加参数。",
+          "example": "输入[0x21,0x32,0x43]，high=[2,3,4]，低半字节打包为[0x12,0x30]，N=3指明最后0是padding。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A076",
+          "name": "Camel decimal/XOR record bitstream writer",
+          "layer": "mechanism",
+          "description": "以首个float64原始位型开块；后续记录写literal标记+64位值，或写decimal标记、整数差分分级码、十进制位数和值；每1000条形成带count/body_size的块。",
+          "inputs": "1路Camel XOR packet:bytes（记录含float64位型/decimal字段）",
+          "outputs": "1路Camel public wire:bytes。chunk_size固定1000；整数差分仅支持既定分级范围。",
+          "example": "输入first原位100.0，后续decimal记录integer_delta=0、decimal_count=2、decimal_value=25，写记录类型、分级整数码和小数字段。解码得到100.25；literal记录则携带其XOR残差的64位载荷。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "entropy_huffman",
-      "name": "huffman coding",
+      "family_number": "22",
+      "name": "Huffman Coding / 霍夫曼编码",
       "group": "Probability coding",
       "description": "Builds a prefix code in which more frequent symbols receive shorter integral-bit codewords and every symbol remains independently decodable from the bitstream.",
       "reference_ids": [
         "O20"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A077",
+          "name": "Project Byte Huffman",
+          "layer": "mechanism",
+          "description": "统计256个byte频率，按项目固定建树规则生成静态Huffman码；包内保存原长、频率/树恢复信息和有效bit数，解码逐bit沿左右子树直到叶节点。",
+          "inputs": "1路raw:uint8[L]",
+          "outputs": "1路Huffman packet:bytes（头部模型/原长/bit数与payload同包）。当前无公开树策略参数。",
+          "example": "字节AAAA BBB C（频数4、3、1）建立静态Huffman树；高频A获得更短码。若示意树取A=0、B=10、C=11，则ABAC为010011；实际码字由固定建树平局规则决定，模型与有效bit数必须入包。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "entropy_range",
-      "name": "range coding",
+      "family_number": "23",
+      "name": "Range Coding / 区间编码",
       "group": "Probability coding",
       "description": "Encodes a symbol sequence by successively narrowing a numeric interval according to model probabilities, approaching fractional-bit entropy costs through arithmetic state updates.",
       "reference_ids": [
         "O21"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A078",
+          "name": "Static Byte Range Coder",
+          "layer": "mechanism",
+          "description": "先把256符号原始频数归一到总频率2^15并构造cum；编码每个byte时令temp=range/2^15，更新low+=cum[s]*temp、range=freq[s]*temp并归一化输出。",
+          "inputs": "1路uint8[L]",
+          "outputs": "1路bytes包，内含origLen:uint32、256×uint32原频数、有效bit数和range payload。总频率2^15固定。",
+          "example": "示意归一化模型总频率32768，freq(A)=24576、freq(B)=8192；初始range=2^32时temp=131072。编码B令low增加24576×131072，range变为8192×131072；解码使用相同cum/freq。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A079",
+          "name": "FPZIP Adaptive 129-symbol Range Model",
+          "layer": "mechanism",
+          "description": "以上一float64重建值做1D预测；把预测与当前映射整数的差分符号和最高位宽映射到129符号，余下低bits直接入range流；RCqsmodel在每个符号后更新。",
+          "inputs": "1路FPZIP residual packet:bytes（count:uint32+uint64残差）",
+          "outputs": "1路range wire:bytes。预测器固定lossless 1D double，符号数129。",
+          "example": "连续相同值的mapped residual=0，选择表示零差分的模型符号并更新自适应频数；解码先从range流读该符号，再按同一预测得到原位。实际符号编号由FPZIP映射固定。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "entropy_fse",
-      "name": "fse/ans coding",
+      "family_number": "24",
+      "name": "ANS / FSE / ANS／FSE编码",
       "group": "Probability coding",
       "description": "Uses an Asymmetric Numeral Systems state, often table-normalized as tANS/FSE, to combine near-arithmetic-coding compression with table-driven encode/decode transitions.",
       "reference_ids": [
         "O22"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A080",
+          "name": "Project Static Byte rANS",
+          "layer": "mechanism",
+          "description": "把256频率归一到2^15，按输入倒序更新state=(state/fs)*M+(state%fs)+cum；state过大时低字节renorm输出，末尾写32位state。解码按state%M查符号。",
+          "inputs": "1路uint8[L]",
+          "outputs": "1路rANS packet:bytes，含origLen:uint32、256×uint16频率表、state/body。prob_bits=15与初态固定。",
+          "example": "示意模型M=32768、freq(A)=16384、cum(A)=0，state=100000时编码A的新状态=(100000 div16384)×32768+(100000 mod16384)=198304；归一化字节与末状态也必须保存。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "entropy_special",
-      "name": "special coding",
+      "family_number": "25",
+      "name": "Special / Literal Coding / 特殊值／字面量编码",
       "group": "Probability coding",
       "description": "Represents codec-specific entropy or statistical back ends that do not fit the shared Huffman, range, or FSE/ANS categories; behavior is defined by the selected method.",
       "reference_ids": [
         "O23"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A081",
+          "name": "SPDP History-context Repeat Encoder",
+          "layer": "mechanism",
+          "description": "以6字节历史匹配作为上下文，hash状态索引last位置；若历史相同则输出最多255的复制count，再输出literal，并以(history<<2)^value更新状态。解码同步重放复制。",
+          "inputs": "1路SPDP block packet:bytes",
+          "outputs": "1路repeat/literal bytes。level:uint32∈[0,9]控制表大小，默认5；逆向还需original_size:uint64。",
+          "example": "历史6字节上下文相同且已输出前缀包含ABCDEFG时，可发出复制count再发literal；count受255上限限制。解码使用相同hash/last状态，从已恢复位置复制，随后观察literal并更新历史。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "literal_entropy",
-      "name": "literal coding",
+      "family_number": "26",
+      "name": "Literal Entropy / 字面量熵编码",
       "group": "LZ decisions and format",
       "description": "Codes literal bytes through a separate probability model or codebook while match lengths, offsets, and other sequence symbols use their own representation.",
       "reference_ids": [
         "O24"
+      ],
+      "implementations": [
+        {
+          "id": "A053",
+          "name": "Frequency Ordered Dictionary IDs",
+          "layer": "configuration",
+          "description": "先统计每个int64符号频数，再按频数降序stable_sort唯一符号；同频保持std::map数值升序，随后令ID为该排名，解码依赖完整dictionary查表。",
+          "inputs": "1流symbols:int64[N]",
+          "outputs": "2流dictionary:int64[D]、ids:int64[N]；无熵模型参数，排序规则固定。",
+          "example": "输入[8,3,8,5,3,8]，频数8:3、3:2、5:1，字典[8,3,5]，ID=[0,1,0,2,1,0]。输出仍是ID流，需要另接熵编码才能得到前缀码。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A077",
+          "name": "Project Byte Huffman",
+          "layer": "mechanism",
+          "description": "统计256个byte频率，按项目固定建树规则生成静态Huffman码；包内保存原长、频率/树恢复信息和有效bit数，解码逐bit沿左右子树直到叶节点。",
+          "inputs": "1路raw:uint8[L]",
+          "outputs": "1路Huffman packet:bytes（头部模型/原长/bit数与payload同包）。当前无公开树策略参数。",
+          "example": "字节AAAA BBB C（频数4、3、1）建立静态Huffman树；高频A获得更短码。若示意树取A=0、B=10、C=11，则ABAC为010011；实际码字由固定建树平局规则决定，模型与有效bit数必须入包。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
       ]
     },
     {
       "id": "block_state_control",
-      "name": "block/state",
+      "family_number": "27",
+      "name": "Block State Control / 块状态控制",
       "group": "Layout and state",
       "description": "Controls block boundaries, state reuse or reset, streaming flushes, and per-block mode choices that determine which history and models remain available to later data.",
       "reference_ids": [
         "O25"
+      ],
+      "implementations": [
+        {
+          "id": "A082",
+          "name": "Native Snappy Match Records",
+          "layer": "mechanism",
+          "description": "对raw调用当前Snappy RawCompress，再解析其varint原长和literal/copy tag为SNM1记录。逆向按literal或向后复制恢复字节；它实际上保留了完整原生matcher的决策。",
+          "inputs": "raw:uint8[L]，L≤UINT32_MAX",
+          "outputs": "5语义流tag:uint8、literals:uint8、literal_length:uint32、copy_offset:uint32、copy_length:uint32。物理为SNM1，当前无公开参数。",
+          "example": "输入ABCABCABC，由Snappy库产生实际压缩结果，再解析为literal/copy记录，例如literal ABC与向后复制的语义。SNM1保存raw_size及库选定的实际记录，不假定每次都选择同一手工切分。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A083",
+          "name": "Native LZ4 Linked-block Match Records",
+          "layer": "mechanism",
+          "description": "先按64KiB linked-block、level=0生成LZ4F，再解析literal run、offset及match length为LZM1。原生LZ4查hash候选，命中后可向前回扩到anchor，再延长匹配。",
+          "inputs": "raw:uint8[L]",
+          "outputs": "5语义流literals:uint8、literal_length:uint32、has_match:uint8、offset:uint16、match_length:uint32。物理为LZM1；块长及level当前固定。",
+          "example": "输入重复的64KiB字节块，先由LZ4 linked-block编码，再把生成块解析为literal序列及(offset,length)。linked模式的第二块可引用第一块保留的字典，解码必须维持该跨块状态。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A084",
+          "name": "ALP Native Remaining Pipeline",
+          "layer": "composition",
+          "description": "先逆转ALP1前缀中的bitpack、FOR、scaling恢复float64，再调用原生ALP：每1024项选择factor/exponent、标记不能精确恢复的异常，以两条32位limb做FastPFOR并写ALP2。",
+          "inputs": "ALP1:bytes。",
+          "outputs": "raw块1流uint64；scaled块5流factor_exponent:int8、low_words:uint32、high_words:uint32、exception_positions:uint16、exception_bits:uint64；混合6角色。物理ALP2封包。",
+          "example": "输入一个表示[1.25,1.50,1.75]的ALP1前缀包；入口先恢复这三个float64，再运行完整ALP生成ALP2。输出参数、两肢压缩块与异常信息由ALP重新选定，不能把ALP1前缀载荷直接当作原生ALP主体。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A085",
+          "name": "Current REGER Search and Payload",
+          "layer": "composition",
+          "description": "逆转RGR1的位打包、FOR、相邻预测与排列后，调用当前REGER。对候选顺序和是否存time比较完整块成本；每序列再选raw、constant、FOR、Delta、TimeLinear或PrevLinear并分段打包。",
+          "inputs": "输入RGR1:bytes。time/value每序列随模式为1/1/3/4/4/5语义流；字段为int64主体/first/minimum、float32[2]模型、uint8位宽、bytes残差，可另有order。物理为完整REGER wire。",
+          "outputs": "输入RGR1:bytes。time/value每序列随模式为1/1/3/4/4/5语义流；字段为int64主体/first/minimum、float32[2]模型、uint8位宽、bytes残差，可另有order。物理为完整REGER wire。",
+          "example": "输入可逆RGR1前缀表示[10,12,14,16]；入口先恢复数值，再由REGER比较常量、FOR、Delta及回归等候选的完整块大小，输出选择标志和对应payload。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A087",
+          "name": "Brotli Quality-6 Remaining Pipeline",
+          "layer": "composition",
+          "description": "先逆项目Huffman、LZ和固定字典前缀恢复raw，再调用Brotli quality=6。内部将literal、command、distance分开建模，literal/distance可按context map选Huffman表，块切换另有控制码。",
+          "inputs": "输入Huffman(LZS1(BRD1(raw)))结构化bytes。压缩块4语义角色：entropy_models、literal_codebits、command_codebits、distance_codebits（均bytes），有块切换则加1；raw块1角色。quality/window当前固定。",
+          "outputs": "输入Huffman(LZS1(BRD1(raw)))结构化bytes。压缩块4语义角色：entropy_models、literal_codebits、command_codebits、distance_codebits（均bytes），有块切换则加1；raw块1角色。quality/window当前固定。",
+          "example": "项目前缀可逆表示ASCII ABCABCABC；入口先还原这9字节，再由Brotli quality=6生成压缩流B。用Brotli解码B回到同一9字节；不把项目前缀中的token当作Brotli内部command。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A088",
+          "name": "Zstd Level-9 Remaining Pipeline",
+          "layer": "composition",
+          "description": "逆项目rANS、Huffman、parse wrapper及LZ前缀得到raw，交给Zstd level=9。原生路径对literal使用Huffman或raw/RLE，对literal length、match length、offset等序列符号使用FSE及附加位。",
+          "inputs": "输入项目rANS(Huffman(ZPP1(LZS1(raw)))) bytes。压缩schema为L+H+F+S+I(sequence)：L=1/4路literal bytes，H=0/1模型，F=0..3模型，S=0..3个uint32状态及sequence_bits；raw/RLE各1角色。",
+          "outputs": "输入项目rANS(Huffman(ZPP1(LZS1(raw)))) bytes。压缩schema为L+H+F+S+I(sequence)：L=1/4路literal bytes，H=0/1模型，F=0..3模型，S=0..3个uint32状态及sequence_bits；raw/RLE各1角色。",
+          "example": "项目前缀表示ABCABCABC，入口恢复raw后用Zstd level=9生成Zstd frame；其literal和sequence熵模型由Zstd内部选择。解码frame，再逆构造前缀所需表示。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A089",
+          "name": "C-Blosc1 BLOSCLZ with Shuffle",
+          "layer": "composition",
+          "description": "逆项目token、LZ及SHF1 shuffle前缀后，以typesize执行Blosc1 shuffle与BLOSCLZ-5。BLOSCLZ先对末1/4采样，probe使用12-bit hash；根据split标志或预测压缩性选择minlen/ipshift为3或4。",
+          "inputs": "输入LZT1(LZS1(SHF1)) bytes，typesize∈{1,4,8}。正常chunk按plane编号合并为1至typesize流encoded_plane:bytes；memcpy为1流raw:bytes。level5/shuffle/单线程固定。",
+          "outputs": "输入LZT1(LZS1(SHF1)) bytes，typesize∈{1,4,8}。正常chunk按plane编号合并为1至typesize流encoded_plane:bytes；memcpy为1流raw:bytes。level5/shuffle/单线程固定。",
+          "example": "输入4个相同的64位字，typesize=8；恢复原始32字节后，Blosc1按字节shuffle再运行BLOSCLZ-5，输出完整Blosc块。解码和逆shuffle恢复32字节。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A090",
+          "name": "C-Blosc2 BLOSCLZ Shared Pipeline",
+          "layer": "composition",
+          "description": "执行C-Blosc2的BLOSCLZ-5、byte shuffle、单线程和自动块划分。P114先逆项目prefix；P119直接接raw，再把输出chunk转成B2P1。两者来源版本的该活动压缩路径已归为同一组。",
+          "inputs": "P114输入结构化prefix及typesize=1/4/8；P119输入raw:uint8且typesize固定1。正常按plane合并1至typesize路bytes，memcpy/特殊模式1路body（zero可空）；物理chunk或B2P1。",
+          "outputs": "P114输入结构化prefix及typesize=1/4/8；P119输入raw:uint8且typesize固定1。正常按plane合并1至typesize路bytes，memcpy/特殊模式1路body（zero可空）；物理chunk或B2P1。",
+          "example": "raw为4个相同64位字，typesize=8、单线程、BLOSCLZ-5、byte shuffle；C-Blosc2生成chunk，再由对应入口转成B2P1或保留本机块结构。解码恢复32字节。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A091",
+          "name": "Bzip2 Block-sort Remaining Pipeline",
+          "layer": "composition",
+          "description": "逆项目Huffman、URL1、MTF、BWT恢复raw，再调用Bzip2 level4。原生编码包含块排序/BWT、MTF与RUNA/RUNB零游程符号，并按组选择多张Huffman表编码。",
+          "inputs": "Huffman(URL1(MTF(BWT(raw)))) bytes，URL1 symbol_width=1。",
+          "outputs": "5语义组used_alphabet:uint8、BWT_primary:uint32、code_lengths:uint8、selectors:uint8、coded_MTF_RLE2:bytes；跨块按同角色合并。",
+          "example": "项目前缀BWT/MTF/RLE/Huffman表示BANANA，入口先恢复6字节，再调用Bzip2 level=4，生成带块排序和自身熵模型的完整流。最终解压应为BANANA。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A092",
+          "name": "Parameterized DEFLATE Core",
+          "layer": "composition",
+          "description": "gzip/zlib profile先逆项目前缀得到raw；CORAD直接压CTK2。三者共用parameterized_deflate，执行LZ匹配及stored/fixed/dynamic块选择；压缩块使用literal/length与distance两套Huffman码。",
+          "inputs": "输入由io_variant选择gzip_prefix/zlib_prefix bytes或CTK2；level:int32∈[0,9]。stored/fixed/dynamic语义流分别1/2/3路，混合最多4角色：raw、literal_length_bits、distance_bits、Huffman_model（bytes）。",
+          "outputs": "输入由io_variant选择gzip_prefix/zlib_prefix bytes或CTK2；level:int32∈[0,9]。stored/fixed/dynamic语义流分别1/2/3路，混合最多4角色：raw、literal_length_bits、distance_bits、Huffman_model（bytes）。",
+          "example": "raw=ABCABCABC，DEFLATE核心选择stored/fixed/dynamic块并输出压缩core；raw-DEFLATE、zlib、gzip的窗口和封包配置由调用方指定，恢复使用匹配配置。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A093",
+          "name": "XZ / LZMA2 Remaining Pipeline",
+          "layer": "composition",
+          "description": "逆项目Range、parse wrapper和LZ前缀恢复raw，再用preset5、CRC64的LZMA2路径。其literal/匹配/重复距离由二元自适应概率模型和range coder写出，并在chunk边界处理模型或字典重置。",
+          "inputs": "Range(ZPP1(LZS1(raw))) bytes；压缩chunk",
+          "outputs": "range_bytes:bytes与final_flush:bytes两角色，raw为1角色，混合3角色；物理为XZ核心包，preset5固定。",
+          "example": "项目前缀可逆表示ABCABCABC，入口还原raw后运行preset=5、CRC64的XZ/LZMA2路径；输出XZ流，解压得到同一9字节。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        },
+        {
+          "id": "A094",
+          "name": "REGER Candidate Search with Compatibility Arithmetic",
+          "layer": "composition",
+          "description": "把64位原字按int64处理，在块内比较排列、是否保存time及六种序列模式，选择完整payload较小的候选。拟合用double乘积及Python式fsum，预测用double，再做截断和范围处理。",
+          "inputs": "words:uint8[8N]，按int64位型解释；配置block_size默认513、segment_size默认16、profile=fast/balanced。",
+          "outputs": "每time/value序列按模式1/1/3/4/4/5路，可加order；字段类型同A085，物理RGP1。",
+          "example": "一个int64块[5,5,5,5]会把constant作为候选，与raw/FOR/Delta等完整候选比较；最终payload同时记录实际选定模式，解码不能自行重新运行成本搜索。",
+          "status": "完整或剩余流程入口，包含多个内部机制；不声称已拆成独立原子动作。"
+        }
       ]
     },
     {
       "id": "container_frame",
-      "name": "container framing",
+      "family_number": "28",
+      "name": "Container / Framing / 容器与封包",
       "group": "Layout and state",
       "description": "Wraps a compressed payload with format identifiers, lengths, checksums, member boundaries, or other metadata needed to transport, validate, and decode the stream.",
       "reference_ids": [
         "O26"
+      ],
+      "implementations": [
+        {
+          "id": "A086",
+          "name": "Magic and Length Envelope",
+          "layer": "adapter",
+          "description": "在已有payload前写4字节magic和8字节payload长度，逆向移除并校验对应字段。五个reference容器使用同一wrap/unwrap；CORAD在CZL2外增加CRD2外壳。",
+          "inputs": "payload:uint8[L]；CORAD输入CZL2:bytes。",
+          "outputs": "1条完整container:bytes，主体不变；magic/profile及payload合法性属于格式配置。",
+          "example": "magic=TEST、payload=01 02 03，输出TEST、长度3的小端8字节字段、01 02 03。解码核对长度后返回3字节。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A095",
+          "name": "Reference Integer Header and Checksum Slots",
+          "layer": "adapter",
+          "description": "在int64值序列前插入[31,139,N低16位]，尾部插入所有值之和的低16位；逆向直接取去掉前三项和最后一项后的原序列。",
+          "inputs": "values:int64[N]",
+          "outputs": "1流container:int64[N+4]。无参数，新增4个int64槽位；与byte帧的区别留在I/O和schema中。",
+          "example": "输入[5,7]，输出int64序列[31,139,2,5,7,12]。当前逆函数去除前3项及末项得到[5,7]；末字段是槽位，不构成经过验证的校验和保障。",
+          "status": "当前项目参考/代理或封装步骤；按下面实际计算解释，不等同名称暗示的上游算法。"
+        },
+        {
+          "id": "A096",
+          "name": "LZ4 Frame Assembly",
+          "layer": "adapter",
+          "description": "由LZI1已编码块生成LZ4F：写magic、descriptor及其XXH32派生校验字节，再写块长度与raw标志、块body，最后写零长度终止块。逆向解析回块记录。",
+          "inputs": "LZI1:bytes（raw_size:uint64及每块标志、长度、body）",
+          "outputs": "1流LZ4F:bytes。不接受裸值或原始payload，无公开算法参数。",
+          "example": "已有一个3字节raw块ABC，LZ4F块长字段为0x80000003，后接ABC，再写0终止块；frame descriptor及校验字节另按配置生成。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A097",
+          "name": "Stored Header / Core / Trailer Assembly",
+          "layer": "adapter",
+          "description": "解析已保存的header、core、trailer长度，将三段原样按顺序拼接。gzip/zlib共用assemble；XZ固定两端各12字节，直接移除XZC1的描述头得到原frame。",
+          "inputs": "DFC1(G/Z)或XZC1:bytes，内含3段uint8[]",
+          "outputs": "1流完整gzip/zlib/XZ:bytes。profile固定选择格式，长度必须与packet一致。",
+          "example": "输入header=01 02、core=aa bb cc、trailer=ff及三段长度，输出01 02 aa bb cc ff。逆向用固定或已记录边界恢复三段。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A098",
+          "name": "Legacy Two-limb Numeric Frame",
+          "layer": "adapter",
+          "description": "从LNS1的两条已编码limb取出low/high字节；写low长度后依次放两条body。整数前置I标签，浮点前置F标签及scale；逆向依标签与长度还原字段。",
+          "inputs": "LNS1 JSON bytes，stage=wires、format=scaled、单块、wires为2个hex串；float另含scale:int32。",
+          "outputs": "1流legacy numeric wire:bytes。",
+          "example": "整数profile，两肢body分别为aa bb和cc，输出I类型标记、low长度2、low body与high body；浮点profile还写F和scale。长度字段确定两肢边界。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A099",
+          "name": "Legacy ALP2 Block Frame",
+          "layer": "adapter",
+          "description": "把上游已选择的raw/scaled块写成ALP2；raw块写原字，scaled块写fac、exp、两肢body及异常位置/原字；总长、块长与模式按固定字段宽度序列化。",
+          "inputs": "LNS1 JSON bytes，stage=wires、format=alp；含count、raw或fac/exp、wires及exceptions。",
+          "outputs": "1流ALP2:bytes；块长≤1024，无数值搜索参数。",
+          "example": "ALP2一块mode=raw、count=2、原字对应1.25与2.5，封包写块模式和两原字；scaled块则保存fac/exp、两肢body及异常表，模式决定解码分支。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A100",
+          "name": "REGER3 Single-column Frame",
+          "layer": "adapter",
+          "description": "解析RGP1，写REGER3 magic、总数、固定列数1、块长和segment长；逐块写count、flags、body长度和既有body。逆向重新构造RGP1。",
+          "inputs": "RGP1:bytes，count:uint64、block/segment_size:uint32、块记录",
+          "outputs": "1流REGER3:bytes。输出总数限uint32、块及segment尺寸限uint16。",
+          "example": "单列共3项、一块，RGP1内已有flags及body；REGER3 frame写总数3、列数1、块长、segment长，再写该块count/flags/body_size和body。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A101",
+          "name": "BUFF Raw64 Header",
+          "layer": "adapter",
+          "description": "对已经按BUFF高32位在前布局的words，前置count:uint32、bits_per_value=64、lower_bits=0；空输入输出空包。逆向核对这三个头字段后返回原words。",
+          "inputs": "words:uint8[8N]，每字高32位在前、各肢内部小端",
+          "outputs": "1流BUFF raw64 wire:bytes。N≤UINT32_MAX，无公开参数。",
+          "example": "已有两项重排后的64位word，前置count=2、bits_per_value=64、lower_bits=0。解码核对头后取出16字节word载荷，再由A052恢复字序。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        },
+        {
+          "id": "A102",
+          "name": "Blosc2 Logical-to-physical Block Frame",
+          "layer": "adapter",
+          "description": "解析B2P1的logical_id与block body；按记录的物理顺序拼body，并为各逻辑块重建offset表。direct/memcpy/special-zero模式走专门分支，最后写Blosc2头与扩展字段。",
+          "inputs": "B2P1:bytes，含header/extension、direct、logical_id:uint32、body:bytes",
+          "outputs": "1流Blosc2 chunk:bytes。当前schema固定version=5、codec_version=1、typesize=1。",
+          "example": "两个逻辑块L0、L1在物理区按L1后L0存放，offset表分别指向各块的实际开始地址。解码按逻辑顺序索引块，不把物理拼接次序误当作列顺序。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。"
+        }
+      ]
+    },
+    {
+      "id": "split_columns",
+      "family_number": "29",
+      "name": "Split Columns / 列拆分",
+      "group": "Layout and state",
+      "description": "Splits fixed records, floating-point fields, numeric bit fields, or serialized fixed-width bitstreams into typed component streams while retaining the metadata required for exact reconstruction. The four current entries are project implementations informed by OpenZL layout nodes; their local transport is not the OpenZL wire format.",
+      "reference_ids": [
+        "O27",
+        "S01"
+      ],
+      "implementations": [
+        {
+          "id": "A049",
+          "name": "Parameterized Fixed-record Byte Columnization（参数化定宽记录列化）",
+          "layer": "mechanism",
+          "description": "把输入解释为 N 个宽度 W 的定长记录；transpose 按记录内字节位置输出 W 条 byte 列。split-struct 则按给定字段宽度数组切连续字节字段，各字段仍保持行序。1/4/8-byte shuffle 是 W 的固定 profile。",
+          "inputs": "Struct(W) 的 N 条定长记录；兼容 Serial adapter 可接任意 byte[L]，仅完整记录参与列化并保留尾部。参数：W 或字段宽度数组，当前兼容 profile W∈{1,4,8}。",
+          "outputs": "transpose 为 W 条 bytes[N]；split-struct 为字段数条 Struct(field_width) 流。",
+          "example": "两条宽3字节记录[01,02,03]和[11,12,13]，transpose输出三列[01,11]、[02,12]、[03,13]。若字段宽[1,2]，输出1字节列和2字节结构列。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。",
+          "source_url": "https://github.com/facebook/openzl",
+          "reference_ids": [
+            "O27"
+          ]
+        },
+        {
+          "id": "A103",
+          "name": "Float Sign-fraction/Exponent Deconstruction（浮点符号尾数与指数拆分）",
+          "layer": "mechanism",
+          "description": "按 fp16、bf16 或 fp32 位格式读取原始位型，将 fraction 左移一位并把 sign 填入最低位，形成 sign_fraction；exponent 单独取出。逆变换再把 sign、fraction、exponent 放回原位，因此保留 NaN、无穷和 signed zero 的位型。",
+          "inputs": "Numeric fp16/bf16/fp32 原始位型，存储宽度分别 2/2/4 bytes；参数：format。",
+          "outputs": "2 条流--Struct(ceil((fraction_bits+1)/8)) 的 sign_fraction[N] 与 uint8 exponent[N]。当前实现不接 fp64。",
+          "example": "fp32的-0原位0x80000000：exponent=0、fraction=0、sign=1，输出sign_fraction=1、exponent=0。fp32的1.0则输出sign_fraction=0、exponent=127。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。",
+          "source_url": "https://github.com/facebook/openzl",
+          "reference_ids": [
+            "O27"
+          ]
+        },
+        {
+          "id": "A104",
+          "name": "LSB-first Bit-field Split（低位优先位域拆分）",
+          "layer": "mechanism",
+          "description": "对每个 Numeric 元素从最低位起，依次按 widths=[w0,w1,…] 掩码并右移，得到若干定宽数值字段。各宽度为 1-64 bit，总宽不超过输入存储位数；若未覆盖高位，所有被省略高位必须为 0 才可逆。",
+          "inputs": "Numeric 整数或原始浮点位型，storage_bits 由类型确定；参数：widths，或 top8/浮点格式 profile。",
+          "outputs": "len(widths) 条 Numeric 流，每条为能容纳对应 wi 的最小存储宽度；浮点 profile 输出 fraction、exponent、sign 3 流。",
+          "example": "uint16值0x1234，widths=[4,4,8]，低位优先输出[4,3,0x12]。逆向4|(3<<4)|(0x12<<8)=0x1234。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。",
+          "source_url": "https://github.com/facebook/openzl",
+          "reference_ids": [
+            "O27"
+          ]
+        },
+        {
+          "id": "A105",
+          "name": "Fixed-width Bitstream Unpack（定宽位流解包）",
+          "layer": "mechanism",
+          "description": "把 Serial byte 流视为 LSB-first 连续位串，每 bits 位读出一个无符号值，共 floor(8L/bits) 个；末尾不足 bits 的 remainder 位值写入 side metadata。逆变换按相同位序重打包并补回 remainder。",
+          "inputs": "Serial bytes[L]；参数bits∈[1,64]。N=floor(8L/bits)，要求ceil(N*bits/8)=L，即未消费部分不足一个完整字节。",
+          "outputs": "Numeric unsigned[N]，每元素按storage_width(bits)占用1/2/4/8字节；其存储字节数可大于输入。side metadata保存bits与末尾remainder_value，原输入长度L随框架保存。",
+          "example": "单字节0xd6按LSB-first、bits=3解包：得到[6,2]，剩余高2位值3作为remainder保存��逆向6|(2<<3)|(3<<6)=0xd6。",
+          "status": "源码机制与调用入口已定位；本手册不把目录项数作为可执行内核数。",
+          "source_url": "https://github.com/facebook/openzl",
+          "reference_ids": [
+            "O27"
+          ]
+        }
+      ]
+    },
+    {
+      "id": "prediction_probability",
+      "family_number": "30",
+      "name": "Prediction Probability / 概率预测",
+      "group": "Probability coding",
+      "description": "Produces causal probabilities before the current event is observed. A106-A109 expose next-bit P(1) from distinct cmix-family models, while A110 exposes a 256-way next-byte distribution from NNCP. These providers remain separate from graph-level entropy integration and benchmark method scheduling.",
+      "reference_ids": [
+        "O28",
+        "O29"
+      ],
+      "implementations": [
+        {
+          "id": "A106",
+          "name": "cmix PPMd Byte-model Probability（PPMd 字节模型概率）",
+          "layer": "mechanism",
+          "description": "PPMd 按最近字节上下文维护自适应符号概率。adapter 在每个 bit 前从模型取 P(1)，观察 8 个 MSB-first bit 后才组装字节并调用 ByteUpdate；字节边界还可把 256 个符号权重归一化为完整下一字节分布。",
+          "inputs": "状态化命令流；每步 observe 输入 uint8 bit∈{0,1}，批量接口输入 bytes[L] 并按 MSB-first 展开。参数：order 2-64（默认 6）、memory 4-256 MiB（默认 16）。",
+          "outputs": "每 bit 1 条 float64 P(1) 流；字节边界可选 256×float64 分布。",
+          "example": "输入字节A=0x41，对应MSB-first事件0,1,0,0,0,0,0,1。每个事件之前读取模型的P(1)，随后观察该bit；第8次观察后执行ByteUpdate。八个实际概率由固定PPMd状态产生，不用常数概率代替。",
+          "status": "真实来源模型与adapter已完成本轮PPMd/DMC/PAQ共8项有限回归；尚未接入图熵编码边，不能据此声称完整方法测评完成。",
+          "reference_ids": [
+            "O29"
+          ],
+          "source_url": "https://github.com/byronknoll/cmix"
+        },
+        {
+          "id": "A107",
+          "name": "cmix PAQ dmcModel Count Branch（PAQ DMC 计数分支）",
+          "layer": "mechanism",
+          "description": "在 bit 状态图当前节点保存定点 c0、c1；观察 y 后用 x←x·63/64+y·1024 更新计数和有限状态，达到阈值时按访问占比分裂后继节点，随后沿 nx[y] 转移。预测为 (c1+1)·4096/(c0+c1+2)。",
+          "inputs": "与 A106 相同的因果 uint8 bit 观察流或 MSB-first bytes[L]；当前参数固定 extra_nodes=65536、cloning_threshold_fixed_point=1024。",
+          "outputs": "1 条 float64 P(1) 流，由原生 12-bit 整数概率除以 4096；无字节分布流。",
+          "example": "在已给定节点c0=c1=1024时，预测整数概率为(1024+1)×4096/(2048+2)=2048，即P(1)=0.5；接收bit=1后再更新计数并沿nx[1]转移。此例是节点状态计算，不声称为默认初始节点。",
+          "status": "真实来源模型与adapter已完成本轮PPMd/DMC/PAQ共8项有限回归；尚未接入图熵编码边，不能据此声称完整方法测评完成。",
+          "reference_ids": [
+            "O29"
+          ],
+          "source_url": "https://github.com/byronknoll/cmix"
+        },
+        {
+          "id": "A108",
+          "name": "cmix PAQ8 Hybrid Final Predictor（PAQ8 混合最终预测器）",
+          "layer": "mechanism",
+          "description": "运行 PAQ8 Predictor：contextModel2 先汇集上下文模型，再按内容状态经过 APM/APM1 校准与加权，形成 12-bit 最终 pr；每次 observe 把真实 bit 写入全局 y 并执行完整 update，字节完成时同步缓冲区和上下文。",
+          "inputs": "因果 uint8 bit 流或 MSB-first bytes[L]；参数：paq_level 0-3（默认 0），用于选择内存级别。",
+          "outputs": "1 条 float64 P(1) 流，值为原生最终 p()/4096；无压缩字节或额外语义流。",
+          "example": "对输入bits=[0,1]，先取得最终12-bit pr0，再observe(0)更新整套PAQ状态；取pr1后再observe(1)。pr0/pr1是混合和APM校准后的最终输出，不能用某个子模型值替代。",
+          "status": "真实来源模型与adapter已完成本轮PPMd/DMC/PAQ共8项有限回归；尚未接入图熵编码边，不能据此声称完整方法测评完成。",
+          "reference_ids": [
+            "O29"
+          ],
+          "source_url": "https://github.com/byronknoll/cmix"
+        },
+        {
+          "id": "A109",
+          "name": "cmix v21 Full Predictor（cmix v21 完整预测器）",
+          "layer": "mechanism",
+          "description": "完整 Predictor 收集 models、byte_models 与 byte_mixers 的输出，送入分层 mixers；最终经 logistic 与 SSE 校准得到 P(1)，observe 时逐一更新模型、mixer、SSE 和上下文管理器。当前构造使用全 256 字节 vocabulary，不做预处理或预训练。",
+          "inputs": "因果 uint8 bit 流或 MSB-first bytes[L]，vocabulary 固定为全部 256 个字节；参数：allow_large_memory=true 才允许启动，adapter 另有 timeout。",
+          "outputs": "1 条 float64 P(1) 流，由上游 float 转为传输用 binary64；无压缩数据流。",
+          "example": "输入字节00时，依次执行8次predict→处理当前0→observe(0)；各层mixer与SSE在观察后更新。解码端从相同256字节词表及模型初始化开始重放相同8次状态转移。",
+          "status": "来源模型及adapter见源码；可运行性受构建依赖与内存门控约束。本次未执行cmix或验证其图熵编码接入。",
+          "reference_ids": [
+            "O29"
+          ],
+          "source_url": "https://github.com/byronknoll/cmix"
+        },
+        {
+          "id": "A110",
+          "name": "NNCP Transformer Byte Probability (stream1)",
+          "layer": "mechanism",
+          "description": "调用官方NNCP 3.3 Transformer与LibNC得到下一字节的256项softmax概率。先predict，再由匹配的write_sym/read_sym处理当前事件，最后observe以该字节为训练目标执行gradient和model_update；模型状态、初始化及重置在解码端一致。",
+          "inputs": "逐个 uint8 字节事件；必须先 predict，再对当前字节 encode/decode，最后 observe。每会话最多 4096 字节。",
+          "outputs": "float32[256]，按符号0..255排列。transformer-stream1-v1固定batch=1、seg_len=1、seed=123、V=256，保留上游default网络结构；每会话最多4096字节。官方LibNC依赖Linux x86-64，本机通过显式Docker验证。独立NNP1压缩路径有24字节固定头和完整算术码体；未接图熵边或86方法调度。",
+          "example": "以初始previous=0预测首字节t0的256项分布，write_sym/read_sym处理t0后再observe(t0)，调用原模型gradient/update；下一步以已知t0预测t1。重复predict返回同一缓存分布。独立NNCPSymbolSession和NNP1冷解码路径已接入；不把概率向量当作压缩数据。",
+          "status": "真实NNCP独立字节概率接口与配套NNP1冷解码路径已接入；官方LibNC要求Linux x86-64或显式Docker。与图熵编码边、默认NNCP方法评测分开。",
+          "reference_ids": [
+            "O28"
+          ],
+          "source_url": "https://bellard.org/nncp/"
+        }
       ]
     }
   ],
@@ -1862,6 +3132,27 @@
       "kind": "official_specification",
       "source_slide": 3,
       "verification_status": "ppt_note_primary_source"
+    },
+    {
+      "id": "O27",
+      "citation": "Meta Platforms, Inc. “OpenZL.” Official source repository.",
+      "url": "https://github.com/facebook/openzl",
+      "kind": "official_source",
+      "verification_status": "primary_source_verified"
+    },
+    {
+      "id": "O28",
+      "citation": "Fabrice Bellard. “NNCP: Lossless Data Compression with Neural Networks.” Official project page.",
+      "url": "https://bellard.org/nncp/",
+      "kind": "official_source",
+      "verification_status": "primary_source_verified"
+    },
+    {
+      "id": "O29",
+      "citation": "Byron Knoll. “cmix version 21.” Official source repository.",
+      "url": "https://github.com/byronknoll/cmix",
+      "kind": "official_source",
+      "verification_status": "primary_source_verified"
     }
   ],
   "source": {
@@ -2617,6 +3908,53 @@
         ]
       }
     ],
-    "description_note": "Descriptions outline the cited designs and the selected project kernels. Reference sources are from presentation Notes, with an additional official source for BYTE_STREAM_SPLIT."
+    "description_note": "Method references follow presentation Notes (slides 2–3). Operator descriptions follow the final 30-family implementation catalog, preserving source-backed boundaries and reusing presentation citations with additional official sources.",
+    "operator_catalog": {
+      "catalog_version": "operator-implementation-layers-v1",
+      "files": [
+        "docs/operator_102/review_current.json",
+        "benchmark/reference/actions/operator_implementations_layered_v1.json",
+        "docs/operator_102/interface_revision_status.json",
+        "docs/operator_102/source_inputs/comparison_01_05.json",
+        "docs/operator_102/source_inputs/comparison_06_10.json",
+        "docs/operator_102/source_inputs/comparison_11_20.json",
+        "docs/operator_102/source_inputs/comparison_21_30.json",
+        "docs/operator_102/source_inputs/comparison_27_root.json",
+        "docs/operator_102/source_inputs/comparison_28_root.json",
+        "docs/operator_102/source_inputs/comparison_29_30_final.json",
+        "deploy/huggingface-compressionbenchmark/qa/operator_catalog_content.json",
+        "deploy/huggingface-compressionbenchmark/qa/method_catalog_content.json"
+      ],
+      "sha256": {
+        "docs/operator_102/review_current.json": "ac5e403edd361c04b4f0f4d33de3b089456a3f9cc958062704b050ddfc16fcaf",
+        "benchmark/reference/actions/operator_implementations_layered_v1.json": "09e41517b2e8aea04067546aa24f6d0e1dc4e6eef1475339114283a0c9acf252",
+        "docs/operator_102/interface_revision_status.json": "4075f9783b85767fda48c82cfda125a27d3f649529d6ae5ce989924daddc844f",
+        "docs/operator_102/source_inputs/comparison_01_05.json": "78f88580fd1030969a4ff012add30a4f8d751dd7bf0ab1539fc87e48746911ae",
+        "docs/operator_102/source_inputs/comparison_06_10.json": "bfd843823e76fba92a7bfe310ac0b1de64a02642e66bb97b273c74ad0ee5eff9",
+        "docs/operator_102/source_inputs/comparison_11_20.json": "6ccff1fff27f874261fa1f07c1f344c79692705a398e9a49b417cfc9193b8135",
+        "docs/operator_102/source_inputs/comparison_21_30.json": "f1c09afcba5f0c0eb7a183dce94439e53be947c00c66a48268d8ceb1c7fcc4cf",
+        "docs/operator_102/source_inputs/comparison_27_root.json": "6de78e3539cabfd9495cb5d34f5dc3c8df22dcc5a51c8a9007e71857e6d048fd",
+        "docs/operator_102/source_inputs/comparison_28_root.json": "7ab1ac8902d079907d36b14d951b70faf442010946927ecf10423703d99c2165",
+        "docs/operator_102/source_inputs/comparison_29_30_final.json": "4913028f99abcc70e5915053c1603ed65f85fa7450f3a056ad409f845feca7c6",
+        "deploy/huggingface-compressionbenchmark/qa/operator_catalog_content.json": "8ffdeda95b1599cdb3fcb846471cae39a9a51f6fbb4c3c94685b6dfd9bd49b53",
+        "deploy/huggingface-compressionbenchmark/qa/method_catalog_content.json": "5bc289539e6d3298cb4f2b6006c5503b7973f52707cf10219f878c2cabcc33df"
+      },
+      "boundaries": [
+        "A013 is Minimum Frame of Reference only.",
+        "A048 is pure byte-plane split; minimum, scale, and width selection remain outside this mechanism.",
+        "STOP, Concat, and continuous Split are special graph operations and are not counted among the 30 families or 102 entries.",
+        "Complete backends and compatibility adapters are labeled separately from mechanisms.",
+        "A110 has a verified independent NNCP/NNP1 path but is not integrated into the graph entropy edge or default method schedule.",
+        "A111 has an independent three-stream C++ interface; the original fused FastPFor path remains separate."
+      ]
+    }
+  },
+  "operator_summary": {
+    "family_count": 30,
+    "entry_count": 102,
+    "mechanism_count": 67,
+    "configuration_count": 7,
+    "composition_count": 14,
+    "adapter_count": 14
   }
 }