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

{infinity_data-2.2.1/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.1
+Version: 3.1.1
 Summary: InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库
 Author: infinity_system: yin_bailiang
 License: MIT

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

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-data"
-version = "2.2.1"
+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.1 → 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.1 → 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.1 → 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)
@@ -116,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]  # 导入项列表
@@ -126,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
@@ -199,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（自动检测后缀）
@@ -211,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
@@ -428,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()
@@ -442,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:

{infinity_data-2.2.1 → infinity_data-3.1.1}/src/infinity_data/parser/parser.py

@@ -67,6 +67,7 @@ from infinity_data.tokenizer.models.tokens import (
     NewlineToken,
     NoexistToken,
     NullToken,
+    PathToken,
     QuestionToken,
     RangleToken,
     RbraceToken,
@@ -333,12 +334,34 @@ class Parser:
             alias=alias,
         )
 
+    @staticmethod
+    def _expect_import_path(stream: TokenStream, collector: DiagnosticCollector) -> PathToken | SinglelineStringToken:
+        """!file / !from 的路径参数：必须用 ``p"..."`` 路径字面量（§1.5 / §3.2）。
+
+        普通字符串（旧语法）→ ``parse.import_path_required`` 错误，仍容错取用其值继续编译；
+        其他 token → 走 :meth:`expect` 的错误恢复（合成 PathToken）。
+        """
+        tok = stream.peek()
+        if isinstance(tok, PathToken):
+            return stream.expect(PathToken)
+        if isinstance(tok, SinglelineStringToken):
+            collector.add(diag('parse.import_path_required', {}, tok.raw.source))
+            return stream.expect(SinglelineStringToken)
+        return stream.expect(PathToken)
+
+    @staticmethod
+    def _import_path_str(path_tok: PathToken | SinglelineStringToken) -> str:
+        """导入路径参数 → 语言内 POSIX 字符串（PathToken 取 as_posix）。"""
+        if isinstance(path_tok, PathToken):
+            return path_tok.value.as_posix()
+        return path_tok.value
+
     @staticmethod
     def _parse_file_import(
         stream: TokenStream, collector: DiagnosticCollector, kw_tok: FileImportToken
     ) -> FileImportStmt:
-        """!file "path" [as <format>] import .path.to.key as alias, ..."""
-        path_tok = stream.expect(SinglelineStringToken)
+        """!file p"path" [as <format>] import .path.to.key as alias, ..."""
+        path_tok = Parser._expect_import_path(stream, collector)
 
         # 可选 as <format>
         fmt = None
@@ -380,7 +403,7 @@ class Parser:
         # 注意：不在此消费尾部换行（语句间分隔由 _parse_statement 统一处理）
         return FileImportStmt(
             source=stream.span_from(kw_tok),
-            file_path=path_tok.value,
+            file_path=Parser._import_path_str(path_tok),
             format=fmt,
             imports=items,
         )
@@ -521,8 +544,8 @@ class Parser:
     def _parse_template_import(
         stream: TokenStream, collector: DiagnosticCollector, kw_tok: FromImportToken
     ) -> TemplateImportStmt:
-        """!from "path" import Name1 [as Alias1], Name2, ..."""
-        path_tok = stream.expect(SinglelineStringToken)
+        """!from p"path" import Name1 [as Alias1], Name2, ..."""
+        path_tok = Parser._expect_import_path(stream, collector)
         Parser._expect_keyword(stream, collector, 'import')
 
         # 导入项列表（项之间必须用逗号分隔）
@@ -545,7 +568,7 @@ class Parser:
         # 注意：不在此消费尾部换行（语句间分隔由 _parse_statement 统一处理）
         return TemplateImportStmt(
             source=stream.span_from(kw_tok),
-            from_path=path_tok.value,
+            from_path=Parser._import_path_str(path_tok),
             items=items,
         )
 
@@ -842,6 +865,7 @@ class Parser:
                 BoolToken,
                 NullToken,
                 NoexistToken,
+                PathToken,
                 LbraceToken,
                 LbracketToken,
                 IdentifierToken,
@@ -856,7 +880,7 @@ class Parser:
             return False
         return isinstance(
             tok,
-            (IdentifierToken, QuestionToken, StringToken, IntegerToken, FloatToken, BoolToken, NullToken),
+            (IdentifierToken, QuestionToken, StringToken, IntegerToken, FloatToken, BoolToken, NullToken, PathToken),
         )
 
     # ═══════════════════════════════════════════════════════
@@ -1039,7 +1063,7 @@ class Parser:
                 stream.advance()
                 return ConstraintIdent(source=tok.raw.source, name='?')
 
-            case StringToken() | IntegerToken() | FloatToken() | BoolToken() | NullToken():
+            case StringToken() | IntegerToken() | FloatToken() | BoolToken() | NullToken() | PathToken():
                 base = Parser._parse_constraint_literal(stream)
 
             case _:
@@ -1122,7 +1146,15 @@ class Parser:
                 return Parser._parse_dollar_value(stream, collector)
 
             # ── 字面量（FloatToken 覆盖所有浮点值，含 NaN / ±Inf）──
-            case StringToken() | IntegerToken() | FloatToken() | BoolToken() | NullToken() | NoexistToken() as tok:
+            case (
+                StringToken()
+                | IntegerToken()
+                | FloatToken()
+                | BoolToken()
+                | NullToken()
+                | NoexistToken()
+                | PathToken() as tok
+            ):
                 stream.advance()
                 return Parser._wrap_literal(tok)
 
@@ -1176,7 +1208,7 @@ class Parser:
             cast_tok = stream.peek()
             if isinstance(cast_tok, IdentifierToken):
                 name = cast_tok.name
-                if name in ('int', 'float', 'bool', 'str'):
+                if name in ('int', 'float', 'bool', 'str', 'path'):
                     type_cast = name
                 else:
                     collector.add(diag('parse.invalid_cast', {'type': name}, cast_tok.raw.source))

{infinity_data-2.2.1 → infinity_data-3.1.1}/src/infinity_data/pipeline.py

@@ -18,9 +18,8 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field, replace
 from functools import cached_property
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
-from infinity_data.emit import reduce_object
 from infinity_data.frontend import parse_source
 from infinity_data.infra.diagnostics import Diagnostic, DiagnosticCollector, Severity
 from infinity_data.infra.file import DiskFile, File, MemFile
@@ -29,6 +28,7 @@ from infinity_data.semantic.builder import AstBuilder, StdDocument
 from infinity_data.semantic.executor import ConstraintExecutor
 from infinity_data.semantic.registry import ConstraintRegistry
 from infinity_data.semantic.resolver import ImportResolver, TemplateGraphResolver
+from infinity_data.semantic.std import std_to_python
 
 
 @dataclass(frozen=True)
@@ -60,8 +60,10 @@ class CompilationResult:
     """一次编译的完整产物（根产物 + 诊断）。
 
     - ``document``：:class:`StdDocument`（纯数据：root / templates / scope；诊断见 ``diagnostics``）
-    - ``root`` / ``value``：由 ``document`` 派生（惰性）——降维属 emit 层职责，
-      编译阶段不急于产出，访问时经 :mod:`infinity_data.emit` 计算
+    - ``root`` / ``value``：由 ``document`` 派生（惰性）——value 经
+      :func:`~infinity_data.semantic.std.std_to_python` **忠实**转换
+      （path → :class:`PurePosixPath`、float → :class:`decimal.Decimal`，语义最小丢失）；
+      有损输出投影（path → 字符串等）属 emit 层职责，不在本层发生
     """
 
     document: StdDocument
@@ -69,8 +71,12 @@ class CompilationResult:
 
     @cached_property
     def value(self) -> dict[str, Any]:
-        """降维后的纯 Python dict（惰性，由 emit 层负责；尽力而为）。"""
-        return reduce_object(self.document.root)
+        """忠实 std → Python（path 保持 PurePosixPath；惰性计算）。
+
+        ``noexist`` 显式丢弃（``keep_noexist=False``）：转换层本身默认无损（§1.6
+        三态经 NOEXIST 哨兵保留），而这里是**输出投影**，兑现「noexist 键不出现」。
+        """
+        return cast(dict[str, Any], std_to_python(self.document.root, keep_noexist=False))
 
     @property
     def has_errors(self) -> bool:
@@ -129,6 +135,7 @@ def _compile(file: File, options: CompileOptions) -> CompilationResult:
             registry=resolver.registry,
             templates=std.templates,
             template_scopes=context.template_scopes,
+            sandbox=sandbox_impl,
         )
         executor.validate(std.root, collector)
         if resolver.schema is not None:

{infinity_data-2.2.1 → infinity_data-3.1.1}/src/infinity_data/sandbox/mediator.py

@@ -193,6 +193,20 @@ class Sandbox:
         """!from 目标：路径解析 + allow_templates 授权 → File。"""
         return self._open(from_path, self._config.allow_templates, '模板导入', base_dir, source)
 
+    def probe_path(self, from_path: str, *, base_dir: Path | None = None) -> Path | None:
+        """构建期路径探测：路径解析 + allow_files 授权 → 原生 Path；未授权 → None。
+
+        供文件系统约束（``exist`` / ``dir`` / ``file`` / ``link``）使用——与导入同属
+        当前机器文件系统状态；相对路径以 ``base_dir``（默认编译入口目录）解析。
+        """
+        base = base_dir if base_dir is not None else self._base_dir
+        path = posix_to_native(from_path)  # 语言内 POSIX → 当前平台原生（/c/... → C:\...）
+        if not path.is_absolute():
+            path = base / path
+        if not match_globs(path, self._config.allow_files, self._base_dir):
+            return None
+        return path
+
     def _open(
         self,
         from_path: str,