behavior-contracts 0.2.0__tar.gz → 0.2.2__tar.gz

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behavior-contracts
-Version: 0.2.0
+Version: 0.2.2
 Summary: Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies.
 Author: foo-log
 License: MIT
@@ -60,12 +60,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (164 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
+python -m behavior_contracts.conformance      # → "164 passed, 0 failed / 164 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/README.md

@@ -48,12 +48,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (164 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
+python -m behavior_contracts.conformance      # → "164 passed, 0 failed / 164 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "behavior-contracts"
-version = "0.2.0"
+version = "0.2.2"
 description = "Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies."
 readme = "README.md"
 requires-python = ">=3.9"

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/src/behavior_contracts/__init__.py

@@ -70,9 +70,11 @@ from .envelope import (  # noqa: E402
 # ── guard（Portability Guard） ────────────────────────────────────────────────
 from .guard import (  # noqa: E402
     PORTABLE_EXPR_OPERATORS,
+    PORTABLE_SCALAR_TYPES,
     PortabilityError,
     assert_portable,
     assert_portable_component_graph,
+    assert_portable_type_notation,
 )
 
 # ── behavior（component-graph IR + run_behavior） ──────────────────────────────
@@ -93,6 +95,20 @@ from .fingerprint import (  # noqa: E402
     fingerprint_component_graph,
 )
 
+# ── codegen primitive surface（bc#36 / typed-codegen.md §3.4）──────────────────
+# 生成コードが直呼びできる安定 primitive 公開面。式演算子は個別関数として ``primitives``
+# サブモジュール（``behavior_contracts.primitives``）で公開する。意味論は SSoT
+# ``evaluate_expression`` へ委譲する薄いラッパ（再実装しない）。bounded 並行 /
+# skip・unproduced / hydration helper も top-level に公開する。
+from . import primitives  # noqa: E402
+from .primitives import (  # noqa: E402
+    hydrate_into,
+    map_with_concurrency,
+    skip_connection,
+    skip_single,
+    unproduced_value,
+)
+
 __all__ = [
     "SPEC_VERSIONS",
     "ENVELOPE_SPEC_VERSION",
@@ -121,7 +137,9 @@ __all__ = [
     # guard
     "assert_portable",
     "assert_portable_component_graph",
+    "assert_portable_type_notation",
     "PORTABLE_EXPR_OPERATORS",
+    "PORTABLE_SCALAR_TYPES",
     "PortabilityError",
     # behavior
     "run_behavior",
@@ -132,4 +150,11 @@ __all__ = [
     # generator 支援（fingerprint）
     "fingerprint_component_graph",
     "FingerprintFailure",
+    # codegen primitive surface (bc#36)
+    "primitives",
+    "map_with_concurrency",
+    "unproduced_value",
+    "skip_single",
+    "skip_connection",
+    "hydrate_into",
 ]

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/src/behavior_contracts/guard.py

@@ -66,6 +66,62 @@ PORTABLE_EXPR_OPERATORS = frozenset(
     }
 )
 
+# 可搬型記法（Portable Type Notation, B0 / bc#44 — scp-ir-architecture.md §5.2）の
+# スカラ閉集合。複合型は `{opt|arr|obj: …}` の単一キー object のみ。
+PORTABLE_SCALAR_TYPES = frozenset({"string", "int", "float", "bool", "null"})
+
+
+def assert_portable_type_notation(node: Any, path: str) -> None:
+    """可搬型記法（§5.2）を Expression IR と同じ強度で検証する（fail-closed）。
+
+    閉集合:
+      - スカラ: PORTABLE_SCALAR_TYPES（文字列のみ・``"any"`` エスケープ無し）。
+      - ``{opt: T}`` / ``{arr: T}``: 単一キー object・値は型 T（再帰）。
+      - ``{obj: {field: T, …}}``: 単一キー object・値は field→型の object（``__proto__`` キー禁止）。
+
+    :raises PortabilityError: 閉集合外の型記法を検出したとき。
+    """
+    if isinstance(node, str):
+        if node not in PORTABLE_SCALAR_TYPES:
+            raise PortabilityError(
+                path, f"Portability Guard: unknown scalar type '{node}' (fail-closed) at {path}"
+            )
+        return
+    if not isinstance(node, dict):
+        raise PortabilityError(
+            path,
+            f"Portability Guard: type notation must be a scalar-type string or a single-key {{opt|arr|obj}} object (fail-closed) at {path}",
+        )
+    keys = list(node.keys())
+    if len(keys) != 1:
+        raise PortabilityError(
+            path,
+            f"Portability Guard: compound type must be a single-key object (opt|arr|obj), got {len(keys)} keys (fail-closed) at {path}",
+        )
+    kind = keys[0]
+    arg = node[kind]
+    if kind in ("opt", "arr"):
+        assert_portable_type_notation(arg, f"{path}.{kind}")
+        return
+    if kind == "obj":
+        if not isinstance(arg, dict):
+            raise PortabilityError(
+                f"{path}.obj",
+                f"Portability Guard: {{obj: ...}} type expects a field->type object (fail-closed) at {path}.obj",
+            )
+        for k, v in arg.items():
+            if k == FORBIDDEN_OBJECT_KEY:
+                raise PortabilityError(
+                    f"{path}.obj",
+                    f'Portability Guard: object type key "{FORBIDDEN_OBJECT_KEY}" is forbidden (fail-closed) at {path}.obj',
+                )
+            assert_portable_type_notation(v, f"{path}.obj.{k}")
+        return
+    raise PortabilityError(
+        path,
+        f"Portability Guard: unknown compound type kind '{kind}' (opt|arr|obj) (fail-closed) at {path}",
+    )
+
 
 def assert_portable_component_graph(ir: Any, path: str = "$") -> None:
     """component-graph IR（scp-ir-architecture.md §5）の可搬性 Guard（P0-2）。
@@ -99,6 +155,9 @@ def _assert_portable_component(c: Any, path: str) -> None:
     for ni, n in enumerate(body):
         _assert_portable_body_node(n, f"{path}.body[{ni}]")
     _assert_portable_expr(c.get("output"), f"{path}.output")
+    # 可搬型記法（B0 / bc#44・§5.2）: outputType は additive・省略可。
+    if "outputType" in c:
+        assert_portable_type_notation(c.get("outputType"), f"{path}.outputType")
 
 
 def _assert_portable_body_node(n: Any, path: str) -> None:
@@ -132,6 +191,9 @@ def _assert_portable_body_node(n: Any, path: str) -> None:
         _assert_portable_ports(n.get("ports"), f"{path}.ports")
     else:
         raise PortabilityError(path, f"Portability Guard: unknown body node kind (not componentRef/map/cond) at {path}")
+    # 可搬型記法（B0 / bc#44・§5.2）: node の outType は additive・省略可（全ノード種で共通）。
+    if "outType" in n:
+        assert_portable_type_notation(n.get("outType"), f"{path}.outType")
 
 
 def _require_string_component(v: Any, path: str) -> None:

behavior_contracts-0.2.2/src/behavior_contracts/primitives.py

@@ -0,0 +1,285 @@
+"""primitives.py — codegen が直呼びできる安定 primitive 公開面（bc#36 / typed-codegen.md §3.4）。
+
+A0 = 公開面の確定（emitter 生成ロジックは A1/#37）。生成コードが「細粒度 primitive を
+呼ぶ」ための callable surface を additive に切り出す。
+
+最重要規律（AC 7）: **演算子意味論は再実装しない。** 各 primitive は Expression IR の
+単一キーノードを組んで既存 SSoT ``evaluate``（expr_eval.py）へ委譲するだけの薄いラッパ。
+よって意味論（INT_OVERFLOW / PRECISION_LOSS / MOD_ZERO / NULL_REF / TYPE_MISMATCH /
+短絡未評価 / code-point 順 / CPython float repr 等）は ``evaluate`` と**完全一致**する。
+
+短絡の保存: ``and_`` / ``or_`` / ``cond`` / ``coalesce`` は **未評価の IR ノード**を引数に
+取り、内部で ``evaluate`` が短絡する（値を先に渡す API は採らない）。
+
+加えて run_plan / bounded 並行 / skip・unproduced / hydration helper を再エクスポートまたは
+薄く公開する（いずれも既存実装を SSoT として共有）。
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, List, Mapping, Optional, Sequence, TypeVar
+
+from .expr_eval import Scope, Value, evaluate
+from .plan import run_plan  # re-export（SSoT）
+
+Expr = Any  # 未評価の Expression IR ノード（primitive の被演算子）
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+def _scope(scope: Optional[Scope]) -> Scope:
+    return scope if scope is not None else {}
+
+
+# ── (a) Expression IR 全演算子の個別 primitive ────────────────────────────────
+# 各関数は単一キーの IR ノードを組んで evaluate に委譲する（意味論 SSoT は evaluate 一本）。
+
+
+def ref(path: Sequence[str], scope: Optional[Scope] = None) -> Value:
+    """参照。中間 null は NULL_REF。"""
+    return evaluate({"ref": list(path)}, _scope(scope))
+
+
+def ref_opt(path: Sequence[str], scope: Optional[Scope] = None) -> Value:
+    """null 安全参照。中間 null は null 伝播。"""
+    return evaluate({"refOpt": list(path)}, _scope(scope))
+
+
+def int_lit(literal: str, scope: Optional[Scope] = None) -> Value:
+    """``{int:"..."}`` リテラル（i64 checked）。"""
+    return evaluate({"int": literal}, _scope(scope))
+
+
+def float_lit(n: float, scope: Optional[Scope] = None) -> Value:
+    """``{float:n}`` リテラル（NaN/Inf は NAN_OR_INF）。"""
+    return evaluate({"float": n}, _scope(scope))
+
+
+def obj(fields: Mapping[str, Expr], scope: Optional[Scope] = None) -> Value:
+    """object 構築（own key ``__proto__`` は FORBIDDEN_KEY）。値は Expression IR。"""
+    return evaluate({"obj": dict(fields)}, _scope(scope))
+
+
+def arr(elems: Sequence[Expr], scope: Optional[Scope] = None) -> Value:
+    """array 構築。要素は Expression IR。"""
+    return evaluate({"arr": list(elems)}, _scope(scope))
+
+
+def add(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """加算（int×int / float×float checked。混在は TYPE_MISMATCH）。"""
+    return evaluate({"add": [a, b]}, _scope(scope))
+
+
+def sub(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """減算。"""
+    return evaluate({"sub": [a, b]}, _scope(scope))
+
+
+def mul(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """乗算。"""
+    return evaluate({"mul": [a, b]}, _scope(scope))
+
+
+def neg(a: Expr, scope: Optional[Scope] = None) -> Value:
+    """単項マイナス。"""
+    return evaluate({"neg": [a]}, _scope(scope))
+
+
+def div(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """除算（常に float。|int|>2^53 は PRECISION_LOSS、0除算は NAN_OR_INF）。"""
+    return evaluate({"div": [a, b]}, _scope(scope))
+
+
+def mod(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """剰余（truncated、符号は被除数。int の 0 剰余は MOD_ZERO）。"""
+    return evaluate({"mod": [a, b]}, _scope(scope))
+
+
+def concat(parts: Sequence[Expr], scope: Optional[Scope] = None) -> Value:
+    """文字列連結（n-ary, min 2。string のみ）。"""
+    return evaluate({"concat": list(parts)}, _scope(scope))
+
+
+def eq(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """等価（同一スカラ型のみ。null==null 可）。"""
+    return evaluate({"eq": [a, b]}, _scope(scope))
+
+
+def ne(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """非等価。"""
+    return evaluate({"ne": [a, b]}, _scope(scope))
+
+
+def lt(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """小なり（同一型 int/float/string。string は code-point 順）。"""
+    return evaluate({"lt": [a, b]}, _scope(scope))
+
+
+def le(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """以下。"""
+    return evaluate({"le": [a, b]}, _scope(scope))
+
+
+def gt(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """大なり。"""
+    return evaluate({"gt": [a, b]}, _scope(scope))
+
+
+def ge(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """以上。"""
+    return evaluate({"ge": [a, b]}, _scope(scope))
+
+
+def and_(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """論理積（短絡: a=false なら b は評価されない）。b は未評価 IR で渡す。"""
+    return evaluate({"and": [a, b]}, _scope(scope))
+
+
+def or_(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """論理和（短絡: a=true なら b は評価されない）。"""
+    return evaluate({"or": [a, b]}, _scope(scope))
+
+
+def not_(a: Expr, scope: Optional[Scope] = None) -> Value:
+    """論理否定（strict bool。truthiness なし）。"""
+    return evaluate({"not": [a]}, _scope(scope))
+
+
+def coalesce(a: Expr, b: Expr, scope: Optional[Scope] = None) -> Value:
+    """null 合体（左が null のときだけ右を評価）。右は未評価 IR で渡す。"""
+    return evaluate({"coalesce": [a, b]}, _scope(scope))
+
+
+def cond(c: Expr, then: Expr, els: Expr, scope: Optional[Scope] = None) -> Value:
+    """条件（strict bool。採用側のみ評価）。then/else は未評価 IR で渡す。"""
+    return evaluate({"cond": [c, then, els]}, _scope(scope))
+
+
+def len_(a: Expr, scope: Optional[Scope] = None) -> Value:
+    """配列長（配列のみ。string length は v1 に無い）。"""
+    return evaluate({"len": [a]}, _scope(scope))
+
+
+def eval_expr(node: Expr, scope: Optional[Scope] = None) -> Value:
+    """生の Expression IR を直接評価する汎用 primitive（意味論は個別 primitive と同一 SSoT）。"""
+    return evaluate(node, _scope(scope))
+
+
+# ── (c) bounded 並行プリミティブ（順序保存）─────────────────────────────────────
+def map_with_concurrency(
+    items: Sequence[T],
+    concurrency: int,
+    worker: Callable[[T, int], R],
+) -> List[R]:
+    """入力順を保存し in-flight を ``concurrency`` で上限する bounded 並行 map。
+
+    execution-plan.md §4 の determinism 規律（output[i]=worker(items[i]) / 完了順非依存 /
+    ThreadPoolExecutor bounded dispatch）を単体 primitive として公開する。plan.py の並列経路と
+    同一規律（結果は index 順に確定するので逐次実行と一致）。
+
+    :param items: 入力（順序保存の基準）。
+    :param concurrency: 同時 in-flight 上限（<=1 で逐次）。
+    :param worker: 各要素の処理 ``worker(item, index)``。
+    :returns: ``items`` と同じ長さ・順序の結果リスト。
+    """
+    n = len(items)
+    out: List[Optional[R]] = [None] * n
+    limit = max(1, int(concurrency))
+    if limit <= 1 or n <= 1:
+        for i in range(n):
+            out[i] = worker(items[i], i)
+        return out  # type: ignore[return-value]
+    workers = min(limit, n)
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        futures = {pool.submit(worker, items[i], i): i for i in range(n)}
+        for fut, i in futures.items():
+            out[i] = fut.result()  # 完了順非依存: index 固定スロットに書く
+    return out  # type: ignore[return-value]
+
+
+# ── (d) skip / unproduced-value helper ────────────────────────────────────────
+def unproduced_value(kind: Optional[str]) -> Value:
+    """未生成 Port（Skip）の表現値。single→None / connection→空 connection。"""
+    return {"items": [], "cursor": None} if kind == "connection" else None
+
+
+def skip_single() -> Value:
+    """single relation の未生成 = None。"""
+    return None
+
+
+def skip_connection() -> Value:
+    """connection relation の未生成 = {items:[],cursor:None}。"""
+    return {"items": [], "cursor": None}
+
+
+# ── (e) hydration / relation helper ───────────────────────────────────────────
+def hydrate_into(
+    over: Sequence[Value],
+    key: str,
+    kept_idx: Sequence[int],
+    values: Sequence[Value],
+) -> List[Value]:
+    """behavior.py の map.into と同一規律の zip-attach helper。
+
+    ``over`` の各要素へ ``key`` で ``values[k]`` を書き戻した augment 済みリストを返す
+    （over と同じ長さ・順序、親不変＝コピー、guard skip 要素は無変更で pass-through）。
+
+    :raises ValueError: augment 対象が dict でない場合（MAP_INTO_ELEMENT_NOT_OBJECT 相当）。
+    """
+    augmented: List[Value] = []
+    k = 0
+    for i, el in enumerate(over):
+        if k < len(kept_idx) and kept_idx[k] == i:
+            if not isinstance(el, dict):
+                raise ValueError(
+                    f"hydrate_into: element {i} is not an object (into requires object elements)"
+                )
+            augmented.append({**el, key: values[k]})
+            k += 1
+        else:
+            augmented.append(el)
+    return augmented
+
+
+__all__ = [
+    "Expr",
+    # (a) expression operators
+    "ref",
+    "ref_opt",
+    "int_lit",
+    "float_lit",
+    "obj",
+    "arr",
+    "add",
+    "sub",
+    "mul",
+    "neg",
+    "div",
+    "mod",
+    "concat",
+    "eq",
+    "ne",
+    "lt",
+    "le",
+    "gt",
+    "ge",
+    "and_",
+    "or_",
+    "not_",
+    "coalesce",
+    "cond",
+    "len_",
+    "eval_expr",
+    # (b) run_plan (re-export)
+    "run_plan",
+    # (c) bounded concurrency
+    "map_with_concurrency",
+    # (d) skip / unproduced
+    "unproduced_value",
+    "skip_single",
+    "skip_connection",
+    # (e) hydration
+    "hydrate_into",
+]

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/src/behavior_contracts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behavior-contracts
-Version: 0.2.0
+Version: 0.2.2
 Summary: Multi-language IR-Runtime common core (Python port). The COMMON 'thin core' primitives from dsl-contracts runtime-boundary.md — validate_envelope / evaluate_expression / render_template / run_plan / canonical_value / canonical_json / py_float_repr / assert_portable — with zero backend (DynamoDB/graphddb) dependencies.
 Author: foo-log
 License: MIT
@@ -60,12 +60,12 @@ string matching the conformance protocol's failure-code set.
 
 ## Conformance
 
-Runs the 7 shared suites (147 vectors) from `../conformance/vectors/*.json`
+Runs the 7 shared suites (164 vectors) from `../conformance/vectors/*.json`
 through this package per [`../conformance/PROTOCOL.md`](../conformance/PROTOCOL.md),
 including the pre-flight version fail-closed sweep.
 
 ```bash
-python -m behavior_contracts.conformance      # → "147 passed, 0 failed / 147 vectors across 7 suites"
+python -m behavior_contracts.conformance      # → "164 passed, 0 failed / 164 vectors across 7 suites"
 # or the console script:
 behavior-contracts-conformance
 ```

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/src/behavior_contracts.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/behavior_contracts/expr_eval.py
 src/behavior_contracts/fingerprint.py
 src/behavior_contracts/guard.py
 src/behavior_contracts/plan.py
+src/behavior_contracts/primitives.py
 src/behavior_contracts/template.py
 src/behavior_contracts.egg-info/PKG-INFO
 src/behavior_contracts.egg-info/SOURCES.txt
@@ -20,4 +21,5 @@ src/behavior_contracts.egg-info/top_level.txt
 tests/test_codegen_generated.py
 tests/test_conformance.py
 tests/test_plan_parallel.py
+tests/test_primitives.py
 tests/test_public_api.py

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/tests/test_conformance.py

@@ -1,4 +1,4 @@
-"""conformance runner を pytest から実行する（147 vectors 全 PASS を要求）。"""
+"""conformance runner を pytest から実行する（164 vectors 全 PASS を要求）。"""
 
 from __future__ import annotations
 

behavior_contracts-0.2.2/tests/test_primitives.py

@@ -0,0 +1,142 @@
+"""test_primitives.py — codegen primitive surface（bc#36）の pytest ユニットテスト。
+
+各式演算子 primitive が「正常系 + fail-closed エッジ」で ``evaluate_expression``（SSoT）と
+完全一致することを差分検証する。さらに map_with_concurrency（順序保存・bounded）/
+unproduced helper / hydrate_into を検証する。
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+
+import pytest
+
+from behavior_contracts import (
+    ExprFailure,
+    evaluate_expression,
+    hydrate_into,
+    map_with_concurrency,
+    primitives as P,
+    skip_connection,
+    skip_single,
+    unproduced_value,
+)
+
+
+def _same(actual, node, scope=None):
+    assert actual == evaluate_expression(node, scope or {})
+
+
+def _both_fail(prim_call, node, scope=None):
+    with pytest.raises(ExprFailure) as pe:
+        prim_call()
+    with pytest.raises(ExprFailure) as ee:
+        evaluate_expression(node, scope or {})
+    assert pe.value.code == ee.value.code
+
+
+def test_literals_and_refs_match():
+    scope = {"a": {"b": 7}, "n": None}
+    _same(P.int_lit("42"), {"int": "42"})
+    _same(P.float_lit(3.5), {"float": 3.5})
+    _same(P.ref(["a", "b"], scope), {"ref": ["a", "b"]}, scope)
+    _same(P.ref_opt(["n", "x"], scope), {"refOpt": ["n", "x"]}, scope)
+    _same(P.obj({"x": {"int": "1"}}, scope), {"obj": {"x": {"int": "1"}}}, scope)
+    _same(P.arr([{"int": "1"}, {"int": "2"}], scope), {"arr": [{"int": "1"}, {"int": "2"}]}, scope)
+
+
+def test_arithmetic_match_and_fail_closed():
+    _same(P.add({"int": "1"}, {"int": "2"}), {"add": [{"int": "1"}, {"int": "2"}]})
+    _same(P.sub({"int": "5"}, {"int": "3"}), {"sub": [{"int": "5"}, {"int": "3"}]})
+    _same(P.mul({"int": "4"}, {"int": "6"}), {"mul": [{"int": "4"}, {"int": "6"}]})
+    _same(P.neg({"int": "9"}), {"neg": [{"int": "9"}]})
+    _same(P.div({"int": "7"}, {"int": "2"}), {"div": [{"int": "7"}, {"int": "2"}]})
+    _same(P.mod({"int": "7"}, {"int": "3"}), {"mod": [{"int": "7"}, {"int": "3"}]})
+
+    _both_fail(
+        lambda: P.add({"int": "9223372036854775807"}, {"int": "1"}),
+        {"add": [{"int": "9223372036854775807"}, {"int": "1"}]},
+    )
+    _both_fail(lambda: P.mod({"int": "1"}, {"int": "0"}), {"mod": [{"int": "1"}, {"int": "0"}]})
+    _both_fail(lambda: P.add({"int": "1"}, {"float": 2.5}), {"add": [{"int": "1"}, {"float": 2.5}]})
+    _both_fail(
+        lambda: P.div({"int": "9007199254740993"}, {"int": "1"}),
+        {"div": [{"int": "9007199254740993"}, {"int": "1"}]},
+    )
+
+
+def test_comparison_concat_bool_cond_len_match():
+    _same(P.eq({"int": "1"}, {"int": "1"}), {"eq": [{"int": "1"}, {"int": "1"}]})
+    _same(P.ne({"int": "1"}, {"int": "2"}), {"ne": [{"int": "1"}, {"int": "2"}]})
+    _same(P.lt("a", "b"), {"lt": ["a", "b"]})
+    _same(P.le("a", "a"), {"le": ["a", "a"]})
+    _same(P.gt({"int": "3"}, {"int": "2"}), {"gt": [{"int": "3"}, {"int": "2"}]})
+    _same(P.ge({"int": "2"}, {"int": "2"}), {"ge": [{"int": "2"}, {"int": "2"}]})
+    _same(P.concat(["x", "y", "z"]), {"concat": ["x", "y", "z"]})
+    _same(P.and_(True, False), {"and": [True, False]})
+    _same(P.or_(False, True), {"or": [False, True]})
+    _same(P.not_(True), {"not": [True]})
+    _same(P.coalesce(None, "fb"), {"coalesce": [None, "fb"]})
+    _same(P.cond(True, "t", "e"), {"cond": [True, "t", "e"]})
+    _same(P.len_({"arr": [True, False]}), {"len": [{"arr": [True, False]}]})
+
+    _both_fail(lambda: P.concat(["x", {"int": "1"}]), {"concat": ["x", {"int": "1"}]})
+    _both_fail(lambda: P.len_("nope"), {"len": ["nope"]})
+    _both_fail(lambda: P.cond({"int": "1"}, "t", "e"), {"cond": [{"int": "1"}, "t", "e"]})
+    _both_fail(lambda: P.ref(["n", "x"], {"n": None}), {"ref": ["n", "x"]}, {"n": None})
+
+
+def test_short_circuit_preserved():
+    # {int:"bad"} would raise INVALID_LITERAL if evaluated.
+    assert P.and_(False, {"int": "bad"}) is False
+    assert P.or_(True, {"int": "bad"}) is True
+    assert P.cond(True, "ok", {"int": "bad"}) == "ok"
+    assert P.coalesce("present", {"int": "bad"}) == "present"
+
+
+def test_eval_expr_same_ssot():
+    _same(P.eval_expr({"add": [{"int": "2"}, {"int": "3"}]}), {"add": [{"int": "2"}, {"int": "3"}]})
+
+
+def test_map_with_concurrency_order_and_bound():
+    items = list(range(8))
+    in_flight = 0
+    max_in_flight = 0
+    lock = threading.Lock()
+
+    def worker(x, _i):
+        nonlocal in_flight, max_in_flight
+        with lock:
+            in_flight += 1
+            max_in_flight = max(max_in_flight, in_flight)
+        time.sleep(0.005)
+        with lock:
+            in_flight -= 1
+        return x * 10
+
+    out = map_with_concurrency(items, 3, worker)
+    assert out == [x * 10 for x in items]  # order preserved
+    assert max_in_flight <= 3
+
+
+def test_map_with_concurrency_degenerate():
+    assert map_with_concurrency([1, 2, 3], 1, lambda x, _i: x + 1) == [2, 3, 4]
+    assert map_with_concurrency([], 4, lambda x, _i: x) == []
+
+
+def test_skip_unproduced_helpers():
+    assert unproduced_value("single") is None
+    assert unproduced_value("connection") == {"items": [], "cursor": None}
+    assert unproduced_value(None) is None
+    assert skip_single() is None
+    assert skip_connection() == {"items": [], "cursor": None}
+
+
+def test_hydrate_into():
+    over = [{"id": 1}, {"id": 2}, {"id": 3}]
+    out = hydrate_into(over, "tag", [0, 2], ["A", "C"])
+    assert out == [{"id": 1, "tag": "A"}, {"id": 2}, {"id": 3, "tag": "C"}]
+    assert over[0] == {"id": 1}  # parent not mutated
+    with pytest.raises(ValueError):
+        hydrate_into([42], "tag", [0], ["x"])

{behavior_contracts-0.2.0 → behavior_contracts-0.2.2}/tests/test_public_api.py

@@ -6,6 +6,7 @@ conformance vector とは独立に、公開 API を直接叩いて境界条件
 
 from __future__ import annotations
 
+import json
 import math
 
 import pytest
@@ -22,6 +23,7 @@ from behavior_contracts import (
     BehaviorFailure,
     assert_portable,
     assert_portable_component_graph,
+    assert_portable_type_notation,
     canonical_json,
     canonical_value,
     cmp_code_points,
@@ -30,6 +32,7 @@ from behavior_contracts import (
     encode_value,
     evaluate_expression,
     final_tree,
+    fingerprint_component_graph,
     py_float_repr,
     render_template,
     resolve_partial,
@@ -642,3 +645,102 @@ class TestAssertPortableComponentGraph:
              "output": {"obj": {"k": {"bogusOp": [1]}}}}]}
         with pytest.raises(PortabilityError):
             assert_portable_component_graph(bad)
+
+
+# 型注記付き可搬 IR（B0 / bc#44）— MINI_IR に additive な outType/outputType を載せた変種。
+# fingerprint pin 値は TS 参照（ts/test/generator.test.ts）/ Rust / Go / PHP と一致する。
+_TYPED_MINI_IR = {
+    "irVersion": 1,
+    "exprVersion": 2,
+    "components": [
+        {
+            "name": "getA",
+            "inputPorts": {"id": {"type": "string", "required": True}},
+            "body": [
+                {
+                    "id": "a",
+                    "component": "GetItem",
+                    "ports": {"PK": {"concat": ["A#", {"ref": ["id"]}]}},
+                    "outType": {"obj": {"id": "string", "n": "int", "tags": {"arr": "string"}, "note": {"opt": "string"}}},
+                }
+            ],
+            "output": {"ref": ["a"]},
+            "outputType": {"obj": {"id": "string", "n": "int", "tags": {"arr": "string"}, "note": {"opt": "string"}}},
+            "plan": {"groups": [[0]], "concurrency": 16},
+        }
+    ],
+}
+_UNTYPED_MINI_IR = {
+    "irVersion": 1,
+    "exprVersion": 2,
+    "components": [
+        {
+            "name": "getA",
+            "inputPorts": {"id": {"type": "string", "required": True}},
+            "body": [{"id": "a", "component": "GetItem", "ports": {"PK": {"concat": ["A#", {"ref": ["id"]}]}}}],
+            "output": {"ref": ["a"]},
+            "plan": {"groups": [[0]], "concurrency": 16},
+        }
+    ],
+}
+
+
+class TestPortableTypeNotation:
+    """可搬型記法（B0 / bc#44 — scp-ir-architecture.md §5.2）の閉集合 + fail-closed。"""
+
+    def test_accepts_closed_set(self):
+        for t in ("string", "int", "float", "bool", "null"):
+            assert_portable_type_notation(t, "$")
+        assert_portable_type_notation({"opt": "string"}, "$")
+        assert_portable_type_notation({"arr": "int"}, "$")
+        assert_portable_type_notation(
+            {"obj": {"id": "string", "tags": {"arr": {"opt": "string"}}, "meta": {"obj": {"x": "bool"}}}}, "$"
+        )
+
+    def test_fail_closed_variants(self):
+        for bad in [
+            "int32",  # unknown scalar
+            "any",  # no escape hatch
+            {"set": "int"},  # unknown compound kind
+            {"opt": "int", "arr": "int"},  # multi-key
+            {},  # zero-key
+            {"arr": "int64"},  # recursive unknown scalar
+            {"obj": ["string"]},  # obj value not a field->type object
+            42,  # non-str / non-object
+            ["string"],  # array
+        ]:
+            with pytest.raises(PortabilityError):
+                assert_portable_type_notation(bad, "$")
+
+    def test_fail_closed_proto_obj_type_field_key(self):
+        bad = json.loads('{"obj":{"__proto__":"string"}}')
+        with pytest.raises(PortabilityError, match="__proto__"):
+            assert_portable_type_notation(bad, "$")
+
+    def test_graph_accepts_additive_annotations(self):
+        assert_portable_component_graph(_TYPED_MINI_IR)  # must not raise
+
+    def test_graph_backward_compat_outtype_absent(self):
+        # outType/outputType の無い IR は従来通り accept（B0 後方互換の pin）。
+        assert_portable_component_graph(_UNTYPED_MINI_IR)  # must not raise
+
+    def test_graph_fail_closed_bad_outtype(self):
+        bad = {"irVersion": 1, "exprVersion": 2, "components": [
+            {"name": "x", "inputPorts": {}, "body": [
+                {"id": "a", "component": "GetItem", "ports": {}, "outType": "int32"}], "output": None}]}
+        with pytest.raises(PortabilityError) as ei:
+            assert_portable_component_graph(bad)
+        assert ei.value.path == "$.components[0].body[0].outType"
+
+
+class TestTypedFingerprintParity:
+    """型注記付き IR の fingerprint parity（B0 / bc#44）。TS/Rust/Go/PHP と同一 fnv1a64。"""
+
+    def test_typed_pinned_cross_language_value(self):
+        assert fingerprint_component_graph(_TYPED_MINI_IR) == "fnv1a64:c4d20ffa450dc313"
+
+    def test_untyped_unchanged_and_annotations_change_hash(self):
+        # 後方互換: untyped MINI_IR は従来値（TS/Go/Rust/PHP pin）。
+        assert fingerprint_component_graph(_UNTYPED_MINI_IR) == "fnv1a64:9421ef4d0840926a"
+        # 型注記の有無で fingerprint が変わる（改変検出）。
+        assert fingerprint_component_graph(_TYPED_MINI_IR) != fingerprint_component_graph(_UNTYPED_MINI_IR)