infinity-data 2.2.0__tar.gz → 3.1.1__tar.gz

{infinity_data-2.2.0/src/infinity_data.egg-info → infinity_data-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infinity-data
-Version: 2.2.0
+Version: 3.1.1
 Summary: InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库
 Author: infinity_system: yin_bailiang
 License: MIT

{infinity_data-2.2.0 → infinity_data-3.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-data"
-version = "2.2.0"
+version = "3.1.1"
 description = "InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库"
 readme = "README.md"
 license = { text = "MIT" }
@@ -95,6 +95,6 @@ venvPath = "."
 venv = ".venv"
 
 [tool.interrogate]
-fail-under = 70
+fail-under = 60
 # 测试函数名自解释，docstring 可选；产品代码（src）不豁免
 ignore-regex = ["^test_"]

infinity_data-3.1.1/src/infinity_data/emit/__init__.py

@@ -0,0 +1,35 @@
+"""产物发射层：Python / std → 输出格式（JSON / YAML / TOML）。
+
+与 semantic 层边界：
+- **内部表示（忠实双向）** → :mod:`infinity_data.semantic.std` 的
+  ``python_to_std`` / ``std_to_python``（path → PurePosixPath、float → Decimal、
+  noexist → :data:`~infinity_data.semantic.std.NOEXIST` 哨兵）
+- **本层（emit，有损投影）** → :func:`to_json` / :func:`to_yaml` / :func:`to_toml`，
+  按 :class:`EmitConfig` 控制 Decimal 编码与 noexist 标记；:func:`project_output`
+  为纯 Python 值的轻量投影；:func:`restore_python` 反向**尝试还原**加载的原始
+  dict 为 :data:`~infinity_data.semantic.std.StdPythonValue`
+
+**emit 不应被流水线内部使用**——内部表示一律走 semantic 的忠实转换。
+"""
+
+from infinity_data.emit.config import EmitConfig
+from infinity_data.emit.converter import (
+    dump_to_json,
+    load_from_json,
+    project_output,
+    restore_python,
+    to_json,
+    to_toml,
+    to_yaml,
+)
+
+__all__ = [
+    'EmitConfig',
+    'dump_to_json',
+    'load_from_json',
+    'project_output',
+    'restore_python',
+    'to_json',
+    'to_toml',
+    'to_yaml',
+]

infinity_data-3.1.1/src/infinity_data/emit/config.py

@@ -0,0 +1,37 @@
+"""输出转换配置（emit 层）：控制 std/python → 输出格式的有损投影语义。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+__all__ = ['EmitConfig']
+
+
+@dataclass(frozen=True)
+class EmitConfig:
+    """emit 层输出转换配置。
+
+    转换语义：
+    - ``full_float``：``float`` 值（:class:`decimal.Decimal`）以自描述标记
+      ``{"__type__": "decimal", "num": "<十进制字符串>"}`` 编码（无损）；False 时
+      有限值转普通 JSON 数字，NaN / ±Infinity 无法用 JSON 数字表达 → 仍以标记编码
+    - ``full_path``：路径值（:class:`PurePosixPath`）以自描述标记
+      ``{"__type__": "path", "path": "<POSIX 字符串>"}`` 编码（可辨识「这是路径」）；
+      False 时投影为普通 POSIX 字符串
+    - ``keep_noexist``：``noexist`` 字段保留为 ``{"__type__": "noexist"}`` 标记
+      （依赖 :data:`~infinity_data.semantic.std.NOEXIST` 哨兵保留三态）；默认丢弃
+      （键不出现，§1.6）
+
+    序列化选项：
+    - ``indent`` / ``sort_keys`` / ``ensure_ascii``：JSON 缩进 / 排序 / ASCII 转义
+    """
+
+    # ── 转换语义 ──────────────────────────────────────
+    full_float: bool = False
+    full_path: bool = False
+    keep_noexist: bool = False
+
+    # ── 序列化选项 ────────────────────────────────────
+    indent: int | None = 2
+    sort_keys: bool = False
+    ensure_ascii: bool = False

infinity_data-3.1.1/src/infinity_data/emit/converter.py

@@ -0,0 +1,258 @@
+"""产物发射层：Python / std → 输出格式（JSON / YAML / TOML）。
+
+职责边界（与 semantic 层严格分离）：
+
+- **内部表示**（忠实双向，语义最小丢失）：:func:`~infinity_data.semantic.std.python_to_std`
+  与 :func:`~infinity_data.semantic.std.std_to_python`——path 保持
+  :class:`PurePosixPath`、float 保持 :class:`decimal.Decimal`、noexist 经
+  :data:`~infinity_data.semantic.std.NOEXIST` 哨兵保留三态。
+  流水线内部（如 :class:`~infinity_data.pipeline.CompilationResult.value`）一律走该层。
+- **本层（emit）**：做**有损投影**供输出格式消费，无需担心完整性——
+  path → POSIX 字符串；Decimal 的 NaN / ±Infinity 等特殊编码由本层按
+  :class:`EmitConfig` 决定（``full_float`` 标记编码）。
+
+入口：
+- :func:`to_json` / :func:`to_yaml` / :func:`to_toml`：输出文本（接受 std 或 Python 值）
+- :func:`project_output`：纯 Python 值的轻量有损投影（path → 字符串）
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+from decimal import Decimal, InvalidOperation
+from pathlib import PurePath, PurePosixPath
+from typing import Any, cast
+
+from infinity_data.emit.config import EmitConfig
+from infinity_data.semantic.std import NOEXIST, StdPythonValue, is_std_value, std_to_python
+
+__all__ = [
+    'dump_to_json',
+    'load_from_json',
+    'project_output',
+    'restore_python',
+    'to_json',
+    'to_yaml',
+    'to_toml',
+]
+
+# ── 自描述标记（输出格式无法原生表达的值的编码） ──────
+
+
+def _decimal_marker(dec: Any) -> dict[str, str]:
+    """Decimal 自描述标记：``{"__type__": "decimal", "num": "<十进制字符串>"}``。"""
+    return {'__type__': 'decimal', 'num': str(dec)}
+
+
+def _path_marker(s: str) -> dict[str, str]:
+    """路径自描述标记：``{"__type__": "path", "path": "<POSIX 字符串>"}``。"""
+    return {'__type__': 'path', 'path': s}
+
+
+def _noexist_marker() -> dict[str, str]:
+    """noexist 自描述标记：``{"__type__": "noexist"}``。"""
+    return {'__type__': 'noexist'}
+
+
+# ── 标记还原（反向：加载的原始 dict → StdPythonValue） ────
+
+
+def _restore_marker(value: dict[Any, Any]) -> Any | None:
+    """若 dict 是 emit 自描述标记则还原为 Python 值，否则 None（非标记）。
+
+    仅识别 emit 层产出的**精确标记形状**；结构不符（额外键 / 负载非字符串 /
+    数值无法解析）一律视为普通 dict（返回 None，尽力而为）。
+    """
+    typ = value.get('__type__')
+    if typ == 'decimal':
+        if set(value) == {'__type__', 'num'} and isinstance(value.get('num'), str):
+            try:
+                return Decimal(value['num'])
+            except (InvalidOperation, ValueError, TypeError):
+                return None
+        return None
+    if typ == 'path':
+        if set(value) == {'__type__', 'path'} and isinstance(value.get('path'), str):
+            return PurePosixPath(value['path'])
+        return None
+    if typ == 'noexist':
+        if set(value) == {'__type__'}:
+            return NOEXIST
+        return None
+    return None
+
+
+def restore_python(value: Any) -> StdPythonValue:
+    """从加载的原始 dict（含可选 emit 自描述标记）**尝试**还原为 StdPythonValue。
+
+    - ``{"__type__": "decimal", "num": "..."}`` → :class:`decimal.Decimal`
+    - ``{"__type__": "path", "path": "..."}`` → :class:`PurePosixPath`
+    - ``{"__type__": "noexist"}`` → :data:`NOEXIST`
+    - 普通 ``float`` → :class:`decimal.Decimal`（忠实形式，与
+      :func:`~infinity_data.semantic.std.python_to_std` 规范一致）
+    - int / bool / str / None 原样；dict / list 递归
+    - 识别不了的形状（含疑似标记但结构不符）按普通 dict / list 保留（尽力而为）
+
+    配合 :func:`to_json` 等 + ``EmitConfig(full_float=True, full_path=True,
+    keep_noexist=True)`` 可实现「std → 输出文本 → 加载 → StdPythonValue」
+    无损闭环（再经 :func:`~infinity_data.semantic.std.python_to_std` 回 std）。
+    """
+    if isinstance(value, dict):
+        obj = cast(dict[Any, Any], value)
+        marker = _restore_marker(obj)
+        if marker is not None:
+            return marker
+        return {str(k): restore_python(v) for k, v in obj.items()}
+    if isinstance(value, list):
+        arr = cast(list[Any], value)
+        return [restore_python(v) for v in arr]
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return Decimal(str(value))
+    return value
+
+
+# ── 序列化核心 ──────────────────────────────────────
+
+
+def _to_serializable(value: Any, config: EmitConfig) -> Any:
+    """std 或 Python 值 → 可序列化结构（按 config 做有损投影）。"""
+    if is_std_value(value):
+        # std 输入：忠实转 Python（noexist 按需保留为 NOEXIST 哨兵），再投影
+        py = std_to_python(value, keep_noexist=config.keep_noexist)
+        return _serializable(py, config)
+    # Python 输入（如 CompilationResult.value）：直接投影
+    return _serializable(value, config)
+
+
+def _serializable(value: Any, config: EmitConfig) -> Any:
+    """Python 值 → 可序列化结构（递归有损投影）。
+
+    - :data:`NOEXIST` 哨兵 → ``{"__type__": "noexist"}``
+    - :class:`PurePath` → POSIX 字符串
+    - :class:`decimal.Decimal` → 按 ``full_float`` 编码（有限值默认 JSON 数字）
+    - dict / list 递归；其余（int / bool / str / None 等）原样
+    """
+    if value is NOEXIST:
+        return _noexist_marker()
+    if isinstance(value, PurePath):
+        s = value.as_posix()
+        return _path_marker(s) if config.full_path else s
+    if isinstance(value, dict):
+        obj = cast(dict[Any, Any], value)
+        return {k: _serializable(v, config) for k, v in obj.items()}
+    if isinstance(value, list):
+        arr = cast(list[Any], value)
+        return [_serializable(v, config) for v in arr]
+    if isinstance(value, Decimal):
+        return _decimal_serializable(value, config)
+    return value
+
+
+def _decimal_serializable(dec: Any, config: EmitConfig) -> Any:
+    """Decimal → 可序列化形式。
+
+    - ``full_float`` → 自描述标记（无损）
+    - 否则：有限值 → JSON 数字（整值转 int，避免 ``1.0``；溢出回退标记）；
+      NaN / ±Infinity 无法用 JSON 数字表达 → 自描述标记
+    """
+    if config.full_float:
+        return _decimal_marker(dec)
+    if dec.is_nan() or dec.is_infinite():
+        return _decimal_marker(dec)
+    try:
+        if dec == dec.to_integral_value():
+            return int(dec)
+        return float(dec)
+    except (OverflowError, ValueError):
+        return _decimal_marker(dec)
+
+
+# ── 输出入口 ────────────────────────────────────────
+
+
+def to_json(value: Any, *, config: EmitConfig | None = None) -> str:
+    """std 或 Python 值 → JSON 文本。
+
+    ``value`` 可为 :class:`~infinity_data.semantic.std.StdValue`（如
+    ``CompilationResult.document.root``，支持完整选项）或 Python 值
+    （如 ``CompilationResult.value``，noexist 信息已在转换时丢失）。
+    """
+    cfg = config or EmitConfig()
+    data = _to_serializable(value, cfg)
+    return json.dumps(data, indent=cfg.indent, sort_keys=cfg.sort_keys, ensure_ascii=cfg.ensure_ascii)
+
+
+def to_yaml(value: Any, *, config: EmitConfig | None = None) -> str:
+    """std 或 Python 值 → YAML 文本（需安装 PyYAML）。"""
+    cfg = config or EmitConfig()
+    data = _to_serializable(value, cfg)
+    try:
+        yaml = importlib.import_module('yaml')
+    except ImportError as exc:  # pragma: no cover - 依赖缺失路径
+        raise ImportError('to_yaml 需要 PyYAML（pip install pyyaml）') from exc
+    return yaml.safe_dump(data, allow_unicode=not cfg.ensure_ascii, sort_keys=cfg.sort_keys)
+
+
+def to_toml(value: Any, *, config: EmitConfig | None = None) -> str:
+    """std 或 Python 值 → TOML 文本（需安装 tomli-w）。"""
+    cfg = config or EmitConfig()
+    data = _to_serializable(value, cfg)
+    try:
+        tomli_w = importlib.import_module('tomli_w')
+    except ImportError as exc:  # pragma: no cover - 依赖缺失路径
+        raise NotImplementedError('to_toml 需要 tomli-w（pip install tomli-w）；当前未安装') from exc
+    return tomli_w.dumps(data)
+
+
+# ── 便捷自由函数（默认尝试保留一切语义） ────────────
+
+
+def dump_to_json(value: Any, *, config: EmitConfig | None = None) -> str:
+    """std / Python 值 → JSON 文本（便捷入口，**默认保留一切语义**）。
+
+    默认等价 ``EmitConfig(full_float=True, full_path=True, keep_noexist=True)``——
+    Decimal / PurePosixPath / noexist 以 ``{"__type__": ...}`` 标记编码；
+    传入 ``config`` 可覆盖（关闭标记、改缩进等，见 :class:`EmitConfig`）。
+
+    与 :func:`load_from_json` 配对可实现「std → JSON → StdPythonValue」无损闭环。
+    """
+    cfg = config or EmitConfig(full_float=True, full_path=True, keep_noexist=True)
+    return to_json(value, config=cfg)
+
+
+def load_from_json(text: str) -> StdPythonValue:
+    """JSON 文本 → StdPythonValue（便捷入口，**默认尝试还原全部语义**）。
+
+    解析后经 :func:`restore_python`：``{"__type__": ...}`` 标记还原为
+    Decimal / PurePosixPath / NOEXIST，普通 float 归一到 Decimal；
+    识别不了的形状原样保留（尽力而为）。
+    """
+    return restore_python(json.loads(text))
+
+
+# ── 轻量有损投影（纯 Python 值） ─────────────────────
+
+
+def project_output(value: Any) -> Any:
+    """Python 值 → 输出友好投影（递归，有损，无配置）。
+
+    - :class:`PurePath`（含 :class:`PurePosixPath`）→ POSIX 字符串
+    - dict / list 递归投影；其余（int / Decimal / bool / str / None 等）原样保留
+
+    完整选项（Decimal 编码 / noexist 标记）请用 :func:`to_json` 等带
+    :class:`EmitConfig` 的入口。
+    """
+    if isinstance(value, PurePath):
+        return value.as_posix()
+    if isinstance(value, dict):
+        obj = cast(dict[Any, Any], value)
+        return {k: project_output(v) for k, v in obj.items()}
+    if isinstance(value, list):
+        arr = cast(list[Any], value)
+        return [project_output(v) for v in arr]
+    return value

{infinity_data-2.2.0 → infinity_data-3.1.1}/src/infinity_data/infra/path.py

@@ -14,7 +14,23 @@ from __future__ import annotations
 import sys
 from pathlib import Path, PurePosixPath, PureWindowsPath
 
-__all__ = ['posix_to_native', 'native_to_posix']
+__all__ = ['posix_to_native', 'native_to_posix', 'is_valid_posix_path']
+
+
+def is_valid_posix_path(s: str) -> bool:
+    """语言内 POSIX 路径合法性（纯语法校验，无文件系统访问）。
+
+    - 非空
+    - 无 NUL 字符（:class:`PurePosixPath` 拒绝）
+    - 可被 :class:`PurePosixPath` 解析
+    """
+    if not s or '\x00' in s:
+        return False
+    try:
+        PurePosixPath(s)
+        return True
+    except ValueError:
+        return False
 
 
 def posix_to_native(path: str, *, platform: str | None = None) -> Path:

{infinity_data-2.2.0 → infinity_data-3.1.1}/src/infinity_data/parser/__init__.py

@@ -34,6 +34,7 @@ from infinity_data.parser.models import (
     JsonPathKey,
     JsonPathSegment,
     LiteralValue,
+    NamedArg,
     Statement,
     TemplateCallValue,
     TemplateConfig,
@@ -72,6 +73,7 @@ __all__ = [
     'JsonPathKey',
     'JsonPathSegment',
     'LiteralValue',
+    'NamedArg',
     'Parser',
     'Statement',
     'TemplateCallValue',

{infinity_data-2.2.0 → infinity_data-3.1.1}/src/infinity_data/parser/diagnostics.py

@@ -63,6 +63,11 @@ register_diagnostic_define(
         '[{location}] 导入语句必须以换行结尾（同一行逗号后不能再接其他语句）',
         en='[{location}] import statement must end with a newline (cannot be followed by more tokens on the same line)',
     ),
+    diagnostic_define(
+        'parse.import_path_required',
+        '[{location}] 导入路径必须用 p"..." 路径字面量（§1.5 / §3.2），已按字符串容错取用',
+        en='[{location}] import path must use a p"..." path literal (§1.5 / §3.2); recovered as string',
+    ),
     diagnostic_define(
         'parse.value_field',
         '[{location}] 值位置出现字段定义 {name}（外层数组/对象未闭合）',

{infinity_data-2.2.0 → infinity_data-3.1.1}/src/infinity_data/parser/models.py

@@ -14,6 +14,7 @@ from infinity_data.tokenizer.models.tokens import (
     IntegerToken,
     NoexistToken,
     NullToken,
+    PathToken,
     StringToken,
 )
 
@@ -27,6 +28,11 @@ def _canonical_str(s: str) -> str:
     return json.dumps(s, ensure_ascii=False)
 
 
+def _canonical_path(s: str) -> str:
+    """路径 → 标准 infd 路径字面量（``p"..."``，§1.5）。"""
+    return 'p' + json.dumps(s, ensure_ascii=False)
+
+
 def _canonical_constraint_list(constraints: Iterable['Constraint']) -> str:
     """约束列表 → infd 类型标注：单约束省略尖括号，多约束 ``<a, b>``。"""
     items = list(constraints)
@@ -37,6 +43,16 @@ def _canonical_constraint_list(constraints: Iterable['Constraint']) -> str:
     return '<' + ', '.join(c.canonical() for c in items) + '>'
 
 
+def _canonical_error(message: str) -> str:
+    """错误节点容错序列化：``error("...")`` 占位符。
+
+    错误节点是**解析失败恢复**的产物，对应的源码本就无效，无法还原为等价 AST——
+    canonical 仅作**容错**（模板真名哈希 / 调试 / LSP 提示不因错误节点崩溃），
+    不承诺 round-trip（``error(...)`` 是显示占位符，不是可解析的模板调用语法）。
+    """
+    return f'error({_canonical_str(message)})'
+
+
 # ═══════════════════════════════════════════════════════════
 # 节点
 # ═══════════════════════════════════════════════════════════
@@ -106,7 +122,7 @@ class TemplateImportItem(AstNode):
 
 @dataclass
 class TemplateImportStmt(AstNode):
-    """模板导入: !from "path" import Name1, Name2 as N2"""
+    """模板导入: !from p"path" import Name1, Name2 as N2"""
 
     from_path: str  # 文件路径（unix 风格）
     items: list[TemplateImportItem]  # 导入项列表
@@ -116,7 +132,7 @@ class TemplateImportStmt(AstNode):
 
     def canonical(self) -> str:
         items = ', '.join(i.canonical() for i in self.items)
-        return f'!from {_canonical_str(self.from_path)} import {items}'
+        return f'!from {_canonical_path(self.from_path)} import {items}'
 
 
 @dataclass
@@ -189,7 +205,7 @@ class FileImportItem(AstNode):
 
 @dataclass
 class FileImportStmt(AstNode):
-    """配置文件导入: !file "path" as <format> import .path.to.key as alias, ..."""
+    """配置文件导入: !file p"path" as <format> import .path.to.key as alias, ..."""
 
     file_path: str  # 文件路径
     format: str | None  # 文件格式: "yaml", "json", "toml", "raw" 或 None（自动检测后缀）
@@ -201,7 +217,7 @@ class FileImportStmt(AstNode):
     def canonical(self) -> str:
         fmt = f' as {self.format}' if self.format else ''
         items = ', '.join(i.canonical() for i in self.imports)
-        return f'!file {_canonical_str(self.file_path)}{fmt} import {items}'
+        return f'!file {_canonical_path(self.file_path)}{fmt} import {items}'
 
 
 @dataclass
@@ -418,7 +434,7 @@ class Constraints(AstNode):
 class LiteralValue(AstNode):
     """字面量值"""
 
-    value: FloatToken | IntegerToken | BoolToken | NullToken | NoexistToken | StringToken
+    value: FloatToken | IntegerToken | BoolToken | NullToken | NoexistToken | StringToken | PathToken
 
     def canonical(self) -> str:
         return self.value.canonical()
@@ -432,7 +448,7 @@ class DollarValue(AstNode):
     """
 
     name: str  # 变量名
-    type_cast: Literal['int', 'float', 'bool', 'str', None]  # 可选类型转换
+    type_cast: Literal['int', 'float', 'bool', 'str', 'path', None]  # 可选类型转换
 
     def canonical(self) -> str:
         if self.type_cast is None:
@@ -457,24 +473,41 @@ class UnpackValue(AstNode):
         return ('**' if self.double else '*') + self.value.canonical()
 
 
+@dataclass
+class NamedArg(AstNode):
+    """模板调用命名参数槽: name = value。
+
+    与 ``**expr`` 解包项（:class:`UnpackValue`）在 :attr:`TemplateCallValue.named_args`
+    中按**源码顺序**混排——键冲突「保留先到者」（disjoint merge，§2.7）与书写顺序一致。
+    """
+
+    name: str
+    value: Value
+
+    def children(self) -> Iterable[AstNode]:
+        return [self.value]
+
+    def canonical(self) -> str:
+        return f'{self.name} = {self.value.canonical()}'
+
+
 @dataclass
 class DictValue(AstNode):
     """对象值: { ... }
 
     ``: <constraint, ...>`` 结构级约束作用于该字面量 dict 的整体。
-    ``unpacks``：``**expr`` 解包项（展开为键值对后并入字段集）。
+    ``items``：字段（:class:`Field`）与 ``**expr`` 解包项（:class:`UnpackValue`）按
+    **源码顺序**混排——键冲突「保留先到者」（disjoint merge，§2.7）与书写顺序一致。
     """
 
-    fields: list[Field]
+    items: list[Field | UnpackValue]
     constraints: list[Constraint] = field(default_factory=lambda: [])
-    unpacks: list[UnpackValue] = field(default_factory=lambda: [])
 
     def children(self) -> Iterable[AstNode]:
-        return [*self.fields, *self.constraints, *self.unpacks]
+        return [*self.items, *self.constraints]
 
     def canonical(self) -> str:
-        inner: list[str] = [f.canonical() for f in self.fields]
-        inner.extend(u.canonical() for u in self.unpacks)
+        inner: list[str] = [i.canonical() for i in self.items]
         cs = _canonical_constraint_list(self.constraints)
         if cs:
             inner.append(': ' + cs)
@@ -501,18 +534,21 @@ class TemplateCallValue(AstNode):
     展开（§2.8）：参数值后缀 ``...`` = 展开轴；调用级（``)`` 后）``...`` = 展开传播
     （本调用的展开结果作为包围模板调用的轴，整体模式逐元素重复）、``^`` = 笛卡尔积
     （多轴全组合，首轴最慢变化；与 ``propagate`` 正交，``^...`` 可叠加）。
-    - ``axis_positional``：位置参数中带 ``...`` 的索引
-    - ``axis_named``：命名参数中带 ``...`` 的键
-    - ``axis_unpack_kwargs``：``**expr`` 解包参数中带 ``...`` 的索引
+    - ``positional_args``：位置参数槽，**保持源码顺序**；``*expr`` 解包项
+      （:class:`UnpackValue`，double=False）也在其中，实例化时展开为多个位置参数（§2.7）
+    - ``named_args``：命名参数槽，**保持源码顺序**；显式 ``name = value``（:class:`NamedArg`）
+      与 ``**expr`` 解包项（:class:`UnpackValue`，double=True）混排——键冲突「保留先到者」
+      与书写顺序一致（§2.7 disjoint merge）
+    - ``axis_positional``：位置参数槽中带 ``...`` 的索引（``*expr`` 解包项不是轴）
+    - ``axis_named``：命名参数（:class:`NamedArg`）中带 ``...`` 的键
+    - ``axis_unpack_kwargs``：``**expr`` 解包项（named_args 槽索引）中带 ``...`` 的索引
     - ``propagate``：调用级 ``...``（展开传播；无 = 展开止于本调用）
     - ``cartesian``：调用级 ``^``（笛卡尔积展开；无 = zip 配对）
     """
 
     template_name: str
-    positional_args: list[Value]
-    named_args: dict[str, Value]
-    unpack_args: list[UnpackValue] = field(default_factory=lambda: [])  # *expr（list → 位置参数）
-    unpack_kwargs: list[UnpackValue] = field(default_factory=lambda: [])  # **expr（dict → 命名参数）
+    positional_args: list[Value | UnpackValue]
+    named_args: list[NamedArg | UnpackValue]
     axis_positional: frozenset[int] = field(default_factory=frozenset[int])
     axis_named: frozenset[str] = field(default_factory=frozenset[str])
     axis_unpack_kwargs: frozenset[int] = field(default_factory=frozenset[int])
@@ -522,27 +558,22 @@ class TemplateCallValue(AstNode):
     def children(self) -> Iterable[AstNode]:
         return [
             *self.positional_args,
-            *self.named_args.values(),
-            *self.unpack_args,
-            *self.unpack_kwargs,
+            *self.named_args,
         ]
 
     def canonical(self) -> str:
         args: list[str] = []
         for i, a in enumerate(self.positional_args):
             s = a.canonical()
-            if i in self.axis_positional:
-                s += '...'
-            args.append(s)
-        args.extend(u.canonical() for u in self.unpack_args)
-        for k, v in sorted(self.named_args.items()):
-            s = f'{k} = {v.canonical()}'
-            if k in self.axis_named:
+            if not isinstance(a, UnpackValue) and i in self.axis_positional:
                 s += '...'
             args.append(s)
-        for j, u in enumerate(self.unpack_kwargs):
-            s = u.canonical()
-            if j in self.axis_unpack_kwargs:
+        for i, n in enumerate(self.named_args):
+            s = n.canonical()
+            if isinstance(n, UnpackValue):
+                if i in self.axis_unpack_kwargs:
+                    s += '...'
+            elif n.name in self.axis_named:
                 s += '...'
             args.append(s)
         out = f'{self.template_name}({", ".join(args)})'
@@ -560,32 +591,41 @@ class TemplateCallValue(AstNode):
 
 @dataclass
 class ErrorStatement(AstNode):
-    """解析失败的语句。用于错误恢复。"""
+    """解析失败的语句。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 @dataclass
 class ErrorValue(AstNode):
-    """解析失败的值。用于错误恢复。"""
+    """解析失败的值。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 @dataclass
 class ErrorConstraint(AstNode):
-    """解析失败的约束。用于错误恢复。"""
+    """解析失败的约束。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 # ═══════════════════════════════════════════════════════════